diff --git a/.gitignore b/.gitignore index 7d6d9021f12ebfcb837d19c443362f1ecbc4077f..28a830818af36faad3f4278c6adcba5562b59ee7 100644 --- a/.gitignore +++ b/.gitignore @@ -47,6 +47,8 @@ tests/brute_force_27_perturbed.dat tests/swift_dopair_27_perturbed.dat tests/brute_force_125_standard.dat tests/swift_dopair_125_standard.dat +tests/brute_force_125_perturbed.dat +tests/swift_dopair_125_perturbed.dat tests/testGreetings tests/testReading tests/input.hdf5 @@ -65,6 +67,7 @@ tests/parser_output.yml tests/test27cells.sh tests/test27cellsPerturbed.sh tests/test125cells.sh +tests/test125cellsPerturbed.sh tests/testPair.sh tests/testPairPerturbed.sh tests/testParser.sh diff --git a/configure.ac b/configure.ac index 8a2d0f30ae297993b34153bc9a4c04085f4748f5..788bb57eed801c1a1dff2204b57b34c4fadf3b58 100644 --- a/configure.ac +++ b/configure.ac @@ -853,6 +853,7 @@ AC_CONFIG_FILES([tests/testPairPerturbed.sh], [chmod +x tests/testPairPerturbed. AC_CONFIG_FILES([tests/test27cells.sh], [chmod +x tests/test27cells.sh]) AC_CONFIG_FILES([tests/test27cellsPerturbed.sh], [chmod +x tests/test27cellsPerturbed.sh]) AC_CONFIG_FILES([tests/test125cells.sh], [chmod +x tests/test125cells.sh]) +AC_CONFIG_FILES([tests/test125cellsPerturbed.sh], [chmod +x tests/test125cellsPerturbed.sh]) AC_CONFIG_FILES([tests/testParser.sh], [chmod +x tests/testParser.sh]) # Save the compilation options diff --git a/examples/DiscPatch/HydroStatic/plot.py b/examples/DiscPatch/HydroStatic/plot.py new file mode 100644 index 0000000000000000000000000000000000000000..2de749f9e3b3c287390218e09ea347d660f9ce8a --- /dev/null +++ b/examples/DiscPatch/HydroStatic/plot.py @@ -0,0 +1,103 @@ +################################################################################ +# This file is part of SWIFT. +# Copyright (c) 2017 Bert Vandenbroucke (bert.vandenbroucke@gmail.com) +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# +################################################################################ + +## +# This script plots the Disc-Patch_*.hdf5 snapshots. +# It takes two (optional) parameters: the counter value of the first and last +# snapshot to plot (default: 0 81). +## + +import numpy as np +import h5py +import matplotlib +matplotlib.use("Agg") +import pylab as pl +import glob +import sys + +# Parameters +surface_density = 10. +scale_height = 100. +z_disc = 200. +utherm = 20.2615290634 +gamma = 5. / 3. + +start = 0 +stop = 81 +if len(sys.argv) > 1: + start = int(sys.argv[1]) +if len(sys.argv) > 2: + stop = int(sys.argv[2]) + +# Get the analytic solution for the density +def get_analytic_density(x): + return 0.5 * surface_density / scale_height / \ + np.cosh( (x - z_disc) / scale_height )**2 + +# Get the analytic solution for the (isothermal) pressure +def get_analytic_pressure(x): + return (gamma - 1.) * utherm * get_analytic_density(x) + +# Get the data fields to plot from the snapshot file with the given name: +# snapshot time, z-coord, density, pressure, velocity norm +def get_data(name): + file = h5py.File(name, "r") + coords = np.array(file["/PartType0/Coordinates"]) + rho = np.array(file["/PartType0/Density"]) + u = np.array(file["/PartType0/InternalEnergy"]) + v = np.array(file["/PartType0/Velocities"]) + + P = (gamma - 1.) * rho * u + + vtot = np.sqrt( v[:,0]**2 + v[:,1]**2 + v[:,2]**2 ) + + return float(file["/Header"].attrs["Time"]), coords[:,2], rho, P, vtot + +# scan the folder for snapshot files and plot all of them (within the requested +# range) +for f in sorted(glob.glob("Disc-Patch_*.hdf5")): + num = int(f[-8:-5]) + if num < start or num > stop: + continue + + print "processing", f, "..." + + zrange = np.linspace(0., 400., 1000) + time, z, rho, P, v = get_data(f) + + fig, ax = pl.subplots(3, 1, sharex = True) + + ax[0].plot(z, rho, "r.") + ax[0].plot(zrange, get_analytic_density(zrange), "k-") + ax[0].set_ylabel("density") + + ax[1].plot(z, v, "r.") + ax[1].plot(zrange, np.zeros(len(zrange)), "k-") + ax[1].set_ylabel("velocity norm") + + ax[2].plot(z, P, "r.") + ax[2].plot(zrange, get_analytic_pressure(zrange), "k-") + ax[2].set_xlim(0., 400.) + ax[2].set_xlabel("z") + ax[2].set_ylabel("pressure") + + pl.suptitle("t = {0:.2f}".format(time)) + + pl.savefig("{name}.png".format(name = f[:-5])) + pl.close() diff --git a/examples/HydrostaticHalo/density_profile.py b/examples/HydrostaticHalo/density_profile.py index d0afd399f951cf3b727e869ca8571a3a802c2e8d..5248587ec343d3c0ffe2cef0cbd8716b9a1e055c 100644 --- a/examples/HydrostaticHalo/density_profile.py +++ b/examples/HydrostaticHalo/density_profile.py @@ -1,6 +1,27 @@ +############################################################################### + # This file is part of SWIFT. + # Copyright (c) 2016 Stefan Arridge (stefan.arridge@durham.ac.uk) + # + # This program is free software: you can redistribute it and/or modify + # it under the terms of the GNU Lesser General Public License as published + # by the Free Software Foundation, either version 3 of the License, or + # (at your option) any later version. + # + # This program is distributed in the hope that it will be useful, + # but WITHOUT ANY WARRANTY; without even the implied warranty of + # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + # GNU General Public License for more details. + # + # You should have received a copy of the GNU Lesser General Public License + # along with this program. If not, see <http://www.gnu.org/licenses/>. + # + ############################################################################## + import numpy as np import h5py as h5 -import matplotlib.pyplot as plt +import matplotlib +matplotlib.use("Agg") +from pylab import * import sys #for the plotting @@ -46,7 +67,8 @@ for i in range(n_snaps): f = h5.File(filename,'r') coords_dset = f["PartType0/Coordinates"] coords = np.array(coords_dset) -#translate coords by centre of box + + #translate coords by centre of box header = f["Header"] snap_time = header.attrs["Time"] snap_time_cgs = snap_time * unit_time_cgs @@ -63,58 +85,46 @@ for i in range(n_snaps): bin_width = bin_edges[1] - bin_edges[0] hist = np.histogram(r,bins = bin_edges)[0] # number of particles in each bin -#find the mass in each radial bin + #find the mass in each radial bin mass_dset = f["PartType0/Masses"] -#mass of each particles should be equal + + #mass of each particles should be equal part_mass = np.array(mass_dset)[0] part_mass_cgs = part_mass * unit_mass_cgs part_mass_over_virial_mass = part_mass_cgs / M_vir_cgs mass_hist = hist * part_mass_over_virial_mass radial_bin_mids = np.linspace(bin_width/2.,max_r - bin_width/2.,n_radial_bins) -#volume in each radial bin + + #volume in each radial bin volume = 4.*np.pi * radial_bin_mids**2 * bin_width -#now divide hist by the volume so we have a density in each bin + #now divide hist by the volume so we have a density in each bin density = mass_hist / volume - ##read the densities - - # density_dset = f["PartType0/Density"] - # density = np.array(density_dset) - # density_cgs = density * unit_mass_cgs / unit_length_cgs**3 - # rho = density_cgs * r_vir_cgs**3 / M_vir_cgs - t = np.linspace(10./n_radial_bins,10.0,1000) rho_analytic = t**(-2)/(4.*np.pi) - #calculate cooling radius - - #r_cool_over_r_vir = np.sqrt((2.*(gamma - 1.)*lambda_cgs*M_vir_cgs*X_H**2)/(4.*np.pi*CONST_m_H_CGS**2*v_c_cgs**2*r_vir_cgs**3))*np.sqrt(snap_time_cgs) - #initial analytic density profile - + #initial analytic density profile if (i == 0): r_0 = radial_bin_mids[0] rho_0 = density[0] - rho_analytic_init = rho_0 * (radial_bin_mids/r_0)**(-2) - plt.plot(radial_bin_mids,density/rho_analytic_init,'ko',label = "Average density of shell") - #plt.plot(t,rho_analytic,label = "Initial analytic density profile" - plt.xlabel(r"$r / r_{vir}$") - plt.ylabel(r"$\rho / \rho_{init})$") - plt.title(r"$\mathrm{Time}= %.3g \, s \, , \, %d \, \, \mathrm{particles} \,,\, v_c = %.1f \, \mathrm{km / s}$" %(snap_time_cgs,N,v_c)) - #plt.ylim((1.e-2,1.e1)) - #plt.plot((r_cool_over_r_vir,r_cool_over_r_vir),(0,20),'r',label = "Cooling radius") - plt.xlim((radial_bin_mids[0],max_r)) - plt.ylim((0,20)) - plt.plot((0,max_r),(1,1)) - #plt.xscale('log') - #plt.yscale('log') - plt.legend(loc = "upper right") + + figure() + plot(radial_bin_mids,density/rho_analytic_init,'ko',label = "Average density of shell") + #plot(t,rho_analytic,label = "Initial analytic density profile") + xlabel(r"$r / r_{vir}$") + ylabel(r"$\rho / \rho_{init}$") + title(r"$\mathrm{Time}= %.3g \, s \, , \, %d \, \, \mathrm{particles} \,,\, v_c = %.1f \, \mathrm{km / s}$" %(snap_time_cgs,N,v_c)) + xlim((radial_bin_mids[0],max_r)) + ylim((0,2)) + plot((0,max_r),(1,1)) + legend(loc = "upper right") plot_filename = "./plots/density_profile/density_profile_%03d.png" %i - plt.savefig(plot_filename,format = "png") - plt.close() + savefig(plot_filename,format = "png") + close() diff --git a/examples/HydrostaticHalo/internal_energy_profile.py b/examples/HydrostaticHalo/internal_energy_profile.py index ea52cf8fc5fd098a46f05eaa58494529a868000c..f1be049adb8e972f89fd9ffe86106b1b9f3b19dc 100644 --- a/examples/HydrostaticHalo/internal_energy_profile.py +++ b/examples/HydrostaticHalo/internal_energy_profile.py @@ -1,6 +1,27 @@ +############################################################################### + # This file is part of SWIFT. + # Copyright (c) 2016 Stefan Arridge (stefan.arridge@durham.ac.uk) + # + # This program is free software: you can redistribute it and/or modify + # it under the terms of the GNU Lesser General Public License as published + # by the Free Software Foundation, either version 3 of the License, or + # (at your option) any later version. + # + # This program is distributed in the hope that it will be useful, + # but WITHOUT ANY WARRANTY; without even the implied warranty of + # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + # GNU General Public License for more details. + # + # You should have received a copy of the GNU Lesser General Public License + # along with this program. If not, see <http://www.gnu.org/licenses/>. + # + ############################################################################## + import numpy as np import h5py as h5 -import matplotlib.pyplot as plt +import matplotlib +matplotlib.use("Agg") +from pylab import * import sys def do_binning(x,y,x_bin_edges): @@ -48,8 +69,6 @@ unit_velocity_cgs = float(params.attrs["InternalUnitSystem:UnitVelocity_in_cgs"] unit_time_cgs = unit_length_cgs / unit_velocity_cgs v_c = float(params.attrs["IsothermalPotential:vrot"]) v_c_cgs = v_c * unit_velocity_cgs -#lambda_cgs = float(params.attrs["LambdaCooling:lambda_cgs"]) -#X_H = float(params.attrs["LambdaCooling:hydrogen_mass_abundance"]) header = f["Header"] N = header.attrs["NumPart_Total"][0] box_centre = np.array(header.attrs["BoxSize"]) @@ -64,7 +83,8 @@ for i in range(n_snaps): f = h5.File(filename,'r') coords_dset = f["PartType0/Coordinates"] coords = np.array(coords_dset) -#translate coords by centre of box + + #translate coords by centre of box header = f["Header"] snap_time = header.attrs["Time"] snap_time_cgs = snap_time * unit_time_cgs @@ -75,11 +95,11 @@ for i in range(n_snaps): radius_cgs = radius*unit_length_cgs radius_over_virial_radius = radius_cgs / r_vir_cgs -#get the internal energies + #get the internal energies u_dset = f["PartType0/InternalEnergy"] u = np.array(u_dset) -#make dimensionless + #make dimensionless u /= v_c**2/(2. * (gamma - 1.)) r = radius_over_virial_radius @@ -90,21 +110,16 @@ for i in range(n_snaps): radial_bin_mids = np.linspace(bin_widths / 2. , max_r - bin_widths / 2. , n_radial_bins) binned_u = u_totals / hist - #calculate cooling radius - - #r_cool_over_r_vir = np.sqrt((2.*(gamma - 1.)*lambda_cgs*M_vir_cgs*X_H**2)/(4.*np.pi*CONST_m_H_CGS**2*v_c_cgs**2*r_vir_cgs**3))*np.sqrt(snap_time_cgs) - - plt.plot(radial_bin_mids,binned_u,'ko',label = "Numerical solution") - #plt.plot((0,1),(1,1),label = "Analytic Solution") - #plt.plot((r_cool_over_r_vir,r_cool_over_r_vir),(0,2),'r',label = "Cooling radius") - plt.legend(loc = "lower right") - plt.xlabel(r"$r / r_{vir}$") - plt.ylabel(r"$u / (v_c^2 / (2(\gamma - 1)) $") - plt.title(r"$\mathrm{Time}= %.3g \, s \, , \, %d \, \, \mathrm{particles} \,,\, v_c = %.1f \, \mathrm{km / s}$" %(snap_time_cgs,N,v_c)) - plt.ylim((0,2)) + figure() + plot(radial_bin_mids,binned_u,'ko',label = "Numerical solution") + legend(loc = "lower right") + xlabel(r"$r / r_{vir}$") + ylabel(r"$u / (v_c^2 / (2(\gamma - 1)) $") + title(r"$\mathrm{Time}= %.3g \, s \, , \, %d \, \, \mathrm{particles} \,,\, v_c = %.1f \, \mathrm{km / s}$" %(snap_time_cgs,N,v_c)) + ylim((0,2)) plot_filename = "./plots/internal_energy/internal_energy_profile_%03d.png" %i - plt.savefig(plot_filename,format = "png") - plt.close() + savefig(plot_filename,format = "png") + close() diff --git a/examples/HydrostaticHalo/run.sh b/examples/HydrostaticHalo/run.sh index d23ead6a67f43c9d19d76a797e72d050a3978d61..82584282559c1fceb0492aada671ff83fb74c924 100755 --- a/examples/HydrostaticHalo/run.sh +++ b/examples/HydrostaticHalo/run.sh @@ -1,11 +1,14 @@ #!/bin/bash # Generate the initial conditions if they are not present. -echo "Generating initial conditions for the isothermal potential box example..." -python makeIC.py 100000 +if [ ! -e Hydrostatic.hdf5 ] +then + echo "Generating initial conditions for the isothermal potential box example..." + python makeIC.py 100000 +fi # Run for 10 dynamical times -../swift -g -s -t 2 hydrostatic.yml 2>&1 | tee output.log +../swift -g -s -t 1 hydrostatic.yml 2>&1 | tee output.log echo "Plotting density profiles" mkdir plots diff --git a/examples/HydrostaticHalo/test_energy_conservation.py b/examples/HydrostaticHalo/test_energy_conservation.py index ca091050c4127d11a37a2cc7504e42d244031e25..8368d475813d248ca93c12e46737b062752ab779 100644 --- a/examples/HydrostaticHalo/test_energy_conservation.py +++ b/examples/HydrostaticHalo/test_energy_conservation.py @@ -1,6 +1,27 @@ +############################################################################### + # This file is part of SWIFT. + # Copyright (c) 2016 Stefan Arridge (stefan.arridge@durham.ac.uk) + # + # This program is free software: you can redistribute it and/or modify + # it under the terms of the GNU Lesser General Public License as published + # by the Free Software Foundation, either version 3 of the License, or + # (at your option) any later version. + # + # This program is distributed in the hope that it will be useful, + # but WITHOUT ANY WARRANTY; without even the implied warranty of + # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + # GNU General Public License for more details. + # + # You should have received a copy of the GNU Lesser General Public License + # along with this program. If not, see <http://www.gnu.org/licenses/>. + # + ############################################################################## + import numpy as np import h5py as h5 -import matplotlib.pyplot as plt +import matplotlib +matplotlib.use("Agg") +from pylab import * import sys n_snaps = int(sys.argv[1]) @@ -24,7 +45,7 @@ unit_mass_cgs = float(params.attrs["InternalUnitSystem:UnitMass_in_cgs"]) unit_length_cgs = float(params.attrs["InternalUnitSystem:UnitLength_in_cgs"]) unit_velocity_cgs = float(params.attrs["InternalUnitSystem:UnitVelocity_in_cgs"]) unit_time_cgs = unit_length_cgs / unit_velocity_cgs -v_c = float(params.attrs["SoftenedIsothermalPotential:vrot"]) +v_c = float(params.attrs["IsothermalPotential:vrot"]) v_c_cgs = v_c * unit_velocity_cgs header = f["Header"] N = header.attrs["NumPart_Total"][0] @@ -45,7 +66,8 @@ for i in range(n_snaps): f = h5.File(filename,'r') coords_dset = f["PartType0/Coordinates"] coords = np.array(coords_dset) -#translate coords by centre of box + + #translate coords by centre of box header = f["Header"] snap_time = header.attrs["Time"] snap_time_cgs = snap_time * unit_time_cgs @@ -73,7 +95,6 @@ for i in range(n_snaps): internal_energy_array = np.append(internal_energy_array,total_internal_energy) #put energies in units of v_c^2 and rescale by number of particles - pe = potential_energy_array / (N*v_c**2) ke = kinetic_energy_array / (N*v_c**2) ie = internal_energy_array / (N*v_c**2) @@ -82,14 +103,15 @@ te = pe + ke + ie dyn_time_cgs = r_vir_cgs / v_c_cgs time_array = time_array_cgs / dyn_time_cgs -plt.plot(time_array,ke,label = "Kinetic Energy") -plt.plot(time_array,pe,label = "Potential Energy") -plt.plot(time_array,ie,label = "Internal Energy") -plt.plot(time_array,te,label = "Total Energy") -plt.legend(loc = "lower right") -plt.xlabel(r"$t / t_{dyn}$") -plt.ylabel(r"$E / v_c^2$") -plt.title(r"$%d \, \, \mathrm{particles} \,,\, v_c = %.1f \, \mathrm{km / s}$" %(N,v_c)) -plt.ylim((-2,2)) -plt.savefig("energy_conservation.png",format = 'png') +figure() +plot(time_array,ke,label = "Kinetic Energy") +plot(time_array,pe,label = "Potential Energy") +plot(time_array,ie,label = "Internal Energy") +plot(time_array,te,label = "Total Energy") +legend(loc = "lower right") +xlabel(r"$t / t_{dyn}$") +ylabel(r"$E / v_c^2$") +title(r"$%d \, \, \mathrm{particles} \,,\, v_c = %.1f \, \mathrm{km / s}$" %(N,v_c)) +ylim((-2,2)) +savefig("energy_conservation.png",format = 'png') diff --git a/examples/HydrostaticHalo/velocity_profile.py b/examples/HydrostaticHalo/velocity_profile.py index 9133195d942233514148aa419003ee0ab7923494..f8f607362846a323937a9203dab8bc228f52a149 100644 --- a/examples/HydrostaticHalo/velocity_profile.py +++ b/examples/HydrostaticHalo/velocity_profile.py @@ -1,6 +1,27 @@ +############################################################################### + # This file is part of SWIFT. + # Copyright (c) 2016 Stefan Arridge (stefan.arridge@durham.ac.uk) + # + # This program is free software: you can redistribute it and/or modify + # it under the terms of the GNU Lesser General Public License as published + # by the Free Software Foundation, either version 3 of the License, or + # (at your option) any later version. + # + # This program is distributed in the hope that it will be useful, + # but WITHOUT ANY WARRANTY; without even the implied warranty of + # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + # GNU General Public License for more details. + # + # You should have received a copy of the GNU Lesser General Public License + # along with this program. If not, see <http://www.gnu.org/licenses/>. + # + ############################################################################## + import numpy as np import h5py as h5 -import matplotlib.pyplot as plt +import matplotlib +matplotlib.use("Agg") +from pylab import * import sys def do_binning(x,y,x_bin_edges): @@ -62,7 +83,8 @@ for i in range(n_snaps): f = h5.File(filename,'r') coords_dset = f["PartType0/Coordinates"] coords = np.array(coords_dset) -#translate coords by centre of box + + #translate coords by centre of box header = f["Header"] snap_time = header.attrs["Time"] snap_time_cgs = snap_time * unit_time_cgs @@ -73,16 +95,15 @@ for i in range(n_snaps): radius_cgs = radius*unit_length_cgs radius_over_virial_radius = radius_cgs / r_vir_cgs -#get the internal energies + #get the internal energies vel_dset = f["PartType0/Velocities"] vel = np.array(vel_dset) -#make dimensionless + #make dimensionless vel /= v_c r = radius_over_virial_radius #find radial component of velocity - v_r = np.zeros(r.size) for j in range(r.size): v_r[j] = -np.dot(coords[j,:],vel[j,:])/radius[j] @@ -94,18 +115,13 @@ for i in range(n_snaps): radial_bin_mids = np.linspace(bin_widths / 2. , max_r - bin_widths / 2. , n_radial_bins) binned_v_r = v_r_totals / hist - #calculate cooling radius - - #r_cool_over_r_vir = np.sqrt((2.*(gamma - 1.)*lambda_cgs*M_vir_cgs*X_H**2)/(4.*np.pi*CONST_m_H_CGS**2*v_c_cgs**2*r_vir_cgs**3))*np.sqrt(snap_time_cgs) - - plt.plot(radial_bin_mids,binned_v_r,'ko',label = "Average radial velocity in shell") - #plt.plot((0,1),(1,1),label = "Analytic Solution") - #plt.plot((r_cool_over_r_vir,r_cool_over_r_vir),(0,2),'r',label = "Cooling radius") - plt.legend(loc = "upper right") - plt.xlabel(r"$r / r_{vir}$") - plt.ylabel(r"$v_r / v_c$") - plt.title(r"$\mathrm{Time}= %.3g \, s \, , \, %d \, \, \mathrm{particles} \,,\, v_c = %.1f \, \mathrm{km / s}$" %(snap_time_cgs,N,v_c)) - plt.ylim((0,2)) + figure() + plot(radial_bin_mids,binned_v_r,'ko',label = "Average radial velocity in shell") + legend(loc = "upper right") + xlabel(r"$r / r_{vir}$") + ylabel(r"$v_r / v_c$") + title(r"$\mathrm{Time}= %.3g \, s \, , \, %d \, \, \mathrm{particles} \,,\, v_c = %.1f \, \mathrm{km / s}$" %(snap_time_cgs,N,v_c)) + ylim((-1,1)) plot_filename = "./plots/radial_velocity_profile/velocity_profile_%03d.png" %i - plt.savefig(plot_filename,format = "png") - plt.close() + savefig(plot_filename,format = "png") + close() diff --git a/examples/analyse_tasks.py b/examples/analyse_tasks.py new file mode 100755 index 0000000000000000000000000000000000000000..04cd59feedba7ee41621ac0891d544c4aa294543 --- /dev/null +++ b/examples/analyse_tasks.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python +""" +Usage: + analsyse_tasks.py [options] input.dat + +where input.dat is a thread info file for a step. Use the '-y interval' flag +of the swift command to create these. + +The output is an analysis of the task timings, including deadtime per thread +and step, total amount of time spent for each task type, for the whole step +and per thread and the minimum and maximum times spent per task type. + +This file is part of SWIFT. +Copyright (c) 2017 Peter W. Draper (p.w.draper@durham.ac.uk) + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published +by the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this program. If not, see <http://www.gnu.org/licenses/>. +""" + +import matplotlib +matplotlib.use("Agg") +import matplotlib.collections as collections +import matplotlib.ticker as plticker +import pylab as pl +import sys +import argparse + +# Handle the command line. +parser = argparse.ArgumentParser(description="Analyse task dumps") + +parser.add_argument("input", help="Thread data file (-y output)") +parser.add_argument("-v", "--verbose", dest="verbose", + help="Verbose output (default: False)", + default=False, action="store_true") + +args = parser.parse_args() +infile = args.input + +# Tasks and subtypes. Indexed as in tasks.h. +TASKTYPES = ["none", "sort", "self", "pair", "sub_self", "sub_pair", + "init_grav", "ghost", "extra_ghost", "drift_part", + "drift_gpart", "kick1", "kick2", "timestep", "send", "recv", + "grav_top_level", "grav_long_range", "grav_mm", "grav_down", + "cooling", "sourceterms", "count"] + +SUBTYPES = ["none", "density", "gradient", "force", "grav", "external_grav", + "tend", "xv", "rho", "gpart", "multipole", "spart", "count"] + +# Read input. +data = pl.loadtxt( infile ) + +maxthread = int(max(data[:,0])) + 1 +print "# Maximum thread id:", maxthread + +# Recover the start and end time +full_step = data[0,:] +tic_step = int(full_step[4]) +toc_step = int(full_step[5]) +CPU_CLOCK = float(full_step[-1]) / 1000.0 +data = data[1:,:] +if args.verbose: + print "CPU frequency:", CPU_CLOCK * 1000.0 + +# Avoid start and end times of zero. +data = data[data[:,4] != 0] +data = data[data[:,5] != 0] + +# Calculate the time range. +total_t = (toc_step - tic_step)/ CPU_CLOCK +print "# Data range: ", total_t, "ms" + +# Correct times to relative values. +start_t = float(tic_step) +data[:,4] -= start_t +data[:,5] -= start_t + +tasks = {} +tasks[-1] = [] +for i in range(maxthread): + tasks[i] = [] + +# Gather into by thread data. +num_lines = pl.size(data) / 10 +for line in range(num_lines): + thread = int(data[line,0]) + tic = int(data[line,4]) / CPU_CLOCK + toc = int(data[line,5]) / CPU_CLOCK + tasktype = int(data[line,1]) + subtype = int(data[line,2]) + + tasks[thread].append([tic,toc,tasktype,subtype]) + +# Sort by tic and gather used thread ids. +threadids = [] +for i in range(maxthread): + if len(tasks[i]) > 0: + tasks[i] = sorted(tasks[i], key=lambda task: task[0]) + threadids.append(i) + +# Times per task. +print "# Task times:" +print "# {0:<16s}: {1:>7s} {2:>9s} {3:>9s} {4:>9s} {5:>9s} {6:>9s}"\ + .format("type/subtype", "count","minimum", "maximum", + "sum", "mean", "percent") +alltasktimes = {} +for i in threadids: + tasktimes = {} + for task in tasks[i]: + key = TASKTYPES[task[2]] + "/" + SUBTYPES[task[3]] + dt = task[1] - task[0] + if not key in tasktimes: + tasktimes[key] = [] + tasktimes[key].append(dt) + + if not key in alltasktimes: + alltasktimes[key] = [] + alltasktimes[key].append(dt) + + print "# Thread : ", i + for key in sorted(tasktimes.keys()): + taskmin = min(tasktimes[key]) + taskmax = max(tasktimes[key]) + tasksum = sum(tasktimes[key]) + print "{0:18s}: {1:7d} {2:9.4f} {3:9.4f} {4:9.4f} {5:9.4f} {6:9.2f}"\ + .format(key, len(tasktimes[key]), taskmin, taskmax, tasksum, + tasksum / len(tasktimes[key]), tasksum / total_t * 100.0) + print + +print "# All threads : " +for key in sorted(alltasktimes.keys()): + taskmin = min(alltasktimes[key]) + taskmax = max(alltasktimes[key]) + tasksum = sum(alltasktimes[key]) + print "{0:18s}: {1:7d} {2:9.4f} {3:9.4f} {4:9.4f} {5:9.4f} {6:9.2f}"\ + .format(key, len(alltasktimes[key]), taskmin, taskmax, tasksum, + tasksum / len(alltasktimes[key]), + tasksum / (len(threadids) * total_t) * 100.0) +print + +# Dead times. +print "# Deadtimes:" +print "# no. : {0:>9s} {1:>9s} {2:>9s} {3:>9s} {4:>9s} {5:>9s}"\ + .format("count", "minimum", "maximum", "sum", "mean", "percent") +alldeadtimes = [] +for i in threadids: + deadtimes = [] + last = 0 + for task in tasks[i]: + dt = task[0] - last + deadtimes.append(dt) + last = task[1] + dt = total_t - last + deadtimes.append(dt) + + deadmin = min(deadtimes) + deadmax = max(deadtimes) + deadsum = sum(deadtimes) + print "thread {0:2d}: {1:9d} {2:9.4f} {3:9.4f} {4:9.4f} {5:9.4f} {6:9.2f}"\ + .format(i, len(deadtimes), deadmin, deadmax, deadsum, + deadsum / len(deadtimes), deadsum / total_t * 100.0) + alldeadtimes.extend(deadtimes) + +deadmin = min(alldeadtimes) +deadmax = max(alldeadtimes) +deadsum = sum(alldeadtimes) +print "all : {0:9d} {1:9.4f} {2:9.4f} {3:9.4f} {4:9.4f} {5:9.2f}"\ + .format(len(alldeadtimes), deadmin, deadmax, deadsum, + deadsum / len(alldeadtimes), + deadsum / (len(threadids) * total_t ) * 100.0) +print + + +sys.exit(0) diff --git a/examples/analyse_tasks_MPI.py b/examples/analyse_tasks_MPI.py new file mode 100755 index 0000000000000000000000000000000000000000..9feffaf67ec393257d75428e310a2e8b807df39a --- /dev/null +++ b/examples/analyse_tasks_MPI.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python +""" +Usage: + analsyse_tasks_MPI.py [options] input.dat + +where input.dat is a thread info file for an MPI step. Use the '-y interval' +flag of the swift command to create these. + +The output is an analysis of the task timings, including deadtime per thread +and step, total amount of time spent for each task type, for the whole step +and per thread and the minimum and maximum times spent per task type. + +This file is part of SWIFT. +Copyright (c) 2017 Peter W. Draper (p.w.draper@durham.ac.uk) + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published +by the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this program. If not, see <http://www.gnu.org/licenses/>. +""" + +import matplotlib +matplotlib.use("Agg") +import matplotlib.collections as collections +import matplotlib.ticker as plticker +import pylab as pl +import sys +import argparse + +# Handle the command line. +parser = argparse.ArgumentParser(description="Analyse task dumps") + +parser.add_argument("input", help="Thread data file (-y output)") +parser.add_argument("-v", "--verbose", dest="verbose", + help="Verbose output (default: False)", + default=False, action="store_true") + +args = parser.parse_args() +infile = args.input + +# Tasks and subtypes. Indexed as in tasks.h. +TASKTYPES = ["none", "sort", "self", "pair", "sub_self", "sub_pair", + "init_grav", "ghost", "extra_ghost", "drift_part", + "drift_gpart", "kick1", "kick2", "timestep", "send", "recv", + "grav_top_level", "grav_long_range", "grav_mm", "grav_down", + "cooling", "sourceterms", "count"] + +SUBTYPES = ["none", "density", "gradient", "force", "grav", "external_grav", + "tend", "xv", "rho", "gpart", "multipole", "spart", "count"] + +# Read input. +data = pl.loadtxt( infile ) + +# Get the CPU clock to convert ticks into milliseconds. +full_step = data[0,:] +CPU_CLOCK = float(full_step[-1]) / 1000.0 +if args.verbose: + print "# CPU frequency:", CPU_CLOCK * 1000.0 + +nranks = int(max(data[:,0])) + 1 +print "# Number of ranks:", nranks +maxthread = int(max(data[:,1])) + 1 +print "# Maximum thread id:", maxthread + +# Avoid start and end times of zero. +sdata = data[data[:,5] != 0] +sdata = data[data[:,6] != 0] + +# Now we process all the ranks. +for rank in range(nranks): + print "# Rank", rank + data = sdata[sdata[:,0] == rank] + + # Recover the start and end time + full_step = data[0,:] + tic_step = int(full_step[5]) + toc_step = int(full_step[6]) + data = data[1:,:] + + # Avoid start and end times of zero. + data = data[data[:,5] != 0] + data = data[data[:,6] != 0] + + # Calculate the time range. + total_t = (toc_step - tic_step)/ CPU_CLOCK + print "# Data range: ", total_t, "ms" + + # Correct times to relative values. + start_t = float(tic_step) + data[:,5] -= start_t + data[:,6] -= start_t + end_t = (toc_step - start_t) / CPU_CLOCK + + tasks = {} + tasks[-1] = [] + for i in range(maxthread): + tasks[i] = [] + + # Gather into by thread data. + num_lines = pl.size(data) / 12 + for line in range(num_lines): + thread = int(data[line,1]) + tic = int(data[line,5]) / CPU_CLOCK + toc = int(data[line,6]) / CPU_CLOCK + tasktype = int(data[line,2]) + subtype = int(data[line,3]) + + tasks[thread].append([tic,toc,tasktype,subtype]) + + # Sort by tic and gather used threads. + threadids = [] + for i in range(maxthread): + tasks[i] = sorted(tasks[i], key=lambda task: task[0]) + threadids.append(i) + + # Times per task. + print "# Task times:" + print "# {0:<16s}: {1:>7s} {2:>9s} {3:>9s} {4:>9s} {5:>9s} {6:>9s}"\ + .format("type/subtype", "count","minimum", "maximum", + "sum", "mean", "percent") + alltasktimes = {} + for i in threadids: + tasktimes = {} + for task in tasks[i]: + key = TASKTYPES[task[2]] + "/" + SUBTYPES[task[3]] + dt = task[1] - task[0] + if not key in tasktimes: + tasktimes[key] = [] + tasktimes[key].append(dt) + + if not key in alltasktimes: + alltasktimes[key] = [] + alltasktimes[key].append(dt) + + print "# Thread : ", i + for key in sorted(tasktimes.keys()): + taskmin = min(tasktimes[key]) + taskmax = max(tasktimes[key]) + tasksum = sum(tasktimes[key]) + print "{0:18s}: {1:7d} {2:9.4f} {3:9.4f} {4:9.4f} {5:9.4f} {6:9.2f}"\ + .format(key, len(tasktimes[key]), taskmin, taskmax, tasksum, + tasksum / len(tasktimes[key]), tasksum / total_t * 100.0) + print + + print "# All threads : " + for key in sorted(alltasktimes.keys()): + taskmin = min(alltasktimes[key]) + taskmax = max(alltasktimes[key]) + tasksum = sum(alltasktimes[key]) + print "{0:18s}: {1:7d} {2:9.4f} {3:9.4f} {4:9.4f} {5:9.4f} {6:9.2f}"\ + .format(key, len(alltasktimes[key]), taskmin, taskmax, tasksum, + tasksum / len(alltasktimes[key]), + tasksum / (len(threadids) * total_t) * 100.0) + print + + # Dead times. + print "# Deadtimes:" + print "# no. : {0:>9s} {1:>9s} {2:>9s} {3:>9s} {4:>9s} {5:>9s}"\ + .format("count", "minimum", "maximum", "sum", "mean", "percent") + alldeadtimes = [] + for i in threadids: + deadtimes = [] + last = 0 + for task in tasks[i]: + dt = task[0] - last + deadtimes.append(dt) + last = task[1] + dt = total_t - last + deadtimes.append(dt) + + deadmin = min(deadtimes) + deadmax = max(deadtimes) + deadsum = sum(deadtimes) + print "thread {0:2d}: {1:9d} {2:9.4f} {3:9.4f} {4:9.4f} {5:9.4f} {6:9.2f}"\ + .format(i, len(deadtimes), deadmin, deadmax, deadsum, + deadsum / len(deadtimes), deadsum / total_t * 100.0) + alldeadtimes.extend(deadtimes) + + deadmin = min(alldeadtimes) + deadmax = max(alldeadtimes) + deadsum = sum(alldeadtimes) + print "all : {0:9d} {1:9.4f} {2:9.4f} {3:9.4f} {4:9.4f} {5:9.2f}"\ + .format(len(alldeadtimes), deadmin, deadmax, deadsum, + deadsum / len(alldeadtimes), + deadsum / (len(threadids) * total_t ) * 100.0) + print + + +sys.exit(0) diff --git a/examples/parameter_example.yml b/examples/parameter_example.yml index 14bc60bc1e1c05ecdc66fb7ac828102b1d5748bf..8006c1a325845d6e9fec655b809310a63daa9ddb 100644 --- a/examples/parameter_example.yml +++ b/examples/parameter_example.yml @@ -107,6 +107,12 @@ DiscPatchPotential: timestep_mult: 0.03 # Dimensionless pre-factor for the time-step condition growth_time: 5. # (Optional) Time for the disc to grow to its final size (multiple of the dynamical time) +# Sine Wave potential +SineWavePotential: + amplitude: 10. # Amplitude of the sine wave (internal units) + timestep_limit: 1. # Time-step dimensionless pre-factor. + growth_time: 0. # (Optional) Time for the potential to grow to its final size. + # Parameters related to cooling function ---------------------------------------------- # Constant du/dt cooling function diff --git a/examples/plot_tasks.py b/examples/plot_tasks.py index 75ac2db65cac748606c143b3c691a167b314a926..88f176687db8116cfd4370970769164985e4d366 100755 --- a/examples/plot_tasks.py +++ b/examples/plot_tasks.py @@ -89,9 +89,10 @@ pl.rcParams.update(PLOT_PARAMS) # Tasks and subtypes. Indexed as in tasks.h. TASKTYPES = ["none", "sort", "self", "pair", "sub_self", "sub_pair", - "init_grav", "ghost", "extra_ghost", "drift", "kick1", "kick2", - "timestep", "send", "recv", "grav_top_level", "grav_long_range", - "grav_mm", "grav_down", "cooling", "sourceterms", "count"] + "init_grav", "ghost", "extra_ghost", "drift_part", + "drift_gpart", "kick1", "kick2", "timestep", "send", "recv", + "grav_top_level", "grav_long_range", "grav_mm", "grav_down", + "cooling", "sourceterms", "count"] SUBTYPES = ["none", "density", "gradient", "force", "grav", "external_grav", "tend", "xv", "rho", "gpart", "multipole", "spart", "count"] @@ -105,14 +106,14 @@ FULLTYPES = ["self/force", "self/density", "self/grav", "sub_self/force", # A number of colours for the various types. Recycled when there are # more task types than colours... - colours = ["cyan", "lightgray", "darkblue", "yellow", "tan", "dodgerblue", - "sienna", "aquamarine", "bisque", "blue", "green", "brown", - "purple", "mocassin", "olivedrab", "chartreuse", "darksage", - "darkgreen", "green", "mediumseagreen", "mediumaquamarine", - "darkslategrey", "mediumturquoise", "black", "cadetblue", "skyblue", - "red", "slategray", "gold", "slateblue", "blueviolet", - "mediumorchid", "firebrick", "magenta", "hotpink", "pink"] + "sienna", "aquamarine", "bisque", "blue", "green", "lightgreen", + "brown", "purple", "moccasin", "olivedrab", "chartreuse", + "darksage", "darkgreen", "green", "mediumseagreen", + "mediumaquamarine", "darkslategrey", "mediumturquoise", + "black", "cadetblue", "skyblue", "red", "slategray", "gold", + "slateblue", "blueviolet", "mediumorchid", "firebrick", + "magenta", "hotpink", "pink", "orange", "lightgreen"] maxcolours = len(colours) # Set colours of task/subtype. @@ -134,9 +135,9 @@ for task in SUBTYPES: # For fiddling with colours... if args.verbose: print "#Selected colours:" - for task in TASKCOLOURS.keys(): + for task in sorted(TASKCOLOURS.keys()): print "# " + task + ": " + TASKCOLOURS[task] - for task in SUBCOLOURS.keys(): + for task in sorted(SUBCOLOURS.keys()): print "# " + task + ": " + SUBCOLOURS[task] # Read input. @@ -161,7 +162,7 @@ data = data[data[:,5] != 0] # Calculate the time range, if not given. delta_t = delta_t * CPU_CLOCK if delta_t == 0: - dt = max(data[:,5]) - min(data[:,4]) + dt = toc_step - tic_step if dt > delta_t: delta_t = dt print "Data range: ", delta_t / CPU_CLOCK, "ms" diff --git a/examples/plot_tasks_MPI.py b/examples/plot_tasks_MPI.py index a1f81bb1789c73ebe21391509c7d7674f6e43100..83465aee87e8b641775d760fa4db2f06b125dd8b 100755 --- a/examples/plot_tasks_MPI.py +++ b/examples/plot_tasks_MPI.py @@ -95,9 +95,10 @@ pl.rcParams.update(PLOT_PARAMS) # Tasks and subtypes. Indexed as in tasks.h. TASKTYPES = ["none", "sort", "self", "pair", "sub_self", "sub_pair", - "init_grav", "ghost", "extra_ghost", "drift", "kick1", "kick2", - "timestep", "send", "recv", "grav_top_level", "grav_long_range", - "grav_mm", "grav_down", "cooling", "sourceterms", "count"] + "init_grav", "ghost", "extra_ghost", "drift_part", "drift_gpart", + "kick1", "kick2", "timestep", "send", "recv", "grav_top_level", + "grav_long_range", "grav_mm", "grav_down", "cooling", + "sourceterms", "count"] SUBTYPES = ["none", "density", "gradient", "force", "grav", "external_grav", "tend", "xv", "rho", "gpart", "multipole", "spart", "count"] @@ -111,15 +112,14 @@ FULLTYPES = ["self/force", "self/density", "self/grav", "sub_self/force", # A number of colours for the various types. Recycled when there are # more task types than colours... - colours = ["cyan", "lightgray", "darkblue", "yellow", "tan", "dodgerblue", - "sienna", "aquamarine", "bisque", "blue", "green", "brown", - "purple", "mocassin", "olivedrab", "chartreuse", "darksage", - "darkgreen", "green", "mediumseagreen", "mediumaquamarine", - "darkslategrey", "mediumturquoise", "black", "cadetblue", "skyblue", - "red", "slategray", "gold", "slateblue", "blueviolet", - "mediumorchid", "firebrick", "magenta", "hotpink", "pink", - "orange", "lightgreen"] + "sienna", "aquamarine", "bisque", "blue", "green", "lightgreen", + "brown", "purple", "moccasin", "olivedrab", "chartreuse", + "darksage", "darkgreen", "green", "mediumseagreen", + "mediumaquamarine", "darkslategrey", "mediumturquoise", + "black", "cadetblue", "skyblue", "red", "slategray", "gold", + "slateblue", "blueviolet", "mediumorchid", "firebrick", + "magenta", "hotpink", "pink", "orange", "lightgreen"] maxcolours = len(colours) # Set colours of task/subtype. @@ -141,9 +141,9 @@ for task in SUBTYPES: # For fiddling with colours... if args.verbose: print "#Selected colours:" - for task in TASKCOLOURS.keys(): + for task in sorted(TASKCOLOURS.keys()): print "# " + task + ": " + TASKCOLOURS[task] - for task in SUBCOLOURS.keys(): + for task in sorted(SUBCOLOURS.keys()): print "# " + task + ": " + SUBCOLOURS[task] # Read input. @@ -171,12 +171,14 @@ delta_t = delta_t * CPU_CLOCK if delta_t == 0: for rank in range(nranks): data = sdata[sdata[:,0] == rank] - dt = max(data[:,6]) - min(data[:,5]) + full_step = data[0,:] + tic_step = int(full_step[5]) + toc_step = int(full_step[6]) + dt = toc_step - tic_step if dt > delta_t: delta_t = dt print "Data range: ", delta_t / CPU_CLOCK, "ms" - # Once more doing the real gather and plots this time. for rank in range(nranks): data = sdata[sdata[:,0] == rank] @@ -186,6 +188,8 @@ for rank in range(nranks): tic_step = int(full_step[5]) toc_step = int(full_step[6]) data = data[1:,:] + typesseen = [] + nethread = 0 # Dummy image for ranks that have no tasks. if data.size == 0: diff --git a/examples/process_plot_tasks b/examples/process_plot_tasks index c33531269617e81d4e8f18f1528b43492b08cf26..b46fce03d8c5f21046a0e4a95a304e006c7b2293 100755 --- a/examples/process_plot_tasks +++ b/examples/process_plot_tasks @@ -57,6 +57,7 @@ done # And process them, echo "Processing thread info files..." echo $list | xargs -P $NPROCS -n 3 /bin/bash -c "./plot_tasks.py --expand 1 --limit $TIMERANGE --width 16 --height 4 \$0 \$2 " +echo $list | xargs -P $NPROCS -n 3 /bin/bash -c "./analyse_tasks.py \$0 > \$2.stats" echo "Writing output index.html file" # Construct document - serial. @@ -75,8 +76,21 @@ echo $list | xargs -n 3 | while read f s g; do <h2>Step $s</h2> EOF cat <<EOF >> index.html -<a href="step${s}r${i}.png"><img src="step${s}r${i}.png" width=400px/></a> +<a href="step${s}r${i}.html"><img src="step${s}r${i}.png" width=400px/></a> EOF + cat <<EOF > step${s}r${i}.html + <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> +<html> +<body> +<img src="step${s}r${i}.png"> +<pre> +EOF +cat step${s}r${i}.stats >> step${s}r${i}.html +cat <<EOF >> step${s}r${i}.html +</body> +</html> +EOF + done cat <<EOF >> index.html diff --git a/examples/process_plot_tasks_MPI b/examples/process_plot_tasks_MPI index 268a5393dc94f8b05cb4ff0a71c45b3b8e554c84..b2672b3711823eb87d0bede5b1ffd8945a735f98 100755 --- a/examples/process_plot_tasks_MPI +++ b/examples/process_plot_tasks_MPI @@ -62,6 +62,7 @@ nrank=$(($nrank-1)) # And process them, echo "Processing thread info files..." echo $list | xargs -P $NPROCS -n 3 /bin/bash -c "./plot_tasks_MPI.py --expand 1 --limit $TIMERANGE \$0 \$2 " +echo $list | xargs -P $NPROCS -n 3 /bin/bash -c "./analyse_tasks_MPI.py \$0 > \$2.stats" echo "Writing output index.html file" # Construct document - serial. @@ -78,12 +79,31 @@ EOF echo $list | xargs -n 3 | while read f s g; do cat <<EOF >> index.html <h2>Step $s</h2> +<ul style="list-style-type:none"> +<li> EOF for i in $(seq 0 $nrank); do - cat <<EOF >> index.html -<a href="step${s}r${i}.png"><img src="step${s}r${i}.png" width=400px/></a> -EOF + cat <<EOF2 >> index.html +<a href="step${s}r${i}.html"><img src="step${s}r${i}.png" width=400px/></a> +EOF2 + cat <<EOF2 > step${s}r${i}.html + <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> +<html> +<body> +<img src="step${s}r${i}.png"> +<pre> +EOF2 +cat step${s}r.stats >> step${s}r${i}.html +cat <<EOF2 >> step${s}r${i}.html +</pre> +</body> +</html> +EOF2 done +cat <<EOF >> index.html +</li> +</ul> +EOF done cat <<EOF >> index.html diff --git a/src/Makefile.am b/src/Makefile.am index 809f5c34642392d001f1987c1c8926b8b97eae1e..2ddcdb0908201c65053d7cc5380a4217277b5c13 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -86,6 +86,8 @@ nobase_noinst_HEADERS = align.h approx_math.h atomic.h cycle.h error.h inline.h hydro/Gizmo/hydro_slope_limiters_cell.h \ hydro/Gizmo/hydro_slope_limiters_face.h \ hydro/Gizmo/hydro_slope_limiters.h \ + hydro/Gizmo/hydro_unphysical.h \ + hydro/Gizmo/hydro_velocities.h \ hydro/Shadowswift/hydro_debug.h \ hydro/Shadowswift/hydro_gradients.h hydro/Shadowswift/hydro.h \ hydro/Shadowswift/hydro_iact.h \ diff --git a/src/cell.c b/src/cell.c index 657cd85cea63635c532bd05e4425600e2f7fefb5..dbccfd2f42cabf38417cd87de0450489240884be 100644 --- a/src/cell.c +++ b/src/cell.c @@ -1385,6 +1385,9 @@ int cell_unskip_tasks(struct cell *c, struct scheduler *s) { scheduler_activate(s, ci->recv_xv); if (cell_is_active(ci, e)) { scheduler_activate(s, ci->recv_rho); +#ifdef EXTRA_HYDRO_LOOP + scheduler_activate(s, ci->recv_gradient); +#endif scheduler_activate(s, ci->recv_ti); } @@ -1404,12 +1407,21 @@ int cell_unskip_tasks(struct cell *c, struct scheduler *s) { if (t->type == task_type_pair) scheduler_activate(s, cj->drift_part); if (cell_is_active(cj, e)) { + for (l = cj->send_rho; l != NULL && l->t->cj->nodeID != ci->nodeID; l = l->next) ; if (l == NULL) error("Missing link to send_rho task."); scheduler_activate(s, l->t); +#ifdef EXTRA_HYDRO_LOOP + for (l = cj->send_gradient; + l != NULL && l->t->cj->nodeID != ci->nodeID; l = l->next) + ; + if (l == NULL) error("Missing link to send_gradient task."); + scheduler_activate(s, l->t); +#endif + for (l = cj->send_ti; l != NULL && l->t->cj->nodeID != ci->nodeID; l = l->next) ; @@ -1423,6 +1435,9 @@ int cell_unskip_tasks(struct cell *c, struct scheduler *s) { scheduler_activate(s, cj->recv_xv); if (cell_is_active(cj, e)) { scheduler_activate(s, cj->recv_rho); +#ifdef EXTRA_HYDRO_LOOP + scheduler_activate(s, cj->recv_gradient); +#endif scheduler_activate(s, cj->recv_ti); } @@ -1442,12 +1457,21 @@ int cell_unskip_tasks(struct cell *c, struct scheduler *s) { if (t->type == task_type_pair) scheduler_activate(s, ci->drift_part); if (cell_is_active(ci, e)) { + for (l = ci->send_rho; l != NULL && l->t->cj->nodeID != cj->nodeID; l = l->next) ; if (l == NULL) error("Missing link to send_rho task."); scheduler_activate(s, l->t); +#ifdef EXTRA_HYDRO_LOOP + for (l = ci->send_gradient; + l != NULL && l->t->cj->nodeID != cj->nodeID; l = l->next) + ; + if (l == NULL) error("Missing link to send_gradient task."); + scheduler_activate(s, l->t); +#endif + for (l = ci->send_ti; l != NULL && l->t->cj->nodeID != cj->nodeID; l = l->next) ; diff --git a/src/const.h b/src/const.h index 6962ee8bca32e92664e3f20cdb23e7cb6fbc4abd..141eb48acc633542aa98655caa8debdd2dbce530 100644 --- a/src/const.h +++ b/src/const.h @@ -52,8 +52,43 @@ /* Options to control the movement of particles for GIZMO_SPH. */ /* This option disables particle movement */ //#define GIZMO_FIX_PARTICLES +/* Try to keep cells regular by adding a correction velocity. */ +#define GIZMO_STEER_MOTION //#define GIZMO_TOTAL_ENERGY +/* Options to control handling of unphysical values (GIZMO_SPH only). */ +/* In GIZMO, mass and energy (and hence density and pressure) can in principle + become negative, which will cause unwanted behaviour that can make the code + crash. + If no options are selected below, we assume (and pray) that this will not + happen, and add no restrictions to how these variables are treated. */ +/* Check for unphysical values and crash if they occur. */ +//#define GIZMO_UNPHYSICAL_ERROR +/* Check for unphysical values and reset them to safe values. */ +#define GIZMO_UNPHYSICAL_RESCUE +/* Show a warning message if an unphysical value was reset (only works if + GIZMO_UNPHYSICAL_RESCUE is also selected). */ +//#define GIZMO_UNPHYSICAL_WARNING + +/* Parameters that control how GIZMO handles pathological particle + configurations. */ +/* Show a warning message if a pathological configuration has been detected. */ +//#define GIZMO_PATHOLOGICAL_WARNING +/* Crash if a pathological configuration has been detected. */ +//#define GIZMO_PATHOLOGICAL_ERROR +/* Maximum allowed gradient matrix condition number. If the condition number of + the gradient matrix (defined in equation C1 in Hopkins, 2015) is larger than + this value, we artificially increase the number of neighbours to get a more + homogeneous sampling. */ +#define const_gizmo_max_condition_number 100.0f +/* Correction factor applied to the particle wcount to force more neighbours if + the condition number is too large. */ +#define const_gizmo_w_correction_factor 0.9f +/* Lower limit on the wcount correction factor. If the condition number is still + too high after this wcount correction has been applied, we give up on the + gradient matrix and use SPH gradients instead. */ +#define const_gizmo_min_wcorr 0.5f + /* Types of gradients to use for SHADOWFAX_SPH */ /* If no option is chosen, no gradients are used (first order scheme) */ #define SHADOWFAX_GRADIENTS diff --git a/src/drift.h b/src/drift.h index d9b79f7f0549d85b6f05e8ce4a394aaa5b2a4d8d..e86d290cb796153d3c3fc43c21b25d2c7e435657 100644 --- a/src/drift.h +++ b/src/drift.h @@ -39,7 +39,7 @@ * @param ti_current Integer end of time-step */ __attribute__((always_inline)) INLINE static void drift_gpart( - struct gpart *restrict gp, float dt, double timeBase, integertime_t ti_old, + struct gpart *restrict gp, double dt, double timeBase, integertime_t ti_old, integertime_t ti_current) { #ifdef SWIFT_DEBUG_CHECKS @@ -75,7 +75,7 @@ __attribute__((always_inline)) INLINE static void drift_gpart( * @param ti_current Integer end of time-step */ __attribute__((always_inline)) INLINE static void drift_part( - struct part *restrict p, struct xpart *restrict xp, float dt, + struct part *restrict p, struct xpart *restrict xp, double dt, double timeBase, integertime_t ti_old, integertime_t ti_current) { #ifdef SWIFT_DEBUG_CHECKS @@ -119,7 +119,7 @@ __attribute__((always_inline)) INLINE static void drift_part( * @param ti_current Integer end of time-step */ __attribute__((always_inline)) INLINE static void drift_spart( - struct spart *restrict sp, float dt, double timeBase, integertime_t ti_old, + struct spart *restrict sp, double dt, double timeBase, integertime_t ti_old, integertime_t ti_current) { #ifdef SWIFT_DEBUG_CHECKS diff --git a/src/engine.c b/src/engine.c index ddf317a7d67ef96962f8212b0c1aab6767a5f148..926c7bb1d8eee3ba4e70551ed1a0b04611385887 100644 --- a/src/engine.c +++ b/src/engine.c @@ -1876,6 +1876,14 @@ void engine_count_and_link_tasks(struct engine *e) { if (finger != NULL) scheduler_addunlock(sched, t, finger->drift_part); } + /* Link drift tasks to the next-higher drift task. */ + else if (t->type == task_type_drift_gpart) { + struct cell *finger = ci->parent; + while (finger != NULL && finger->drift_gpart == NULL) + finger = finger->parent; + if (finger != NULL) scheduler_addunlock(sched, t, finger->drift_gpart); + } + /* Link self tasks to cells. */ else if (t->type == task_type_self) { atomic_inc(&ci->nr_tasks); @@ -2580,6 +2588,9 @@ void engine_marktasks_mapper(void *map_data, int num_elements, scheduler_activate(s, ci->recv_xv); if (cell_is_active(ci, e)) { scheduler_activate(s, ci->recv_rho); +#ifdef EXTRA_HYDRO_LOOP + scheduler_activate(s, ci->recv_gradient); +#endif scheduler_activate(s, ci->recv_ti); } @@ -2599,12 +2610,21 @@ void engine_marktasks_mapper(void *map_data, int num_elements, if (t->type == task_type_pair) scheduler_activate(s, cj->drift_part); if (cell_is_active(cj, e)) { + for (l = cj->send_rho; l != NULL && l->t->cj->nodeID != ci->nodeID; l = l->next) ; if (l == NULL) error("Missing link to send_rho task."); scheduler_activate(s, l->t); +#ifdef EXTRA_HYDRO_LOOP + for (l = cj->send_gradient; + l != NULL && l->t->cj->nodeID != ci->nodeID; l = l->next) + ; + if (l == NULL) error("Missing link to send_gradient task."); + scheduler_activate(s, l->t); +#endif + for (l = cj->send_ti; l != NULL && l->t->cj->nodeID != ci->nodeID; l = l->next) ; @@ -2618,6 +2638,9 @@ void engine_marktasks_mapper(void *map_data, int num_elements, scheduler_activate(s, cj->recv_xv); if (cell_is_active(cj, e)) { scheduler_activate(s, cj->recv_rho); +#ifdef EXTRA_HYDRO_LOOP + scheduler_activate(s, cj->recv_gradient); +#endif scheduler_activate(s, cj->recv_ti); } @@ -2643,6 +2666,14 @@ void engine_marktasks_mapper(void *map_data, int num_elements, if (l == NULL) error("Missing link to send_rho task."); scheduler_activate(s, l->t); +#ifdef EXTRA_HYDRO_LOOP + for (l = ci->send_gradient; + l != NULL && l->t->cj->nodeID != cj->nodeID; l = l->next) + ; + if (l == NULL) error("Missing link to send_gradient task."); + scheduler_activate(s, l->t); +#endif + for (l = ci->send_ti; l != NULL && l->t->cj->nodeID != cj->nodeID; l = l->next) ; @@ -3059,7 +3090,7 @@ void engine_print_stats(struct engine *e) { e->policy & engine_policy_self_gravity); /* Be verbose about this */ - message("Saving statistics at t=%e.", e->time); + if (e->nodeID == 0) message("Saving statistics at t=%e.", e->time); #else if (e->verbose) message("Saving statistics at t=%e.", e->time); #endif @@ -3539,10 +3570,15 @@ void engine_drift_all(struct engine *e) { threadpool_map(&e->threadpool, engine_do_drift_all_mapper, e->s->cells_top, e->s->nr_cells, sizeof(struct cell), 1, e); + /* Synchronize particle positions */ + space_synchronize_particle_positions(e->s); + #ifdef SWIFT_DEBUG_CHECKS /* Check that all cells have been drifted to the current time. */ space_check_drift_point(e->s, e->ti_current, e->policy & engine_policy_self_gravity); + part_verify_links(e->s->parts, e->s->gparts, e->s->sparts, e->s->nr_parts, + e->s->nr_gparts, e->s->nr_sparts, e->verbose); #endif if (e->verbose) @@ -3841,7 +3877,7 @@ void engine_dump_snapshot(struct engine *e) { e->policy & engine_policy_self_gravity); /* Be verbose about this */ - message("writing snapshot at t=%e.", e->time); + if (e->nodeID == 0) message("writing snapshot at t=%e.", e->time); #else if (e->verbose) message("writing snapshot at t=%e.", e->time); #endif diff --git a/src/hydro/Gadget2/hydro.h b/src/hydro/Gadget2/hydro.h index 747c81a8e64c18a06b04160cfab326a3521c5901..91626749a89ede387547b6351dce59fa3569307a 100644 --- a/src/hydro/Gadget2/hydro.h +++ b/src/hydro/Gadget2/hydro.h @@ -293,7 +293,7 @@ __attribute__((always_inline)) INLINE static void hydro_reset_acceleration( p->force.h_dt = 0.0f; /* Reset maximal signal velocity */ - p->force.v_sig = 0.0f; + p->force.v_sig = p->force.soundspeed; } /** diff --git a/src/hydro/Gizmo/hydro.h b/src/hydro/Gizmo/hydro.h index 2e340a03b99ae51bc49a2e57456f4d6838d62f21..6d39c54d2ddc3571ac34c54fc9eede6f7dee6ac5 100644 --- a/src/hydro/Gizmo/hydro.h +++ b/src/hydro/Gizmo/hydro.h @@ -2,6 +2,7 @@ /******************************************************************************* * This file is part of SWIFT. * Coypright (c) 2015 Matthieu Schaller (matthieu.schaller@durham.ac.uk) + * 2016, 2017 Bert Vandenbroucke (bert.vandenbroucke@gmail.com) * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published @@ -24,9 +25,13 @@ #include "equation_of_state.h" #include "hydro_gradients.h" #include "hydro_space.h" +#include "hydro_unphysical.h" +#include "hydro_velocities.h" #include "minmax.h" #include "riemann.h" +//#define GIZMO_LLOYD_ITERATION + /** * @brief Computes the hydro time-step of a given particle * @@ -40,6 +45,10 @@ __attribute__((always_inline)) INLINE static float hydro_compute_timestep( const float CFL_condition = hydro_properties->CFL_condition; +#ifdef GIZMO_LLOYD_ITERATION + return CFL_condition; +#endif + if (p->timestepvars.vmax == 0.) { /* vmax can be zero in vacuum cells that only have vacuum neighbours */ /* in this case, the time step should be limited by the maximally @@ -47,7 +56,9 @@ __attribute__((always_inline)) INLINE static float hydro_compute_timestep( the time step to a very large value */ return FLT_MAX; } else { - return CFL_condition * p->h / fabsf(p->timestepvars.vmax); + const float psize = powf(p->geometry.volume / hydro_dimension_unit_sphere, + hydro_dimension_inv); + return 2. * CFL_condition * psize / fabsf(p->timestepvars.vmax); } } @@ -128,16 +139,27 @@ __attribute__((always_inline)) INLINE static void hydro_first_init_part( p->conserved.momentum[2] * p->primitives.v[2]); #endif -#if defined(GIZMO_FIX_PARTICLES) - /* make sure the particles are initially at rest */ +#ifdef GIZMO_LLOYD_ITERATION + /* overwrite all variables to make sure they have safe values */ + p->primitives.rho = 1.; + p->primitives.v[0] = 0.; + p->primitives.v[1] = 0.; + p->primitives.v[2] = 0.; + p->primitives.P = 1.; + + p->conserved.mass = 1.; + p->conserved.momentum[0] = 0.; + p->conserved.momentum[1] = 0.; + p->conserved.momentum[2] = 0.; + p->conserved.energy = 1.; + p->v[0] = 0.; p->v[1] = 0.; p->v[2] = 0.; #endif - xp->v_full[0] = p->v[0]; - xp->v_full[1] = p->v[1]; - xp->v_full[2] = p->v[2]; + /* initialize the particle velocity based on the primitive fluid velocity */ + hydro_velocities_init(p, xp); /* we cannot initialize wcorr in init_part, as init_part gets called every time the density loop is repeated, and the whole point of storing wcorr @@ -169,6 +191,9 @@ __attribute__((always_inline)) INLINE static void hydro_init_part( p->geometry.matrix_E[2][0] = 0.0f; p->geometry.matrix_E[2][1] = 0.0f; p->geometry.matrix_E[2][2] = 0.0f; + p->geometry.centroid[0] = 0.0f; + p->geometry.centroid[1] = 0.0f; + p->geometry.centroid[2] = 0.0f; p->geometry.Atot = 0.0f; /* Set the active flag to active. */ @@ -226,6 +251,14 @@ __attribute__((always_inline)) INLINE static void hydro_end_density( p->geometry.matrix_E[2][1] = ihdim * p->geometry.matrix_E[2][1]; p->geometry.matrix_E[2][2] = ihdim * p->geometry.matrix_E[2][2]; + p->geometry.centroid[0] *= kernel_norm; + p->geometry.centroid[1] *= kernel_norm; + p->geometry.centroid[2] *= kernel_norm; + + p->geometry.centroid[0] /= p->density.wcount; + p->geometry.centroid[1] /= p->density.wcount; + p->geometry.centroid[2] /= p->density.wcount; + /* Check the condition number to see if we have a stable geometry. */ float condition_number_E = 0.0f; int i, j; @@ -249,12 +282,18 @@ __attribute__((always_inline)) INLINE static void hydro_end_density( float condition_number = hydro_dimension_inv * sqrtf(condition_number_E * condition_number_Einv); - if (condition_number > 100.0f) { - // error("Condition number larger than 100!"); - // message("Condition number too large: %g (p->id: %llu)!", - // condition_number, p->id); + if (condition_number > const_gizmo_max_condition_number && + p->density.wcorr > const_gizmo_min_wcorr) { +#ifdef GIZMO_PATHOLOGICAL_ERROR + error("Condition number larger than %g (%g)!", + const_gizmo_max_condition_number, condition_number); +#endif +#ifdef GIZMO_PATHOLOGICAL_WARNING + message("Condition number too large: %g (> %g, p->id: %llu)!", + condition_number, const_gizmo_max_condition_number, p->id); +#endif /* add a correction to the number of neighbours for this particle */ - p->density.wcorr *= 0.75; + p->density.wcorr *= const_gizmo_w_correction_factor; } hydro_gradients_init(p); @@ -264,8 +303,8 @@ __attribute__((always_inline)) INLINE static void hydro_end_density( const float m = p->conserved.mass; #ifdef SWIFT_DEBUG_CHECKS - if (m == 0.) { - error("Mass is 0!"); + if (m < 0.) { + error("Mass is negative!"); } if (volume == 0.) { @@ -278,15 +317,20 @@ __attribute__((always_inline)) INLINE static void hydro_end_density( momentum[1] = p->conserved.momentum[1]; momentum[2] = p->conserved.momentum[2]; p->primitives.rho = m / volume; - p->primitives.v[0] = momentum[0] / m; - p->primitives.v[1] = momentum[1] / m; - p->primitives.v[2] = momentum[2] / m; + if (m == 0.) { + p->primitives.v[0] = 0.; + p->primitives.v[1] = 0.; + p->primitives.v[2] = 0.; + } else { + p->primitives.v[0] = momentum[0] / m; + p->primitives.v[1] = momentum[1] / m; + p->primitives.v[2] = momentum[2] / m; + } #ifdef EOS_ISOTHERMAL_GAS /* although the pressure is not formally used anywhere if an isothermal eos has been selected, we still make sure it is set to the correct value */ - p->primitives.P = const_isothermal_soundspeed * const_isothermal_soundspeed * - p->primitives.rho; + p->primitives.P = gas_pressure_from_internal_energy(p->primitives.rho, 0.); #else float energy = p->conserved.energy; @@ -304,12 +348,17 @@ __attribute__((always_inline)) INLINE static void hydro_end_density( #endif /* sanity checks */ - /* it would probably be safer to throw a warning if netive densities or - pressures occur */ - if (p->primitives.rho < 0.0f || p->primitives.P < 0.0f) { - p->primitives.rho = 0.0f; - p->primitives.P = 0.0f; - } + gizmo_check_physical_quantity("density", p->primitives.rho); + gizmo_check_physical_quantity("pressure", p->primitives.P); + +#ifdef GIZMO_LLOYD_ITERATION + /* overwrite primitive variables to make sure they still have safe values */ + p->primitives.rho = 1.; + p->primitives.v[0] = 0.; + p->primitives.v[1] = 0.; + p->primitives.v[2] = 0.; + p->primitives.P = 1.; +#endif /* Add a correction factor to wcount (to force a neighbour number increase if the geometry matrix is close to singular) */ @@ -330,8 +379,6 @@ __attribute__((always_inline)) INLINE static void hydro_end_density( * * @param p The particle to act upon. * @param xp The extended particle data to act upon. - * @param ti_current Current integer time. - * @param timeBase Conversion factor between integer time and physical time. */ __attribute__((always_inline)) INLINE static void hydro_prepare_force( struct part* restrict p, struct xpart* restrict xp) { @@ -340,10 +387,7 @@ __attribute__((always_inline)) INLINE static void hydro_prepare_force( p->timestepvars.vmax = 0.0f; /* Set the actual velocity of the particle */ - /* if GIZMO_FIX_PARTICLES has been selected, v_full will always be zero */ - p->force.v_full[0] = xp->v_full[0]; - p->force.v_full[1] = xp->v_full[1]; - p->force.v_full[2] = xp->v_full[2]; + hydro_velocities_prepare_force(p, xp); } /** @@ -364,6 +408,11 @@ __attribute__((always_inline)) INLINE static void hydro_end_gradient( p->gravity.mflux[0] = 0.0f; p->gravity.mflux[1] = 0.0f; p->gravity.mflux[2] = 0.0f; + +#ifdef GIZMO_LLOYD_ITERATION + /* reset the gradients to zero, as we don't want them */ + hydro_gradients_init(p); +#endif } /** @@ -422,6 +471,10 @@ __attribute__((always_inline)) INLINE static void hydro_convert_quantities( __attribute__((always_inline)) INLINE static void hydro_predict_extra( struct part* p, struct xpart* xp, float dt) { +#ifdef GIZMO_LLOYD_ITERATION + return; +#endif + const float h_inv = 1.0f / p->h; /* Predict smoothing length */ @@ -432,8 +485,9 @@ __attribute__((always_inline)) INLINE static void hydro_predict_extra( else h_corr = expf(w1); - /* Limit the smoothing length correction. */ - if (h_corr < 2.0f) { + /* Limit the smoothing length correction (and make sure it is always + positive). */ + if (h_corr < 2.0f && h_corr > 0.) { p->h *= h_corr; } @@ -483,22 +537,13 @@ __attribute__((always_inline)) INLINE static void hydro_end_force( /* set the variables that are used to drift the primitive variables */ - /* Add normalization to h_dt. */ - p->force.h_dt *= p->h * hydro_dimension_inv; - - if (p->force.dt) { + if (p->force.dt > 0.) { p->du_dt = p->conserved.flux.energy / p->force.dt; } else { p->du_dt = 0.0f; } -#if defined(GIZMO_FIX_PARTICLES) - p->du_dt = 0.0f; - - /* disable the smoothing length update, since the smoothing lengths should - stay the same for all steps (particles don't move) */ - p->force.h_dt = 0.0f; -#endif + hydro_velocities_end_force(p); } /** @@ -527,7 +572,12 @@ __attribute__((always_inline)) INLINE static void hydro_kick_extra( p->conserved.energy += p->conserved.flux.energy; #endif + gizmo_check_physical_quantity("mass", p->conserved.mass); + gizmo_check_physical_quantity("energy", p->conserved.energy); + #ifdef SWIFT_DEBUG_CHECKS + /* Note that this check will only have effect if no GIZMO_UNPHYSICAL option + was selected. */ if (p->conserved.mass < 0.) { error( "Negative mass after conserved variables update (mass: %g, dmass: %g)!", @@ -535,7 +585,10 @@ __attribute__((always_inline)) INLINE static void hydro_kick_extra( } if (p->conserved.energy < 0.) { - error("Negative energy after conserved variables update!"); + error( + "Negative energy after conserved variables update (energy: %g, " + "denergy: %g)!", + p->conserved.energy, p->conserved.flux.energy); } #endif @@ -549,7 +602,7 @@ __attribute__((always_inline)) INLINE static void hydro_kick_extra( a_grav[2] = p->gpart->a_grav[2]; /* Store the gravitational acceleration for later use. */ - /* This is currently only used for output purposes. */ + /* This is used for the prediction step. */ p->gravity.old_a[0] = a_grav[0]; p->gravity.old_a[1] = a_grav[1]; p->gravity.old_a[2] = a_grav[2]; @@ -564,7 +617,7 @@ __attribute__((always_inline)) INLINE static void hydro_kick_extra( p->conserved.momentum[1] += dt * p->conserved.mass * a_grav[1]; p->conserved.momentum[2] += dt * p->conserved.mass * a_grav[2]; -#if !defined(EOS_ISOTHERMAL_GAS) && defined(GIZMO_TOTAL_ENERGY) +#if !defined(EOS_ISOTHERMAL_GAS) /* This part still needs to be tested! */ p->conserved.energy += dt * (p->conserved.momentum[0] * a_grav[0] + p->conserved.momentum[1] * a_grav[1] + @@ -585,45 +638,25 @@ __attribute__((always_inline)) INLINE static void hydro_kick_extra( p->conserved.flux.momentum[2] = 0.0f; p->conserved.flux.energy = 0.0f; -#if defined(GIZMO_FIX_PARTICLES) - xp->v_full[0] = 0.; - xp->v_full[1] = 0.; - xp->v_full[2] = 0.; - - p->v[0] = 0.; - p->v[1] = 0.; - p->v[2] = 0.; - - if (p->gpart) { - p->gpart->v_full[0] = 0.; - p->gpart->v_full[1] = 0.; - p->gpart->v_full[2] = 0.; - } -#else - /* Set particle movement */ - if (p->conserved.mass > 0.) { - xp->v_full[0] = p->conserved.momentum[0] / p->conserved.mass; - xp->v_full[1] = p->conserved.momentum[1] / p->conserved.mass; - xp->v_full[2] = p->conserved.momentum[2] / p->conserved.mass; - } else { - /* vacuum particles don't move */ - xp->v_full[0] = 0.; - xp->v_full[1] = 0.; - xp->v_full[2] = 0.; - } + hydro_velocities_set(p, xp); + +#ifdef GIZMO_LLOYD_ITERATION + /* reset conserved variables to safe values */ + p->conserved.mass = 1.; + p->conserved.momentum[0] = 0.; + p->conserved.momentum[1] = 0.; + p->conserved.momentum[2] = 0.; + p->conserved.energy = 1.; + + /* set the particle velocities to the Lloyd velocities */ + /* note that centroid is the relative position of the centroid w.r.t. the + particle position (position - centroid) */ + xp->v_full[0] = -p->geometry.centroid[0] / p->force.dt; + xp->v_full[1] = -p->geometry.centroid[1] / p->force.dt; + xp->v_full[2] = -p->geometry.centroid[2] / p->force.dt; p->v[0] = xp->v_full[0]; p->v[1] = xp->v_full[1]; p->v[2] = xp->v_full[2]; - - /* Update gpart! */ - /* This is essential, as the gpart drift is done independently from the part - drift, and we don't want the gpart and the part to have different - positions! */ - if (p->gpart) { - p->gpart->v_full[0] = xp->v_full[0]; - p->gpart->v_full[1] = xp->v_full[1]; - p->gpart->v_full[2] = xp->v_full[2]; - } #endif /* reset wcorr */ diff --git a/src/hydro/Gizmo/hydro_gradients.h b/src/hydro/Gizmo/hydro_gradients.h index a5c1e9038d0d3de6896afe773e3193a2304a6b6b..5ad6d87619a7629a703a8b9c03d089e69ffbdf7d 100644 --- a/src/hydro/Gizmo/hydro_gradients.h +++ b/src/hydro/Gizmo/hydro_gradients.h @@ -22,6 +22,7 @@ #define SWIFT_HYDRO_GRADIENTS_H #include "hydro_slope_limiters.h" +#include "hydro_unphysical.h" #include "riemann.h" #if defined(GRADIENTS_SPH) @@ -98,6 +99,7 @@ __attribute__((always_inline)) INLINE static void hydro_gradients_predict( float xij_j[3]; int k; float xfac; + float a_grav_i[3], a_grav_j[3]; /* perform gradient reconstruction in space and time */ /* space */ @@ -139,37 +141,38 @@ __attribute__((always_inline)) INLINE static void hydro_gradients_predict( pj->primitives.gradients.P[1] * xij_j[1] + pj->primitives.gradients.P[2] * xij_j[2]; + a_grav_i[0] = pi->gravity.old_a[0]; + a_grav_i[1] = pi->gravity.old_a[1]; + a_grav_i[2] = pi->gravity.old_a[2]; + + a_grav_i[0] += pi->gravity.grad_a[0][0] * xij_i[0] + + pi->gravity.grad_a[0][1] * xij_i[1] + + pi->gravity.grad_a[0][2] * xij_i[2]; + a_grav_i[1] += pi->gravity.grad_a[1][0] * xij_i[0] + + pi->gravity.grad_a[1][1] * xij_i[1] + + pi->gravity.grad_a[1][2] * xij_i[2]; + a_grav_i[2] += pi->gravity.grad_a[2][0] * xij_i[0] + + pi->gravity.grad_a[2][1] * xij_i[1] + + pi->gravity.grad_a[2][2] * xij_i[2]; + + a_grav_j[0] = pj->gravity.old_a[0]; + a_grav_j[1] = pj->gravity.old_a[1]; + a_grav_j[2] = pj->gravity.old_a[2]; + + a_grav_j[0] += pj->gravity.grad_a[0][0] * xij_j[0] + + pj->gravity.grad_a[0][1] * xij_j[1] + + pj->gravity.grad_a[0][2] * xij_j[2]; + a_grav_j[1] += pj->gravity.grad_a[1][0] * xij_j[0] + + pj->gravity.grad_a[1][1] * xij_j[1] + + pj->gravity.grad_a[1][2] * xij_j[2]; + a_grav_j[2] += pj->gravity.grad_a[2][0] * xij_j[0] + + pj->gravity.grad_a[2][1] * xij_j[1] + + pj->gravity.grad_a[2][2] * xij_j[2]; + hydro_slope_limit_face(Wi, Wj, dWi, dWj, xij_i, xij_j, r); /* time */ if (Wi[0] > 0.0f) { -#ifdef EOS_ISOTHERMAL_GAS - dWi[0] -= 0.5 * mindt * (Wi[1] * pi->primitives.gradients.rho[0] + - Wi[2] * pi->primitives.gradients.rho[1] + - Wi[3] * pi->primitives.gradients.rho[2] + - Wi[0] * (pi->primitives.gradients.v[0][0] + - pi->primitives.gradients.v[1][1] + - pi->primitives.gradients.v[2][2])); - dWi[1] -= 0.5 * mindt * - (Wi[1] * pi->primitives.gradients.v[0][0] + - Wi[2] * pi->primitives.gradients.v[0][1] + - Wi[3] * pi->primitives.gradients.v[0][2] + - const_isothermal_soundspeed * const_isothermal_soundspeed * - pi->primitives.gradients.rho[0] / Wi[0]); - dWi[2] -= 0.5 * mindt * - (Wi[1] * pi->primitives.gradients.v[1][0] + - Wi[2] * pi->primitives.gradients.v[1][1] + - Wi[3] * pi->primitives.gradients.v[1][2] + - const_isothermal_soundspeed * const_isothermal_soundspeed * - pi->primitives.gradients.rho[1] / Wi[0]); - dWi[3] -= 0.5 * mindt * - (Wi[1] * pi->primitives.gradients.v[2][0] + - Wi[2] * pi->primitives.gradients.v[2][1] + - Wi[3] * pi->primitives.gradients.v[2][2] + - const_isothermal_soundspeed * const_isothermal_soundspeed * - pi->primitives.gradients.rho[2] / Wi[0]); -/* we don't care about P in this case */ -#else dWi[0] -= 0.5 * mindt * (Wi[1] * pi->primitives.gradients.rho[0] + Wi[2] * pi->primitives.gradients.rho[1] + Wi[3] * pi->primitives.gradients.rho[2] + @@ -195,36 +198,13 @@ __attribute__((always_inline)) INLINE static void hydro_gradients_predict( hydro_gamma * Wi[4] * (pi->primitives.gradients.v[0][0] + pi->primitives.gradients.v[1][1] + pi->primitives.gradients.v[2][2])); -#endif + + dWi[1] += 0.5 * mindt * a_grav_i[0]; + dWi[2] += 0.5 * mindt * a_grav_i[1]; + dWi[3] += 0.5 * mindt * a_grav_i[2]; } if (Wj[0] > 0.0f) { -#ifdef EOS_ISOTHERMAL_GAS - dWj[0] -= 0.5 * mindt * (Wj[1] * pj->primitives.gradients.rho[0] + - Wj[2] * pj->primitives.gradients.rho[1] + - Wj[3] * pj->primitives.gradients.rho[2] + - Wj[0] * (pj->primitives.gradients.v[0][0] + - pj->primitives.gradients.v[1][1] + - pj->primitives.gradients.v[2][2])); - dWj[1] -= 0.5 * mindt * - (Wj[1] * pj->primitives.gradients.v[0][0] + - Wj[2] * pj->primitives.gradients.v[0][1] + - Wj[3] * pj->primitives.gradients.v[0][2] + - const_isothermal_soundspeed * const_isothermal_soundspeed * - pj->primitives.gradients.rho[0] / Wj[0]); - dWj[2] -= 0.5 * mindt * - (Wj[1] * pj->primitives.gradients.v[1][0] + - Wj[2] * pj->primitives.gradients.v[1][1] + - Wj[3] * pj->primitives.gradients.v[1][2] + - const_isothermal_soundspeed * const_isothermal_soundspeed * - pj->primitives.gradients.rho[1] / Wj[0]); - dWj[3] -= 0.5 * mindt * - (Wj[1] * pj->primitives.gradients.v[2][0] + - Wj[2] * pj->primitives.gradients.v[2][1] + - Wj[3] * pj->primitives.gradients.v[2][2] + - const_isothermal_soundspeed * const_isothermal_soundspeed * - pj->primitives.gradients.rho[2] / Wj[0]); -#else dWj[0] -= 0.5 * mindt * (Wj[1] * pj->primitives.gradients.rho[0] + Wj[2] * pj->primitives.gradients.rho[1] + Wj[3] * pj->primitives.gradients.rho[2] + @@ -250,36 +230,28 @@ __attribute__((always_inline)) INLINE static void hydro_gradients_predict( hydro_gamma * Wj[4] * (pj->primitives.gradients.v[0][0] + pj->primitives.gradients.v[1][1] + pj->primitives.gradients.v[2][2])); -#endif - } - if (-dWi[0] > Wi[0]) { - Wi[0] = 0.0f; - } else { - Wi[0] += dWi[0]; + dWj[1] += 0.5 * mindt * a_grav_j[0]; + dWj[2] += 0.5 * mindt * a_grav_j[1]; + dWj[3] += 0.5 * mindt * a_grav_j[2]; } + + Wi[0] += dWi[0]; Wi[1] += dWi[1]; Wi[2] += dWi[2]; Wi[3] += dWi[3]; - if (-dWi[4] > Wi[4]) { - Wi[4] = 0.0f; - } else { - Wi[4] += dWi[4]; - } + Wi[4] += dWi[4]; - if (-dWj[0] > Wj[0]) { - Wj[0] = 0.0f; - } else { - Wj[0] += dWj[0]; - } + Wj[0] += dWj[0]; Wj[1] += dWj[1]; Wj[2] += dWj[2]; Wj[3] += dWj[3]; - if (-dWj[4] > Wj[4]) { - Wj[4] = 0.0f; - } else { - Wj[4] += dWj[4]; - } + Wj[4] += dWj[4]; + + gizmo_check_physical_quantity("density", Wi[0]); + gizmo_check_physical_quantity("pressure", Wi[4]); + gizmo_check_physical_quantity("density", Wj[0]); + gizmo_check_physical_quantity("pressure", Wj[4]); } #endif // SWIFT_HYDRO_GRADIENTS_H diff --git a/src/hydro/Gizmo/hydro_gradients_gizmo.h b/src/hydro/Gizmo/hydro_gradients_gizmo.h index aa6e4406b94e7a5cafcd0ca556162476003477de..ee3ad6919f81f042ceacc5db8b4e818d63c90266 100644 --- a/src/hydro/Gizmo/hydro_gradients_gizmo.h +++ b/src/hydro/Gizmo/hydro_gradients_gizmo.h @@ -45,6 +45,18 @@ __attribute__((always_inline)) INLINE static void hydro_gradients_init( p->primitives.gradients.P[1] = 0.0f; p->primitives.gradients.P[2] = 0.0f; + p->gravity.grad_a[0][0] = 0.0f; + p->gravity.grad_a[0][1] = 0.0f; + p->gravity.grad_a[0][2] = 0.0f; + + p->gravity.grad_a[1][0] = 0.0f; + p->gravity.grad_a[1][1] = 0.0f; + p->gravity.grad_a[1][2] = 0.0f; + + p->gravity.grad_a[2][0] = 0.0f; + p->gravity.grad_a[2][1] = 0.0f; + p->gravity.grad_a[2][2] = 0.0f; + hydro_slope_limit_cell_init(p); } @@ -93,56 +105,146 @@ __attribute__((always_inline)) INLINE static void hydro_gradients_collect( xi = r * hi_inv; kernel_deval(xi, &wi, &wi_dx); - /* Compute gradients for pi */ - /* there is a sign difference w.r.t. eqn. (6) because of the inverse - * definition of dx */ - pi->primitives.gradients.rho[0] += - (Wi[0] - Wj[0]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.rho[1] += - (Wi[0] - Wj[0]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.rho[2] += - (Wi[0] - Wj[0]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); - - pi->primitives.gradients.v[0][0] += - (Wi[1] - Wj[1]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.v[0][1] += - (Wi[1] - Wj[1]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.v[0][2] += - (Wi[1] - Wj[1]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); - pi->primitives.gradients.v[1][0] += - (Wi[2] - Wj[2]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.v[1][1] += - (Wi[2] - Wj[2]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.v[1][2] += - (Wi[2] - Wj[2]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); - pi->primitives.gradients.v[2][0] += - (Wi[3] - Wj[3]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.v[2][1] += - (Wi[3] - Wj[3]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.v[2][2] += - (Wi[3] - Wj[3]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); - - pi->primitives.gradients.P[0] += - (Wi[4] - Wj[4]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.P[1] += - (Wi[4] - Wj[4]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.P[2] += - (Wi[4] - Wj[4]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + if (pi->density.wcorr > const_gizmo_min_wcorr) { + /* Compute gradients for pi */ + /* there is a sign difference w.r.t. eqn. (6) because of the inverse + * definition of dx */ + pi->primitives.gradients.rho[0] += + (Wi[0] - Wj[0]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.rho[1] += + (Wi[0] - Wj[0]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.rho[2] += + (Wi[0] - Wj[0]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->primitives.gradients.v[0][0] += + (Wi[1] - Wj[1]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.v[0][1] += + (Wi[1] - Wj[1]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.v[0][2] += + (Wi[1] - Wj[1]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + pi->primitives.gradients.v[1][0] += + (Wi[2] - Wj[2]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.v[1][1] += + (Wi[2] - Wj[2]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.v[1][2] += + (Wi[2] - Wj[2]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + pi->primitives.gradients.v[2][0] += + (Wi[3] - Wj[3]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.v[2][1] += + (Wi[3] - Wj[3]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.v[2][2] += + (Wi[3] - Wj[3]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->primitives.gradients.P[0] += + (Wi[4] - Wj[4]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.P[1] += + (Wi[4] - Wj[4]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.P[2] += + (Wi[4] - Wj[4]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->gravity.grad_a[0][0] += + (pi->gravity.old_a[0] - pj->gravity.old_a[0]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->gravity.grad_a[0][1] += + (pi->gravity.old_a[0] - pj->gravity.old_a[0]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->gravity.grad_a[0][2] += + (pi->gravity.old_a[0] - pj->gravity.old_a[0]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->gravity.grad_a[1][0] += + (pi->gravity.old_a[1] - pj->gravity.old_a[1]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->gravity.grad_a[1][1] += + (pi->gravity.old_a[1] - pj->gravity.old_a[1]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->gravity.grad_a[1][2] += + (pi->gravity.old_a[1] - pj->gravity.old_a[1]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->gravity.grad_a[2][0] += + (pi->gravity.old_a[2] - pj->gravity.old_a[2]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->gravity.grad_a[2][1] += + (pi->gravity.old_a[2] - pj->gravity.old_a[2]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->gravity.grad_a[2][2] += + (pi->gravity.old_a[2] - pj->gravity.old_a[2]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + } else { + /* The gradient matrix was not well-behaved, switch to SPH gradients */ + + pi->primitives.gradients.rho[0] -= + wi_dx * dx[0] * (pi->primitives.rho - pj->primitives.rho) / r; + pi->primitives.gradients.rho[1] -= + wi_dx * dx[1] * (pi->primitives.rho - pj->primitives.rho) / r; + pi->primitives.gradients.rho[2] -= + wi_dx * dx[2] * (pi->primitives.rho - pj->primitives.rho) / r; + + pi->primitives.gradients.v[0][0] -= + wi_dx * dx[0] * (pi->primitives.v[0] - pj->primitives.v[0]) / r; + pi->primitives.gradients.v[0][1] -= + wi_dx * dx[1] * (pi->primitives.v[0] - pj->primitives.v[0]) / r; + pi->primitives.gradients.v[0][2] -= + wi_dx * dx[2] * (pi->primitives.v[0] - pj->primitives.v[0]) / r; + + pi->primitives.gradients.v[1][0] -= + wi_dx * dx[0] * (pi->primitives.v[1] - pj->primitives.v[1]) / r; + pi->primitives.gradients.v[1][1] -= + wi_dx * dx[1] * (pi->primitives.v[1] - pj->primitives.v[1]) / r; + pi->primitives.gradients.v[1][2] -= + wi_dx * dx[2] * (pi->primitives.v[1] - pj->primitives.v[1]) / r; + + pi->primitives.gradients.v[2][0] -= + wi_dx * dx[0] * (pi->primitives.v[2] - pj->primitives.v[2]) / r; + pi->primitives.gradients.v[2][1] -= + wi_dx * dx[1] * (pi->primitives.v[2] - pj->primitives.v[2]) / r; + pi->primitives.gradients.v[2][2] -= + wi_dx * dx[2] * (pi->primitives.v[2] - pj->primitives.v[2]) / r; + + pi->primitives.gradients.P[0] -= + wi_dx * dx[0] * (pi->primitives.P - pj->primitives.P) / r; + pi->primitives.gradients.P[1] -= + wi_dx * dx[1] * (pi->primitives.P - pj->primitives.P) / r; + pi->primitives.gradients.P[2] -= + wi_dx * dx[2] * (pi->primitives.P - pj->primitives.P) / r; + + pi->gravity.grad_a[0][0] -= + wi_dx * dx[0] * (pi->gravity.old_a[0] - pj->gravity.old_a[0]) / r; + pi->gravity.grad_a[0][1] -= + wi_dx * dx[1] * (pi->gravity.old_a[0] - pj->gravity.old_a[0]) / r; + pi->gravity.grad_a[0][2] -= + wi_dx * dx[2] * (pi->gravity.old_a[0] - pj->gravity.old_a[0]) / r; + + pi->gravity.grad_a[1][0] -= + wi_dx * dx[0] * (pi->gravity.old_a[1] - pj->gravity.old_a[1]) / r; + pi->gravity.grad_a[1][1] -= + wi_dx * dx[1] * (pi->gravity.old_a[1] - pj->gravity.old_a[1]) / r; + pi->gravity.grad_a[1][2] -= + wi_dx * dx[2] * (pi->gravity.old_a[1] - pj->gravity.old_a[1]) / r; + + pi->gravity.grad_a[2][0] -= + wi_dx * dx[0] * (pi->gravity.old_a[2] - pj->gravity.old_a[2]) / r; + pi->gravity.grad_a[2][1] -= + wi_dx * dx[1] * (pi->gravity.old_a[2] - pj->gravity.old_a[2]) / r; + pi->gravity.grad_a[2][2] -= + wi_dx * dx[2] * (pi->gravity.old_a[2] - pj->gravity.old_a[2]) / r; + } hydro_slope_limit_cell_collect(pi, pj, r); @@ -151,57 +253,146 @@ __attribute__((always_inline)) INLINE static void hydro_gradients_collect( xj = r * hj_inv; kernel_deval(xj, &wj, &wj_dx); - /* Compute gradients for pj */ - /* there is no sign difference w.r.t. eqn. (6) because dx is now what we - * want - * it to be */ - pj->primitives.gradients.rho[0] += - (Wi[0] - Wj[0]) * wj * - (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); - pj->primitives.gradients.rho[1] += - (Wi[0] - Wj[0]) * wj * - (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); - pj->primitives.gradients.rho[2] += - (Wi[0] - Wj[0]) * wj * - (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); - - pj->primitives.gradients.v[0][0] += - (Wi[1] - Wj[1]) * wj * - (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); - pj->primitives.gradients.v[0][1] += - (Wi[1] - Wj[1]) * wj * - (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); - pj->primitives.gradients.v[0][2] += - (Wi[1] - Wj[1]) * wj * - (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); - pj->primitives.gradients.v[1][0] += - (Wi[2] - Wj[2]) * wj * - (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); - pj->primitives.gradients.v[1][1] += - (Wi[2] - Wj[2]) * wj * - (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); - pj->primitives.gradients.v[1][2] += - (Wi[2] - Wj[2]) * wj * - (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); - pj->primitives.gradients.v[2][0] += - (Wi[3] - Wj[3]) * wj * - (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); - pj->primitives.gradients.v[2][1] += - (Wi[3] - Wj[3]) * wj * - (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); - pj->primitives.gradients.v[2][2] += - (Wi[3] - Wj[3]) * wj * - (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); - - pj->primitives.gradients.P[0] += - (Wi[4] - Wj[4]) * wj * - (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); - pj->primitives.gradients.P[1] += - (Wi[4] - Wj[4]) * wj * - (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); - pj->primitives.gradients.P[2] += - (Wi[4] - Wj[4]) * wj * - (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); + if (pj->density.wcorr > const_gizmo_min_wcorr) { + /* Compute gradients for pj */ + /* there is no sign difference w.r.t. eqn. (6) because dx is now what we + * want + * it to be */ + pj->primitives.gradients.rho[0] += + (Wi[0] - Wj[0]) * wj * + (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); + pj->primitives.gradients.rho[1] += + (Wi[0] - Wj[0]) * wj * + (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); + pj->primitives.gradients.rho[2] += + (Wi[0] - Wj[0]) * wj * + (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); + + pj->primitives.gradients.v[0][0] += + (Wi[1] - Wj[1]) * wj * + (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); + pj->primitives.gradients.v[0][1] += + (Wi[1] - Wj[1]) * wj * + (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); + pj->primitives.gradients.v[0][2] += + (Wi[1] - Wj[1]) * wj * + (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); + pj->primitives.gradients.v[1][0] += + (Wi[2] - Wj[2]) * wj * + (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); + pj->primitives.gradients.v[1][1] += + (Wi[2] - Wj[2]) * wj * + (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); + pj->primitives.gradients.v[1][2] += + (Wi[2] - Wj[2]) * wj * + (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); + pj->primitives.gradients.v[2][0] += + (Wi[3] - Wj[3]) * wj * + (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); + pj->primitives.gradients.v[2][1] += + (Wi[3] - Wj[3]) * wj * + (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); + pj->primitives.gradients.v[2][2] += + (Wi[3] - Wj[3]) * wj * + (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); + + pj->primitives.gradients.P[0] += + (Wi[4] - Wj[4]) * wj * + (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); + pj->primitives.gradients.P[1] += + (Wi[4] - Wj[4]) * wj * + (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); + pj->primitives.gradients.P[2] += + (Wi[4] - Wj[4]) * wj * + (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); + + pj->gravity.grad_a[0][0] += + (pi->gravity.old_a[0] - pj->gravity.old_a[0]) * wj * + (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); + pj->gravity.grad_a[0][1] += + (pi->gravity.old_a[0] - pj->gravity.old_a[0]) * wj * + (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); + pj->gravity.grad_a[0][2] += + (pi->gravity.old_a[0] - pj->gravity.old_a[0]) * wj * + (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); + + pj->gravity.grad_a[1][0] += + (pi->gravity.old_a[1] - pj->gravity.old_a[1]) * wj * + (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); + pj->gravity.grad_a[1][1] += + (pi->gravity.old_a[1] - pj->gravity.old_a[1]) * wj * + (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); + pj->gravity.grad_a[1][2] += + (pi->gravity.old_a[1] - pj->gravity.old_a[1]) * wj * + (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); + + pj->gravity.grad_a[2][0] += + (pi->gravity.old_a[2] - pj->gravity.old_a[2]) * wj * + (Bj[0][0] * dx[0] + Bj[0][1] * dx[1] + Bj[0][2] * dx[2]); + pj->gravity.grad_a[2][1] += + (pi->gravity.old_a[2] - pj->gravity.old_a[2]) * wj * + (Bj[1][0] * dx[0] + Bj[1][1] * dx[1] + Bj[1][2] * dx[2]); + pj->gravity.grad_a[2][2] += + (pi->gravity.old_a[2] - pj->gravity.old_a[2]) * wj * + (Bj[2][0] * dx[0] + Bj[2][1] * dx[1] + Bj[2][2] * dx[2]); + } else { + /* SPH gradients */ + + pj->primitives.gradients.rho[0] -= + wj_dx * dx[0] * (pi->primitives.rho - pj->primitives.rho) / r; + pj->primitives.gradients.rho[1] -= + wj_dx * dx[1] * (pi->primitives.rho - pj->primitives.rho) / r; + pj->primitives.gradients.rho[2] -= + wj_dx * dx[2] * (pi->primitives.rho - pj->primitives.rho) / r; + + pj->primitives.gradients.v[0][0] -= + wj_dx * dx[0] * (pi->primitives.v[0] - pj->primitives.v[0]) / r; + pj->primitives.gradients.v[0][1] -= + wj_dx * dx[1] * (pi->primitives.v[0] - pj->primitives.v[0]) / r; + pj->primitives.gradients.v[0][2] -= + wj_dx * dx[2] * (pi->primitives.v[0] - pj->primitives.v[0]) / r; + + pj->primitives.gradients.v[1][0] -= + wj_dx * dx[0] * (pi->primitives.v[1] - pj->primitives.v[1]) / r; + pj->primitives.gradients.v[1][1] -= + wj_dx * dx[1] * (pi->primitives.v[1] - pj->primitives.v[1]) / r; + pj->primitives.gradients.v[1][2] -= + wj_dx * dx[2] * (pi->primitives.v[1] - pj->primitives.v[1]) / r; + pj->primitives.gradients.v[2][0] -= + wj_dx * dx[0] * (pi->primitives.v[2] - pj->primitives.v[2]) / r; + pj->primitives.gradients.v[2][1] -= + wj_dx * dx[1] * (pi->primitives.v[2] - pj->primitives.v[2]) / r; + pj->primitives.gradients.v[2][2] -= + wj_dx * dx[2] * (pi->primitives.v[2] - pj->primitives.v[2]) / r; + + pj->primitives.gradients.P[0] -= + wj_dx * dx[0] * (pi->primitives.P - pj->primitives.P) / r; + pj->primitives.gradients.P[1] -= + wj_dx * dx[1] * (pi->primitives.P - pj->primitives.P) / r; + pj->primitives.gradients.P[2] -= + wj_dx * dx[2] * (pi->primitives.P - pj->primitives.P) / r; + + pj->gravity.grad_a[0][0] -= + wj_dx * dx[0] * (pi->gravity.old_a[0] - pj->gravity.old_a[0]) / r; + pj->gravity.grad_a[0][1] -= + wj_dx * dx[1] * (pi->gravity.old_a[0] - pj->gravity.old_a[0]) / r; + pj->gravity.grad_a[0][2] -= + wj_dx * dx[2] * (pi->gravity.old_a[0] - pj->gravity.old_a[0]) / r; + + pj->gravity.grad_a[1][0] -= + wj_dx * dx[0] * (pi->gravity.old_a[1] - pj->gravity.old_a[1]) / r; + pj->gravity.grad_a[1][1] -= + wj_dx * dx[1] * (pi->gravity.old_a[1] - pj->gravity.old_a[1]) / r; + pj->gravity.grad_a[1][2] -= + wj_dx * dx[2] * (pi->gravity.old_a[1] - pj->gravity.old_a[1]) / r; + + pj->gravity.grad_a[2][0] -= + wj_dx * dx[0] * (pi->gravity.old_a[2] - pj->gravity.old_a[2]) / r; + pj->gravity.grad_a[2][1] -= + wj_dx * dx[1] * (pi->gravity.old_a[2] - pj->gravity.old_a[2]) / r; + pj->gravity.grad_a[2][2] -= + wj_dx * dx[2] * (pi->gravity.old_a[2] - pj->gravity.old_a[2]) / r; + } hydro_slope_limit_cell_collect(pj, pi, r); } @@ -250,56 +441,145 @@ hydro_gradients_nonsym_collect(float r2, float *dx, float hi, float hj, xi = r * hi_inv; kernel_deval(xi, &wi, &wi_dx); - /* Compute gradients for pi */ - /* there is a sign difference w.r.t. eqn. (6) because of the inverse - * definition of dx */ - pi->primitives.gradients.rho[0] += - (Wi[0] - Wj[0]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.rho[1] += - (Wi[0] - Wj[0]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.rho[2] += - (Wi[0] - Wj[0]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); - - pi->primitives.gradients.v[0][0] += - (Wi[1] - Wj[1]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.v[0][1] += - (Wi[1] - Wj[1]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.v[0][2] += - (Wi[1] - Wj[1]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); - pi->primitives.gradients.v[1][0] += - (Wi[2] - Wj[2]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.v[1][1] += - (Wi[2] - Wj[2]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.v[1][2] += - (Wi[2] - Wj[2]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); - pi->primitives.gradients.v[2][0] += - (Wi[3] - Wj[3]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.v[2][1] += - (Wi[3] - Wj[3]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.v[2][2] += - (Wi[3] - Wj[3]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); - - pi->primitives.gradients.P[0] += - (Wi[4] - Wj[4]) * wi * - (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); - pi->primitives.gradients.P[1] += - (Wi[4] - Wj[4]) * wi * - (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); - pi->primitives.gradients.P[2] += - (Wi[4] - Wj[4]) * wi * - (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + if (pi->density.wcorr > const_gizmo_min_wcorr) { + /* Compute gradients for pi */ + /* there is a sign difference w.r.t. eqn. (6) because of the inverse + * definition of dx */ + pi->primitives.gradients.rho[0] += + (Wi[0] - Wj[0]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.rho[1] += + (Wi[0] - Wj[0]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.rho[2] += + (Wi[0] - Wj[0]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->primitives.gradients.v[0][0] += + (Wi[1] - Wj[1]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.v[0][1] += + (Wi[1] - Wj[1]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.v[0][2] += + (Wi[1] - Wj[1]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + pi->primitives.gradients.v[1][0] += + (Wi[2] - Wj[2]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.v[1][1] += + (Wi[2] - Wj[2]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.v[1][2] += + (Wi[2] - Wj[2]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + pi->primitives.gradients.v[2][0] += + (Wi[3] - Wj[3]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.v[2][1] += + (Wi[3] - Wj[3]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.v[2][2] += + (Wi[3] - Wj[3]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->primitives.gradients.P[0] += + (Wi[4] - Wj[4]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->primitives.gradients.P[1] += + (Wi[4] - Wj[4]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->primitives.gradients.P[2] += + (Wi[4] - Wj[4]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->gravity.grad_a[0][0] += + (pi->gravity.old_a[0] - pj->gravity.old_a[0]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->gravity.grad_a[0][1] += + (pi->gravity.old_a[0] - pj->gravity.old_a[0]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->gravity.grad_a[0][2] += + (pi->gravity.old_a[0] - pj->gravity.old_a[0]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->gravity.grad_a[1][0] += + (pi->gravity.old_a[1] - pj->gravity.old_a[1]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->gravity.grad_a[1][1] += + (pi->gravity.old_a[1] - pj->gravity.old_a[1]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->gravity.grad_a[1][2] += + (pi->gravity.old_a[1] - pj->gravity.old_a[1]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + + pi->gravity.grad_a[2][0] += + (pi->gravity.old_a[2] - pj->gravity.old_a[2]) * wi * + (Bi[0][0] * dx[0] + Bi[0][1] * dx[1] + Bi[0][2] * dx[2]); + pi->gravity.grad_a[2][1] += + (pi->gravity.old_a[2] - pj->gravity.old_a[2]) * wi * + (Bi[1][0] * dx[0] + Bi[1][1] * dx[1] + Bi[1][2] * dx[2]); + pi->gravity.grad_a[2][2] += + (pi->gravity.old_a[2] - pj->gravity.old_a[2]) * wi * + (Bi[2][0] * dx[0] + Bi[2][1] * dx[1] + Bi[2][2] * dx[2]); + } else { + /* Gradient matrix is not well-behaved, switch to SPH gradients */ + + pi->primitives.gradients.rho[0] -= + wi_dx * dx[0] * (pi->primitives.rho - pj->primitives.rho) / r; + pi->primitives.gradients.rho[1] -= + wi_dx * dx[1] * (pi->primitives.rho - pj->primitives.rho) / r; + pi->primitives.gradients.rho[2] -= + wi_dx * dx[2] * (pi->primitives.rho - pj->primitives.rho) / r; + + pi->primitives.gradients.v[0][0] -= + wi_dx * dx[0] * (pi->primitives.v[0] - pj->primitives.v[0]) / r; + pi->primitives.gradients.v[0][1] -= + wi_dx * dx[1] * (pi->primitives.v[0] - pj->primitives.v[0]) / r; + pi->primitives.gradients.v[0][2] -= + wi_dx * dx[2] * (pi->primitives.v[0] - pj->primitives.v[0]) / r; + pi->primitives.gradients.v[1][0] -= + wi_dx * dx[0] * (pi->primitives.v[1] - pj->primitives.v[1]) / r; + pi->primitives.gradients.v[1][1] -= + wi_dx * dx[1] * (pi->primitives.v[1] - pj->primitives.v[1]) / r; + pi->primitives.gradients.v[1][2] -= + wi_dx * dx[2] * (pi->primitives.v[1] - pj->primitives.v[1]) / r; + + pi->primitives.gradients.v[2][0] -= + wi_dx * dx[0] * (pi->primitives.v[2] - pj->primitives.v[2]) / r; + pi->primitives.gradients.v[2][1] -= + wi_dx * dx[1] * (pi->primitives.v[2] - pj->primitives.v[2]) / r; + pi->primitives.gradients.v[2][2] -= + wi_dx * dx[2] * (pi->primitives.v[2] - pj->primitives.v[2]) / r; + + pi->primitives.gradients.P[0] -= + wi_dx * dx[0] * (pi->primitives.P - pj->primitives.P) / r; + pi->primitives.gradients.P[1] -= + wi_dx * dx[1] * (pi->primitives.P - pj->primitives.P) / r; + pi->primitives.gradients.P[2] -= + wi_dx * dx[2] * (pi->primitives.P - pj->primitives.P) / r; + + pi->gravity.grad_a[0][0] -= + wi_dx * dx[0] * (pi->gravity.old_a[0] - pj->gravity.old_a[0]) / r; + pi->gravity.grad_a[0][1] -= + wi_dx * dx[1] * (pi->gravity.old_a[0] - pj->gravity.old_a[0]) / r; + pi->gravity.grad_a[0][2] -= + wi_dx * dx[2] * (pi->gravity.old_a[0] - pj->gravity.old_a[0]) / r; + + pi->gravity.grad_a[1][0] -= + wi_dx * dx[0] * (pi->gravity.old_a[1] - pj->gravity.old_a[1]) / r; + pi->gravity.grad_a[1][1] -= + wi_dx * dx[1] * (pi->gravity.old_a[1] - pj->gravity.old_a[1]) / r; + pi->gravity.grad_a[1][2] -= + wi_dx * dx[2] * (pi->gravity.old_a[1] - pj->gravity.old_a[1]) / r; + + pi->gravity.grad_a[2][0] -= + wi_dx * dx[0] * (pi->gravity.old_a[2] - pj->gravity.old_a[2]) / r; + pi->gravity.grad_a[2][1] -= + wi_dx * dx[1] * (pi->gravity.old_a[2] - pj->gravity.old_a[2]) / r; + pi->gravity.grad_a[2][2] -= + wi_dx * dx[2] * (pi->gravity.old_a[2] - pj->gravity.old_a[2]) / r; + } hydro_slope_limit_cell_collect(pi, pj, r); } @@ -319,23 +599,73 @@ __attribute__((always_inline)) INLINE static void hydro_gradients_finalize( ih = 1.0f / h; const float ihdim = pow_dimension(ih); - p->primitives.gradients.rho[0] *= ihdim; - p->primitives.gradients.rho[1] *= ihdim; - p->primitives.gradients.rho[2] *= ihdim; - - p->primitives.gradients.v[0][0] *= ihdim; - p->primitives.gradients.v[0][1] *= ihdim; - p->primitives.gradients.v[0][2] *= ihdim; - p->primitives.gradients.v[1][0] *= ihdim; - p->primitives.gradients.v[1][1] *= ihdim; - p->primitives.gradients.v[1][2] *= ihdim; - p->primitives.gradients.v[2][0] *= ihdim; - p->primitives.gradients.v[2][1] *= ihdim; - p->primitives.gradients.v[2][2] *= ihdim; - - p->primitives.gradients.P[0] *= ihdim; - p->primitives.gradients.P[1] *= ihdim; - p->primitives.gradients.P[2] *= ihdim; + if (p->density.wcorr > const_gizmo_min_wcorr) { + p->primitives.gradients.rho[0] *= ihdim; + p->primitives.gradients.rho[1] *= ihdim; + p->primitives.gradients.rho[2] *= ihdim; + + p->primitives.gradients.v[0][0] *= ihdim; + p->primitives.gradients.v[0][1] *= ihdim; + p->primitives.gradients.v[0][2] *= ihdim; + p->primitives.gradients.v[1][0] *= ihdim; + p->primitives.gradients.v[1][1] *= ihdim; + p->primitives.gradients.v[1][2] *= ihdim; + p->primitives.gradients.v[2][0] *= ihdim; + p->primitives.gradients.v[2][1] *= ihdim; + p->primitives.gradients.v[2][2] *= ihdim; + + p->primitives.gradients.P[0] *= ihdim; + p->primitives.gradients.P[1] *= ihdim; + p->primitives.gradients.P[2] *= ihdim; + + p->gravity.grad_a[0][0] *= ihdim; + p->gravity.grad_a[0][1] *= ihdim; + p->gravity.grad_a[0][2] *= ihdim; + + p->gravity.grad_a[1][0] *= ihdim; + p->gravity.grad_a[1][1] *= ihdim; + p->gravity.grad_a[1][2] *= ihdim; + + p->gravity.grad_a[2][0] *= ihdim; + p->gravity.grad_a[2][1] *= ihdim; + p->gravity.grad_a[2][2] *= ihdim; + } else { + const float ihdimp1 = pow_dimension_plus_one(ih); + + float volume = p->geometry.volume; + + /* finalize gradients by multiplying with volume */ + p->primitives.gradients.rho[0] *= ihdimp1 * volume; + p->primitives.gradients.rho[1] *= ihdimp1 * volume; + p->primitives.gradients.rho[2] *= ihdimp1 * volume; + + p->primitives.gradients.v[0][0] *= ihdimp1 * volume; + p->primitives.gradients.v[0][1] *= ihdimp1 * volume; + p->primitives.gradients.v[0][2] *= ihdimp1 * volume; + + p->primitives.gradients.v[1][0] *= ihdimp1 * volume; + p->primitives.gradients.v[1][1] *= ihdimp1 * volume; + p->primitives.gradients.v[1][2] *= ihdimp1 * volume; + p->primitives.gradients.v[2][0] *= ihdimp1 * volume; + p->primitives.gradients.v[2][1] *= ihdimp1 * volume; + p->primitives.gradients.v[2][2] *= ihdimp1 * volume; + + p->primitives.gradients.P[0] *= ihdimp1 * volume; + p->primitives.gradients.P[1] *= ihdimp1 * volume; + p->primitives.gradients.P[2] *= ihdimp1 * volume; + + p->gravity.grad_a[0][0] *= ihdimp1 * volume; + p->gravity.grad_a[0][1] *= ihdimp1 * volume; + p->gravity.grad_a[0][2] *= ihdimp1 * volume; + + p->gravity.grad_a[1][0] *= ihdimp1 * volume; + p->gravity.grad_a[1][1] *= ihdimp1 * volume; + p->gravity.grad_a[1][2] *= ihdimp1 * volume; + + p->gravity.grad_a[2][0] *= ihdimp1 * volume; + p->gravity.grad_a[2][1] *= ihdimp1 * volume; + p->gravity.grad_a[2][2] *= ihdimp1 * volume; + } hydro_slope_limit_cell(p); } diff --git a/src/hydro/Gizmo/hydro_iact.h b/src/hydro/Gizmo/hydro_iact.h index d707e0ee1b5707086393ea206ea9f0f60f9c1853..8798dc859a790a83ab7a3b6f1709b1302f574581 100644 --- a/src/hydro/Gizmo/hydro_iact.h +++ b/src/hydro/Gizmo/hydro_iact.h @@ -23,6 +23,8 @@ #include "hydro_gradients.h" #include "riemann.h" +#define GIZMO_VOLUME_CORRECTION + /** * @brief Calculate the volume interaction between particle i and particle j * @@ -62,6 +64,10 @@ __attribute__((always_inline)) INLINE static void runner_iact_density( for (k = 0; k < 3; k++) for (l = 0; l < 3; l++) pi->geometry.matrix_E[k][l] += dx[k] * dx[l] * wi; + pi->geometry.centroid[0] -= dx[0] * wi; + pi->geometry.centroid[1] -= dx[1] * wi; + pi->geometry.centroid[2] -= dx[2] * wi; + /* Compute density of pj. */ h_inv = 1.0 / hj; xj = r * h_inv; @@ -74,6 +80,10 @@ __attribute__((always_inline)) INLINE static void runner_iact_density( pj->geometry.volume += wj; for (k = 0; k < 3; k++) for (l = 0; l < 3; l++) pj->geometry.matrix_E[k][l] += dx[k] * dx[l] * wj; + + pj->geometry.centroid[0] += dx[0] * wj; + pj->geometry.centroid[1] += dx[1] * wj; + pj->geometry.centroid[2] += dx[2] * wj; } /** @@ -117,6 +127,10 @@ __attribute__((always_inline)) INLINE static void runner_iact_nonsym_density( pi->geometry.volume += wi; for (k = 0; k < 3; k++) for (l = 0; l < 3; l++) pi->geometry.matrix_E[k][l] += dx[k] * dx[l] * wi; + + pi->geometry.centroid[0] -= dx[0] * wi; + pi->geometry.centroid[1] -= dx[1] * wi; + pi->geometry.centroid[2] -= dx[2] * wi; } /** @@ -325,14 +339,8 @@ __attribute__((always_inline)) INLINE static void runner_iact_fluxes_common( /* calculate the maximal signal velocity */ if (Wi[0] > 0.0f && Wj[0] > 0.0f) { -#ifdef EOS_ISOTHERMAL_GAS - /* we use a value that is slightly higher than necessary, since the correct - value does not always work */ - vmax = 2.5 * const_isothermal_soundspeed; -#else vmax = sqrtf(hydro_gamma * Wi[4] / Wi[0]) + sqrtf(hydro_gamma * Wj[4] / Wj[0]); -#endif } else { vmax = 0.0f; } @@ -381,23 +389,63 @@ __attribute__((always_inline)) INLINE static void runner_iact_fluxes_common( /* Compute area */ /* eqn. (7) */ Anorm = 0.0f; - for (k = 0; k < 3; k++) { - /* we add a minus sign since dx is pi->x - pj->x */ - A[k] = -Vi * (Bi[k][0] * dx[0] + Bi[k][1] * dx[1] + Bi[k][2] * dx[2]) * wi * - hi_inv_dim - - Vj * (Bj[k][0] * dx[0] + Bj[k][1] * dx[1] + Bj[k][2] * dx[2]) * wj * - hj_inv_dim; - Anorm += A[k] * A[k]; + if (pi->density.wcorr > const_gizmo_min_wcorr && + pj->density.wcorr > const_gizmo_min_wcorr) { + /* in principle, we use Vi and Vj as weights for the left and right + contributions to the generalized surface vector. + However, if Vi and Vj are very different (because they have very + different + smoothing lengths), then the expressions below are more stable. */ + float Xi = Vi; + float Xj = Vj; +#ifdef GIZMO_VOLUME_CORRECTION + if (fabsf(Vi - Vj) / fminf(Vi, Vj) > 1.5 * hydro_dimension) { + Xi = (Vi * hj + Vj * hi) / (hi + hj); + Xj = Xi; + } +#endif + for (k = 0; k < 3; k++) { + /* we add a minus sign since dx is pi->x - pj->x */ + A[k] = -Xi * (Bi[k][0] * dx[0] + Bi[k][1] * dx[1] + Bi[k][2] * dx[2]) * + wj * hj_inv_dim - + Xj * (Bj[k][0] * dx[0] + Bj[k][1] * dx[1] + Bj[k][2] * dx[2]) * + wi * hi_inv_dim; + Anorm += A[k] * A[k]; + } + } else { + /* ill condition gradient matrix: revert to SPH face area */ + Anorm = -(hidp1 * Vi * Vi * wi_dx + hjdp1 * Vj * Vj * wj_dx) * ri; + A[0] = -Anorm * dx[0]; + A[1] = -Anorm * dx[1]; + A[2] = -Anorm * dx[2]; + Anorm *= Anorm * r2; } - if (!Anorm) { + if (Anorm == 0.) { /* if the interface has no area, nothing happens and we return */ /* continuing results in dividing by zero and NaN's... */ return; } - /* compute the normal vector of the interface */ Anorm = sqrtf(Anorm); + +#ifdef SWIFT_DEBUG_CHECKS + /* For stability reasons, we do require A and dx to have opposite + directions (basically meaning that the surface normal for the surface + always points from particle i to particle j, as it would in a real + moving-mesh code). If not, our scheme is no longer upwind and hence can + become unstable. */ + float dA_dot_dx = A[0] * dx[0] + A[1] * dx[1] + A[2] * dx[2]; + /* In GIZMO, Phil Hopkins reverts to an SPH integration scheme if this + happens. We curently just ignore this case and display a message. */ + const float rdim = pow_dimension(r); + if (dA_dot_dx > 1.e-6 * rdim) { + message("Ill conditioned gradient matrix (%g %g %g %g %g)!", dA_dot_dx, + Anorm, Vi, Vj, r); + } +#endif + + /* compute the normal vector of the interface */ for (k = 0; k < 3; k++) n_unit[k] = A[k] / Anorm; /* Compute interface position (relative to pi, since we don't need the actual @@ -436,43 +484,6 @@ __attribute__((always_inline)) INLINE static void runner_iact_fluxes_common( /* we don't need to rotate, we can use the unit vector in the Riemann problem * itself (see GIZMO) */ - if (Wi[0] < 0.0f || Wj[0] < 0.0f || Wi[4] < 0.0f || Wj[4] < 0.0f) { - printf("mindt: %g\n", mindt); - printf("WL: %g %g %g %g %g\n", pi->primitives.rho, pi->primitives.v[0], - pi->primitives.v[1], pi->primitives.v[2], pi->primitives.P); -#ifdef USE_GRADIENTS - printf("dWL: %g %g %g %g %g\n", dWi[0], dWi[1], dWi[2], dWi[3], dWi[4]); -#endif - printf("gradWL[0]: %g %g %g\n", pi->primitives.gradients.rho[0], - pi->primitives.gradients.rho[1], pi->primitives.gradients.rho[2]); - printf("gradWL[1]: %g %g %g\n", pi->primitives.gradients.v[0][0], - pi->primitives.gradients.v[0][1], pi->primitives.gradients.v[0][2]); - printf("gradWL[2]: %g %g %g\n", pi->primitives.gradients.v[1][0], - pi->primitives.gradients.v[1][1], pi->primitives.gradients.v[1][2]); - printf("gradWL[3]: %g %g %g\n", pi->primitives.gradients.v[2][0], - pi->primitives.gradients.v[2][1], pi->primitives.gradients.v[2][2]); - printf("gradWL[4]: %g %g %g\n", pi->primitives.gradients.P[0], - pi->primitives.gradients.P[1], pi->primitives.gradients.P[2]); - printf("WL': %g %g %g %g %g\n", Wi[0], Wi[1], Wi[2], Wi[3], Wi[4]); - printf("WR: %g %g %g %g %g\n", pj->primitives.rho, pj->primitives.v[0], - pj->primitives.v[1], pj->primitives.v[2], pj->primitives.P); -#ifdef USE_GRADIENTS - printf("dWR: %g %g %g %g %g\n", dWj[0], dWj[1], dWj[2], dWj[3], dWj[4]); -#endif - printf("gradWR[0]: %g %g %g\n", pj->primitives.gradients.rho[0], - pj->primitives.gradients.rho[1], pj->primitives.gradients.rho[2]); - printf("gradWR[1]: %g %g %g\n", pj->primitives.gradients.v[0][0], - pj->primitives.gradients.v[0][1], pj->primitives.gradients.v[0][2]); - printf("gradWR[2]: %g %g %g\n", pj->primitives.gradients.v[1][0], - pj->primitives.gradients.v[1][1], pj->primitives.gradients.v[1][2]); - printf("gradWR[3]: %g %g %g\n", pj->primitives.gradients.v[2][0], - pj->primitives.gradients.v[2][1], pj->primitives.gradients.v[2][2]); - printf("gradWR[4]: %g %g %g\n", pj->primitives.gradients.P[0], - pj->primitives.gradients.P[1], pj->primitives.gradients.P[2]); - printf("WR': %g %g %g %g %g\n", Wj[0], Wj[1], Wj[2], Wj[3], Wj[4]); - error("Negative density or pressure!\n"); - } - float totflux[5]; riemann_solve_for_flux(Wi, Wj, n_unit, vij, totflux); diff --git a/src/hydro/Gizmo/hydro_io.h b/src/hydro/Gizmo/hydro_io.h index 236106a1fb04cc2e5b84f997a2389d583ce17cff..3d58be2f47c4e1904aaac5f69d1862f1d453e488 100644 --- a/src/hydro/Gizmo/hydro_io.h +++ b/src/hydro/Gizmo/hydro_io.h @@ -127,7 +127,7 @@ float convert_Etot(struct engine* e, struct part* p) { void hydro_write_particles(struct part* parts, struct io_props* list, int* num_fields) { - *num_fields = 14; + *num_fields = 11; /* List what we want to write */ list[0] = io_make_output_field("Coordinates", DOUBLE, 3, UNIT_CONV_LENGTH, @@ -143,22 +143,16 @@ void hydro_write_particles(struct part* parts, struct io_props* list, parts, primitives.P, convert_u); list[5] = io_make_output_field("ParticleIDs", ULONGLONG, 1, UNIT_CONV_NO_UNITS, parts, id); - list[6] = io_make_output_field("Acceleration", FLOAT, 3, - UNIT_CONV_ACCELERATION, parts, a_hydro); - list[7] = io_make_output_field("Density", FLOAT, 1, UNIT_CONV_DENSITY, parts, + list[6] = io_make_output_field("Density", FLOAT, 1, UNIT_CONV_DENSITY, parts, primitives.rho); - list[8] = io_make_output_field("Volume", FLOAT, 1, UNIT_CONV_VOLUME, parts, - geometry.volume); - list[9] = io_make_output_field("GradDensity", FLOAT, 3, UNIT_CONV_DENSITY, - parts, primitives.gradients.rho); - list[10] = io_make_output_field_convert_part( + list[7] = io_make_output_field_convert_part( "Entropy", FLOAT, 1, UNIT_CONV_ENTROPY, parts, primitives.P, convert_A); - list[11] = io_make_output_field("Pressure", FLOAT, 1, UNIT_CONV_PRESSURE, - parts, primitives.P); - list[12] = + list[8] = io_make_output_field("Pressure", FLOAT, 1, UNIT_CONV_PRESSURE, + parts, primitives.P); + list[9] = io_make_output_field_convert_part("TotEnergy", FLOAT, 1, UNIT_CONV_ENERGY, parts, conserved.energy, convert_Etot); - list[13] = io_make_output_field("GravAcceleration", FLOAT, 3, + list[10] = io_make_output_field("GravAcceleration", FLOAT, 3, UNIT_CONV_ACCELERATION, parts, gravity.old_a); } diff --git a/src/hydro/Gizmo/hydro_part.h b/src/hydro/Gizmo/hydro_part.h index d552a3f7e86031311098293845f1aa11270c417f..6c96004847ae23b46ec3f5182f742e0e84f1118d 100644 --- a/src/hydro/Gizmo/hydro_part.h +++ b/src/hydro/Gizmo/hydro_part.h @@ -148,6 +148,9 @@ struct part { /* Total surface area of the particle. */ float Atot; + /* Centroid of the "cell". */ + float centroid[3]; + } geometry; /* Variables used for timestep calculation (currently not used). */ @@ -201,6 +204,8 @@ struct part { /* Previous value of the gravitational acceleration. */ float old_a[3]; + float grad_a[3][3]; + /* Previous value of the mass flux vector. */ float old_mflux[3]; diff --git a/src/hydro/Gizmo/hydro_slope_limiters_face.h b/src/hydro/Gizmo/hydro_slope_limiters_face.h index 7ae5dd2eb073d9aae8ab6f2efffdf8df15b4bb4a..ba96063d661a93a4efc4069ff7e7269a4ac58c3b 100644 --- a/src/hydro/Gizmo/hydro_slope_limiters_face.h +++ b/src/hydro/Gizmo/hydro_slope_limiters_face.h @@ -53,14 +53,22 @@ hydro_slope_limit_face_quantity(float phi_i, float phi_j, float phi_mid0, if ((phimax + delta1) * phimax > 0.0f) { phiplus = phimax + delta1; } else { - phiplus = phimax / (1.0f + delta1 / fabs(phimax)); + if (phimax != 0.) { + phiplus = phimax / (1.0f + delta1 / fabs(phimax)); + } else { + phiplus = 0.; + } } /* if sign(phimin-delta1) == sign(phimin) */ if ((phimin - delta1) * phimin > 0.0f) { phiminus = phimin - delta1; } else { - phiminus = phimin / (1.0f + delta1 / fabs(phimin)); + if (phimin != 0.) { + phiminus = phimin / (1.0f + delta1 / fabs(phimin)); + } else { + phiminus = 0.; + } } if (phi_i < phi_j) { diff --git a/src/hydro/Gizmo/hydro_unphysical.h b/src/hydro/Gizmo/hydro_unphysical.h new file mode 100644 index 0000000000000000000000000000000000000000..517e3e0918ad340580e270477c0a166590546850 --- /dev/null +++ b/src/hydro/Gizmo/hydro_unphysical.h @@ -0,0 +1,55 @@ +/******************************************************************************* + * This file is part of SWIFT. + * Copyright (c) 2017 Bert Vandenbroucke (bert.vandenbroucke@gmail.com) + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + ******************************************************************************/ +#ifndef SWIFT_HYDRO_UNPHYSICAL_H +#define SWIFT_HYDRO_UNPHYSICAL_H + +#if defined(GIZMO_UNPHYSICAL_ERROR) || defined(GIZMO_UNPHYSICAL_RESCUE) + +#if defined(GIZMO_UNPHYSICAL_ERROR) + +/*! @brief Crash whenever an unphysical value is detected. */ +#define gizmo_unphysical_message(name, quantity) \ + error("Unphysical " name " detected (%g)!", quantity); + +#elif defined(GIZMO_UNPHYSICAL_WARNING) + +/*! @brief Show a warning whenever an unphysical value is detected. */ +#define gizmo_unphysical_message(name, quantity) \ + message("Unphysical " name " detected (%g), reset to 0!", quantity); + +#else + +/*! @brief Don't tell anyone an unphysical value was detected. */ +#define gizmo_unphysical_message(name, quantity) + +#endif + +#define gizmo_check_physical_quantity(name, quantity) \ + if (quantity < 0.) { \ + gizmo_unphysical_message(name, quantity); \ + quantity = 0.; \ + } + +#else // defined(GIZMO_UNPHYSICAL_ERROR) || defined(GIZMO_UNPHYSICAL_RESCUE) + +#define gizmo_check_physical_quantity(name, quantity) + +#endif // defined(GIZMO_UNPHYSICAL_ERROR) || defined(GIZMO_UNPHYSICAL_RESCUE) + +#endif // SWIFT_HYDRO_UNPHYSICAL_H diff --git a/src/hydro/Gizmo/hydro_velocities.h b/src/hydro/Gizmo/hydro_velocities.h new file mode 100644 index 0000000000000000000000000000000000000000..08ba1f972b2f7a7b8a01ac4750c50a36f69784d0 --- /dev/null +++ b/src/hydro/Gizmo/hydro_velocities.h @@ -0,0 +1,162 @@ +/******************************************************************************* + * This file is part of SWIFT. + * Coypright (c) 2017 Bert Vandenbroucke (bert.vandenbroucke@gmail.com) + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + ******************************************************************************/ +#ifndef SWIFT_HYDRO_VELOCITIES_H +#define SWIFT_HYDRO_VELOCITIES_H + +/** + * @brief Initialize the GIZMO particle velocities before the start of the + * actual run based on the initial value of the primitive velocity. + * + * @param p The particle to act upon. + * @param xp The extended particle data to act upon. + */ +__attribute__((always_inline)) INLINE static void hydro_velocities_init( + struct part* restrict p, struct xpart* restrict xp) { + +#ifdef GIZMO_FIX_PARTICLES + p->v[0] = 0.; + p->v[1] = 0.; + p->v[2] = 0.; +#else + p->v[0] = p->primitives.v[0]; + p->v[1] = p->primitives.v[1]; + p->v[2] = p->primitives.v[2]; +#endif + + xp->v_full[0] = p->v[0]; + xp->v_full[1] = p->v[1]; + xp->v_full[2] = p->v[2]; +} + +/** + * @brief Set the particle velocity field that will be used to deboost fluid + * velocities during the force loop. + * + * @param p The particle to act upon. + * @param xp The extended particel data to act upon. + */ +__attribute__((always_inline)) INLINE static void +hydro_velocities_prepare_force(struct part* restrict p, + const struct xpart* restrict xp) { + +#ifndef GIZMO_FIX_PARTICLES + p->force.v_full[0] = xp->v_full[0]; + p->force.v_full[1] = xp->v_full[1]; + p->force.v_full[2] = xp->v_full[2]; +#endif +} + +/** + * @brief Set the variables that will be used to update the smoothing length + * during the drift (these will depend on the movement of the particles). + * + * @param p The particle to act upon. + */ +__attribute__((always_inline)) INLINE static void hydro_velocities_end_force( + struct part* restrict p) { + +#ifdef GIZMO_FIX_PARTICLES + /* disable the smoothing length update, since the smoothing lengths should + stay the same for all steps (particles don't move) */ + p->force.h_dt = 0.0f; +#else + /* Add normalization to h_dt. */ + p->force.h_dt *= p->h * hydro_dimension_inv; +#endif +} + +/** + * @brief Set the velocity of a GIZMO particle, based on the values of its + * primitive variables and the geometry of its mesh-free "cell". + * + * @param p The particle to act upon. + * @param xp The extended particle data to act upon. + */ +__attribute__((always_inline)) INLINE static void hydro_velocities_set( + struct part* restrict p, struct xpart* restrict xp) { + +/* We first set the particle velocity. */ +#ifdef GIZMO_FIX_PARTICLES + + p->v[0] = 0.; + p->v[1] = 0.; + p->v[2] = 0.; + +#else // GIZMO_FIX_PARTICLES + + if (p->conserved.mass > 0. && p->primitives.rho > 0.) { + /* Normal case: set particle velocity to fluid velocity. */ + p->v[0] = p->conserved.momentum[0] / p->conserved.mass; + p->v[1] = p->conserved.momentum[1] / p->conserved.mass; + p->v[2] = p->conserved.momentum[2] / p->conserved.mass; + +#ifdef GIZMO_STEER_MOTION + + /* Add a correction to the velocity to keep particle positions close enough + to + the centroid of their mesh-free "cell". */ + /* The correction term below is the same one described in Springel (2010). + */ + float ds[3]; + ds[0] = p->geometry.centroid[0]; + ds[1] = p->geometry.centroid[1]; + ds[2] = p->geometry.centroid[2]; + const float d = sqrtf(ds[0] * ds[0] + ds[1] * ds[1] + ds[2] * ds[2]); + const float R = get_radius_dimension_sphere(p->geometry.volume); + const float eta = 0.25; + const float etaR = eta * R; + const float xi = 1.; + const float soundspeed = + sqrtf(hydro_gamma * p->primitives.P / p->primitives.rho); + /* We only apply the correction if the offset between centroid and position + is + too large. */ + if (d > 0.9 * etaR) { + float fac = xi * soundspeed / d; + if (d < 1.1 * etaR) { + fac *= 5. * (d - 0.9 * etaR) / etaR; + } + p->v[0] -= ds[0] * fac; + p->v[1] -= ds[1] * fac; + p->v[2] -= ds[2] * fac; + } + +#endif // GIZMO_STEER_MOTION + } else { + /* Vacuum particles have no fluid velocity. */ + p->v[0] = 0.; + p->v[1] = 0.; + p->v[2] = 0.; + } + +#endif // GIZMO_FIX_PARTICLES + + /* Now make sure all velocity variables are up to date. */ + xp->v_full[0] = p->v[0]; + xp->v_full[1] = p->v[1]; + xp->v_full[2] = p->v[2]; + + if (p->gpart) { + p->gpart->v_full[0] = p->v[0]; + p->gpart->v_full[1] = p->v[1]; + p->gpart->v_full[2] = p->v[2]; + } +} + +#endif // SWIFT_HYDRO_VELOCITIES_H diff --git a/src/potential/sine_wave/potential.h b/src/potential/sine_wave/potential.h index e2e2b8ffcc170c28a5facc8373a81746811a9991..1a4ee8aae8238c5db4c99eacb9e96bd967bcc7c4 100644 --- a/src/potential/sine_wave/potential.h +++ b/src/potential/sine_wave/potential.h @@ -43,6 +43,9 @@ struct external_potential { /*! Amplitude of the sine wave. */ double amplitude; + /*! Growth time of the potential. */ + double growth_time; + /*! Time-step limiting factor. */ double timestep_limit; }; @@ -76,7 +79,13 @@ __attribute__((always_inline)) INLINE static void external_gravity_acceleration( double time, const struct external_potential* restrict potential, const struct phys_const* restrict phys_const, struct gpart* restrict g) { - g->a_grav[0] = potential->amplitude * sin(2. * M_PI * g->x[0]) / + float Acorr = 1.; + + if (time < potential->growth_time) { + Acorr = time / potential->growth_time; + } + + g->a_grav[0] = potential->amplitude * Acorr * sin(2. * M_PI * g->x[0]) / phys_const->const_newton_G; } @@ -114,6 +123,8 @@ static INLINE void potential_init_backend( potential->amplitude = parser_get_param_double(parameter_file, "SineWavePotential:amplitude"); + potential->growth_time = parser_get_opt_param_double( + parameter_file, "SineWavePotential:growth_time", 0.); potential->timestep_limit = parser_get_param_double( parameter_file, "SineWavePotential:timestep_limit"); } diff --git a/src/riemann.h b/src/riemann.h index 685d40708e598249151f6cbe13be016edea79553..ab6d162514326778e8d6478e07c9bae2947a7c2a 100644 --- a/src/riemann.h +++ b/src/riemann.h @@ -25,10 +25,8 @@ #if defined(RIEMANN_SOLVER_EXACT) #define RIEMANN_SOLVER_IMPLEMENTATION "Exact Riemann solver (Toro 2009)" -#if defined(EOS_IDEAL_GAS) +#if defined(EOS_IDEAL_GAS) || defined(EOS_ISOTHERMAL_GAS) #include "riemann/riemann_exact.h" -#elif defined(EOS_ISOTHERMAL_GAS) -#include "riemann/riemann_exact_isothermal.h" #else #error "The Exact Riemann solver is incompatible with this equation of state!" #endif diff --git a/src/runner.c b/src/runner.c index dd8cd7f426d80b81bbe4522f5098120731053aad..9be0a9ee2ce23888d04346679ccb36fdc6f13a02 100644 --- a/src/runner.c +++ b/src/runner.c @@ -1914,6 +1914,8 @@ void *runner_main(void *data) { runner_do_recv_part(r, ci, 1, 1); } else if (t->subtype == task_subtype_rho) { runner_do_recv_part(r, ci, 1, 1); + } else if (t->subtype == task_subtype_gradient) { + runner_do_recv_part(r, ci, 1, 1); } else if (t->subtype == task_subtype_gpart) { runner_do_recv_gpart(r, ci, 1); } else if (t->subtype == task_subtype_spart) { diff --git a/src/runner_doiact_fft.c b/src/runner_doiact_fft.c index 01ccb3446dda35135c01a13cd213c8b6368d79ec..a3e3f38fba920c0c58d600bb25feda88d4a3cf84 100644 --- a/src/runner_doiact_fft.c +++ b/src/runner_doiact_fft.c @@ -37,6 +37,8 @@ #include "space.h" #include "timers.h" +#ifdef HAVE_FFTW + /** * @brief Returns 1D index of a 3D NxNxN array using row-major style. * @@ -137,6 +139,8 @@ __attribute__((always_inline)) INLINE static void mesh_to_multipole_CIC( m->pot.F_000 += pot[row_major_id(i + 1, j + 1, k + 1, N)] * dx * dy * dz; } +#endif + /** * @brief Computes the potential on the top multipoles using a Fourier transform * diff --git a/src/scheduler.c b/src/scheduler.c index 7e42c3a214cff3fe30e7c885b06c48d25eac0e8d..b07c403e4ecd960b22b51f24372ca0a3420a453f 100644 --- a/src/scheduler.c +++ b/src/scheduler.c @@ -1379,7 +1379,8 @@ void scheduler_enqueue(struct scheduler *s, struct task *t) { MPI_BYTE, t->ci->nodeID, t->flags, MPI_COMM_WORLD, &t->req); } else if (t->subtype == task_subtype_xv || - t->subtype == task_subtype_rho) { + t->subtype == task_subtype_rho || + t->subtype == task_subtype_gradient) { err = MPI_Irecv(t->ci->parts, t->ci->count, part_mpi_type, t->ci->nodeID, t->flags, MPI_COMM_WORLD, &t->req); // message( "receiving %i parts with tag=%i from %i to %i." , @@ -1414,7 +1415,8 @@ void scheduler_enqueue(struct scheduler *s, struct task *t) { MPI_BYTE, t->cj->nodeID, t->flags, MPI_COMM_WORLD, &t->req); } else if (t->subtype == task_subtype_xv || - t->subtype == task_subtype_rho) { + t->subtype == task_subtype_rho || + t->subtype == task_subtype_gradient) { #ifdef SWIFT_DEBUG_CHECKS for (int k = 0; k < t->ci->count; k++) if (t->ci->parts[k].ti_drift != s->space->e->ti_current) diff --git a/src/space.c b/src/space.c index 677219a0a201ca357d0e2e24fa9cc1b61baa3e31..b1612876b6339fb29648a87e9aec93a1d8f64664 100644 --- a/src/space.c +++ b/src/space.c @@ -2431,6 +2431,58 @@ void space_getcells(struct space *s, int nr_cells, struct cell **cells) { } } +void space_synchronize_particle_positions_mapper(void *map_data, int nr_gparts, + void *extra_data) { + /* Unpack the data */ + struct gpart *restrict gparts = (struct gpart *)map_data; + struct space *s = (struct space *)extra_data; + + for (int k = 0; k < nr_gparts; k++) { + + /* Get the particle */ + const struct gpart *restrict gp = &gparts[k]; + + if (gp->type == swift_type_dark_matter) + continue; + + else if (gp->type == swift_type_gas) { + + /* Get it's gassy friend */ + struct part *p = &s->parts[-gp->id_or_neg_offset]; + struct xpart *xp = &s->xparts[-gp->id_or_neg_offset]; + + /* Synchronize positions and velocities */ + p->x[0] = gp->x[0]; + p->x[1] = gp->x[1]; + p->x[2] = gp->x[2]; + + xp->v_full[0] = gp->v_full[0]; + xp->v_full[1] = gp->v_full[1]; + xp->v_full[2] = gp->v_full[2]; + } + + else if (gp->type == swift_type_star) { + + /* Get it's stellar friend */ + struct spart *sp = &s->sparts[-gp->id_or_neg_offset]; + + /* Synchronize positions */ + sp->x[0] = gp->x[0]; + sp->x[1] = gp->x[1]; + sp->x[2] = gp->x[2]; + } + } +} + +void space_synchronize_particle_positions(struct space *s) { + + if ((s->nr_gparts > 0 && s->nr_parts > 0) || + (s->nr_gparts > 0 && s->nr_sparts > 0)) + threadpool_map(&s->e->threadpool, + space_synchronize_particle_positions_mapper, s->gparts, + s->nr_gparts, sizeof(struct gpart), 1000, (void *)s); +} + /** * @brief Initialises all the particles by setting them into a valid state * diff --git a/src/space.h b/src/space.h index 69742eaa3319d6371006014ee2cab1ac5f10bfe7..e8e8600349c97ff8a60f0fcf2964d6ec514a7589 100644 --- a/src/space.h +++ b/src/space.h @@ -209,6 +209,7 @@ void space_gparts_get_cell_index(struct space *s, int *gind, struct cell *cells, int verbose); void space_sparts_get_cell_index(struct space *s, int *sind, struct cell *cells, int verbose); +void space_synchronize_particle_positions(struct space *s); void space_do_parts_sort(); void space_do_gparts_sort(); void space_do_sparts_sort(); diff --git a/tests/Makefile.am b/tests/Makefile.am index 09142a3744755b3d380235a0030d62dca487b7c9..7c45ead22f77da7e0aa53e03051c7351cc97f550 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -22,7 +22,7 @@ AM_LDFLAGS = ../src/.libs/libswiftsim.a $(HDF5_LDFLAGS) $(HDF5_LIBS) $(FFTW_LIBS # List of programs and scripts to run in the test suite TESTS = testGreetings testMaths testReading.sh testSingle testKernel testSymmetry \ testPair.sh testPairPerturbed.sh test27cells.sh test27cellsPerturbed.sh \ - testParser.sh testSPHStep test125cells.sh testFFT \ + testParser.sh testSPHStep test125cells.sh test125cellsPerturbed.sh testFFT \ testAdiabaticIndex testRiemannExact testRiemannTRRS testRiemannHLLC \ testMatrixInversion testThreadpool testDump testLogger \ testVoronoi1D testVoronoi2D testVoronoi3D @@ -92,7 +92,8 @@ testLogger_SOURCES = testLogger.c # Files necessary for distribution EXTRA_DIST = testReading.sh makeInput.py testPair.sh testPairPerturbed.sh \ test27cells.sh test27cellsPerturbed.sh testParser.sh \ - test125cells.sh testParserInput.yaml difffloat.py \ - tolerance_125.dat tolerance_27_normal.dat tolerance_27_perturbed.dat \ + test125cells.sh test125cellsPerturbed.sh testParserInput.yaml difffloat.py \ + tolerance_125_normal.dat tolerance_125_perturbed.dat \ + tolerance_27_normal.dat tolerance_27_perturbed.dat \ tolerance_pair_normal.dat tolerance_pair_perturbed.dat \ fft_params.yml diff --git a/tests/difffloat.py b/tests/difffloat.py index f989ccb56fb1f008d4a60931cb7165f4f2156ebd..0bdc706a1c44ee6c42c54ad37e93f634742e06bc 100644 --- a/tests/difffloat.py +++ b/tests/difffloat.py @@ -107,7 +107,7 @@ for i in range(n_lines_to_check): print "" error = True - if abs(data1[i,j]) + abs(data2[i,j]) < 1e-6 : continue + if abs(data1[i,j]) < 4e-6 and abs(data2[i,j]) < 4e-6 : continue # Ignore pathological cases with rho_dh if ignoreSmallRhoDh and j == 8 and abs(data1[i,j]) < 2e-4: continue diff --git a/tests/test125cells.c b/tests/test125cells.c index 91023ae76b70f8e997a162bed7402c3515673f74..e4c73b5e75df56436d277d719b3b83a179924a6f 100644 --- a/tests/test125cells.c +++ b/tests/test125cells.c @@ -237,11 +237,13 @@ void reset_particles(struct cell *c, struct hydro_space *hs, * separation. * @param density The density of the fluid. * @param partId The running counter of IDs. + * @param pert The perturbation to apply to the particles in the cell in units + *of the inter-particle separation. * @param vel The type of velocity field. * @param press The type of pressure field. */ struct cell *make_cell(size_t n, const double offset[3], double size, double h, - double density, long long *partId, + double density, long long *partId, double pert, enum velocity_field vel, enum pressure_field press) { const size_t count = n * n * n; @@ -264,9 +266,15 @@ struct cell *make_cell(size_t n, const double offset[3], double size, double h, for (size_t x = 0; x < n; ++x) { for (size_t y = 0; y < n; ++y) { for (size_t z = 0; z < n; ++z) { - part->x[0] = offset[0] + size * (x + 0.5) / (float)n; - part->x[1] = offset[1] + size * (y + 0.5) / (float)n; - part->x[2] = offset[2] + size * (z + 0.5) / (float)n; + part->x[0] = + offset[0] + + size * (x + 0.5 + random_uniform(-0.5, 0.5) * pert) / (float)n; + part->x[1] = + offset[1] + + size * (y + 0.5 + random_uniform(-0.5, 0.5) * pert) / (float)n; + part->x[2] = + offset[2] + + size * (z + 0.5 + random_uniform(-0.5, 0.5) * pert) / (float)n; part->h = size * h / (float)n; #if defined(GIZMO_SPH) || defined(SHADOWFAX_SPH) @@ -355,8 +363,8 @@ void dump_particle_fields(char *fileName, struct cell *main_cell, /* Write header */ fprintf(file, - "# %4s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s " - "%8s %8s %8s %8s %8s\n", + "# %4s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %8s %13s %13s " + "%13s %13s %13s %8s %8s\n", "ID", "pos_x", "pos_y", "pos_z", "v_x", "v_y", "v_z", "h", "rho", "div_v", "S", "u", "P", "c", "a_x", "a_y", "a_z", "h_dt", "v_sig", "dS/dt", "du/dt"); @@ -368,7 +376,7 @@ void dump_particle_fields(char *fileName, struct cell *main_cell, fprintf(file, "%6llu %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f " "%8.5f " - "%8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f\n", + "%8.5f %8.5f %13e %13e %13e %13e %13e %8.5f %8.5f\n", main_cell->parts[pid].id, main_cell->parts[pid].x[0], main_cell->parts[pid].x[1], main_cell->parts[pid].x[2], main_cell->parts[pid].v[0], main_cell->parts[pid].v[1], @@ -407,7 +415,7 @@ void dump_particle_fields(char *fileName, struct cell *main_cell, fprintf(file, "%6llu %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f " "%8.5f %8.5f " - "%8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f %8.5f\n", + "%8.5f %8.5f %13f %13f %13f %13f %13f %8.5f %8.5f\n", solution[pid].id, solution[pid].x[0], solution[pid].x[1], solution[pid].x[2], solution[pid].v[0], solution[pid].v[1], solution[pid].v[2], solution[pid].h, solution[pid].rho, @@ -433,6 +441,7 @@ int main(int argc, char *argv[]) { size_t runs = 0, particles = 0; double h = 1.23485, size = 1., rho = 2.5; + double perturbation = 0.; char outputFileNameExtension[200] = ""; char outputFileName[200] = ""; enum velocity_field vel = velocity_zero; @@ -463,6 +472,9 @@ int main(int argc, char *argv[]) { case 'r': sscanf(optarg, "%zu", &runs); break; + case 'd': + sscanf(optarg, "%lf", &perturbation); + break; case 'm': sscanf(optarg, "%lf", &rho); break; @@ -492,6 +504,7 @@ int main(int argc, char *argv[]) { "\n-h DISTANCE=1.2348 - Smoothing length in units of <x>" "\n-m rho - Physical density in the cell" "\n-s size - Physical size of the cell" + "\n-d pert - Perturbation to apply to the particles [0,1[" "\n-v type (0,1,2,3) - Velocity field: (zero, constant, divergent, " "rotating)" "\n-p type (0,1,2) - Pressure field: (constant, gradient divergent)" @@ -536,7 +549,8 @@ int main(int argc, char *argv[]) { struct hydro_props hp; hp.target_neighbours = pow_dimension(h) * kernel_norm; - hp.delta_neighbours = 2.; + hp.delta_neighbours = 4.; + hp.h_max = FLT_MAX; hp.max_smoothing_iterations = 1; hp.CFL_condition = 0.1; @@ -566,8 +580,8 @@ int main(int argc, char *argv[]) { const double offset[3] = {i * size, j * size, k * size}; /* Construct it */ - cells[i * 25 + j * 5 + k] = - make_cell(particles, offset, size, h, rho, &partId, vel, press); + cells[i * 25 + j * 5 + k] = make_cell( + particles, offset, size, h, rho, &partId, perturbation, vel, press); /* Store the inner cells */ if (i > 0 && i < 4 && j > 0 && j < 4 && k > 0 && k < 4) { @@ -595,6 +609,12 @@ int main(int argc, char *argv[]) { /* Initialise the particles */ for (int j = 0; j < 125; ++j) runner_do_drift_part(&runner, cells[j], 0); + /* Reset particles. */ + for (int i = 0; i < 125; ++i) { + for (int n = 0; n < cells[i]->count; ++n) + hydro_init_part(&cells[i]->parts[n], &space.hs); + } + /* First, sort stuff */ for (int j = 0; j < 125; ++j) runner_do_sort(&runner, cells[j], 0x1FFF, 0); diff --git a/tests/test125cells.sh.in b/tests/test125cells.sh.in index 1d3b0db75d70bf2d5047f71b183812702305df75..d6d3ddc5b6b61bbd493c94005fd500a93ae7a01d 100755 --- a/tests/test125cells.sh.in +++ b/tests/test125cells.sh.in @@ -7,15 +7,25 @@ do rm -f brute_force_125_standard.dat swift_dopair_125_standard.dat + echo "Running ./test125cells -n 6 -r 1 -v $v -p $p -f standard" ./test125cells -n 6 -r 1 -v $v -p $p -f standard if [ -e brute_force_125_standard.dat ] then - python @srcdir@/difffloat.py brute_force_125_standard.dat swift_dopair_125_standard.dat @srcdir@/tolerance_125.dat 6 + if python @srcdir@/difffloat.py brute_force_125_standard.dat swift_dopair_125_standard.dat @srcdir@/tolerance_125_normal.dat 6 + then + echo "Accuracy test passed" + else + echo "Accuracy test failed" + exit 1 + fi else + echo "Error Missing test output file" exit 1 fi + echo "------------" + done done diff --git a/tests/test125cellsPerturbed.sh.in b/tests/test125cellsPerturbed.sh.in new file mode 100755 index 0000000000000000000000000000000000000000..9a5cfc07c978b0cfd5aa050aa117e887a1d40907 --- /dev/null +++ b/tests/test125cellsPerturbed.sh.in @@ -0,0 +1,32 @@ +#!/bin/bash +for v in {0..3} +do + for p in {0..2} + do + echo "" + + rm -f brute_force_125_perturbed.dat swift_dopair_125_perturbed.dat + + echo "Running ./test125cells -n 6 -r 1 -d 0.1 -v $v -p $p -f perturbed" + ./test125cells -n 6 -r 1 -d 0.1 -v $v -p $p -f perturbed + + if [ -e brute_force_125_perturbed.dat ] + then + if python @srcdir@/difffloat.py brute_force_125_perturbed.dat swift_dopair_125_perturbed.dat @srcdir@/tolerance_125_perturbed.dat 6 + then + echo "Accuracy test passed" + else + echo "Accuracy test failed" + exit 1 + fi + else + echo "Error Missing test output file" + exit 1 + fi + + echo "------------" + + done +done + +exit $? diff --git a/tests/test27cells.sh.in b/tests/test27cells.sh.in index 07b6b92a82cee2bbe9c593f8f62e750d4406f84e..4312ce55e13097d4ae40c289b9c5caa885ff37cc 100755 --- a/tests/test27cells.sh.in +++ b/tests/test27cells.sh.in @@ -3,18 +3,28 @@ for v in {0..3} do echo "" - + rm -f brute_force_27_standard.dat swift_dopair_27_standard.dat + echo "Running ./test27cells -n 6 -r 1 -d 0 -f standard -v $v -a 1e-4" ./test27cells -n 6 -r 1 -d 0 -f standard -v $v -a 1e-4 if [ -e brute_force_27_standard.dat ] then - python @srcdir@/difffloat.py brute_force_27_standard.dat swift_dopair_27_standard.dat @srcdir@/tolerance_27_normal.dat 6 + if python @srcdir@/difffloat.py brute_force_27_standard.dat swift_dopair_27_standard.dat @srcdir@/tolerance_27_normal.dat 6 + then + echo "Accuracy test passed" + else + echo "Accuracy test failed" + exit 1 + fi else + echo "Error Missing test output file" exit 1 fi + echo "------------" + done exit $? diff --git a/tests/test27cellsPerturbed.sh.in b/tests/test27cellsPerturbed.sh.in index 1eb7b31bcd668e7362a9eb907be501aa8016abb8..2f2e1db76346ca8f0ea4c2365ee349e232a1ce53 100755 --- a/tests/test27cellsPerturbed.sh.in +++ b/tests/test27cellsPerturbed.sh.in @@ -6,15 +6,25 @@ do rm -f brute_force_27_perturbed.dat swift_dopair_27_perturbed.dat + echo "Running ./test27cells -n 6 -r 1 -d 0.1 -f perturbed -v $v -a 5e-4" ./test27cells -n 6 -r 1 -d 0.1 -f perturbed -v $v -a 5e-4 if [ -e brute_force_27_perturbed.dat ] then - python @srcdir@/difffloat.py brute_force_27_perturbed.dat swift_dopair_27_perturbed.dat @srcdir@/tolerance_27_perturbed.dat 6 1 + if python @srcdir@/difffloat.py brute_force_27_perturbed.dat swift_dopair_27_perturbed.dat @srcdir@/tolerance_27_perturbed.dat 6 1 + then + echo "Accuracy test passed" + else + echo "Accuracy test failed" + exit 1 + fi else + echo "Error Missing test output file" exit 1 fi + echo "------------" + done exit $? diff --git a/tests/testFFT.c b/tests/testFFT.c index 37b1b0ca00097593991dc551ae4dc5e90a11a3b4..4ddd030ece95bf26cbfe41f2408be7c3e0c50535 100644 --- a/tests/testFFT.c +++ b/tests/testFFT.c @@ -28,7 +28,6 @@ int main() { return 0; } #else /* Some standard headers. */ -#include <fenv.h> #include <stdlib.h> #include <string.h> @@ -41,9 +40,6 @@ int main() { unsigned long long cpufreq = 0; clocks_set_cpufreq(cpufreq); - /* Choke on FP-exceptions */ - feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW); - /* Make one particle */ int nr_gparts = 1; struct gpart *gparts = NULL; diff --git a/tests/tolerance_125.dat b/tests/tolerance_125_normal.dat similarity index 100% rename from tests/tolerance_125.dat rename to tests/tolerance_125_normal.dat diff --git a/tests/tolerance_125_perturbed.dat b/tests/tolerance_125_perturbed.dat new file mode 100644 index 0000000000000000000000000000000000000000..04e642b28cb3729cb81f8183c3e69595ac651876 --- /dev/null +++ b/tests/tolerance_125_perturbed.dat @@ -0,0 +1,3 @@ +# ID pos_x pos_y pos_z v_x v_y v_z h rho div_v S u P c a_x a_y a_z h_dt v_sig dS/dt du/dt + 0 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 + 0 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 1e-4 5e-3 5e-3 5e-3 1e-4 1e-4 1e-4 1e-4 diff --git a/tests/tolerance_27_normal.dat b/tests/tolerance_27_normal.dat index 9c7ca10414507746b41e453d75426a072f989d2e..31ee002bb9c73ff8d74cce545aff715476b33507 100644 --- a/tests/tolerance_27_normal.dat +++ b/tests/tolerance_27_normal.dat @@ -1,3 +1,3 @@ # ID pos_x pos_y pos_z v_x v_y v_z rho rho_dh wcount wcount_dh div_v curl_vx curl_vy curl_vz - 0 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 2e-6 4e-5 2e-4 2e-3 8e-6 6e-6 6e-6 6e-6 + 0 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 2e-6 4e-5 2e-4 2e-3 1e-5 6e-6 6e-6 6e-6 0 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1.2e-4 1e-4 1e-4 2e-4 1e-4 1e-4 1e-4 diff --git a/tests/tolerance_27_perturbed.dat b/tests/tolerance_27_perturbed.dat index b6ed8c2c18808156056f9c5816212866c2dfa998..9c6ee8c77cc6d53e67db9dbb86be197d49149b10 100644 --- a/tests/tolerance_27_perturbed.dat +++ b/tests/tolerance_27_perturbed.dat @@ -1,3 +1,3 @@ # ID pos_x pos_y pos_z v_x v_y v_z rho rho_dh wcount wcount_dh div_v curl_vx curl_vy curl_vz - 0 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1.2e-6 1e-4 5e-5 2e-3 3.1e-6 3e-6 3e-6 3e-6 - 0 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 2e-3 1e-5 1e-4 2e-5 2e-3 2e-3 2e-3 + 0 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1.2e-6 1e-4 5e-5 2e-3 4e-6 3e-6 3e-6 3e-6 + 0 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 1e-6 2e-3 1e-5 1e-4 4e-5 2e-3 2e-3 2e-3