Compare commits
39 Commits
cjy-falcon
...
aocc-cuda
| Author | SHA1 | Date | |
|---|---|---|---|
| b83baf8bc0 | |||
| 7ca0433c65 | |||
| 1d7d853691 | |||
| d5d8cda25a | |||
| 57c93ecb91 | |||
| b25d5f89dc | |||
| 8e8a93bad0 | |||
| d46418f1c3 | |||
| fd18380a42 | |||
| 5956a952a0 | |||
| 5d8dfaf679 | |||
| 24f4a45097 | |||
| f16469ea77 | |||
| f754aa1ec2 | |||
| c4194214c6 | |||
| 0ca86afd41 | |||
| f5bf3ab252 | |||
| d0d3f965a6 | |||
| fbb2ed112d | |||
| bd4ce3fbf3 | |||
| 5eb49949d9 | |||
| 39450228f5 | |||
| 063f28b3b4 | |||
| 1064a68d16 | |||
| dcc83bafcb | |||
| c4d8d41b25 | |||
| 0076b3ca18 | |||
| 9ff2f065be | |||
| 2317e4abde | |||
| fea2dcc0d5 | |||
| 5525465cad | |||
| 96829d0441 | |||
| 83afaf19ce | |||
| cb911dec06 | |||
| dd0e20d8c7 | |||
| ffa0d801ed | |||
| ae64a22178 | |||
| 85fe29cc2e | |||
06f62dee36
|
@@ -31,7 +31,7 @@ GPU_Part = 0.0
|
||||
## Setting the physical system and numerical method
|
||||
|
||||
Symmetry = "equatorial-symmetry" ## Symmetry of System: choose equatorial-symmetry、no-symmetry、octant-symmetry
|
||||
Equation_Class = "BSSN-EScalar" ## Evolution Equation: choose "BSSN", "BSSN-EScalar", "BSSN-EM", "Z4C"
|
||||
Equation_Class = "BSSN" ## Evolution Equation: choose "BSSN", "BSSN-EScalar", "BSSN-EM", "Z4C"
|
||||
## If "BSSN-EScalar" is chosen, it is necessary to set other parameters below
|
||||
Initial_Data_Method = "Ansorg-TwoPuncture" ## initial data method: choose "Ansorg-TwoPuncture", "Lousto-Analytical", "Cao-Analytical", "KerrSchild-Analytical"
|
||||
Time_Evolution_Method = "runge-kutta-45" ## time evolution method: choose "runge-kutta-45"
|
||||
@@ -158,7 +158,7 @@ Detector_Rmax = 160.0 ## farest dector distance
|
||||
|
||||
## Setting the apprent horizon
|
||||
|
||||
AHF_Find = "no" ## whether to find the apparent horizon: choose "yes" or "no"
|
||||
AHF_Find = "yes" ## whether to find the apparent horizon: choose "yes" or "no"
|
||||
|
||||
AHF_Find_Every = 24
|
||||
AHF_Dump_Time = 20.0
|
||||
|
||||
100
AMSS_NCKU_Program_Plot.py
Normal file
100
AMSS_NCKU_Program_Plot.py
Normal file
@@ -0,0 +1,100 @@
|
||||
##################################################################
|
||||
##
|
||||
## AMSS-NCKU Plot-Only Restart Script
|
||||
## Author: Xiaoqu / Claude
|
||||
## 2026/05/12
|
||||
##
|
||||
## This script checks for existing output data from AMSS_NCKU_Program.py.
|
||||
## If data exists, it skips all computation and goes directly to plotting,
|
||||
## saving time when plotting was interrupted.
|
||||
## If no data is found, it exits with a message.
|
||||
##
|
||||
##################################################################
|
||||
|
||||
## Guard against re-execution by multiprocessing child processes.
|
||||
if __name__ != '__main__':
|
||||
import sys as _sys
|
||||
_sys.exit(0)
|
||||
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
import AMSS_NCKU_Input as input_data
|
||||
|
||||
##################################################################
|
||||
|
||||
## Construct paths from input configuration
|
||||
File_directory = os.path.join(input_data.File_directory)
|
||||
output_directory = os.path.join(File_directory, "AMSS_NCKU_output")
|
||||
binary_results_directory = os.path.join(output_directory, input_data.Output_directory)
|
||||
figure_directory = os.path.join(File_directory, "figure")
|
||||
|
||||
##################################################################
|
||||
|
||||
## Check whether the required output data files exist
|
||||
|
||||
required_files = [
|
||||
os.path.join(binary_results_directory, "bssn_BH.dat"),
|
||||
os.path.join(binary_results_directory, "bssn_ADMQs.dat"),
|
||||
os.path.join(binary_results_directory, "bssn_psi4.dat"),
|
||||
os.path.join(binary_results_directory, "bssn_constraint.dat"),
|
||||
]
|
||||
|
||||
missing_files = [f for f in required_files if not os.path.exists(f)]
|
||||
|
||||
if missing_files:
|
||||
print(" No existing AMSS_NCKU_Program.py output data found. ")
|
||||
print(" The following required files are missing: ")
|
||||
for f in missing_files:
|
||||
print(f" {f}")
|
||||
print()
|
||||
print(" Please run AMSS_NCKU_Program.py first to generate the simulation data. ")
|
||||
print(" Exiting. ")
|
||||
sys.exit(1)
|
||||
|
||||
print(" Found existing AMSS_NCKU_Program.py output data. " )
|
||||
print(" Skipping all computation and going directly to plotting. " )
|
||||
print()
|
||||
|
||||
## Ensure the figure directory exists (it should, but be safe)
|
||||
os.makedirs(figure_directory, exist_ok=True)
|
||||
|
||||
##################################################################
|
||||
|
||||
## Plot the AMSS-NCKU program results
|
||||
|
||||
import plot_xiaoqu
|
||||
import plot_GW_strain_amplitude_xiaoqu
|
||||
from parallel_plot_helper import run_plot_tasks_parallel
|
||||
|
||||
plot_tasks = []
|
||||
|
||||
## Plot black hole trajectory
|
||||
plot_tasks.append((plot_xiaoqu.generate_puncture_orbit_plot, (binary_results_directory, figure_directory)))
|
||||
plot_tasks.append((plot_xiaoqu.generate_puncture_orbit_plot3D, (binary_results_directory, figure_directory)))
|
||||
|
||||
## Plot black hole separation vs. time
|
||||
plot_tasks.append((plot_xiaoqu.generate_puncture_distence_plot, (binary_results_directory, figure_directory)))
|
||||
|
||||
## Plot gravitational waveforms (psi4 and strain amplitude)
|
||||
for i in range(input_data.Detector_Number):
|
||||
plot_tasks.append((plot_xiaoqu.generate_gravitational_wave_psi4_plot, (binary_results_directory, figure_directory, i)))
|
||||
plot_tasks.append((plot_GW_strain_amplitude_xiaoqu.generate_gravitational_wave_amplitude_plot, (binary_results_directory, figure_directory, i)))
|
||||
|
||||
## Plot ADM mass evolution
|
||||
for i in range(input_data.Detector_Number):
|
||||
plot_tasks.append((plot_xiaoqu.generate_ADMmass_plot, (binary_results_directory, figure_directory, i)))
|
||||
|
||||
## Plot Hamiltonian constraint violation over time
|
||||
for i in range(input_data.grid_level):
|
||||
plot_tasks.append((plot_xiaoqu.generate_constraint_check_plot, (binary_results_directory, figure_directory, i)))
|
||||
|
||||
run_plot_tasks_parallel(plot_tasks)
|
||||
|
||||
## Plot stored binary data (runs serially, not in the parallel pool)
|
||||
plot_xiaoqu.generate_binary_data_plot(binary_results_directory, figure_directory)
|
||||
|
||||
print()
|
||||
print(" Plotting completed successfully. ")
|
||||
print()
|
||||
@@ -198,16 +198,16 @@ int main(int argc, char *argv[])
|
||||
if (myrank == 0)
|
||||
{
|
||||
string out_dir;
|
||||
char filename[50];
|
||||
map<string, string>::iterator iter;
|
||||
iter = parameters::str_par.find("output dir");
|
||||
if (iter != parameters::str_par.end())
|
||||
{
|
||||
out_dir = iter->second;
|
||||
}
|
||||
sprintf(filename, "%s/setting.par", out_dir.c_str());
|
||||
ofstream setfile;
|
||||
setfile.open(filename, ios::trunc);
|
||||
string filename;
|
||||
map<string, string>::iterator iter;
|
||||
iter = parameters::str_par.find("output dir");
|
||||
if (iter != parameters::str_par.end())
|
||||
{
|
||||
out_dir = iter->second;
|
||||
}
|
||||
filename = out_dir + "/setting.par";
|
||||
ofstream setfile;
|
||||
setfile.open(filename.c_str(), ios::trunc);
|
||||
|
||||
if (!setfile.good())
|
||||
{
|
||||
@@ -484,7 +484,11 @@ int main(int argc, char *argv[])
|
||||
cout << endl;
|
||||
}
|
||||
|
||||
delete ADM;
|
||||
// Let the process teardown reclaim the simulation object. Some derived
|
||||
// equation classes keep MPI/CUDA-backed state whose destructor ordering
|
||||
// is fragile at program shutdown.
|
||||
if (getenv("AMSS_DELETE_ADM_ON_EXIT"))
|
||||
delete ADM;
|
||||
|
||||
//=======================caculation done=============================================================
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -102,6 +102,16 @@ public:
|
||||
//-1: means no dumy dimension at all; 0: means rho; 1: means sigma
|
||||
};
|
||||
|
||||
// Thread-safe search result (no pointers to shared mutable state)
|
||||
struct PointSearchResult
|
||||
{
|
||||
bool found;
|
||||
Block *Bg;
|
||||
double gx, gy, gz; // global Cartesian coordinates
|
||||
double lx, ly, lz; // local coordinates within the found block
|
||||
int ssst; // source shell-patch type (-1 = Cartesian)
|
||||
};
|
||||
|
||||
int myrank;
|
||||
int shape[dim]; // for (rho, sigma, R), for rho and sigma means number of points for every pi/2
|
||||
double Rrange[2]; // for Rmin and Rmax
|
||||
@@ -175,6 +185,12 @@ public:
|
||||
MyList<Patch> *Pp, double CDH[dim], MyList<pointstru> *pss);
|
||||
bool prolongpointstru(MyList<pointstru> *&psul, bool ssyn, int tsst, MyList<ss_patch> *sPp, double DH[dim],
|
||||
MyList<Patch> *Pp, double CDH[dim], double x, double y, double z, int Symmetry, int rank_in);
|
||||
// Read-only point search — thread-safe (no shared mutable state modified)
|
||||
PointSearchResult prolongpointstru_search(bool ssyn, int tsst, MyList<ss_patch> *sPp, double DH[dim],
|
||||
MyList<Patch> *Pp, double CDH[dim], double x, double y, double z,
|
||||
int Symmetry, int rank_in);
|
||||
// Append a search result to a linked list — use inside omp critical section
|
||||
void prolongpointstru_append(MyList<pointstru> *&psul, const PointSearchResult &sr, int tsst);
|
||||
void setupintintstuff(int cpusize, MyList<Patch> *CPatL, int Symmetry);
|
||||
void intertransfer(MyList<pointstru> **src, MyList<pointstru> **dst,
|
||||
MyList<var> *VarList1 /* source */, MyList<var> *VarList2 /*target */,
|
||||
@@ -195,11 +211,11 @@ public:
|
||||
bool Interp_One_Point(MyList<var> *VarList,
|
||||
double *XX, /*input global Cartesian coordinate*/
|
||||
double *Shellf, int Symmetry);
|
||||
void write_Pablo_file_ss(int *ext, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax,
|
||||
char *filename, int sst);
|
||||
double L2Norm(var *vf);
|
||||
void L2Norm7(var **vf, double *norms);
|
||||
void Find_Maximum(MyList<var> *VarList, double *XX, double *Shellf);
|
||||
};
|
||||
void write_Pablo_file_ss(int *ext, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax,
|
||||
char *filename, int sst);
|
||||
double L2Norm(var *vf);
|
||||
void L2Norm7(var **vf, double *norms);
|
||||
void Find_Maximum(MyList<var> *VarList, double *XX, double *Shellf);
|
||||
};
|
||||
|
||||
#endif /* SHELLPATCH_H */
|
||||
|
||||
@@ -27,7 +27,7 @@ using namespace std;
|
||||
#endif
|
||||
|
||||
#include "TwoPunctures.h"
|
||||
#include <mkl_cblas.h>
|
||||
#include <cblas.h>
|
||||
|
||||
TwoPunctures::TwoPunctures(double mp, double mm, double b,
|
||||
double P_plusx, double P_plusy, double P_plusz,
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -54,21 +54,17 @@ public:
|
||||
void Interp_Constraint();
|
||||
void Constraint_Out();
|
||||
|
||||
protected:
|
||||
var *Sphio, *Spio;
|
||||
var *Sphi0, *Spi0;
|
||||
protected:
|
||||
var *Sphio, *Spio;
|
||||
var *Sphi0, *Spi0;
|
||||
var *Sphi, *Spi;
|
||||
var *Sphi1, *Spi1;
|
||||
var *Sphi_rhs, *Spi_rhs;
|
||||
|
||||
var *Cons_fR;
|
||||
|
||||
MyList<var> *BSSNStateList, *BSSNSynchList_pre, *BSSNSynchList_cor;
|
||||
MyList<var> *ScalarSynchList_pre, *ScalarSynchList_cor;
|
||||
Parallel::SyncCache *sync_cache_scalar_pre, *sync_cache_scalar_cor;
|
||||
|
||||
monitor *MaxScalar_Monitor;
|
||||
};
|
||||
|
||||
var *Cons_fR;
|
||||
|
||||
monitor *MaxScalar_Monitor;
|
||||
};
|
||||
|
||||
#endif /* BSSNESCALAR_CLASS_H */
|
||||
|
||||
|
||||
@@ -3,143 +3,11 @@
|
||||
!! note that the potential for scalar field in F(R) gravity
|
||||
!! is defined in the file Set_Rho_ADM.f90
|
||||
|
||||
#include "macrodef.fh"
|
||||
|
||||
! scalar RHS and stress-energy only; BSSN RHS can be supplied by CUDA.
|
||||
function compute_rhs_bssn_escalar_matter(ex, T, X, Y, Z, &
|
||||
chi , trK , &
|
||||
dxx , gxy , gxz , dyy , gyz , dzz, &
|
||||
Axx , Axy , Axz , Ayy , Ayz , Azz, &
|
||||
Gamx , Gamy , Gamz , &
|
||||
Lap , betax , betay , betaz , &
|
||||
dtSfx , dtSfy , dtSfz , &
|
||||
Sphi , Spi , &
|
||||
Sphi_rhs , Spi_rhs , &
|
||||
rho,Sx,Sy,Sz,Sxx,Sxy,Sxz,Syy,Syz,Szz, &
|
||||
Symmetry,Lev,eps) result(gont)
|
||||
implicit none
|
||||
|
||||
integer,intent(in ):: ex(1:3), Symmetry,Lev
|
||||
real*8, intent(in ):: T
|
||||
real*8, intent(in ):: X(1:ex(1)),Y(1:ex(2)),Z(1:ex(3))
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(inout) :: chi,dxx,dyy,dzz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(in ) :: trK
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(in ) :: gxy,gxz,gyz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(in ) :: Axx,Axy,Axz,Ayy,Ayz,Azz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(in ) :: Gamx,Gamy,Gamz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(inout) :: Lap, betax, betay, betaz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(in ) :: dtSfx, dtSfy, dtSfz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(in ) :: Sphi,Spi
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(out) :: Sphi_rhs,Spi_rhs
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(inout) :: rho,Sx,Sy,Sz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)),intent(inout) :: Sxx,Sxy,Sxz,Syy,Syz,Szz
|
||||
real*8,intent(in) :: eps
|
||||
integer::gont
|
||||
|
||||
real*8, dimension(ex(1),ex(2),ex(3)) :: gxx,gyy,gzz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)) :: chix,chiy,chiz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)) :: Lapx,Lapy,Lapz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)) :: Kx,Ky,Kz,S
|
||||
real*8, dimension(ex(1),ex(2),ex(3)) :: f,fxx,fxy,fxz,fyy,fyz,fzz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)) :: alpn1,chin1
|
||||
real*8, dimension(ex(1),ex(2),ex(3)) :: gupxx,gupxy,gupxz
|
||||
real*8, dimension(ex(1),ex(2),ex(3)) :: gupyy,gupyz,gupzz
|
||||
|
||||
real*8 :: dX
|
||||
real*8, parameter :: ZEO=0.d0, ONE = 1.D0, TWO = 2.D0, HALF = 0.5D0
|
||||
real*8, parameter :: SYM = 1.D0
|
||||
|
||||
dX = sum(chi)+sum(trK)+sum(dxx)+sum(gxy)+sum(gxz)+sum(dyy)+sum(gyz)+sum(dzz) &
|
||||
+sum(Gamx)+sum(Gamy)+sum(Gamz) &
|
||||
+sum(Lap)+sum(Sphi)+sum(Spi)
|
||||
if(dX.ne.dX) then
|
||||
if(sum(chi).ne.sum(chi))write(*,*)"bssn_escalar_matter: find NaN in chi"
|
||||
if(sum(trK).ne.sum(trK))write(*,*)"bssn_escalar_matter: find NaN in trk"
|
||||
if(sum(dxx).ne.sum(dxx))write(*,*)"bssn_escalar_matter: find NaN in dxx"
|
||||
if(sum(gxy).ne.sum(gxy))write(*,*)"bssn_escalar_matter: find NaN in gxy"
|
||||
if(sum(gxz).ne.sum(gxz))write(*,*)"bssn_escalar_matter: find NaN in gxz"
|
||||
if(sum(dyy).ne.sum(dyy))write(*,*)"bssn_escalar_matter: find NaN in dyy"
|
||||
if(sum(gyz).ne.sum(gyz))write(*,*)"bssn_escalar_matter: find NaN in gyz"
|
||||
if(sum(dzz).ne.sum(dzz))write(*,*)"bssn_escalar_matter: find NaN in dzz"
|
||||
if(sum(Gamx).ne.sum(Gamx))write(*,*)"bssn_escalar_matter: find NaN in Gamx"
|
||||
if(sum(Gamy).ne.sum(Gamy))write(*,*)"bssn_escalar_matter: find NaN in Gamy"
|
||||
if(sum(Gamz).ne.sum(Gamz))write(*,*)"bssn_escalar_matter: find NaN in Gamz"
|
||||
if(sum(Lap).ne.sum(Lap))write(*,*)"bssn_escalar_matter: find NaN in Lap"
|
||||
if(sum(Sphi).ne.sum(Sphi))write(*,*)"bssn_escalar_matter: find NaN in Sphi"
|
||||
if(sum(Spi).ne.sum(Spi))write(*,*)"bssn_escalar_matter: find NaN in Spi"
|
||||
gont = 1
|
||||
return
|
||||
endif
|
||||
|
||||
alpn1 = Lap + ONE
|
||||
chin1 = chi + ONE
|
||||
gxx = dxx + ONE
|
||||
gyy = dyy + ONE
|
||||
gzz = dzz + ONE
|
||||
|
||||
call fderivs(ex,chi,chix,chiy,chiz,X,Y,Z,SYM,SYM,SYM,Symmetry,Lev)
|
||||
call fderivs(ex,Lap,Lapx,Lapy,Lapz,X,Y,Z,SYM,SYM,SYM,Symmetry,Lev)
|
||||
|
||||
gupzz = gxx * gyy * gzz + gxy * gyz * gxz + gxz * gxy * gyz - &
|
||||
gxz * gyy * gxz - gxy * gxy * gzz - gxx * gyz * gyz
|
||||
gupxx = ( gyy * gzz - gyz * gyz ) / gupzz
|
||||
gupxy = - ( gxy * gzz - gyz * gxz ) / gupzz
|
||||
gupxz = ( gxy * gyz - gyy * gxz ) / gupzz
|
||||
gupyy = ( gxx * gzz - gxz * gxz ) / gupzz
|
||||
gupyz = - ( gxx * gyz - gxy * gxz ) / gupzz
|
||||
gupzz = ( gxx * gyy - gxy * gxy ) / gupzz
|
||||
|
||||
#if 1
|
||||
Sphi_rhs = alpn1 * Spi
|
||||
call fderivs(ex,Sphi,Kx,Ky,Kz,X,Y,Z,SYM,SYM,SYM,Symmetry,Lev)
|
||||
call fdderivs(ex,Sphi,fxx,fxy,fxz,fyy,fyz,fzz,X,Y,Z,SYM,SYM,SYM,Symmetry,Lev)
|
||||
Spi_rhs = gupxx * fxx + gupyy * fyy + gupzz * fzz + &
|
||||
( gupxy * fxy + gupxz * fxz + gupyz * fyz ) * TWO - &
|
||||
((Gamx+(gupxx*chix+gupxy*chiy+gupxz*chiz)/TWO/chin1)*Kx &
|
||||
+ (Gamy+(gupxy*chix+gupyy*chiy+gupyz*chiz)/TWO/chin1)*Ky &
|
||||
+ (Gamz+(gupxz*chix+gupyz*chiy+gupzz*chiz)/TWO/chin1)*Kz)
|
||||
Spi_rhs = Spi_rhs*alpn1 + &
|
||||
(gupxx*Lapx*Kx + gupxy*Lapx*Ky + gupxz*Lapx*Kz &
|
||||
+gupxy*Lapy*Kx + gupyy*Lapy*Ky + gupyz*Lapy*Kz &
|
||||
+gupxz*Lapz*Kx + gupyz*Lapz*Ky + gupzz*Lapz*Kz)
|
||||
|
||||
call frpotential(ex,Sphi,f,S)
|
||||
Spi_rhs = Spi_rhs*chin1 + alpn1*(trK*Spi - S)
|
||||
rho = chin1*((gupxx * Kx * Kx + gupyy * Ky * Ky + gupzz * Kz * Kz)/TWO + &
|
||||
gupxy * Kx * Ky + gupxz * Kx * Kz + gupyz * Ky * Kz ) &
|
||||
+ Spi*Spi/TWO+f
|
||||
Sx = -Spi*Kx
|
||||
Sy = -Spi*Ky
|
||||
Sz = -Spi*Kz
|
||||
f = (rho - Spi*Spi)/chin1
|
||||
Sxx = Kx*Kx-f*gxx
|
||||
Sxy = Kx*Ky-f*gxy
|
||||
Sxz = Kx*Kz-f*gxz
|
||||
Syy = Ky*Ky-f*gyy
|
||||
Syz = Ky*Kz-f*gyz
|
||||
Szz = Kz*Kz-f*gzz
|
||||
#else
|
||||
Sphi_rhs = ZEO
|
||||
Spi_rhs = ZEO
|
||||
rho = ZEO
|
||||
Sx = ZEO
|
||||
Sy = ZEO
|
||||
Sz = ZEO
|
||||
Sxx = ZEO
|
||||
Sxy = ZEO
|
||||
Sxz = ZEO
|
||||
Syy = ZEO
|
||||
Syz = ZEO
|
||||
Szz = ZEO
|
||||
#endif
|
||||
|
||||
gont = 0
|
||||
return
|
||||
end function compute_rhs_bssn_escalar_matter
|
||||
|
||||
! rhs for scalar and GR variables
|
||||
! here we consider vacuum spacetime only
|
||||
function compute_rhs_bssn_escalar(ex, T,X, Y, Z, &
|
||||
#include "macrodef.fh"
|
||||
|
||||
! rhs for scalar and GR variables
|
||||
! here we consider vacuum spacetime only
|
||||
function compute_rhs_bssn_escalar(ex, T,X, Y, Z, &
|
||||
chi , trK , &
|
||||
dxx , gxy , gxz , dyy , gyz , dzz, &
|
||||
Axx , Axy , Axz , Ayy , Ayz , Azz, &
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -144,7 +144,7 @@ public:
|
||||
bssn_class(double Couranti, double StartTimei, double TotalTimei, double DumpTimei, double d2DumpTimei, double CheckTimei, double AnasTimei,
|
||||
int Symmetryi, int checkruni, char *checkfilenamei, double numepssi, double numepsbi, double numepshi,
|
||||
int a_levi, int maxli, int decni, double maxrexi, double drexi);
|
||||
~bssn_class();
|
||||
virtual ~bssn_class();
|
||||
|
||||
void Evolve(int Steps);
|
||||
void RecursiveStep(int lev);
|
||||
@@ -178,17 +178,14 @@ public:
|
||||
virtual void Initialize();
|
||||
virtual void Read_Ansorg();
|
||||
virtual void Read_Pablo() {};
|
||||
virtual void Compute_Psi4(int lev);
|
||||
virtual void Step(int lev, int YN);
|
||||
virtual void Interp_Constraint(bool infg);
|
||||
virtual void Constraint_Out();
|
||||
virtual void Compute_Constraint();
|
||||
|
||||
protected:
|
||||
void Initialize_Level_Runtime();
|
||||
|
||||
#ifdef With_AHF
|
||||
protected:
|
||||
virtual void Compute_Psi4(int lev);
|
||||
virtual void Step(int lev, int YN);
|
||||
virtual void Interp_Constraint(bool infg);
|
||||
virtual void Constraint_Out();
|
||||
virtual void Compute_Constraint();
|
||||
|
||||
#ifdef With_AHF
|
||||
protected:
|
||||
MyList<var> *AHList, *AHDList, *GaugeList;
|
||||
int AHfindevery;
|
||||
double AHdumptime;
|
||||
|
||||
323
AMSS_NCKU_source/bssn_em_rhs_c.C
Normal file
323
AMSS_NCKU_source/bssn_em_rhs_c.C
Normal file
@@ -0,0 +1,323 @@
|
||||
#include "macrodef.h"
|
||||
#include "bssn_rhs.h"
|
||||
#include "share_func.h"
|
||||
#include "tool.h"
|
||||
#include <cstddef>
|
||||
|
||||
/*
|
||||
* C 版 BSSN-EM RHS kernel — replaces empart.f90 + bssn_rhs.f90 for BSSN+Maxwell.
|
||||
*
|
||||
* Computes:
|
||||
* 1. All metric and EM field derivatives
|
||||
* 2. Physical metric, Christoffel-like terms
|
||||
* 3. EM field RHS (E, B, Kpsi, Kphi)
|
||||
* 4. Stress-energy tensor (rho, Si, Sij)
|
||||
* 5. Calls f_compute_rhs_bssn (C BSSN RHS) with stress-energy
|
||||
* 6. Advection + KO dissipation for EM fields
|
||||
* 7. NaN check
|
||||
*/
|
||||
int f_compute_rhs_bssn_em_c(int *ex, double &T,
|
||||
double *X, double *Y, double *Z,
|
||||
double *chi, double *trK,
|
||||
double *dxx, double *gxy, double *gxz, double *dyy, double *gyz, double *dzz,
|
||||
double *Axx, double *Axy, double *Axz, double *Ayy, double *Ayz, double *Azz,
|
||||
double *Gamx, double *Gamy, double *Gamz,
|
||||
double *Lap, double *betax, double *betay, double *betaz,
|
||||
double *dtSfx, double *dtSfy, double *dtSfz,
|
||||
double *Ex, double *Ey, double *Ez,
|
||||
double *Bx, double *By, double *Bz,
|
||||
double *Kpsi, double *Kphi,
|
||||
double *Jx, double *Jy, double *Jz, double *qchar,
|
||||
double *chi_rhs, double *trK_rhs,
|
||||
double *gxx_rhs, double *gxy_rhs, double *gxz_rhs,
|
||||
double *gyy_rhs, double *gyz_rhs, double *gzz_rhs,
|
||||
double *Axx_rhs, double *Axy_rhs, double *Axz_rhs,
|
||||
double *Ayy_rhs, double *Ayz_rhs, double *Azz_rhs,
|
||||
double *Gamx_rhs, double *Gamy_rhs, double *Gamz_rhs,
|
||||
double *Lap_rhs, double *betax_rhs, double *betay_rhs, double *betaz_rhs,
|
||||
double *dtSfx_rhs, double *dtSfy_rhs, double *dtSfz_rhs,
|
||||
double *Ex_rhs, double *Ey_rhs, double *Ez_rhs,
|
||||
double *Bx_rhs, double *By_rhs, double *Bz_rhs,
|
||||
double *Kpsi_rhs, double *Kphi_rhs,
|
||||
double *rho, double *Sx, double *Sy, double *Sz,
|
||||
double *Sxx, double *Sxy, double *Sxz,
|
||||
double *Syy, double *Syz, double *Szz,
|
||||
double *Gamxxx, double *Gamxxy, double *Gamxxz,
|
||||
double *Gamxyy, double *Gamxyz, double *Gamxzz,
|
||||
double *Gamyxx, double *Gamyxy, double *Gamyxz,
|
||||
double *Gamyyy, double *Gamyyz, double *Gamyzz,
|
||||
double *Gamzxx, double *Gamzxy, double *Gamzxz,
|
||||
double *Gamzyy, double *Gamzyz, double *Gamzzz,
|
||||
double *Rxx, double *Rxy, double *Rxz,
|
||||
double *Ryy, double *Ryz, double *Rzz,
|
||||
double *ham_Res, double *movx_Res, double *movy_Res, double *movz_Res,
|
||||
double *Gmx_Res, double *Gmy_Res, double *Gmz_Res,
|
||||
int &Symmetry, int &Lev, double &eps, int &co)
|
||||
{
|
||||
(void)T;
|
||||
int gont = 0;
|
||||
const int nx = ex[0], ny = ex[1], nz = ex[2];
|
||||
const int all = nx * ny * nz;
|
||||
const size_t n = (size_t)all;
|
||||
|
||||
const double ZEO = 0.0, ONE = 1.0, TWO = 2.0, FOUR = 4.0, EIT = 8.0;
|
||||
const double HALF = 0.5, THR = 3.0, F3o2 = 1.5, PI = 3.14159265358979323846;
|
||||
const double SYM = 1.0, ANTI = -1.0;
|
||||
const double kappa = 1.0;
|
||||
const double SSS[3]={SYM,SYM,SYM}, AAS[3]={ANTI,ANTI,SYM};
|
||||
const double ASA[3]={ANTI,SYM,ANTI}, SAA[3]={SYM,ANTI,ANTI};
|
||||
const double ASS[3]={ANTI,SYM,SYM}, SAS[3]={SYM,ANTI,SYM};
|
||||
const double SSA[3]={SYM,SYM,ANTI};
|
||||
|
||||
/* ---- allocate temporary arrays ---- */
|
||||
double *chix = (double*)malloc(n*sizeof(double));
|
||||
double *chiy = (double*)malloc(n*sizeof(double));
|
||||
double *chiz = (double*)malloc(n*sizeof(double));
|
||||
double *Exx=(double*)malloc(n*sizeof(double)),*Exy=(double*)malloc(n*sizeof(double)),*Exz=(double*)malloc(n*sizeof(double));
|
||||
double *Eyx=(double*)malloc(n*sizeof(double)),*Eyy=(double*)malloc(n*sizeof(double)),*Eyz=(double*)malloc(n*sizeof(double));
|
||||
double *Ezx=(double*)malloc(n*sizeof(double)),*Ezy=(double*)malloc(n*sizeof(double)),*Ezz=(double*)malloc(n*sizeof(double));
|
||||
double *Bxx=(double*)malloc(n*sizeof(double)),*Bxy=(double*)malloc(n*sizeof(double)),*Bxz=(double*)malloc(n*sizeof(double));
|
||||
double *Byx=(double*)malloc(n*sizeof(double)),*Byy=(double*)malloc(n*sizeof(double)),*Byz=(double*)malloc(n*sizeof(double));
|
||||
double *Bzx=(double*)malloc(n*sizeof(double)),*Bzy=(double*)malloc(n*sizeof(double)),*Bzz=(double*)malloc(n*sizeof(double));
|
||||
double *Kpsix=(double*)malloc(n*sizeof(double)),*Kpsiy=(double*)malloc(n*sizeof(double)),*Kpsiz=(double*)malloc(n*sizeof(double));
|
||||
double *Kphix=(double*)malloc(n*sizeof(double)),*Kphiy=(double*)malloc(n*sizeof(double)),*Kphiz=(double*)malloc(n*sizeof(double));
|
||||
double *Lapx=(double*)malloc(n*sizeof(double)),*Lapy=(double*)malloc(n*sizeof(double)),*Lapz=(double*)malloc(n*sizeof(double));
|
||||
double *betaxx=(double*)malloc(n*sizeof(double)),*betaxy=(double*)malloc(n*sizeof(double)),*betaxz=(double*)malloc(n*sizeof(double));
|
||||
double *betayx=(double*)malloc(n*sizeof(double)),*betayy=(double*)malloc(n*sizeof(double)),*betayz=(double*)malloc(n*sizeof(double));
|
||||
double *betazx=(double*)malloc(n*sizeof(double)),*betazy=(double*)malloc(n*sizeof(double)),*betazz=(double*)malloc(n*sizeof(double));
|
||||
double *gxxx=(double*)malloc(n*sizeof(double)),*gxxy=(double*)malloc(n*sizeof(double)),*gxxz=(double*)malloc(n*sizeof(double));
|
||||
double *gxyx=(double*)malloc(n*sizeof(double)),*gxyy=(double*)malloc(n*sizeof(double)),*gxyz=(double*)malloc(n*sizeof(double));
|
||||
double *gxzx=(double*)malloc(n*sizeof(double)),*gxzy=(double*)malloc(n*sizeof(double)),*gxzz=(double*)malloc(n*sizeof(double));
|
||||
double *gyyx=(double*)malloc(n*sizeof(double)),*gyyy=(double*)malloc(n*sizeof(double)),*gyyz=(double*)malloc(n*sizeof(double));
|
||||
double *gyzx=(double*)malloc(n*sizeof(double)),*gyzy=(double*)malloc(n*sizeof(double)),*gyzz=(double*)malloc(n*sizeof(double));
|
||||
double *gzzx=(double*)malloc(n*sizeof(double)),*gzzy=(double*)malloc(n*sizeof(double)),*gzzz=(double*)malloc(n*sizeof(double));
|
||||
double *gupxx=(double*)malloc(n*sizeof(double)),*gupxy=(double*)malloc(n*sizeof(double)),*gupxz=(double*)malloc(n*sizeof(double));
|
||||
double *gupyy=(double*)malloc(n*sizeof(double)),*gupyz=(double*)malloc(n*sizeof(double)),*gupzz=(double*)malloc(n*sizeof(double));
|
||||
|
||||
if (!chix||!chiy||!chiz||!Exx||!Exy||!Exz||!Eyx||!Eyy||!Eyz||!Ezx||!Ezy||!Ezz||
|
||||
!Bxx||!Bxy||!Bxz||!Byx||!Byy||!Byz||!Bzx||!Bzy||!Bzz||
|
||||
!Kpsix||!Kpsiy||!Kpsiz||!Kphix||!Kphiy||!Kphiz||
|
||||
!Lapx||!Lapy||!Lapz||
|
||||
!betaxx||!betaxy||!betaxz||!betayx||!betayy||!betayz||!betazx||!betazy||!betazz||
|
||||
!gxxx||!gxxy||!gxxz||!gxyx||!gxyy||!gxyz||!gxzx||!gxzy||!gxzz||
|
||||
!gyyx||!gyyy||!gyyz||!gyzx||!gyzy||!gyzz||!gzzx||!gzzy||!gzzz||
|
||||
!gupxx||!gupxy||!gupxz||!gupyy||!gupyz||!gupzz) {
|
||||
gont = 1;
|
||||
}
|
||||
|
||||
/* ==== 1. Compute all derivatives ==== */
|
||||
if (!gont) {
|
||||
|
||||
/* metric derivatives */
|
||||
fderivs(ex, Lap, Lapx, Lapy, Lapz, X, Y, Z, SYM, SYM, SYM, Symmetry, Lev);
|
||||
fderivs(ex, betax, betaxx, betaxy, betaxz, X, Y, Z, ANTI, SYM, SYM, Symmetry, Lev);
|
||||
fderivs(ex, betay, betayx, betayy, betayz, X, Y, Z, SYM, ANTI, SYM, Symmetry, Lev);
|
||||
fderivs(ex, betaz, betazx, betazy, betazz, X, Y, Z, SYM, SYM, ANTI, Symmetry, Lev);
|
||||
fderivs(ex, chi, chix, chiy, chiz, X, Y, Z, SYM, SYM, SYM, Symmetry, Lev);
|
||||
fderivs(ex, dxx, gxxx, gxxy, gxxz, X, Y, Z, SYM, SYM, SYM, Symmetry, Lev);
|
||||
fderivs(ex, gxy, gxyx, gxyy, gxyz, X, Y, Z, ANTI, ANTI, SYM, Symmetry, Lev);
|
||||
fderivs(ex, gxz, gxzx, gxzy, gxzz, X, Y, Z, ANTI, SYM, ANTI, Symmetry, Lev);
|
||||
fderivs(ex, dyy, gyyx, gyyy, gyyz, X, Y, Z, SYM, SYM, SYM, Symmetry, Lev);
|
||||
fderivs(ex, gyz, gyzx, gyzy, gyzz, X, Y, Z, SYM, ANTI, ANTI, Symmetry, Lev);
|
||||
fderivs(ex, dzz, gzzx, gzzy, gzzz, X, Y, Z, SYM, SYM, SYM, Symmetry, Lev);
|
||||
|
||||
/* EM field derivatives */
|
||||
fderivs(ex, Kpsi, Kpsix, Kpsiy, Kpsiz, X, Y, Z, SYM, SYM, SYM, Symmetry, Lev);
|
||||
fderivs(ex, Kphi, Kphix, Kphiy, Kphiz, X, Y, Z, SYM, SYM, SYM, Symmetry, Lev);
|
||||
fderivs(ex, Ex, Exx, Exy, Exz, X, Y, Z, ANTI, SYM, SYM, Symmetry, Lev);
|
||||
fderivs(ex, Ey, Eyx, Eyy, Eyz, X, Y, Z, SYM, ANTI, SYM, Symmetry, Lev);
|
||||
fderivs(ex, Ez, Ezx, Ezy, Ezz, X, Y, Z, SYM, SYM, ANTI, Symmetry, Lev);
|
||||
fderivs(ex, Bx, Bxx, Bxy, Bxz, X, Y, Z, SYM, ANTI, ANTI, Symmetry, Lev);
|
||||
fderivs(ex, By, Byx, Byy, Byz, X, Y, Z, ANTI, SYM, ANTI, Symmetry, Lev);
|
||||
fderivs(ex, Bz, Bzx, Bzy, Bzz, X, Y, Z, ANTI, ANTI, SYM, Symmetry, Lev);
|
||||
|
||||
/* ==== 2. Compute EM RHS and stress-energy ==== */
|
||||
const double F1o4PI = ONE / (FOUR * PI);
|
||||
for (size_t i = 0; i < n; ++i) {
|
||||
const double alpn1 = Lap[i] + ONE;
|
||||
const double chin1 = chi[i] + ONE;
|
||||
const double chi3o2 = sqrt(chin1) * chin1; // chi^{3/2}
|
||||
const double ichi = ONE / chin1;
|
||||
|
||||
/* physical metric */
|
||||
const double pgxx = (dxx[i] + ONE) * ichi;
|
||||
const double pgyy = (dyy[i] + ONE) * ichi;
|
||||
const double pgzz = (dzz[i] + ONE) * ichi;
|
||||
const double pgxy = gxy[i] * ichi;
|
||||
const double pgxz = gxz[i] * ichi;
|
||||
const double pgyz = gyz[i] * ichi;
|
||||
|
||||
/* inverse physical metric */
|
||||
const double det = pgxx * pgyy * pgzz + pgxy * pgyz * pgxz + pgxz * pgxy * pgyz
|
||||
- pgxz * pgyy * pgxz - pgxy * pgxy * pgzz - pgxx * pgyz * pgyz;
|
||||
const double idet = ONE / det;
|
||||
const double upxx = (pgyy * pgzz - pgyz * pgyz) * idet;
|
||||
const double upxy = -(pgxy * pgzz - pgyz * pgxz) * idet;
|
||||
const double upxz = (pgxy * pgyz - pgyy * pgxz) * idet;
|
||||
const double upyy = (pgxx * pgzz - pgxz * pgxz) * idet;
|
||||
const double upyz = -(pgxx * pgyz - pgxy * pgxz) * idet;
|
||||
const double upzz = (pgxx * pgyy - pgxy * pgxy) * idet;
|
||||
gupxx[i]=upxx; gupxy[i]=upxy; gupxz[i]=upxz;
|
||||
gupyy[i]=upyy; gupyz[i]=upyz; gupzz[i]=upzz;
|
||||
|
||||
/* E-field RHS */
|
||||
/* curl(B) part: epsilon^{ijk} ∂_j (alpha * B_k) in coordinate basis */
|
||||
/* Using lower-index B fields: B_i_lower = pg_{ij} * B^j */
|
||||
const double BxL = pgxx*Bx[i] + pgxy*By[i] + pgxz*Bz[i];
|
||||
const double ByL = pgxy*Bx[i] + pgyy*By[i] + pgyz*Bz[i];
|
||||
const double BzL = pgxz*Bx[i] + pgyz*By[i] + pgzz*Bz[i];
|
||||
|
||||
/* Physical metric derivatives (chain rule from conformal) */
|
||||
const double pgxx_x = (gxxx[i] - pgxx*chix[i]) * ichi;
|
||||
/* const double pgxx_y = (gxxy[i] - pgxx*chiy[i]) * ichi; */
|
||||
const double pgxy_x = (gxyx[i] - pgxy*chix[i]) * ichi;
|
||||
const double pgxy_y = (gxyy[i] - pgxy*chiy[i]) * ichi;
|
||||
const double pgxz_x = (gxzx[i] - pgxz*chix[i]) * ichi;
|
||||
const double pgxz_z = (gxzz[i] - pgxz*chiz[i]) * ichi;
|
||||
const double pgyy_y = (gyyy[i] - pgyy*chiy[i]) * ichi;
|
||||
const double pgyz_y = (gyzy[i] - pgyz*chiy[i]) * ichi;
|
||||
const double pgyz_z = (gyzz[i] - pgyz*chiz[i]) * ichi;
|
||||
const double pgzz_z = (gzzz[i] - pgzz*chiz[i]) * ichi;
|
||||
|
||||
/* Curl_x(B) = ∂_y (alpha*BzL) - ∂_z (alpha*ByL) */
|
||||
const double aBx = alpn1*BxL, aBy = alpn1*ByL, aBz = alpn1*BzL;
|
||||
const double curlBx = (aBz*Lapy[i] + alpn1*(pgxz*Bxy[i]+pgyz*Byy[i]+pgzz*Bzy[i]) + alpn1*(Bx[i]*gxzy[i]+By[i]*gyzy[i]+Bz[i]*gzzy[i]))
|
||||
- (aBy*Lapz[i] + alpn1*(pgxy*Bxz[i]+pgyy*Byz[i]+pgyz*Bzz[i]) + alpn1*(Bx[i]*gxyz[i]+By[i]*gyyz[i]+Bz[i]*gyzz[i]));
|
||||
double curlBy = (aBx*Lapz[i] + alpn1*(pgxx*Bxz[i]+pgxy*Byz[i]+pgxz*Bzz[i]) + alpn1*(Bx[i]*gxxz[i]+By[i]*gxyz[i]+Bz[i]*gxzz[i]))
|
||||
- (aBz*Lapx[i] + alpn1*(pgxz*Bxx[i]+pgyz*Byx[i]+pgzz*Bzx[i]) + alpn1*(Bx[i]*gxzx[i]+By[i]*gyzx[i]+Bz[i]*gzzx[i]));
|
||||
double curlBz = (aBy*Lapx[i] + alpn1*(pgxy*Bxx[i]+pgyy*Byx[i]+pgyz*Bzx[i]) + alpn1*(Bx[i]*gxyx[i]+By[i]*gyyx[i]+Bz[i]*gyzx[i]))
|
||||
- (aBx*Lapy[i] + alpn1*(pgxx*Bxy[i]+pgxy*Byy[i]+pgxz*Bzy[i]) + alpn1*(Bx[i]*gxxy[i]+By[i]*gxyy[i]+Bz[i]*gxzy[i]));
|
||||
|
||||
/* Advection part: -beta^j * ∂_j E^i */
|
||||
const double advEx = Ex[i]*betaxx[i] + Ey[i]*betaxy[i] + Ez[i]*betaxz[i];
|
||||
const double advEy = Ex[i]*betayx[i] + Ey[i]*betayy[i] + Ez[i]*betayz[i];
|
||||
const double advEz = Ex[i]*betazx[i] + Ey[i]*betazy[i] + Ez[i]*betazz[i];
|
||||
|
||||
/* grad(Kpsi) contracted with inverse metric */
|
||||
const double gupKx = upxx*Kpsix[i] + upxy*Kpsiy[i] + upxz*Kpsiz[i];
|
||||
const double gupKy = upxy*Kpsix[i] + upyy*Kpsiy[i] + upyz*Kpsiz[i];
|
||||
const double gupKz = upxz*Kpsix[i] + upyz*Kpsiy[i] + upzz*Kpsiz[i];
|
||||
|
||||
Ex_rhs[i] = alpn1*trK[i]*Ex[i] - advEx - FOUR*PI*alpn1*Jx[i] - alpn1*gupKx + chi3o2*curlBx;
|
||||
Ey_rhs[i] = alpn1*trK[i]*Ey[i] - advEy - FOUR*PI*alpn1*Jy[i] - alpn1*gupKy + chi3o2*curlBy;
|
||||
Ez_rhs[i] = alpn1*trK[i]*Ez[i] - advEz - FOUR*PI*alpn1*Jz[i] - alpn1*gupKz + chi3o2*curlBz;
|
||||
|
||||
/* B-field RHS: similar but with -chi^{3/2} * curl(E) and grad(Kphi) */
|
||||
const double ExL = pgxx*Ex[i] + pgxy*Ey[i] + pgxz*Ez[i];
|
||||
const double EyL = pgxy*Ex[i] + pgyy*Ey[i] + pgyz*Ez[i];
|
||||
const double EzL = pgxz*Ex[i] + pgyz*Ey[i] + pgzz*Ez[i];
|
||||
|
||||
const double aEx = alpn1*ExL, aEy = alpn1*EyL, aEz = alpn1*EzL;
|
||||
const double curlEx = (aEz*Lapy[i] + alpn1*(pgxz*Exy[i]+pgyz*Eyy[i]+pgzz*Ezy[i]) + alpn1*(Ex[i]*gxzy[i]+Ey[i]*gyzy[i]+Ez[i]*gzzy[i]))
|
||||
- (aEy*Lapz[i] + alpn1*(pgxy*Exz[i]+pgyy*Eyz[i]+pgyz*Ezz[i]) + alpn1*(Ex[i]*gxyz[i]+Ey[i]*gyyz[i]+Ez[i]*gyzz[i]));
|
||||
double curlEy = (aEx*Lapz[i] + alpn1*(pgxx*Exz[i]+pgxy*Eyz[i]+pgxz*Ezz[i]) + alpn1*(Ex[i]*gxxz[i]+Ey[i]*gxyz[i]+Ez[i]*gxzz[i]))
|
||||
- (aEz*Lapx[i] + alpn1*(pgxz*Exx[i]+pgyz*Eyx[i]+pgzz*Ezx[i]) + alpn1*(Ex[i]*gxzx[i]+Ey[i]*gyzx[i]+Ez[i]*gzzx[i]));
|
||||
double curlEz = (aEy*Lapx[i] + alpn1*(pgxy*Exx[i]+pgyy*Eyx[i]+pgyz*Ezx[i]) + alpn1*(Ex[i]*gxyx[i]+Ey[i]*gyyx[i]+Ez[i]*gyzx[i]))
|
||||
- (aEx*Lapy[i] + alpn1*(pgxx*Exy[i]+pgxy*Eyy[i]+pgxz*Ezy[i]) + alpn1*(Ex[i]*gxxy[i]+Ey[i]*gxyy[i]+Ez[i]*gxzy[i]));
|
||||
|
||||
const double advBx = Bx[i]*betaxx[i] + By[i]*betaxy[i] + Bz[i]*betaxz[i];
|
||||
const double advBy = Bx[i]*betayx[i] + By[i]*betayy[i] + Bz[i]*betayz[i];
|
||||
const double advBz = Bx[i]*betazx[i] + By[i]*betazy[i] + Bz[i]*betazz[i];
|
||||
|
||||
const double gupKphix = upxx*Kphix[i] + upxy*Kphiy[i] + upxz*Kphiz[i];
|
||||
const double gupKphiy = upxy*Kphix[i] + upyy*Kphiy[i] + upyz*Kphiz[i];
|
||||
const double gupKphiz = upxz*Kphix[i] + upyz*Kphiy[i] + upzz*Kphiz[i];
|
||||
|
||||
Bx_rhs[i] = alpn1*trK[i]*Bx[i] - advBx - alpn1*gupKphix - chi3o2*curlEx;
|
||||
By_rhs[i] = alpn1*trK[i]*By[i] - advBy - alpn1*gupKphiy - chi3o2*curlEy;
|
||||
Bz_rhs[i] = alpn1*trK[i]*Bz[i] - advBz - alpn1*gupKphiz - chi3o2*curlEz;
|
||||
|
||||
/* Scalar potential RHS */
|
||||
const double divE = Exx[i] + Eyy[i] + Ezz[i];
|
||||
const double divB = Bxx[i] + Byy[i] + Bzz[i];
|
||||
const double chiCont = F3o2 * ichi * (chix[i]*Ex[i] + chiy[i]*Ey[i] + chiz[i]*Ez[i]);
|
||||
Kpsi_rhs[i] = FOUR*PI*alpn1*qchar[i] - alpn1*kappa*Kpsi[i] - alpn1*(divE - chiCont);
|
||||
Kphi_rhs[i] = -alpn1*kappa*Kphi[i] - alpn1*(divB - F3o2*ichi*(chix[i]*Bx[i] + chiy[i]*By[i] + chiz[i]*Bz[i]));
|
||||
|
||||
/* Stress-energy tensor */
|
||||
const double E2 = pgxx*Ex[i]*Ex[i] + pgyy*Ey[i]*Ey[i] + pgzz*Ez[i]*Ez[i]
|
||||
+ TWO*(pgxy*Ex[i]*Ey[i] + pgxz*Ex[i]*Ez[i] + pgyz*Ey[i]*Ez[i]);
|
||||
const double B2 = pgxx*Bx[i]*Bx[i] + pgyy*By[i]*By[i] + pgzz*Bz[i]*Bz[i]
|
||||
+ TWO*(pgxy*Bx[i]*By[i] + pgxz*Bx[i]*Bz[i] + pgyz*By[i]*Bz[i]);
|
||||
rho[i] = (E2 + B2) / (EIT * PI);
|
||||
const double ichi3o2 = ONE / chi3o2;
|
||||
Sx[i] = (Ey[i]*Bz[i] - Ez[i]*By[i]) * F1o4PI * ichi3o2;
|
||||
Sy[i] = (Ez[i]*Bx[i] - Ex[i]*Bz[i]) * F1o4PI * ichi3o2;
|
||||
Sz[i] = (Ex[i]*By[i] - Ey[i]*Bx[i]) * F1o4PI * ichi3o2;
|
||||
const double lExi = pgxx*Ex[i] + pgxy*Ey[i] + pgxz*Ez[i];
|
||||
const double lEyi = pgxy*Ex[i] + pgyy*Ey[i] + pgyz*Ez[i];
|
||||
const double lEzi = pgxz*Ex[i] + pgyz*Ey[i] + pgzz*Ez[i];
|
||||
const double lBxi = pgxx*Bx[i] + pgxy*By[i] + pgxz*Bz[i];
|
||||
const double lByi = pgxy*Bx[i] + pgyy*By[i] + pgyz*Bz[i];
|
||||
const double lBzi = pgxz*Bx[i] + pgyz*By[i] + pgzz*Bz[i];
|
||||
Sxx[i] = rho[i]*pgxx - (lExi*lExi + lBxi*lBxi) * F1o4PI;
|
||||
Sxy[i] = rho[i]*pgxy - (lExi*lEyi + lBxi*lByi) * F1o4PI;
|
||||
Sxz[i] = rho[i]*pgxz - (lExi*lEzi + lBxi*lBzi) * F1o4PI;
|
||||
Syy[i] = rho[i]*pgyy - (lEyi*lEyi + lByi*lByi) * F1o4PI;
|
||||
Syz[i] = rho[i]*pgyz - (lEyi*lEzi + lByi*lBzi) * F1o4PI;
|
||||
Szz[i] = rho[i]*pgzz - (lEzi*lEzi + lBzi*lBzi) * F1o4PI;
|
||||
}
|
||||
|
||||
/* ==== 3. Call BSSN RHS with EM stress-energy ==== */
|
||||
gont = f_compute_rhs_bssn(ex, T, X, Y, Z,
|
||||
chi, trK, dxx, gxy, gxz, dyy, gyz, dzz,
|
||||
Axx, Axy, Axz, Ayy, Ayz, Azz,
|
||||
Gamx, Gamy, Gamz, Lap, betax, betay, betaz, dtSfx, dtSfy, dtSfz,
|
||||
chi_rhs, trK_rhs,
|
||||
gxx_rhs, gxy_rhs, gxz_rhs, gyy_rhs, gyz_rhs, gzz_rhs,
|
||||
Axx_rhs, Axy_rhs, Axz_rhs, Ayy_rhs, Ayz_rhs, Azz_rhs,
|
||||
Gamx_rhs, Gamy_rhs, Gamz_rhs, Lap_rhs, betax_rhs, betay_rhs, betaz_rhs,
|
||||
dtSfx_rhs, dtSfy_rhs, dtSfz_rhs,
|
||||
rho, Sx, Sy, Sz, Sxx, Sxy, Sxz, Syy, Syz, Szz,
|
||||
Gamxxx, Gamxxy, Gamxxz, Gamxyy, Gamxyz, Gamxzz,
|
||||
Gamyxx, Gamyxy, Gamyxz, Gamyyy, Gamyyz, Gamyzz,
|
||||
Gamzxx, Gamzxy, Gamzxz, Gamzyy, Gamzyz, Gamzzz,
|
||||
Rxx, Rxy, Rxz, Ryy, Ryz, Rzz,
|
||||
ham_Res, movx_Res, movy_Res, movz_Res,
|
||||
Gmx_Res, Gmy_Res, Gmz_Res,
|
||||
Symmetry, Lev, eps, co);
|
||||
if (!gont) {
|
||||
|
||||
/* ==== 4. Advection terms for EM fields ==== */
|
||||
lopsided(ex, X, Y, Z, Kpsi, Kpsi_rhs, betax, betay, betaz, Symmetry, SSS);
|
||||
lopsided(ex, X, Y, Z, Kphi, Kphi_rhs, betax, betay, betaz, Symmetry, SSS);
|
||||
lopsided(ex, X, Y, Z, Ex, Ex_rhs, betax, betay, betaz, Symmetry, ASS);
|
||||
lopsided(ex, X, Y, Z, Ey, Ey_rhs, betax, betay, betaz, Symmetry, SAS);
|
||||
lopsided(ex, X, Y, Z, Ez, Ez_rhs, betax, betay, betaz, Symmetry, SSA);
|
||||
lopsided(ex, X, Y, Z, Bx, Bx_rhs, betax, betay, betaz, Symmetry, SAA);
|
||||
lopsided(ex, X, Y, Z, By, By_rhs, betax, betay, betaz, Symmetry, ASA);
|
||||
lopsided(ex, X, Y, Z, Bz, Bz_rhs, betax, betay, betaz, Symmetry, AAS);
|
||||
|
||||
/* ==== 5. KO dissipation for EM fields ==== */
|
||||
if (eps > ZEO) {
|
||||
kodis(ex, X, Y, Z, Kpsi, Kpsi_rhs, SSS, Symmetry, eps);
|
||||
kodis(ex, X, Y, Z, Kphi, Kphi_rhs, SSS, Symmetry, eps);
|
||||
kodis(ex, X, Y, Z, Ex, Ex_rhs, ASS, Symmetry, eps);
|
||||
kodis(ex, X, Y, Z, Ey, Ey_rhs, SAS, Symmetry, eps);
|
||||
kodis(ex, X, Y, Z, Ez, Ez_rhs, SSA, Symmetry, eps);
|
||||
kodis(ex, X, Y, Z, Bx, Bx_rhs, SAA, Symmetry, eps);
|
||||
kodis(ex, X, Y, Z, By, By_rhs, ASA, Symmetry, eps);
|
||||
kodis(ex, X, Y, Z, Bz, Bz_rhs, AAS, Symmetry, eps);
|
||||
}
|
||||
|
||||
/* ==== 6. NaN check ==== */
|
||||
for (int i = 0; i < all; ++i) {
|
||||
if (!isfinite(Ex_rhs[i]+Ey_rhs[i]+Ez_rhs[i]+Bx_rhs[i]+By_rhs[i]+Bz_rhs[i]+Kpsi_rhs[i]+Kphi_rhs[i])) {
|
||||
gont = 1; break;
|
||||
}
|
||||
}
|
||||
} /* inner if (!gont) */
|
||||
} /* outer if (!gont) */
|
||||
|
||||
free(chix);free(chiy);free(chiz);
|
||||
free(Exx);free(Exy);free(Exz);free(Eyx);free(Eyy);free(Eyz);free(Ezx);free(Ezy);free(Ezz);
|
||||
free(Bxx);free(Bxy);free(Bxz);free(Byx);free(Byy);free(Byz);free(Bzx);free(Bzy);free(Bzz);
|
||||
free(Kpsix);free(Kpsiy);free(Kpsiz);
|
||||
free(Kphix);free(Kphiy);free(Kphiz);
|
||||
free(Lapx);free(Lapy);free(Lapz);
|
||||
free(betaxx);free(betaxy);free(betaxz);free(betayx);free(betayy);free(betayz);free(betazx);free(betazy);free(betazz);
|
||||
free(gxxx);free(gxxy);free(gxxz);free(gxyx);free(gxyy);free(gxyz);free(gxzx);free(gxzy);free(gxzz);
|
||||
free(gyyx);free(gyyy);free(gyyz);free(gyzx);free(gyzy);free(gyzz);free(gzzx);free(gzzy);free(gzzz);
|
||||
free(gupxx);free(gupxy);free(gupxz);free(gupyy);free(gupyz);free(gupzz);
|
||||
return gont;
|
||||
}
|
||||
56
AMSS_NCKU_source/bssn_gpu.h
Normal file
56
AMSS_NCKU_source/bssn_gpu.h
Normal file
@@ -0,0 +1,56 @@
|
||||
|
||||
#ifndef BSSN_GPU_H_
|
||||
#define BSSN_GPU_H_
|
||||
#include "bssn_macro.h"
|
||||
#include "macrodef.h"
|
||||
|
||||
#define DEVICE_ID 0
|
||||
// #define DEVICE_ID_BY_MPI_RANK
|
||||
#define GRID_DIM 256
|
||||
#define BLOCK_DIM 128
|
||||
|
||||
#define _FH2_(i, j, k) fh[(i) + (j) * _1D_SIZE[2] + (k) * _2D_SIZE[2]]
|
||||
#define _FH3_(i, j, k) fh[(i) + (j) * _1D_SIZE[3] + (k) * _2D_SIZE[3]]
|
||||
#define pow2(x) ((x) * (x))
|
||||
#define TimeBetween(a, b) ((b.tv_sec - a.tv_sec) + (b.tv_usec - a.tv_usec) / 1000000.0f)
|
||||
#define M_ metac.
|
||||
#define Mh_ meta->
|
||||
#define Ms_ metassc.
|
||||
#define Msh_ metass->
|
||||
|
||||
// #define TIMING
|
||||
|
||||
#define RHS_SS_PARA int calledby, int mpi_rank, int *ex, double &T, double *crho, double *sigma, double *R, double *X, double *Y, double *Z, double *drhodx, double *drhody, double *drhodz, double *dsigmadx, double *dsigmady, double *dsigmadz, double *dRdx, double *dRdy, double *dRdz, double *drhodxx, double *drhodxy, double *drhodxz, double *drhodyy, double *drhodyz, double *drhodzz, double *dsigmadxx, double *dsigmadxy, double *dsigmadxz, double *dsigmadyy, double *dsigmadyz, double *dsigmadzz, double *dRdxx, double *dRdxy, double *dRdxz, double *dRdyy, double *dRdyz, double *dRdzz, double *chi, double *trK, double *dxx, double *gxy, double *gxz, double *dyy, double *gyz, double *dzz, double *Axx, double *Axy, double *Axz, double *Ayy, double *Ayz, double *Azz, double *Gamx, double *Gamy, double *Gamz, double *Lap, double *betax, double *betay, double *betaz, double *dtSfx, double *dtSfy, double *dtSfz, double *chi_rhs, double *trK_rhs, double *gxx_rhs, double *gxy_rhs, double *gxz_rhs, double *gyy_rhs, double *gyz_rhs, double *gzz_rhs, double *Axx_rhs, double *Axy_rhs, double *Axz_rhs, double *Ayy_rhs, double *Ayz_rhs, double *Azz_rhs, double *Gamx_rhs, double *Gamy_rhs, double *Gamz_rhs, double *Lap_rhs, double *betax_rhs, double *betay_rhs, double *betaz_rhs, double *dtSfx_rhs, double *dtSfy_rhs, double *dtSfz_rhs, double *rho, double *Sx, double *Sy, double *Sz, double *Sxx, double *Sxy, double *Sxz, double *Syy, double *Syz, double *Szz, double *Gamxxx, double *Gamxxy, double *Gamxxz, double *Gamxyy, double *Gamxyz, double *Gamxzz, double *Gamyxx, double *Gamyxy, double *Gamyxz, double *Gamyyy, double *Gamyyz, double *Gamyzz, double *Gamzxx, double *Gamzxy, double *Gamzxz, double *Gamzyy, double *Gamzyz, double *Gamzzz, double *Rxx, double *Rxy, double *Rxz, double *Ryy, double *Ryz, double *Rzz, double *ham_Res, double *movx_Res, double *movy_Res, double *movz_Res, double *Gmx_Res, double *Gmy_Res, double *Gmz_Res, int &Symmetry, int &Lev, double &eps, int &sst, int &co
|
||||
|
||||
/** main function */
|
||||
int gpu_rhs(int calledby, int mpi_rank, int *ex, double &T,
|
||||
double *X, double *Y, double *Z,
|
||||
double *chi, double *trK,
|
||||
double *dxx, double *gxy, double *gxz, double *dyy, double *gyz, double *dzz,
|
||||
double *Axx, double *Axy, double *Axz, double *Ayy, double *Ayz, double *Azz,
|
||||
double *Gamx, double *Gamy, double *Gamz,
|
||||
double *Lap, double *betax, double *betay, double *betaz,
|
||||
double *dtSfx, double *dtSfy, double *dtSfz,
|
||||
double *chi_rhs, double *trK_rhs,
|
||||
double *gxx_rhs, double *gxy_rhs, double *gxz_rhs, double *gyy_rhs, double *gyz_rhs, double *gzz_rhs,
|
||||
double *Axx_rhs, double *Axy_rhs, double *Axz_rhs, double *Ayy_rhs, double *Ayz_rhs, double *Azz_rhs,
|
||||
double *Gamx_rhs, double *Gamy_rhs, double *Gamz_rhs,
|
||||
double *Lap_rhs, double *betax_rhs, double *betay_rhs, double *betaz_rhs,
|
||||
double *dtSfx_rhs, double *dtSfy_rhs, double *dtSfz_rhs,
|
||||
double *rho, double *Sx, double *Sy, double *Sz, double *Sxx,
|
||||
double *Sxy, double *Sxz, double *Syy, double *Syz, double *Szz,
|
||||
double *Gamxxx, double *Gamxxy, double *Gamxxz, double *Gamxyy, double *Gamxyz, double *Gamxzz,
|
||||
double *Gamyxx, double *Gamyxy, double *Gamyxz, double *Gamyyy, double *Gamyyz, double *Gamyzz,
|
||||
double *Gamzxx, double *Gamzxy, double *Gamzxz, double *Gamzyy, double *Gamzyz, double *Gamzzz,
|
||||
double *Rxx, double *Rxy, double *Rxz, double *Ryy, double *Ryz, double *Rzz,
|
||||
double *ham_Res, double *movx_Res, double *movy_Res, double *movz_Res,
|
||||
double *Gmx_Res, double *Gmy_Res, double *Gmz_Res,
|
||||
int &Symmetry, int &Lev, double &eps, int &co);
|
||||
|
||||
int gpu_rhs_ss(RHS_SS_PARA);
|
||||
|
||||
#define Z4C_SS_PARA int calledby, int mpi_rank, int *ex, double &T, double *crho, double *sigma, double *R, double *X, double *Y, double *Z, double *drhodx, double *drhody, double *drhodz, double *dsigmadx, double *dsigmady, double *dsigmadz, double *dRdx, double *dRdy, double *dRdz, double *drhodxx, double *drhodxy, double *drhodxz, double *drhodyy, double *drhodyz, double *drhodzz, double *dsigmadxx, double *dsigmadxy, double *dsigmadxz, double *dsigmadyy, double *dsigmadyz, double *dsigmadzz, double *dRdxx, double *dRdxy, double *dRdxz, double *dRdyy, double *dRdyz, double *dRdzz, double *chi, double *trK, double *dxx, double *gxy, double *gxz, double *dyy, double *gyz, double *dzz, double *Axx, double *Axy, double *Axz, double *Ayy, double *Ayz, double *Azz, double *Gamx, double *Gamy, double *Gamz, double *Lap, double *betax, double *betay, double *betaz, double *dtSfx, double *dtSfy, double *dtSfz, double *TZ, double *chi_rhs, double *trK_rhs, double *gxx_rhs, double *gxy_rhs, double *gxz_rhs, double *gyy_rhs, double *gyz_rhs, double *gzz_rhs, double *Axx_rhs, double *Axy_rhs, double *Axz_rhs, double *Ayy_rhs, double *Ayz_rhs, double *Azz_rhs, double *Gamx_rhs, double *Gamy_rhs, double *Gamz_rhs, double *Lap_rhs, double *betax_rhs, double *betay_rhs, double *betaz_rhs, double *dtSfx_rhs, double *dtSfy_rhs, double *dtSfz_rhs, double *TZ_rhs, double *rho, double *Sx, double *Sy, double *Sz, double *Sxx, double *Sxy, double *Sxz, double *Syy, double *Syz, double *Szz, double *Gamxxx, double *Gamxxy, double *Gamxxz, double *Gamxyy, double *Gamxyz, double *Gamxzz, double *Gamyxx, double *Gamyxy, double *Gamyxz, double *Gamyyy, double *Gamyyz, double *Gamyzz, double *Gamzxx, double *Gamzxy, double *Gamzxz, double *Gamzyy, double *Gamzyz, double *Gamzzz, double *Rxx, double *Rxy, double *Rxz, double *Ryy, double *Ryz, double *Rzz, double *ham_Res, double *movx_Res, double *movy_Res, double *movz_Res, double *Gmx_Res, double *Gmy_Res, double *Gmz_Res, int &Symmetry, int &Lev, double &eps, int &sst, int &co
|
||||
|
||||
int gpu_rhs_z4c_ss(Z4C_SS_PARA);
|
||||
|
||||
#endif
|
||||
@@ -20,12 +20,14 @@ using namespace std;
|
||||
|
||||
__device__ volatile unsigned int global_count = 0;
|
||||
|
||||
#ifdef RESULT_CHECK
|
||||
void compare_result_gpu(int ftag1,double * datac,int data_num){
|
||||
double * data = (double*)malloc(sizeof(double)*data_num);
|
||||
cudaMemcpy(data, datac, data_num * sizeof(double), cudaMemcpyDeviceToHost);
|
||||
compare_result(ftag1,data,data_num);
|
||||
free(data);
|
||||
}
|
||||
#endif
|
||||
|
||||
__global__ void sub_symmetry_bd_ss_partF(int ord, double * func, double *funcc)
|
||||
{
|
||||
@@ -153,11 +155,11 @@ __global__ void sub_symmetry_bd_ss_partJ(int ord,double * func, double * funcc,d
|
||||
|
||||
inline void sub_symmetry_bd_ss(int ord,double * func, double * funcc,double * SoA){
|
||||
sub_symmetry_bd_ss_partF<<<GRID_DIM,BLOCK_DIM>>>(ord,func,funcc);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
sub_symmetry_bd_ss_partI<<<GRID_DIM,BLOCK_DIM>>>(ord,func,funcc,SoA[0]);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
sub_symmetry_bd_ss_partJ<<<GRID_DIM,BLOCK_DIM>>>(ord,func,funcc,SoA[1]);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
|
||||
__global__ void sub_fderivs_shc_part1(double *fx,double *fy,double *fz){
|
||||
@@ -247,13 +249,13 @@ inline void sub_fderivs_shc(int& sst,double * f,double * fh,double *fx,double *f
|
||||
//cudaMemset(Msh_ gy,0,h_3D_SIZE[0] * sizeof(double));
|
||||
//cudaMemset(Msh_ gz,0,h_3D_SIZE[0] * sizeof(double));
|
||||
sub_symmetry_bd_ss(2,f,fh,SoA1);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
//compare_result_gpu(0,fh,h_3D_SIZE[2]);
|
||||
sub_fderivs_sh<<<GRID_DIM,BLOCK_DIM>>>(fh,Msh_ gx,Msh_ gy,Msh_ gz);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
sub_fderivs_shc_part1<<<GRID_DIM,BLOCK_DIM>>>(fx,fy,fz);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
//compare_result_gpu(1,fx,h_3D_SIZE[0]);
|
||||
//compare_result_gpu(2,fy,h_3D_SIZE[0]);
|
||||
//compare_result_gpu(3,fz,h_3D_SIZE[0]);
|
||||
@@ -451,17 +453,17 @@ inline void sub_fdderivs_shc(int& sst,double * f,double * fh,
|
||||
|
||||
//fderivs_sh
|
||||
sub_symmetry_bd_ss(2,f,fh,SoA1);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
//compare_result_gpu(1,fh,h_3D_SIZE[2]);
|
||||
sub_fderivs_sh<<<GRID_DIM,BLOCK_DIM>>>(fh,Msh_ gx,Msh_ gy,Msh_ gz);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
//fdderivs_sh
|
||||
sub_symmetry_bd_ss(2,f,fh,SoA1);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
//compare_result_gpu(21,fh,h_3D_SIZE[2]);
|
||||
sub_fdderivs_sh<<<GRID_DIM,BLOCK_DIM>>>(fh,Msh_ gxx,Msh_ gxy,Msh_ gxz,Msh_ gyy,Msh_ gyz,Msh_ gzz);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
/*compare_result_gpu(11,Msh_ gx,h_3D_SIZE[0]);
|
||||
compare_result_gpu(12,Msh_ gy,h_3D_SIZE[0]);
|
||||
compare_result_gpu(13,Msh_ gz,h_3D_SIZE[0]);
|
||||
@@ -472,7 +474,7 @@ inline void sub_fdderivs_shc(int& sst,double * f,double * fh,
|
||||
compare_result_gpu(5,Msh_ gyz,h_3D_SIZE[0]);
|
||||
compare_result_gpu(6,Msh_ gzz,h_3D_SIZE[0]);*/
|
||||
sub_fdderivs_shc_part1<<<GRID_DIM,BLOCK_DIM>>>(fxx,fxy,fxz,fyy,fyz,fzz);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
/*compare_result_gpu(1,fxx,h_3D_SIZE[0]);
|
||||
compare_result_gpu(2,fxy,h_3D_SIZE[0]);
|
||||
compare_result_gpu(3,fxz,h_3D_SIZE[0]);
|
||||
@@ -496,9 +498,9 @@ __global__ void computeRicci_ss_part1(double * dst)
|
||||
inline void computeRicci_ss(int &sst,double * src,double* dst,double * SoA, Meta* meta)
|
||||
{
|
||||
sub_fdderivs_shc(sst,src,Mh_ fh,Mh_ fxx,Mh_ fxy,Mh_ fxz,Mh_ fyy,Mh_ fyz,Mh_ fzz,SoA);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
computeRicci_ss_part1<<<GRID_DIM,BLOCK_DIM>>>(dst);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
}
|
||||
__global__ void sub_lopsided_ss_part1(double * dst)
|
||||
@@ -516,9 +518,9 @@ __global__ void sub_lopsided_ss_part1(double * dst)
|
||||
inline void sub_lopsided_ss(int& sst,double *src,double* dst,double *SoA)
|
||||
{
|
||||
sub_fderivs_shc(sst,src,Mh_ fh,Mh_ fxx,Mh_ fxy,Mh_ fxz,SoA);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
sub_lopsided_ss_part1<<<GRID_DIM,BLOCK_DIM>>>(dst);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
|
||||
__global__ void sub_kodis_sh_part1(double *f,double *fh,double *f_rhs)
|
||||
@@ -590,11 +592,11 @@ inline void sub_kodis_ss(int &sst,double *f,double *fh,double *f_rhs,double *SoA
|
||||
}
|
||||
//compare_result_gpu(10,f,h_3D_SIZE[0]);
|
||||
sub_symmetry_bd_ss(3,f,fh,SoA1);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
//compare_result_gpu(0,fh,h_3D_SIZE[3]);
|
||||
|
||||
sub_kodis_sh_part1<<<GRID_DIM,BLOCK_DIM>>>(f,fh,f_rhs);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
//compare_result_gpu(1,f_rhs,h_3D_SIZE[0]);
|
||||
}
|
||||
|
||||
@@ -1699,7 +1701,7 @@ void destroy_meta(Meta *meta,Metass *metass)
|
||||
if(Msh_ gzz) cudaFree(Msh_ gzz);
|
||||
|
||||
#if (GAUGE == 2 || GAUGE == 3 || GAUGE == 4 || GAUGE == 5 || GAUGE == 6 || GAUGE == 7)
|
||||
if(Mh_ reta) CUDA_SAFE_CALL(cudaFree(Mh_ reta));
|
||||
if(Mh_ reta) cudaFree(Mh_ reta);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1895,7 +1897,7 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
|
||||
//1.2 local Data
|
||||
cudaMalloc((void**)&(Mh_ gxx), matrix_size * sizeof(double));
|
||||
CUDA_SAFE_CALL( cudaMalloc((void**)&(Mh_ gyy), matrix_size * sizeof(double)));
|
||||
cudaMalloc((void**)&(Mh_ gyy), matrix_size * sizeof(double));
|
||||
cudaMalloc((void**)&(Mh_ gzz), matrix_size * sizeof(double));
|
||||
cudaMalloc((void**)&(Mh_ chix), matrix_size * sizeof(double));
|
||||
cudaMalloc((void**)&(Mh_ chiy), matrix_size * sizeof(double));
|
||||
@@ -2160,7 +2162,7 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
|
||||
double tmp_con2 = 1/Mass[0] - tmp_con;
|
||||
cudaMemcpyToSymbol(C1, &tmp_con2, sizeof(double));
|
||||
double tmp_con2 = 1/Mass[1] - tmp_con;
|
||||
tmp_con2 = 1/Mass[1] - tmp_con;
|
||||
cudaMemcpyToSymbol(C2, &tmp_con2, sizeof(double));
|
||||
|
||||
|
||||
@@ -2233,7 +2235,7 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
if((sst == 2 || sst == 4) && abs[1] < dYh)
|
||||
{
|
||||
ijkmin_h[1] = -2;
|
||||
ijkmin_h[1] = -3;
|
||||
ijkmin3_h[1] = -3;
|
||||
}
|
||||
if((sst == 3 || sst == 5) && abs_Y_ex2 < dYh)
|
||||
{
|
||||
@@ -2287,13 +2289,13 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
|
||||
|
||||
#ifdef TIMING1
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
gettimeofday(&tv2, NULL);
|
||||
cout<<"TIME USED"<<TimeBetween(tv1, tv2)<<endl;
|
||||
#endif
|
||||
//cout<<"GPU meta data ready.\n";
|
||||
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
|
||||
//-------------get device info-------------------------------------
|
||||
@@ -2306,7 +2308,7 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
//sub_enforce_ga(matrix_size);
|
||||
//4.1-----compute rhs---------
|
||||
compute_rhs_ss_part1<<<GRID_DIM,BLOCK_DIM>>>();
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
sub_fderivs_shc(sst,Mh_ betax,Mh_ fh,Mh_ betaxx,Mh_ betaxy,Mh_ betaxz,ass);
|
||||
sub_fderivs_shc(sst,Mh_ betay,Mh_ fh,Mh_ betayx,Mh_ betayy,Mh_ betayz,sas);
|
||||
@@ -2322,7 +2324,7 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
sub_fderivs_shc(sst,Mh_ gyz,Mh_ fh,Mh_ gyzx,Mh_ gyzy,Mh_ gyzz, saa);
|
||||
|
||||
compute_rhs_ss_part2<<<GRID_DIM,BLOCK_DIM>>>();
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
sub_fdderivs_shc(sst,Mh_ betax,Mh_ fh,Mh_ gxxx,Mh_ gxyx,Mh_ gxzx,Mh_ gyyx,Mh_ gyzx,Mh_ gzzx,ass);
|
||||
sub_fdderivs_shc(sst,Mh_ betay,Mh_ fh,Mh_ gxxy,Mh_ gxyy,Mh_ gxzy,Mh_ gyyy,Mh_ gyzy,Mh_ gzzy,sas);
|
||||
@@ -2332,7 +2334,7 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
sub_fderivs_shc( sst,Mh_ Gamz, Mh_ fh,Mh_ Gamzx, Mh_ Gamzy, Mh_ Gamzz,ssa);
|
||||
|
||||
compute_rhs_ss_part3<<<GRID_DIM,BLOCK_DIM>>>();
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
computeRicci_ss(sst,Mh_ dxx,Mh_ Rxx,sss, meta);
|
||||
computeRicci_ss(sst,Mh_ dyy,Mh_ Ryy,sss, meta);
|
||||
@@ -2340,25 +2342,25 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
computeRicci_ss(sst,Mh_ gxy,Mh_ Rxy,aas, meta);
|
||||
computeRicci_ss(sst,Mh_ gxz,Mh_ Rxz,asa, meta);
|
||||
computeRicci_ss(sst,Mh_ gyz,Mh_ Ryz,saa, meta);
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
compute_rhs_ss_part4<<<GRID_DIM,BLOCK_DIM>>>();
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
sub_fdderivs_shc(sst,Mh_ chi,Mh_ fh,Mh_ fxx,Mh_ fxy,Mh_ fxz,Mh_ fyy,Mh_ fyz,Mh_ fzz,sss);
|
||||
|
||||
//cudaThreadSynchronize();
|
||||
//cudaDeviceSynchronize();
|
||||
//compare_result_gpu(0,Mh_ chi,h_3D_SIZE[0]);
|
||||
//compare_result_gpu(1,Mh_ chi,h_3D_SIZE[0]);
|
||||
//compare_result_gpu(2,Mh_ fyz,h_3D_SIZE[0]);
|
||||
|
||||
compute_rhs_ss_part5<<<GRID_DIM,BLOCK_DIM>>>();
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
sub_fdderivs_shc(sst,Mh_ Lap,Mh_ fh,Mh_ fxx,Mh_ fxy,Mh_ fxz,Mh_ fyy,Mh_ fyz,Mh_ fzz,sss);
|
||||
|
||||
compute_rhs_ss_part6<<<GRID_DIM,BLOCK_DIM>>>();
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
#if (GAUGE == 2 || GAUGE == 3 || GAUGE == 4 || GAUGE == 5)
|
||||
sub_fderivs_shc(sst,Mh_ chi,Mh_ fh, Mh_ dtSfx_rhs, Mh_ dtSfy_rhs, Mh_ dtSfz_rhs,sss);
|
||||
@@ -2423,7 +2425,7 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
}
|
||||
if(co == 0){
|
||||
compute_rhs_ss_part7<<<GRID_DIM,BLOCK_DIM>>>();
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
|
||||
sub_fderivs_shc(sst,Mh_ Axx,Mh_ fh,Mh_ gxxx,Mh_ gxxy,Mh_ gxxz,sss);
|
||||
sub_fderivs_shc(sst,Mh_ Axy,Mh_ fh,Mh_ gxyx,Mh_ gxyy,Mh_ gxyz,aas);
|
||||
@@ -2432,7 +2434,7 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
sub_fderivs_shc(sst,Mh_ Ayz,Mh_ fh,Mh_ gyzx,Mh_ gyzy,Mh_ gyzz,saa);
|
||||
sub_fderivs_shc(sst,Mh_ Azz,Mh_ fh,Mh_ gzzx,Mh_ gzzy,Mh_ gzzz,sss);
|
||||
compute_rhs_ss_part8<<<GRID_DIM,BLOCK_DIM>>>();
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
}
|
||||
|
||||
#if (ABV == 1)
|
||||
@@ -2512,7 +2514,7 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
//test kodis
|
||||
//sub_kodis_sh(sst,Msh_ drhodx,Mh_ fh2,Msh_ drhody,sss);
|
||||
#ifdef TIMING
|
||||
cudaThreadSynchronize();
|
||||
cudaDeviceSynchronize();
|
||||
gettimeofday(&tv2, NULL);
|
||||
cout<<"MPI rank is: "<<mpi_rank<<" GPU TIME is"<<TimeBetween(tv1, tv2)<<" (s)."<<endl;
|
||||
#endif
|
||||
@@ -2522,4 +2524,55 @@ int gpu_rhs_ss(RHS_SS_PARA)
|
||||
return 0;//TODO return
|
||||
}
|
||||
|
||||
#if (ABEtype == 2)
|
||||
// Z4C Shell GPU: calls BSSN gpu_rhs_ss with trKd=trK+2*TZ, then applies
|
||||
// TZ_rhs = alpn1*Hcon/2 and constraint damping on CPU.
|
||||
int gpu_rhs_z4c_ss(Z4C_SS_PARA)
|
||||
{
|
||||
int matrix_size = ex[0] * ex[1] * ex[2];
|
||||
double k1 = 0.02, k2 = 0.0;
|
||||
|
||||
double *trKd_host = new double[matrix_size];
|
||||
for (int _i = 0; _i < matrix_size; _i++)
|
||||
trKd_host[_i] = trK[_i] + 2.0 * TZ[_i];
|
||||
|
||||
int result = gpu_rhs_ss(calledby, mpi_rank,
|
||||
ex, T, crho, sigma, R, X, Y, Z,
|
||||
drhodx, drhody, drhodz, dsigmadx, dsigmady, dsigmadz,
|
||||
dRdx, dRdy, dRdz,
|
||||
drhodxx, drhodxy, drhodxz, drhodyy, drhodyz, drhodzz,
|
||||
dsigmadxx, dsigmadxy, dsigmadxz, dsigmadyy, dsigmadyz, dsigmadzz,
|
||||
dRdxx, dRdxy, dRdxz, dRdyy, dRdyz, dRdzz,
|
||||
chi, trKd_host, dxx, gxy, gxz, dyy, gyz, dzz,
|
||||
Axx, Axy, Axz, Ayy, Ayz, Azz,
|
||||
Gamx, Gamy, Gamz,
|
||||
Lap, betax, betay, betaz,
|
||||
dtSfx, dtSfy, dtSfz,
|
||||
chi_rhs, trK_rhs,
|
||||
gxx_rhs, gxy_rhs, gxz_rhs, gyy_rhs, gyz_rhs, gzz_rhs,
|
||||
Axx_rhs, Axy_rhs, Axz_rhs, Ayy_rhs, Ayz_rhs, Azz_rhs,
|
||||
Gamx_rhs, Gamy_rhs, Gamz_rhs,
|
||||
Lap_rhs, betax_rhs, betay_rhs, betaz_rhs,
|
||||
dtSfx_rhs, dtSfy_rhs, dtSfz_rhs,
|
||||
rho, Sx, Sy, Sz, Sxx, Sxy, Sxz, Syy, Syz, Szz,
|
||||
Gamxxx, Gamxxy, Gamxxz, Gamxyy, Gamxyz, Gamxzz,
|
||||
Gamyxx, Gamyxy, Gamyxz, Gamyyy, Gamyyz, Gamyzz,
|
||||
Gamzxx, Gamzxy, Gamzxz, Gamzyy, Gamzyz, Gamzzz,
|
||||
Rxx, Rxy, Rxz, Ryy, Ryz, Rzz,
|
||||
ham_Res, movx_Res, movy_Res, movz_Res,
|
||||
Gmx_Res, Gmy_Res, Gmz_Res,
|
||||
Symmetry, Lev, eps, sst, co);
|
||||
delete[] trKd_host;
|
||||
if (result != 0) return result;
|
||||
|
||||
for (int _i = 0; _i < matrix_size; _i++) {
|
||||
double alp = Lap[_i] + 1.0;
|
||||
TZ_rhs[_i] = alp * ham_Res[_i] * 0.5;
|
||||
TZ_rhs[_i] -= alp * (2.0 + k2) * k1 * TZ[_i];
|
||||
trK_rhs[_i] += alp * k1 * (1.0 - k2) * TZ[_i];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif // ABEtype == 2
|
||||
|
||||
#endif //WithShell
|
||||
|
||||
@@ -5,9 +5,8 @@
|
||||
#ifdef fortran1
|
||||
#define f_compute_rhs_bssn compute_rhs_bssn
|
||||
#define f_compute_rhs_bssn_ss compute_rhs_bssn_ss
|
||||
#define f_compute_rhs_bssn_escalar compute_rhs_bssn_escalar
|
||||
#define f_compute_rhs_bssn_escalar_matter compute_rhs_bssn_escalar_matter
|
||||
#define f_compute_rhs_bssn_escalar_ss compute_rhs_bssn_escalar_ss
|
||||
#define f_compute_rhs_bssn_escalar compute_rhs_bssn_escalar
|
||||
#define f_compute_rhs_bssn_escalar_ss compute_rhs_bssn_escalar_ss
|
||||
#define f_compute_rhs_Z4c compute_rhs_z4c
|
||||
#define f_compute_rhs_Z4cnot compute_rhs_z4cnot
|
||||
#define f_compute_rhs_Z4c_ss compute_rhs_z4c_ss
|
||||
@@ -16,41 +15,39 @@
|
||||
#ifdef fortran2
|
||||
#define f_compute_rhs_bssn COMPUTE_RHS_BSSN
|
||||
#define f_compute_rhs_bssn_ss COMPUTE_RHS_BSSN_SS
|
||||
#define f_compute_rhs_bssn_escalar COMPUTE_RHS_BSSN_ESCALAR
|
||||
#define f_compute_rhs_bssn_escalar_matter COMPUTE_RHS_BSSN_ESCALAR_MATTER
|
||||
#define f_compute_rhs_bssn_escalar_ss COMPUTE_RHS_BSSN_ESCALAR_SS
|
||||
#define f_compute_rhs_bssn_escalar COMPUTE_RHS_BSSN_ESCALAR
|
||||
#define f_compute_rhs_bssn_escalar_ss COMPUTE_RHS_BSSN_ESCALAR_SS
|
||||
#define f_compute_rhs_Z4c COMPUTE_RHS_Z4C
|
||||
#define f_compute_rhs_Z4cnot COMPUTE_RHS_Z4CNOT
|
||||
#define f_compute_rhs_Z4c_ss COMPUTE_RHS_Z4C_SS
|
||||
#define f_compute_constraint_fr COMPUTE_CONSTRAINT_FR
|
||||
#endif
|
||||
#ifdef fortran3
|
||||
#define f_compute_rhs_bssn compute_rhs_bssn_
|
||||
#ifdef fortran3
|
||||
#define f_compute_rhs_bssn compute_rhs_bssn_
|
||||
#define f_compute_rhs_bssn_ss compute_rhs_bssn_ss_
|
||||
#define f_compute_rhs_bssn_escalar compute_rhs_bssn_escalar_
|
||||
#define f_compute_rhs_bssn_escalar_matter compute_rhs_bssn_escalar_matter_
|
||||
#define f_compute_rhs_bssn_escalar_ss compute_rhs_bssn_escalar_ss_
|
||||
#define f_compute_rhs_bssn_escalar compute_rhs_bssn_escalar_
|
||||
#define f_compute_rhs_bssn_escalar_ss compute_rhs_bssn_escalar_ss_
|
||||
#define f_compute_rhs_Z4c compute_rhs_z4c_
|
||||
#define f_compute_rhs_Z4cnot compute_rhs_z4cnot_
|
||||
#define f_compute_rhs_Z4c_ss compute_rhs_z4c_ss_
|
||||
#define f_compute_constraint_fr compute_constraint_fr_
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
void f_bssn_rhs_kernel_timing_reset();
|
||||
int f_bssn_rhs_kernel_timing_bucket_count();
|
||||
const double *f_bssn_rhs_kernel_timing_local_seconds();
|
||||
const char *f_bssn_rhs_kernel_timing_label(int);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
extern "C"
|
||||
{
|
||||
int f_compute_rhs_bssn(int *, double &, double *, double *, double *, // ex,T,X,Y,Z
|
||||
#define f_compute_constraint_fr compute_constraint_fr_
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
void f_bssn_rhs_kernel_timing_reset();
|
||||
int f_bssn_rhs_kernel_timing_bucket_count();
|
||||
const double *f_bssn_rhs_kernel_timing_local_seconds();
|
||||
const char *f_bssn_rhs_kernel_timing_label(int);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
extern "C"
|
||||
{
|
||||
int f_compute_rhs_bssn(int *, double &, double *, double *, double *, // ex,T,X,Y,Z
|
||||
double *, double *, // chi, trK
|
||||
double *, double *, double *, double *, double *, double *, // gij
|
||||
double *, double *, double *, double *, double *, double *, // Aij
|
||||
@@ -70,6 +67,27 @@ extern "C"
|
||||
int &, int &, double &, int &);
|
||||
}
|
||||
|
||||
int f_compute_rhs_bssn_escalar_c(int *, double &, double *, double *, double *, // ex,T,X,Y,Z
|
||||
double *, double *, // chi, trK
|
||||
double *, double *, double *, double *, double *, double *, // gij
|
||||
double *, double *, double *, double *, double *, double *, // Aij
|
||||
double *, double *, double *, // Gam
|
||||
double *, double *, double *, double *, double *, double *, double *, // Gauge
|
||||
double *, double *, // Sphi, Spi
|
||||
double *, double *, // chi, trK
|
||||
double *, double *, double *, double *, double *, double *, // gij
|
||||
double *, double *, double *, double *, double *, double *, // Aij
|
||||
double *, double *, double *, // Gam
|
||||
double *, double *, double *, double *, double *, double *, double *, // Gauge
|
||||
double *, double *, // Sphi, Spi
|
||||
double *, double *, double *, double *, double *, double *, double *, double *, double *, double *, // stress-energy
|
||||
double *, double *, double *, double *, double *, double *, // Christoffel
|
||||
double *, double *, double *, double *, double *, double *, // Christoffel
|
||||
double *, double *, double *, double *, double *, double *, // Christoffel
|
||||
double *, double *, double *, double *, double *, double *, // Ricci
|
||||
double *, double *, double *, double *, double *, double *, double *, // constraint violation
|
||||
int &, int &, double &, int &);
|
||||
|
||||
extern "C"
|
||||
{
|
||||
int f_compute_rhs_bssn_ss(int *, double &, double *, double *, double *, // ex,T,rho,sigma,R
|
||||
@@ -99,24 +117,10 @@ extern "C"
|
||||
int &, int &, double &, int &, int &);
|
||||
}
|
||||
|
||||
extern "C"
|
||||
{
|
||||
int f_compute_rhs_bssn_escalar_matter(int *, double &, double *, double *, double *, // ex,T,X,Y,Z
|
||||
double *, double *, // chi, trK
|
||||
double *, double *, double *, double *, double *, double *, // gij
|
||||
double *, double *, double *, double *, double *, double *, // Aij
|
||||
double *, double *, double *, // Gam
|
||||
double *, double *, double *, double *, double *, double *, double *, // Gauge
|
||||
double *, double *, // Sphi, Spi
|
||||
double *, double *, // Sphi, Spi rhs
|
||||
double *, double *, double *, double *, double *, double *, double *, double *, double *, double *, // stress-energy
|
||||
int &, int &, double &);
|
||||
}
|
||||
|
||||
extern "C"
|
||||
{
|
||||
int f_compute_rhs_bssn_escalar(int *, double &, double *, double *, double *, // ex,T,X,Y,Z
|
||||
double *, double *, // chi, trK
|
||||
extern "C"
|
||||
{
|
||||
int f_compute_rhs_bssn_escalar(int *, double &, double *, double *, double *, // ex,T,X,Y,Z
|
||||
double *, double *, // chi, trK
|
||||
double *, double *, double *, double *, double *, double *, // gij
|
||||
double *, double *, double *, double *, double *, double *, // Aij
|
||||
double *, double *, double *, // Gam
|
||||
@@ -258,4 +262,31 @@ extern "C"
|
||||
double *);
|
||||
} // FR_cons
|
||||
|
||||
// BSSN-EM C kernel (replaces empart.f90 + bssn_rhs.f90 for BSSN+Maxwell)
|
||||
int f_compute_rhs_bssn_em_c(int *, double &, double *, double *, double *,
|
||||
double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *,
|
||||
double *, double *,
|
||||
double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *,
|
||||
double *, double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
double *, double *, double *, double *, double *, double *,
|
||||
int &, int &, double &, int &);
|
||||
|
||||
#endif /* BSSN_H */
|
||||
|
||||
@@ -1075,6 +1075,10 @@ int f_compute_rhs_bssn(int *ex, double &T,
|
||||
}
|
||||
#endif
|
||||
|
||||
#if (GAUGE == 2 || GAUGE == 3 || GAUGE == 4 || GAUGE == 5)
|
||||
fderivs(ex,chi,dtSfx_rhs,dtSfy_rhs,dtSfz_rhs,X,Y,Z,SYM,SYM,SYM,Symmetry,Lev);
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < all; i += 1) {
|
||||
#if (GAUGE == 0)
|
||||
betax_rhs[i] = FF * dtSfx[i];
|
||||
@@ -1160,11 +1164,17 @@ int f_compute_rhs_bssn(int *ex, double &T,
|
||||
lopsided_kodis(ex,X,Y,Z,gyz,gyz_rhs,betax,betay,betaz,Symmetry,SAA,eps);
|
||||
lopsided_kodis(ex,X,Y,Z,betaz,betaz_rhs,betax,betay,betaz,Symmetry,SSA,eps);
|
||||
lopsided_kodis(ex,X,Y,Z,dzz,gzz_rhs,betax,betay,betaz,Symmetry,SSS,eps);
|
||||
#if (GAUGE == 0 || GAUGE == 2 || GAUGE == 3 || GAUGE == 6 || GAUGE == 7)
|
||||
lopsided_kodis(ex,X,Y,Z,dtSfx,dtSfx_rhs,betax,betay,betaz,Symmetry,ASS,eps);
|
||||
#endif
|
||||
lopsided_kodis(ex,X,Y,Z,Axx,Axx_rhs,betax,betay,betaz,Symmetry,SSS,eps);
|
||||
#if (GAUGE == 0 || GAUGE == 2 || GAUGE == 3 || GAUGE == 6 || GAUGE == 7)
|
||||
lopsided_kodis(ex,X,Y,Z,dtSfy,dtSfy_rhs,betax,betay,betaz,Symmetry,SAS,eps);
|
||||
#endif
|
||||
lopsided_kodis(ex,X,Y,Z,Axy,Axy_rhs,betax,betay,betaz,Symmetry,AAS,eps);
|
||||
#if (GAUGE == 0 || GAUGE == 2 || GAUGE == 3 || GAUGE == 6 || GAUGE == 7)
|
||||
lopsided_kodis(ex,X,Y,Z,dtSfz,dtSfz_rhs,betax,betay,betaz,Symmetry,SSA,eps);
|
||||
#endif
|
||||
lopsided_kodis(ex,X,Y,Z,Axz,Axz_rhs,betax,betay,betaz,Symmetry,ASA,eps);
|
||||
lopsided_kodis(ex,X,Y,Z,Ayy,Ayy_rhs,betax,betay,betaz,Symmetry,SSS,eps);
|
||||
lopsided_kodis(ex,X,Y,Z,Ayz,Ayz_rhs,betax,betay,betaz,Symmetry,SAA,eps);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -7,6 +7,9 @@ extern "C" {
|
||||
|
||||
enum {
|
||||
BSSN_CUDA_STATE_COUNT = 24,
|
||||
BSSN_ESCALAR_CUDA_STATE_COUNT = 26,
|
||||
BSSN_EM_CUDA_STATE_COUNT = 32,
|
||||
BSSN_EM_CUDA_SOURCE_COUNT = 4,
|
||||
BSSN_CUDA_MATTER_COUNT = 10
|
||||
};
|
||||
|
||||
@@ -55,116 +58,53 @@ int bssn_cuda_rk4_substep(void *block_tag,
|
||||
int &apply_enforce_ga,
|
||||
double &chitiny);
|
||||
|
||||
int bssn_cuda_compute_escalar_matter(void *block_tag,
|
||||
int *ex, double *X, double *Y, double *Z,
|
||||
double **state_host_in,
|
||||
double *Sphi_host,
|
||||
double *Spi_host,
|
||||
double *Sphi_rhs_host,
|
||||
double *Spi_rhs_host,
|
||||
double a2,
|
||||
int &Symmetry,
|
||||
int &Lev,
|
||||
double &eps,
|
||||
int &co,
|
||||
int &apply_enforce_ga);
|
||||
int bssn_escalar_cuda_rk4_substep(void *block_tag,
|
||||
int *ex, double *X, double *Y, double *Z,
|
||||
double **state_host_in,
|
||||
double **state_host_out,
|
||||
const double *propspeed,
|
||||
const double *soa_flat,
|
||||
const double *bbox,
|
||||
double &dT,
|
||||
double &T,
|
||||
int &RK4,
|
||||
int &apply_bam_bc,
|
||||
int &Symmetry,
|
||||
int &Lev,
|
||||
double &eps,
|
||||
int &co,
|
||||
int &keep_resident_state,
|
||||
int &apply_enforce_ga,
|
||||
double &chitiny);
|
||||
|
||||
int bssn_cuda_escalar_finalize_scalar_fields(void *block_tag,
|
||||
int *ex, double *X, double *Y, double *Z,
|
||||
double *Sphi_out_host,
|
||||
double *Spi_out_host,
|
||||
const double *propspeed,
|
||||
const double *soa_flat,
|
||||
const double *bbox,
|
||||
double &dT,
|
||||
int &RK4,
|
||||
int &apply_bam_bc,
|
||||
int &Symmetry,
|
||||
int &Lev,
|
||||
double &eps,
|
||||
int &precor);
|
||||
int bssn_escalar_cuda_compute_constraints(int *ex, double *X, double *Y, double *Z,
|
||||
double **state_host_in,
|
||||
double **constraint_host_out,
|
||||
int &Symmetry,
|
||||
int &Lev,
|
||||
double &eps);
|
||||
|
||||
int bssn_cuda_escalar_has_resident_fields(void *block_tag,
|
||||
double *Sphi_host,
|
||||
double *Spi_host);
|
||||
int bssn_em_cuda_rk4_substep(void *block_tag,
|
||||
int *ex, double *X, double *Y, double *Z,
|
||||
double **state_host_in,
|
||||
double **state_host_out,
|
||||
double **source_host,
|
||||
const double *propspeed,
|
||||
const double *soa_flat,
|
||||
const double *bbox,
|
||||
double &dT,
|
||||
double &T,
|
||||
int &RK4,
|
||||
int &apply_bam_bc,
|
||||
int &Symmetry,
|
||||
int &Lev,
|
||||
double &eps,
|
||||
int &co,
|
||||
int &keep_resident_state,
|
||||
int &apply_enforce_ga,
|
||||
double &chitiny);
|
||||
|
||||
int bssn_cuda_escalar_has_any_resident_fields(void *block_tag);
|
||||
|
||||
int bssn_cuda_escalar_download_fields_if_present(void *block_tag,
|
||||
int *ex,
|
||||
double *Sphi_host,
|
||||
double *Spi_host);
|
||||
|
||||
int bssn_cuda_pack_escalar_batch_to_host_buffer(void *block_tag,
|
||||
double **scalar_host_key,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int bssn_cuda_unpack_escalar_batch_from_host_buffer(void *block_tag,
|
||||
double **scalar_host_key,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int bssn_cuda_pack_escalar_batch_to_device_buffer(void *block_tag,
|
||||
double **scalar_host_key,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int bssn_cuda_unpack_escalar_batch_from_device_buffer(void *block_tag,
|
||||
double **scalar_host_key,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int bssn_cuda_restrict_escalar_batch_to_host_buffer(void *block_tag,
|
||||
double **scalar_host_key,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int fi0, int fj0, int fk0,
|
||||
const double *scalar_soa);
|
||||
|
||||
int bssn_cuda_prolong_escalar_batch_to_host_buffer(void *block_tag,
|
||||
double **scalar_host_key,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int ii0, int jj0, int kk0,
|
||||
int lbc_i, int lbc_j, int lbc_k,
|
||||
const double *scalar_soa);
|
||||
|
||||
int bssn_cuda_restrict_escalar_batch_to_device_buffer(void *block_tag,
|
||||
double **scalar_host_key,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int fi0, int fj0, int fk0,
|
||||
const double *scalar_soa);
|
||||
|
||||
int bssn_cuda_prolong_escalar_batch_to_device_buffer(void *block_tag,
|
||||
double **scalar_host_key,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int ii0, int jj0, int kk0,
|
||||
int lbc_i, int lbc_j, int lbc_k,
|
||||
const double *scalar_soa);
|
||||
|
||||
int bssn_cuda_prepare_escalar_inter_time_level(void *block_tag,
|
||||
int *ex,
|
||||
double **src1_host_key,
|
||||
double **src2_host_key,
|
||||
double **src3_host_key,
|
||||
double **dst_host_key,
|
||||
int source_count,
|
||||
int tindex);
|
||||
int bssn_em_cuda_resident_zero_fast_state(void *block_tag);
|
||||
|
||||
int bssn_cuda_copy_state_region_to_host(void *block_tag,
|
||||
int state_index,
|
||||
@@ -184,13 +124,37 @@ int bssn_cuda_download_resident_state(void *block_tag,
|
||||
int *ex,
|
||||
double **state_host_out);
|
||||
|
||||
int bssn_escalar_cuda_download_resident_state(void *block_tag,
|
||||
int *ex,
|
||||
double **state_host_out);
|
||||
|
||||
int bssn_cuda_upload_resident_state_count(void *block_tag,
|
||||
int *ex,
|
||||
double **state_host_in,
|
||||
int state_count);
|
||||
|
||||
int bssn_escalar_cuda_upload_resident_state(void *block_tag,
|
||||
int *ex,
|
||||
double **state_host_in);
|
||||
|
||||
int bssn_cuda_keep_only_resident_state_count(void *block_tag,
|
||||
int *ex,
|
||||
double **state_host_key,
|
||||
int state_count);
|
||||
|
||||
int bssn_escalar_cuda_keep_only_resident_state(void *block_tag,
|
||||
int *ex,
|
||||
double **state_host_key);
|
||||
|
||||
int bssn_cuda_download_resident_state_count_if_present(void *block_tag,
|
||||
int *ex,
|
||||
double **state_host_out,
|
||||
int state_count);
|
||||
|
||||
int bssn_cuda_download_resident_state_if_present(void *block_tag,
|
||||
int *ex,
|
||||
double **state_host_out);
|
||||
|
||||
int bssn_cuda_resident_state_matches(void *block_tag,
|
||||
double **state_host_key);
|
||||
|
||||
int bssn_cuda_download_constraint_outputs(int *ex,
|
||||
double **constraint_host_out);
|
||||
|
||||
@@ -217,6 +181,7 @@ int bssn_cuda_interp_state_point3(void *block_tag,
|
||||
double pz,
|
||||
int ordn,
|
||||
int symmetry,
|
||||
double **state_host_key,
|
||||
const double *soa3,
|
||||
double *out3);
|
||||
|
||||
@@ -246,6 +211,15 @@ int bssn_cuda_unpack_state_region_from_host_buffer(void *block_tag,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int bssn_cuda_unpack_state_region_from_host_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
int state_index,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int bssn_cuda_pack_state_batch_to_host_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *host_buffer,
|
||||
@@ -276,44 +250,8 @@ int bssn_cuda_unpack_state_batch_from_host_buffer_for_host_views(void *block_tag
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int bssn_cuda_restrict_state_batch_to_host_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int fi0, int fj0, int fk0,
|
||||
const double *state_soa);
|
||||
|
||||
int bssn_cuda_restrict_state_batch_to_host_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int fi0, int fj0, int fk0,
|
||||
const double *state_soa);
|
||||
|
||||
int bssn_cuda_prolong_state_batch_to_host_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int ii0, int jj0, int kk0,
|
||||
int lbc_i, int lbc_j, int lbc_k,
|
||||
const double *state_soa);
|
||||
|
||||
int bssn_cuda_prolong_state_batch_to_host_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int ii0, int jj0, int kk0,
|
||||
int lbc_i, int lbc_j, int lbc_k,
|
||||
const double *state_soa);
|
||||
|
||||
int bssn_cuda_pack_state_batch_to_device_buffer(void *block_tag,
|
||||
int state_count,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
@@ -452,6 +390,7 @@ int bssn_cuda_upload_state_subset(void *block_tag,
|
||||
|
||||
int bssn_cuda_prepare_inter_time_level(void *block_tag,
|
||||
int *ex,
|
||||
int state_count,
|
||||
double **src1_host_key,
|
||||
double **src2_host_key,
|
||||
double **src3_host_key,
|
||||
@@ -465,6 +404,10 @@ void bssn_cuda_release_step_ctx(void *block_tag);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
// C++-only helpers declared for derived equation classes (Z4C, etc.)
|
||||
// Defined in bssn_class.C. Requires MyList, Patch, var from including TU.
|
||||
bool bssn_cuda_use_resident_sync(int lev);
|
||||
void bssn_cuda_download_level_state_if_present(MyList<Patch> *PatL, MyList<var> *vars, int myrank);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -76,8 +76,11 @@ checkpoint::checkpoint(bool checked, const char fname[], int myrank) : filename(
|
||||
|
||||
I_Print = (myrank == 0);
|
||||
|
||||
int i = strlen(fname);
|
||||
filename = new char[i+30];
|
||||
size_t filename_len = out_dir.size() + strlen(fname) + 32;
|
||||
#ifdef CHECKDETAIL
|
||||
filename_len += 32;
|
||||
#endif
|
||||
filename = new char[filename_len];
|
||||
// cout << filename << endl;
|
||||
// cout << i << endl;
|
||||
|
||||
@@ -100,12 +103,12 @@ checkpoint::checkpoint(bool checked, const char fname[], int myrank) : filename(
|
||||
cout << " checkpoint class created " << endl;
|
||||
}
|
||||
}
|
||||
checkpoint::~checkpoint()
|
||||
{
|
||||
CheckList->clearList();
|
||||
if (I_Print)
|
||||
delete[] filename;
|
||||
}
|
||||
checkpoint::~checkpoint()
|
||||
{
|
||||
CheckList->clearList();
|
||||
if (filename)
|
||||
delete[] filename;
|
||||
}
|
||||
|
||||
void checkpoint::addvariable(var *VV)
|
||||
{
|
||||
@@ -136,7 +139,7 @@ void checkpoint::writecheck_cgh(double time, cgh *GH)
|
||||
if (I_Print)
|
||||
{
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_cgh.CHK", filename);
|
||||
|
||||
outfile.open(fname, ios::out | ios::trunc);
|
||||
@@ -195,7 +198,7 @@ void checkpoint::readcheck_cgh(double &time, cgh *GH, int myrank, int nprocs, in
|
||||
int DIM = dim;
|
||||
ifstream infile;
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_cgh.CHK", filename);
|
||||
|
||||
infile.open(fname);
|
||||
@@ -297,7 +300,7 @@ void checkpoint::writecheck_sh(double time, ShellPatch *SH)
|
||||
|
||||
if (I_Print)
|
||||
{
|
||||
char fname[50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_sh.CHK", filename);
|
||||
|
||||
outfile.open(fname, ios::out | ios::trunc);
|
||||
@@ -335,7 +338,7 @@ void checkpoint::readcheck_sh(ShellPatch *SH, int myrank)
|
||||
int DIM = dim;
|
||||
ifstream infile;
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_sh.CHK", filename);
|
||||
|
||||
infile.open(fname);
|
||||
@@ -390,7 +393,7 @@ void checkpoint::write_Black_Hole_position(int BH_num_input, int BH_num, double
|
||||
|
||||
if (I_Print)
|
||||
{
|
||||
char fname[50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_BHp.CHK", filename);
|
||||
|
||||
outfile.open(fname, ios::out | ios::trunc);
|
||||
@@ -417,7 +420,7 @@ void checkpoint::read_Black_Hole_position(int &BH_num_input, int &BH_num, double
|
||||
{
|
||||
ifstream infile;
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_BHp.CHK", filename);
|
||||
|
||||
infile.open(fname);
|
||||
@@ -461,7 +464,7 @@ void checkpoint::write_bssn(double LastDump, double Last2dDump, double LastAnas)
|
||||
|
||||
if (I_Print)
|
||||
{
|
||||
char fname[50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_bssn.CHK", filename);
|
||||
|
||||
outfile.open(fname, ios::out | ios::trunc);
|
||||
@@ -481,7 +484,7 @@ void checkpoint::read_bssn(double &LastDump, double &Last2dDump, double &LastAna
|
||||
{
|
||||
ifstream infile;
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_bssn.CHK", filename);
|
||||
|
||||
infile.open(fname);
|
||||
@@ -506,7 +509,7 @@ void checkpoint::write_bssn(double LastDump, double Last2dDump, double LastAnas)
|
||||
ofstream outfile;
|
||||
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_bssn.CHK", filename);
|
||||
|
||||
outfile.open(fname, ios::out | ios::trunc);
|
||||
@@ -527,7 +530,7 @@ void checkpoint::read_bssn(double &LastDump, double &Last2dDump, double &LastAna
|
||||
{
|
||||
ifstream infile;
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_bssn.CHK", filename);
|
||||
|
||||
infile.open(fname);
|
||||
@@ -551,7 +554,7 @@ void checkpoint::write_Black_Hole_position(int BH_num_input, int BH_num, double
|
||||
ofstream outfile;
|
||||
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_BHp.CHK", filename);
|
||||
|
||||
outfile.open(fname, ios::out | ios::trunc);
|
||||
@@ -581,7 +584,7 @@ void checkpoint::read_Black_Hole_position(int &BH_num_input, int &BH_num, double
|
||||
{
|
||||
ifstream infile;
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_BHp.CHK", filename);
|
||||
|
||||
infile.open(fname);
|
||||
@@ -628,7 +631,7 @@ void checkpoint::writecheck_cgh(double time, cgh *GH)
|
||||
ofstream outfile;
|
||||
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_cgh.CHK", filename);
|
||||
|
||||
outfile.open(fname, ios::out | ios::trunc);
|
||||
@@ -738,7 +741,7 @@ void checkpoint::readcheck_cgh(double &time, cgh *GH, int myrank, int nprocs, in
|
||||
int DIM = dim;
|
||||
ifstream infile;
|
||||
// char fname[50];
|
||||
char fname[50+50];
|
||||
char fname[4096];
|
||||
sprintf(fname, "%s_cgh.CHK", filename);
|
||||
|
||||
infile.open(fname);
|
||||
|
||||
412
AMSS_NCKU_source/fd_cuda_helpers.cuh
Normal file
412
AMSS_NCKU_source/fd_cuda_helpers.cuh
Normal file
@@ -0,0 +1,412 @@
|
||||
#ifndef AMSS_NCKU_FD_CUDA_HELPERS_CUH
|
||||
#define AMSS_NCKU_FD_CUDA_HELPERS_CUH
|
||||
|
||||
#ifndef ghost_width
|
||||
#error "ghost_width must be defined before including fd_cuda_helpers.cuh"
|
||||
#endif
|
||||
|
||||
#if ghost_width < 2 || ghost_width > 5
|
||||
#error "CUDA finite-difference helpers support ghost_width 2..5"
|
||||
#endif
|
||||
|
||||
#define AMSS_FD_CENTER_RADIUS (ghost_width - 1)
|
||||
#define AMSS_FD_LK_RADIUS (ghost_width)
|
||||
|
||||
__device__ __forceinline__ int fd_axis_radius(int qF, int qminF, int qmaxF)
|
||||
{
|
||||
#if AMSS_FD_CENTER_RADIUS >= 4
|
||||
if (qF - 4 >= qminF && qF + 4 <= qmaxF) return 4;
|
||||
#endif
|
||||
#if AMSS_FD_CENTER_RADIUS >= 3
|
||||
if (qF - 3 >= qminF && qF + 3 <= qmaxF) return 3;
|
||||
#endif
|
||||
#if AMSS_FD_CENTER_RADIUS >= 2
|
||||
if (qF - 2 >= qminF && qF + 2 <= qmaxF) return 2;
|
||||
#endif
|
||||
if (qF - 1 >= qminF && qF + 1 <= qmaxF) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ int fd_common_radius(int iF, int jF, int kF,
|
||||
int iminF, int jminF, int kminF,
|
||||
int imaxF, int jmaxF, int kmaxF)
|
||||
{
|
||||
int r = fd_axis_radius(iF, iminF, imaxF);
|
||||
const int ry = fd_axis_radius(jF, jminF, jmaxF);
|
||||
const int rz = fd_axis_radius(kF, kminF, kmaxF);
|
||||
if (ry < r) r = ry;
|
||||
if (rz < r) r = rz;
|
||||
return r;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_first_coef(int r, int off)
|
||||
{
|
||||
switch (r) {
|
||||
case 1:
|
||||
if (off == -1) return -1.0;
|
||||
if (off == 1) return 1.0;
|
||||
return 0.0;
|
||||
case 2:
|
||||
if (off == -2) return 1.0;
|
||||
if (off == -1) return -8.0;
|
||||
if (off == 1) return 8.0;
|
||||
if (off == 2) return -1.0;
|
||||
return 0.0;
|
||||
case 3:
|
||||
if (off == -3) return -1.0;
|
||||
if (off == -2) return 9.0;
|
||||
if (off == -1) return -45.0;
|
||||
if (off == 1) return 45.0;
|
||||
if (off == 2) return -9.0;
|
||||
if (off == 3) return 1.0;
|
||||
return 0.0;
|
||||
case 4:
|
||||
if (off == -4) return 3.0;
|
||||
if (off == -3) return -32.0;
|
||||
if (off == -2) return 168.0;
|
||||
if (off == -1) return -672.0;
|
||||
if (off == 1) return 672.0;
|
||||
if (off == 2) return -168.0;
|
||||
if (off == 3) return 32.0;
|
||||
if (off == 4) return -3.0;
|
||||
return 0.0;
|
||||
default:
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_second_coef(int r, int off)
|
||||
{
|
||||
switch (r) {
|
||||
case 1:
|
||||
if (off == -1) return 1.0;
|
||||
if (off == 0) return -2.0;
|
||||
if (off == 1) return 1.0;
|
||||
return 0.0;
|
||||
case 2:
|
||||
if (off == -2) return -1.0;
|
||||
if (off == -1) return 16.0;
|
||||
if (off == 0) return -30.0;
|
||||
if (off == 1) return 16.0;
|
||||
if (off == 2) return -1.0;
|
||||
return 0.0;
|
||||
case 3:
|
||||
if (off == -3) return 2.0;
|
||||
if (off == -2) return -27.0;
|
||||
if (off == -1) return 270.0;
|
||||
if (off == 0) return -490.0;
|
||||
if (off == 1) return 270.0;
|
||||
if (off == 2) return -27.0;
|
||||
if (off == 3) return 2.0;
|
||||
return 0.0;
|
||||
case 4:
|
||||
if (off == -4) return -9.0;
|
||||
if (off == -3) return 128.0;
|
||||
if (off == -2) return -1008.0;
|
||||
if (off == -1) return 8064.0;
|
||||
if (off == 0) return -14350.0;
|
||||
if (off == 1) return 8064.0;
|
||||
if (off == 2) return -1008.0;
|
||||
if (off == 3) return 128.0;
|
||||
if (off == 4) return -9.0;
|
||||
return 0.0;
|
||||
default:
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_first_denom(int r)
|
||||
{
|
||||
return (r == 4) ? 840.0 : ((r == 3) ? 60.0 : ((r == 2) ? 12.0 : 2.0));
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_second_denom(int r)
|
||||
{
|
||||
return (r == 4) ? 5040.0 : ((r == 3) ? 180.0 : ((r == 2) ? 12.0 : 1.0));
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_fetch_axis(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int axis, int off,
|
||||
int SoA0, int SoA1, int SoA2)
|
||||
{
|
||||
if (axis == 0) iF += off;
|
||||
else if (axis == 1) jF += off;
|
||||
else kF += off;
|
||||
return fetch_sym_ord2_direct(src, iF, jF, kF, SoA0, SoA1, SoA2);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_fetch_axis2(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int axis_a, int off_a,
|
||||
int axis_b, int off_b,
|
||||
int SoA0, int SoA1, int SoA2)
|
||||
{
|
||||
if (axis_a == 0) iF += off_a;
|
||||
else if (axis_a == 1) jF += off_a;
|
||||
else kF += off_a;
|
||||
if (axis_b == 0) iF += off_b;
|
||||
else if (axis_b == 1) jF += off_b;
|
||||
else kF += off_b;
|
||||
return fetch_sym_ord2_direct(src, iF, jF, kF, SoA0, SoA1, SoA2);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_first_axis_radius(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int axis, int r, double h,
|
||||
int SoA0, int SoA1, int SoA2)
|
||||
{
|
||||
if (r <= 0) return 0.0;
|
||||
double s = 0.0;
|
||||
#pragma unroll
|
||||
for (int off = -4; off <= 4; ++off) {
|
||||
const double c = fd_first_coef(r, off);
|
||||
if (c != 0.0) {
|
||||
s += c * fd_fetch_axis(src, iF, jF, kF, axis, off, SoA0, SoA1, SoA2);
|
||||
}
|
||||
}
|
||||
return s / (fd_first_denom(r) * h);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_second_axis_radius(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int axis, int r, double h,
|
||||
int SoA0, int SoA1, int SoA2)
|
||||
{
|
||||
if (r <= 0) return 0.0;
|
||||
double s = 0.0;
|
||||
#pragma unroll
|
||||
for (int off = -4; off <= 4; ++off) {
|
||||
const double c = fd_second_coef(r, off);
|
||||
if (c != 0.0) {
|
||||
s += c * fd_fetch_axis(src, iF, jF, kF, axis, off, SoA0, SoA1, SoA2);
|
||||
}
|
||||
}
|
||||
return s / (fd_second_denom(r) * h * h);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_mixed_axis_radius(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int axis_a, int r_a, double h_a,
|
||||
int axis_b, int r_b, double h_b,
|
||||
int SoA0, int SoA1, int SoA2)
|
||||
{
|
||||
if (r_a <= 0 || r_b <= 0) return 0.0;
|
||||
double s = 0.0;
|
||||
#pragma unroll
|
||||
for (int off_a = -4; off_a <= 4; ++off_a) {
|
||||
const double ca = fd_first_coef(r_a, off_a);
|
||||
if (ca == 0.0) continue;
|
||||
#pragma unroll
|
||||
for (int off_b = -4; off_b <= 4; ++off_b) {
|
||||
const double cb = fd_first_coef(r_b, off_b);
|
||||
if (cb != 0.0) {
|
||||
s += ca * cb * fd_fetch_axis2(src, iF, jF, kF, axis_a, off_a,
|
||||
axis_b, off_b, SoA0, SoA1, SoA2);
|
||||
}
|
||||
}
|
||||
}
|
||||
return s / (fd_first_denom(r_a) * fd_first_denom(r_b) * h_a * h_b);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void fd_compute_first3(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int iminF, int jminF, int kminF,
|
||||
int imaxF, int jmaxF, int kmaxF,
|
||||
int SoA0, int SoA1, int SoA2,
|
||||
double &fx, double &fy, double &fz)
|
||||
{
|
||||
#if ghost_width == 3
|
||||
const int r = fd_common_radius(iF, jF, kF, iminF, jminF, kminF, imaxF, jmaxF, kmaxF);
|
||||
fx = fd_first_axis_radius(src, iF, jF, kF, 0, r, d_gp.dX, SoA0, SoA1, SoA2);
|
||||
fy = fd_first_axis_radius(src, iF, jF, kF, 1, r, d_gp.dY, SoA0, SoA1, SoA2);
|
||||
fz = fd_first_axis_radius(src, iF, jF, kF, 2, r, d_gp.dZ, SoA0, SoA1, SoA2);
|
||||
#else
|
||||
fx = fd_first_axis_radius(src, iF, jF, kF, 0, fd_axis_radius(iF, iminF, imaxF),
|
||||
d_gp.dX, SoA0, SoA1, SoA2);
|
||||
fy = fd_first_axis_radius(src, iF, jF, kF, 1, fd_axis_radius(jF, jminF, jmaxF),
|
||||
d_gp.dY, SoA0, SoA1, SoA2);
|
||||
fz = fd_first_axis_radius(src, iF, jF, kF, 2, fd_axis_radius(kF, kminF, kmaxF),
|
||||
d_gp.dZ, SoA0, SoA1, SoA2);
|
||||
#endif
|
||||
}
|
||||
|
||||
__device__ __forceinline__ void fd_compute_second6(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int iminF, int jminF, int kminF,
|
||||
int imaxF, int jmaxF, int kmaxF,
|
||||
int SoA0, int SoA1, int SoA2,
|
||||
double &fxx, double &fxy, double &fxz,
|
||||
double &fyy, double &fyz, double &fzz)
|
||||
{
|
||||
#if ghost_width == 3
|
||||
const int r = fd_common_radius(iF, jF, kF, iminF, jminF, kminF, imaxF, jmaxF, kmaxF);
|
||||
const int rx = r, ry = r, rz = r;
|
||||
#else
|
||||
const int rx = fd_axis_radius(iF, iminF, imaxF);
|
||||
const int ry = fd_axis_radius(jF, jminF, jmaxF);
|
||||
const int rz = fd_axis_radius(kF, kminF, kmaxF);
|
||||
#endif
|
||||
fxx = fd_second_axis_radius(src, iF, jF, kF, 0, rx, d_gp.dX, SoA0, SoA1, SoA2);
|
||||
fyy = fd_second_axis_radius(src, iF, jF, kF, 1, ry, d_gp.dY, SoA0, SoA1, SoA2);
|
||||
fzz = fd_second_axis_radius(src, iF, jF, kF, 2, rz, d_gp.dZ, SoA0, SoA1, SoA2);
|
||||
fxy = fd_mixed_axis_radius(src, iF, jF, kF, 0, rx, d_gp.dX, 1, ry, d_gp.dY, SoA0, SoA1, SoA2);
|
||||
fxz = fd_mixed_axis_radius(src, iF, jF, kF, 0, rx, d_gp.dX, 2, rz, d_gp.dZ, SoA0, SoA1, SoA2);
|
||||
fyz = fd_mixed_axis_radius(src, iF, jF, kF, 1, ry, d_gp.dY, 2, rz, d_gp.dZ, SoA0, SoA1, SoA2);
|
||||
}
|
||||
|
||||
__device__ __forceinline__ bool fd_lop_fits(int qF, int qminF, int qmaxF,
|
||||
int dir, int lo, int hi)
|
||||
{
|
||||
for (int off = lo; off <= hi; ++off) {
|
||||
const int q = qF + dir * off;
|
||||
if (q < qminF || q > qmaxF) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_lop_fetch_sum(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int axis, int dir,
|
||||
const double *coef,
|
||||
int lo, int hi,
|
||||
int SoA0, int SoA1, int SoA2)
|
||||
{
|
||||
double s = 0.0;
|
||||
for (int off = lo; off <= hi; ++off) {
|
||||
const double c = coef[off - lo];
|
||||
if (c != 0.0) {
|
||||
s += c * fd_fetch_axis(src, iF, jF, kF, axis, dir * off, SoA0, SoA1, SoA2);
|
||||
}
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_lopsided_axis(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int axis, double speed,
|
||||
int qF, int qminF, int qmaxF,
|
||||
double h,
|
||||
int SoA0, int SoA1, int SoA2)
|
||||
{
|
||||
if (speed == 0.0) return 0.0;
|
||||
const int dir = (speed > 0.0) ? 1 : -1;
|
||||
const double mag = (speed > 0.0) ? speed : -speed;
|
||||
|
||||
#if ghost_width == 2
|
||||
if (fd_lop_fits(qF, qminF, qmaxF, dir, 0, 2)) {
|
||||
const double c[] = {-3.0, 4.0, -1.0};
|
||||
return mag * fd_lop_fetch_sum(src, iF, jF, kF, axis, dir, c, 0, 2, SoA0, SoA1, SoA2) / (2.0 * h);
|
||||
}
|
||||
if (fd_lop_fits(qF, qminF, qmaxF, dir, 0, 1)) {
|
||||
const double c[] = {-1.0, 1.0};
|
||||
return mag * fd_lop_fetch_sum(src, iF, jF, kF, axis, dir, c, 0, 1, SoA0, SoA1, SoA2) / (2.0 * h);
|
||||
}
|
||||
return 0.0;
|
||||
#elif ghost_width == 3
|
||||
if (fd_lop_fits(qF, qminF, qmaxF, dir, -1, 3)) {
|
||||
const double c[] = {-3.0, -10.0, 18.0, -6.0, 1.0};
|
||||
return mag * fd_lop_fetch_sum(src, iF, jF, kF, axis, dir, c, -1, 3, SoA0, SoA1, SoA2) / (12.0 * h);
|
||||
}
|
||||
const int r = fd_axis_radius(qF, qminF, qmaxF);
|
||||
return speed * fd_first_axis_radius(src, iF, jF, kF, axis, r, h, SoA0, SoA1, SoA2);
|
||||
#elif ghost_width == 4
|
||||
if (fd_lop_fits(qF, qminF, qmaxF, dir, -2, 4)) {
|
||||
const double c[] = {2.0, -24.0, -35.0, 80.0, -30.0, 8.0, -1.0};
|
||||
return mag * fd_lop_fetch_sum(src, iF, jF, kF, axis, dir, c, -2, 4, SoA0, SoA1, SoA2) / (60.0 * h);
|
||||
}
|
||||
if (fd_lop_fits(qF, qminF, qmaxF, dir, -1, 5)) {
|
||||
const double c[] = {-10.0, -77.0, 150.0, -100.0, 50.0, -15.0, 2.0};
|
||||
return mag * fd_lop_fetch_sum(src, iF, jF, kF, axis, dir, c, -1, 5, SoA0, SoA1, SoA2) / (60.0 * h);
|
||||
}
|
||||
const int r = fd_axis_radius(qF, qminF, qmaxF);
|
||||
return speed * fd_first_axis_radius(src, iF, jF, kF, axis, r, h, SoA0, SoA1, SoA2);
|
||||
#else
|
||||
if (fd_lop_fits(qF, qminF, qmaxF, dir, -3, 5)) {
|
||||
const double c[] = {-5.0, 60.0, -420.0, -378.0, 1050.0, -420.0, 140.0, -30.0, 3.0};
|
||||
return mag * fd_lop_fetch_sum(src, iF, jF, kF, axis, dir, c, -3, 5, SoA0, SoA1, SoA2) / (840.0 * h);
|
||||
}
|
||||
const int r = fd_axis_radius(qF, qminF, qmaxF);
|
||||
return speed * fd_first_axis_radius(src, iF, jF, kF, axis, r, h, SoA0, SoA1, SoA2);
|
||||
#endif
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_ko_coef(int r, int off)
|
||||
{
|
||||
const int a = off < 0 ? -off : off;
|
||||
if (r == 2) {
|
||||
if (a == 0) return 6.0;
|
||||
if (a == 1) return -4.0;
|
||||
if (a == 2) return 1.0;
|
||||
} else if (r == 3) {
|
||||
if (a == 0) return -20.0;
|
||||
if (a == 1) return 15.0;
|
||||
if (a == 2) return -6.0;
|
||||
if (a == 3) return 1.0;
|
||||
} else if (r == 4) {
|
||||
if (a == 0) return 70.0;
|
||||
if (a == 1) return -56.0;
|
||||
if (a == 2) return 28.0;
|
||||
if (a == 3) return -8.0;
|
||||
if (a == 4) return 1.0;
|
||||
} else if (r == 5) {
|
||||
if (a == 0) return -252.0;
|
||||
if (a == 1) return 210.0;
|
||||
if (a == 2) return -120.0;
|
||||
if (a == 3) return 45.0;
|
||||
if (a == 4) return -10.0;
|
||||
if (a == 5) return 1.0;
|
||||
}
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_ko_axis(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int axis, int r,
|
||||
int SoA0, int SoA1, int SoA2)
|
||||
{
|
||||
double s = 0.0;
|
||||
#pragma unroll
|
||||
for (int off = -5; off <= 5; ++off) {
|
||||
if (off < -r || off > r) continue;
|
||||
const double c = fd_ko_coef(r, off);
|
||||
if (c != 0.0) {
|
||||
s += c * fd_fetch_axis(src, iF, jF, kF, axis, off, SoA0, SoA1, SoA2);
|
||||
}
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
__device__ __forceinline__ double fd_ko_term(const double *src,
|
||||
int iF, int jF, int kF,
|
||||
int iminF, int jminF, int kminF,
|
||||
int imaxF, int jmaxF, int kmaxF,
|
||||
double eps_val,
|
||||
int SoA0, int SoA1, int SoA2)
|
||||
{
|
||||
const int r = AMSS_FD_LK_RADIUS;
|
||||
if (eps_val <= 0.0) return 0.0;
|
||||
#if ghost_width >= 4
|
||||
if (iF - r <= iminF || iF + r >= imaxF ||
|
||||
jF - r <= jminF || jF + r >= jmaxF ||
|
||||
kF - r <= kminF || kF + r >= kmaxF) {
|
||||
return 0.0;
|
||||
}
|
||||
#else
|
||||
if (iF - r < iminF || iF + r > imaxF ||
|
||||
jF - r < jminF || jF + r > jmaxF ||
|
||||
kF - r < kminF || kF + r > kmaxF) {
|
||||
return 0.0;
|
||||
}
|
||||
#endif
|
||||
double cof = 1.0;
|
||||
#pragma unroll
|
||||
for (int n = 0; n < 2 * r; ++n) cof *= 2.0;
|
||||
const double sign = (r & 1) ? 1.0 : -1.0;
|
||||
const double dx = fd_ko_axis(src, iF, jF, kF, 0, r, SoA0, SoA1, SoA2);
|
||||
const double dy = fd_ko_axis(src, iF, jF, kF, 1, r, SoA0, SoA1, SoA2);
|
||||
const double dz = fd_ko_axis(src, iF, jF, kF, 2, r, SoA0, SoA1, SoA2);
|
||||
return sign * eps_val * (dx / d_gp.dX + dy / d_gp.dY + dz / d_gp.dZ) / cof;
|
||||
}
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
321
AMSS_NCKU_source/fdderivs_sh_c.C
Normal file
321
AMSS_NCKU_source/fdderivs_sh_c.C
Normal file
@@ -0,0 +1,321 @@
|
||||
#include "macrodef.h"
|
||||
#include "share_func.h"
|
||||
|
||||
/*
|
||||
* fdderivs_sh — second derivatives on shell patch in (rho, sigma, R) coords.
|
||||
* Same stencil coefficients as Cartesian fdderivs. Uses symmetry_stbd.
|
||||
*/
|
||||
extern "C" void fdderivs_sh_(const int ex[3],
|
||||
const double *f,
|
||||
double *fxx, double *fxy, double *fxz,
|
||||
double *fyy, double *fyz, double *fzz,
|
||||
const double *X, const double *Y, const double *Z,
|
||||
double SYM1, double SYM2, double SYM3,
|
||||
int Symmetry, int onoff, int sst)
|
||||
{
|
||||
(void)SYM3; (void)onoff; (void)sst;
|
||||
|
||||
const int NO_SYMM=0, EQ_SYMM=1, OCTANT=2;
|
||||
const double ZEO=0.0, ONE=1.0, TWO=2.0, F1o4=2.5e-1;
|
||||
const double F8=8.0, F16=16.0, F30=30.0, F1o12=ONE/12.0, F1o144=ONE/144.0;
|
||||
const double F9=9.0, F45=45.0, F60=60.0, F27=27.0, F270=270.0, F490=490.0;
|
||||
const double F1o180=ONE/180.0, F1o3600=ONE/3600.0;
|
||||
const double F32=32.0, F128=128.0, F168=168.0, F672=672.0, F840=840.0;
|
||||
const double F1008=1008.0, F8064=8064.0, F14350=14350.0;
|
||||
const double F1o5040=ONE/5040.0, F1o705600=ONE/705600.0;
|
||||
|
||||
const int ex1=ex[0], ex2=ex[1], ex3=ex[2];
|
||||
const double dX=X[1]-X[0], dY=Y[1]-Y[0], dZ=Z[1]-Z[0];
|
||||
const int imaxF=ex1, jmaxF=ex2, kmaxF=ex3;
|
||||
const double SoA[2]={SYM1,SYM2};
|
||||
|
||||
#if (ghost_width == 2)
|
||||
{
|
||||
const int ord=1;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=0;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=0;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=0;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3,fh_size=nx*ny*nz;
|
||||
static double *fh_buf=NULL;static size_t cap=0;
|
||||
if(fh_size>cap){free(fh_buf);fh_buf=(double*)aligned_alloc(64,fh_size*sizeof(double));cap=fh_size;}
|
||||
double *fh=fh_buf;if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const double Sdxdx=ONE/(dX*dX),Sdydy=ONE/(dY*dY),Sdzdz=ONE/(dZ*dZ);
|
||||
const double Sdxdy=F1o4/(dX*dY),Sdxdz=F1o4/(dX*dZ),Sdydz=F1o4/(dY*dZ);
|
||||
const size_t all=(size_t)ex1*ex2*ex3;
|
||||
for(size_t p=0;p<all;++p){fxx[p]=fyy[p]=fzz[p]=ZEO;fxy[p]=fxz[p]=fyz[p]=ZEO;}
|
||||
|
||||
const int i2_lo=(iminF>0)?iminF:0,j2_lo=(jminF>0)?jminF:0,k2_lo=1,i2_hi=ex1-2,j2_hi=ex2-2,k2_hi=ex3-2;
|
||||
#define FH(iF,jF,kF) fh[idx_fh_stbd(iF,jF,kF,ord,ex)]
|
||||
if(i2_lo<=i2_hi&&j2_lo<=j2_hi&&k2_lo<=k2_hi){
|
||||
for(int k0=k2_lo;k0<=k2_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j2_lo;j0<=j2_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i2_lo;i0<=i2_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Sdxdx*(FH(iF-1,jF,kF)-TWO*FH(iF,jF,kF)+FH(iF+1,jF,kF));
|
||||
fyy[p]=Sdydy*(FH(iF,jF-1,kF)-TWO*FH(iF,jF,kF)+FH(iF,jF+1,kF));
|
||||
fzz[p]=Sdzdz*(FH(iF,jF,kF-1)-TWO*FH(iF,jF,kF)+FH(iF,jF,kF+1));
|
||||
fxy[p]=Sdxdy*(FH(iF-1,jF-1,kF)-FH(iF+1,jF-1,kF)-FH(iF-1,jF+1,kF)+FH(iF+1,jF+1,kF));
|
||||
fxz[p]=Sdxdz*(FH(iF-1,jF,kF-1)-FH(iF+1,jF,kF-1)-FH(iF-1,jF,kF+1)+FH(iF+1,jF,kF+1));
|
||||
fyz[p]=Sdydz*(FH(iF,jF-1,kF-1)-FH(iF,jF+1,kF-1)-FH(iF,jF-1,kF+1)+FH(iF,jF+1,kF+1));
|
||||
}}}
|
||||
}
|
||||
#undef FH
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 3)
|
||||
{
|
||||
const int ord=2;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=-1;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=-1;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=-1;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3,fh_size=nx*ny*nz;
|
||||
static double *fh_buf=NULL;static size_t cap=0;
|
||||
if(fh_size>cap){free(fh_buf);fh_buf=(double*)aligned_alloc(64,fh_size*sizeof(double));cap=fh_size;}
|
||||
double *fh=fh_buf;if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const double Sdxdx=ONE/(dX*dX),Sdydy=ONE/(dY*dY),Sdzdz=ONE/(dZ*dZ);
|
||||
const double Fdxdx=F1o12/(dX*dX),Fdydy=F1o12/(dY*dY),Fdzdz=F1o12/(dZ*dZ);
|
||||
const double Sdxdy=F1o4/(dX*dY),Sdxdz=F1o4/(dX*dZ),Sdydz=F1o4/(dY*dZ);
|
||||
const double Fdxdy=F1o144/(dX*dY),Fdxdz=F1o144/(dX*dZ),Fdydz=F1o144/(dY*dZ);
|
||||
const size_t all=(size_t)ex1*ex2*ex3;
|
||||
for(size_t p=0;p<all;++p){fxx[p]=fyy[p]=fzz[p]=fxy[p]=fxz[p]=fyz[p]=ZEO;}
|
||||
|
||||
const int i2_lo=(iminF>0)?iminF:0,j2_lo=(jminF>0)?jminF:0,k2_lo=1,i2_hi=ex1-2,j2_hi=ex2-2,k2_hi=ex3-2;
|
||||
const int i4_lo=(iminF+1>0)?iminF+1:0,j4_lo=(jminF+1>0)?jminF+1:0,k4_lo=2,i4_hi=ex1-3,j4_hi=ex2-3,k4_hi=ex3-3;
|
||||
const int has4=(i4_lo<=i4_hi&&j4_lo<=j4_hi&&k4_lo<=k4_hi);
|
||||
#define FH(iF,jF,kF) fh[idx_fh_stbd(iF,jF,kF,ord,ex)]
|
||||
|
||||
if(i2_lo<=i2_hi&&j2_lo<=j2_hi&&k2_lo<=k2_hi){
|
||||
for(int k0=k2_lo;k0<=k2_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j2_lo;j0<=j2_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i2_lo;i0<=i2_hi;++i0){
|
||||
if(has4&&i0>=i4_lo&&i0<=i4_hi&&j0>=j4_lo&&j0<=j4_hi&&k0>=k4_lo&&k0<=k4_hi)continue;
|
||||
const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Sdxdx*(FH(iF-1,jF,kF)-TWO*FH(iF,jF,kF)+FH(iF+1,jF,kF));
|
||||
fyy[p]=Sdydy*(FH(iF,jF-1,kF)-TWO*FH(iF,jF,kF)+FH(iF,jF+1,kF));
|
||||
fzz[p]=Sdzdz*(FH(iF,jF,kF-1)-TWO*FH(iF,jF,kF)+FH(iF,jF,kF+1));
|
||||
fxy[p]=Sdxdy*(FH(iF-1,jF-1,kF)-FH(iF+1,jF-1,kF)-FH(iF-1,jF+1,kF)+FH(iF+1,jF+1,kF));
|
||||
fxz[p]=Sdxdz*(FH(iF-1,jF,kF-1)-FH(iF+1,jF,kF-1)-FH(iF-1,jF,kF+1)+FH(iF+1,jF,kF+1));
|
||||
fyz[p]=Sdydz*(FH(iF,jF-1,kF-1)-FH(iF,jF+1,kF-1)-FH(iF,jF-1,kF+1)+FH(iF,jF+1,kF+1));
|
||||
}}}
|
||||
}
|
||||
if(has4){
|
||||
for(int k0=k4_lo;k0<=k4_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j4_lo;j0<=j4_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i4_lo;i0<=i4_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Fdxdx*(-FH(iF-2,jF,kF)+F16*FH(iF-1,jF,kF)-F30*FH(iF,jF,kF)-FH(iF+2,jF,kF)+F16*FH(iF+1,jF,kF));
|
||||
fyy[p]=Fdydy*(-FH(iF,jF-2,kF)+F16*FH(iF,jF-1,kF)-F30*FH(iF,jF,kF)-FH(iF,jF+2,kF)+F16*FH(iF,jF+1,kF));
|
||||
fzz[p]=Fdzdz*(-FH(iF,jF,kF-2)+F16*FH(iF,jF,kF-1)-F30*FH(iF,jF,kF)-FH(iF,jF,kF+2)+F16*FH(iF,jF,kF+1));
|
||||
{const double t_jm2=(FH(iF-2,jF-2,kF)-F8*FH(iF-1,jF-2,kF)+F8*FH(iF+1,jF-2,kF)-FH(iF+2,jF-2,kF));
|
||||
const double t_jm1=(FH(iF-2,jF-1,kF)-F8*FH(iF-1,jF-1,kF)+F8*FH(iF+1,jF-1,kF)-FH(iF+2,jF-1,kF));
|
||||
const double t_jp1=(FH(iF-2,jF+1,kF)-F8*FH(iF-1,jF+1,kF)+F8*FH(iF+1,jF+1,kF)-FH(iF+2,jF+1,kF));
|
||||
const double t_jp2=(FH(iF-2,jF+2,kF)-F8*FH(iF-1,jF+2,kF)+F8*FH(iF+1,jF+2,kF)-FH(iF+2,jF+2,kF));
|
||||
fxy[p]=Fdxdy*(t_jm2-F8*t_jm1+F8*t_jp1-t_jp2);}
|
||||
{const double t_km2=(FH(iF-2,jF,kF-2)-F8*FH(iF-1,jF,kF-2)+F8*FH(iF+1,jF,kF-2)-FH(iF+2,jF,kF-2));
|
||||
const double t_km1=(FH(iF-2,jF,kF-1)-F8*FH(iF-1,jF,kF-1)+F8*FH(iF+1,jF,kF-1)-FH(iF+2,jF,kF-1));
|
||||
const double t_kp1=(FH(iF-2,jF,kF+1)-F8*FH(iF-1,jF,kF+1)+F8*FH(iF+1,jF,kF+1)-FH(iF+2,jF,kF+1));
|
||||
const double t_kp2=(FH(iF-2,jF,kF+2)-F8*FH(iF-1,jF,kF+2)+F8*FH(iF+1,jF,kF+2)-FH(iF+2,jF,kF+2));
|
||||
fxz[p]=Fdxdz*(t_km2-F8*t_km1+F8*t_kp1-t_kp2);}
|
||||
{const double t_km2=(FH(iF,jF-2,kF-2)-F8*FH(iF,jF-1,kF-2)+F8*FH(iF,jF+1,kF-2)-FH(iF,jF+2,kF-2));
|
||||
const double t_km1=(FH(iF,jF-2,kF-1)-F8*FH(iF,jF-1,kF-1)+F8*FH(iF,jF+1,kF-1)-FH(iF,jF+2,kF-1));
|
||||
const double t_kp1=(FH(iF,jF-2,kF+1)-F8*FH(iF,jF-1,kF+1)+F8*FH(iF,jF+1,kF+1)-FH(iF,jF+2,kF+1));
|
||||
const double t_kp2=(FH(iF,jF-2,kF+2)-F8*FH(iF,jF-1,kF+2)+F8*FH(iF,jF+1,kF+2)-FH(iF,jF+2,kF+2));
|
||||
fyz[p]=Fdydz*(t_km2-F8*t_km1+F8*t_kp1-t_kp2);}
|
||||
}}}
|
||||
}
|
||||
#undef FH
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 4)
|
||||
{
|
||||
const int ord=3;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=-2;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=-2;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=-2;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3,fh_size=nx*ny*nz;
|
||||
static double *fh_buf=NULL;static size_t cap=0;
|
||||
if(fh_size>cap){free(fh_buf);fh_buf=(double*)aligned_alloc(64,fh_size*sizeof(double));cap=fh_size;}
|
||||
double *fh=fh_buf;if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const double Sdxdx=ONE/(dX*dX),Sdydy=ONE/(dY*dY),Sdzdz=ONE/(dZ*dZ);
|
||||
const double Fdxdx=F1o12/(dX*dX),Fdydy=F1o12/(dY*dY),Fdzdz=F1o12/(dZ*dZ);
|
||||
const double Xdxdx=F1o180/(dX*dX),Xdydy=F1o180/(dY*dY),Xdzdz=F1o180/(dZ*dZ);
|
||||
const double Sdxdy=F1o4/(dX*dY),Sdxdz=F1o4/(dX*dZ),Sdydz=F1o4/(dY*dZ);
|
||||
const double Fdxdy=F1o144/(dX*dY),Fdxdz=F1o144/(dX*dZ),Fdydz=F1o144/(dY*dZ);
|
||||
const double Xdxdy=F1o3600/(dX*dY),Xdxdz=F1o3600/(dX*dZ),Xdydz=F1o3600/(dY*dZ);
|
||||
const size_t all=(size_t)ex1*ex2*ex3;
|
||||
for(size_t p=0;p<all;++p){fxx[p]=fyy[p]=fzz[p]=fxy[p]=fxz[p]=fyz[p]=ZEO;}
|
||||
|
||||
const int i2_lo=(iminF>0)?iminF:0,j2_lo=(jminF>0)?jminF:0,k2_lo=1,i2_hi=ex1-2,j2_hi=ex2-2,k2_hi=ex3-2;
|
||||
const int i4_lo=(iminF+1>0)?iminF+1:0,j4_lo=(jminF+1>0)?jminF+1:0,k4_lo=2,i4_hi=ex1-3,j4_hi=ex2-3,k4_hi=ex3-3;
|
||||
const int i6_lo=(iminF+2>0)?iminF+2:0,j6_lo=(jminF+2>0)?jminF+2:0,k6_lo=3,i6_hi=ex1-4,j6_hi=ex2-4,k6_hi=ex3-4;
|
||||
const int has4=(i4_lo<=i4_hi&&j4_lo<=j4_hi&&k4_lo<=k4_hi),has6=(i6_lo<=i6_hi&&j6_lo<=j6_hi&&k6_lo<=k6_hi);
|
||||
#define FH(iF,jF,kF) fh[idx_fh_stbd(iF,jF,kF,ord,ex)]
|
||||
|
||||
if(i2_lo<=i2_hi&&j2_lo<=j2_hi&&k2_lo<=k2_hi){for(int k0=k2_lo;k0<=k2_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j2_lo;j0<=j2_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i2_lo;i0<=i2_hi;++i0){bool in4=has4&&i0>=i4_lo&&i0<=i4_hi&&j0>=j4_lo&&j0<=j4_hi&&k0>=k4_lo&&k0<=k4_hi;if(in4)continue;
|
||||
const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Sdxdx*(FH(iF-1,jF,kF)-TWO*FH(iF,jF,kF)+FH(iF+1,jF,kF));
|
||||
fyy[p]=Sdydy*(FH(iF,jF-1,kF)-TWO*FH(iF,jF,kF)+FH(iF,jF+1,kF));
|
||||
fzz[p]=Sdzdz*(FH(iF,jF,kF-1)-TWO*FH(iF,jF,kF)+FH(iF,jF,kF+1));
|
||||
fxy[p]=Sdxdy*(FH(iF-1,jF-1,kF)-FH(iF+1,jF-1,kF)-FH(iF-1,jF+1,kF)+FH(iF+1,jF+1,kF));
|
||||
fxz[p]=Sdxdz*(FH(iF-1,jF,kF-1)-FH(iF+1,jF,kF-1)-FH(iF-1,jF,kF+1)+FH(iF+1,jF,kF+1));
|
||||
fyz[p]=Sdydz*(FH(iF,jF-1,kF-1)-FH(iF,jF+1,kF-1)-FH(iF,jF-1,kF+1)+FH(iF,jF+1,kF+1));
|
||||
}}}}
|
||||
if(has4){for(int k0=k4_lo;k0<=k4_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j4_lo;j0<=j4_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i4_lo;i0<=i4_hi;++i0){if(has6&&i0>=i6_lo&&i0<=i6_hi&&j0>=j6_lo&&j0<=j6_hi&&k0>=k6_lo&&k0<=k6_hi)continue;
|
||||
const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Fdxdx*(-FH(iF-2,jF,kF)+F16*FH(iF-1,jF,kF)-F30*FH(iF,jF,kF)-FH(iF+2,jF,kF)+F16*FH(iF+1,jF,kF));
|
||||
fyy[p]=Fdydy*(-FH(iF,jF-2,kF)+F16*FH(iF,jF-1,kF)-F30*FH(iF,jF,kF)-FH(iF,jF+2,kF)+F16*FH(iF,jF+1,kF));
|
||||
fzz[p]=Fdzdz*(-FH(iF,jF,kF-2)+F16*FH(iF,jF,kF-1)-F30*FH(iF,jF,kF)-FH(iF,jF,kF+2)+F16*FH(iF,jF,kF+1));
|
||||
{const double t_jm2=(FH(iF-2,jF-2,kF)-F8*FH(iF-1,jF-2,kF)+F8*FH(iF+1,jF-2,kF)-FH(iF+2,jF-2,kF));
|
||||
const double t_jm1=(FH(iF-2,jF-1,kF)-F8*FH(iF-1,jF-1,kF)+F8*FH(iF+1,jF-1,kF)-FH(iF+2,jF-1,kF));
|
||||
const double t_jp1=(FH(iF-2,jF+1,kF)-F8*FH(iF-1,jF+1,kF)+F8*FH(iF+1,jF+1,kF)-FH(iF+2,jF+1,kF));
|
||||
const double t_jp2=(FH(iF-2,jF+2,kF)-F8*FH(iF-1,jF+2,kF)+F8*FH(iF+1,jF+2,kF)-FH(iF+2,jF+2,kF));
|
||||
fxy[p]=Fdxdy*(t_jm2-F8*t_jm1+F8*t_jp1-t_jp2);}
|
||||
{const double t_km2=(FH(iF-2,jF,kF-2)-F8*FH(iF-1,jF,kF-2)+F8*FH(iF+1,jF,kF-2)-FH(iF+2,jF,kF-2));
|
||||
const double t_km1=(FH(iF-2,jF,kF-1)-F8*FH(iF-1,jF,kF-1)+F8*FH(iF+1,jF,kF-1)-FH(iF+2,jF,kF-1));
|
||||
const double t_kp1=(FH(iF-2,jF,kF+1)-F8*FH(iF-1,jF,kF+1)+F8*FH(iF+1,jF,kF+1)-FH(iF+2,jF,kF+1));
|
||||
const double t_kp2=(FH(iF-2,jF,kF+2)-F8*FH(iF-1,jF,kF+2)+F8*FH(iF+1,jF,kF+2)-FH(iF+2,jF,kF+2));
|
||||
fxz[p]=Fdxdz*(t_km2-F8*t_km1+F8*t_kp1-t_kp2);}
|
||||
{const double t_km2=(FH(iF,jF-2,kF-2)-F8*FH(iF,jF-1,kF-2)+F8*FH(iF,jF+1,kF-2)-FH(iF,jF+2,kF-2));
|
||||
const double t_km1=(FH(iF,jF-2,kF-1)-F8*FH(iF,jF-1,kF-1)+F8*FH(iF,jF+1,kF-1)-FH(iF,jF+2,kF-1));
|
||||
const double t_kp1=(FH(iF,jF-2,kF+1)-F8*FH(iF,jF-1,kF+1)+F8*FH(iF,jF+1,kF+1)-FH(iF,jF+2,kF+1));
|
||||
const double t_kp2=(FH(iF,jF-2,kF+2)-F8*FH(iF,jF-1,kF+2)+F8*FH(iF,jF+1,kF+2)-FH(iF,jF+2,kF+2));
|
||||
fyz[p]=Fdydz*(t_km2-F8*t_km1+F8*t_kp1-t_kp2);}
|
||||
}}}}
|
||||
if(has6){for(int k0=k6_lo;k0<=k6_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j6_lo;j0<=j6_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i6_lo;i0<=i6_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Xdxdx*(TWO*FH(iF-3,jF,kF)-F27*FH(iF-2,jF,kF)+F270*FH(iF-1,jF,kF)-F490*FH(iF,jF,kF)+F270*FH(iF+1,jF,kF)-F27*FH(iF+2,jF,kF)+TWO*FH(iF+3,jF,kF));
|
||||
fyy[p]=Xdydy*(TWO*FH(iF,jF-3,kF)-F27*FH(iF,jF-2,kF)+F270*FH(iF,jF-1,kF)-F490*FH(iF,jF,kF)+F270*FH(iF,jF+1,kF)-F27*FH(iF,jF+2,kF)+TWO*FH(iF,jF+3,kF));
|
||||
fzz[p]=Xdzdz*(TWO*FH(iF,jF,kF-3)-F27*FH(iF,jF,kF-2)+F270*FH(iF,jF,kF-1)-F490*FH(iF,jF,kF)+F270*FH(iF,jF,kF+1)-F27*FH(iF,jF,kF+2)+TWO*FH(iF,jF,kF+3));
|
||||
#define XS6(JF,KFDUMMY) (-FH(iF-3,JF,KFDUMMY)+F9*FH(iF-2,JF,KFDUMMY)-F45*FH(iF-1,JF,KFDUMMY)+F45*FH(iF+1,JF,KFDUMMY)-F9*FH(iF+2,JF,KFDUMMY)+FH(iF+3,JF,KFDUMMY))
|
||||
fxy[p]=Xdxdy*(-XS6(jF-3,kF)+F9*XS6(jF-2,kF)-F45*XS6(jF-1,kF)+F45*XS6(jF+1,kF)-F9*XS6(jF+2,kF)+XS6(jF+3,kF));
|
||||
fxz[p]=Xdxdz*(-XS6(jF,kF-3)+F9*XS6(jF,kF-2)-F45*XS6(jF,kF-1)+F45*XS6(jF,kF+1)-F9*XS6(jF,kF+2)+XS6(jF,kF+3));
|
||||
#undef XS6
|
||||
#define YS6(JF,KFDUMMY) (-FH(iF,JF-3,KFDUMMY)+F9*FH(iF,JF-2,KFDUMMY)-F45*FH(iF,JF-1,KFDUMMY)+F45*FH(iF,JF+1,KFDUMMY)-F9*FH(iF,JF+2,KFDUMMY)+FH(iF,JF+3,KFDUMMY))
|
||||
fyz[p]=Xdydz*(-YS6(jF,kF-3)+F9*YS6(jF,kF-2)-F45*YS6(jF,kF-1)+F45*YS6(jF,kF+1)-F9*YS6(jF,kF+2)+YS6(jF,kF+3));
|
||||
#undef YS6
|
||||
}}}}
|
||||
#undef FH
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 5)
|
||||
{
|
||||
/* 8th-order shell second derivatives — inherits 8th-order stencil coeffs from Cartesian */
|
||||
const int ord=4;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=-3;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=-3;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=-3;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3,fh_size=nx*ny*nz;
|
||||
static double *fh_buf=NULL;static size_t cap=0;
|
||||
if(fh_size>cap){free(fh_buf);fh_buf=(double*)aligned_alloc(64,fh_size*sizeof(double));cap=fh_size;}
|
||||
double *fh=fh_buf;if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const double Sdxdx=ONE/(dX*dX),Sdydy=ONE/(dY*dY),Sdzdz=ONE/(dZ*dZ);
|
||||
const double Fdxdx=F1o12/(dX*dX),Fdydy=F1o12/(dY*dY),Fdzdz=F1o12/(dZ*dZ);
|
||||
const double Xdxdx=F1o180/(dX*dX),Xdydy=F1o180/(dY*dY),Xdzdz=F1o180/(dZ*dZ);
|
||||
const double Edxdx=F1o5040/(dX*dX),Edydy=F1o5040/(dY*dY),Edzdz=F1o5040/(dZ*dZ);
|
||||
const double Sdxdy=F1o4/(dX*dY),Sdxdz=F1o4/(dX*dZ),Sdydz=F1o4/(dY*dZ);
|
||||
const double Fdxdy=F1o144/(dX*dY),Fdxdz=F1o144/(dX*dZ),Fdydz=F1o144/(dY*dZ);
|
||||
const double Xdxdy=F1o3600/(dX*dY),Xdxdz=F1o3600/(dX*dZ),Xdydz=F1o3600/(dY*dZ);
|
||||
const double Edxdy=F1o705600/(dX*dY),Edxdz=F1o705600/(dX*dZ),Edydz=F1o705600/(dY*dZ);
|
||||
const size_t all=(size_t)ex1*ex2*ex3;
|
||||
for(size_t p=0;p<all;++p){fxx[p]=fyy[p]=fzz[p]=fxy[p]=fxz[p]=fyz[p]=ZEO;}
|
||||
|
||||
const int i2_lo=(iminF>0)?iminF:0,j2_lo=(jminF>0)?jminF:0,k2_lo=1,i2_hi=ex1-2,j2_hi=ex2-2,k2_hi=ex3-2;
|
||||
const int i4_lo=(iminF+1>0)?iminF+1:0,j4_lo=(jminF+1>0)?jminF+1:0,k4_lo=2,i4_hi=ex1-3,j4_hi=ex2-3,k4_hi=ex3-3;
|
||||
const int i6_lo=(iminF+2>0)?iminF+2:0,j6_lo=(jminF+2>0)?jminF+2:0,k6_lo=3,i6_hi=ex1-4,j6_hi=ex2-4,k6_hi=ex3-4;
|
||||
const int i8_lo=(iminF+3>0)?iminF+3:0,j8_lo=(jminF+3>0)?jminF+3:0,k8_lo=4,i8_hi=ex1-5,j8_hi=ex2-5,k8_hi=ex3-5;
|
||||
const int has4=(i4_lo<=i4_hi&&j4_lo<=j4_hi&&k4_lo<=k4_hi),has6=(i6_lo<=i6_hi&&j6_lo<=j6_hi&&k6_lo<=k6_hi),has8=(i8_lo<=i8_hi&&j8_lo<=j8_hi&&k8_lo<=k8_hi);
|
||||
#define FH(iF,jF,kF) fh[idx_fh_stbd(iF,jF,kF,ord,ex)]
|
||||
|
||||
/* 2nd-order pass */
|
||||
if(i2_lo<=i2_hi&&j2_lo<=j2_hi&&k2_lo<=k2_hi){for(int k0=k2_lo;k0<=k2_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j2_lo;j0<=j2_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i2_lo;i0<=i2_hi;++i0){bool in4=has4&&i0>=i4_lo&&i0<=i4_hi&&j0>=j4_lo&&j0<=j4_hi&&k0>=k4_lo&&k0<=k4_hi;if(in4)continue;
|
||||
const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Sdxdx*(FH(iF-1,jF,kF)-TWO*FH(iF,jF,kF)+FH(iF+1,jF,kF));
|
||||
fyy[p]=Sdydy*(FH(iF,jF-1,kF)-TWO*FH(iF,jF,kF)+FH(iF,jF+1,kF));
|
||||
fzz[p]=Sdzdz*(FH(iF,jF,kF-1)-TWO*FH(iF,jF,kF)+FH(iF,jF,kF+1));
|
||||
fxy[p]=Sdxdy*(FH(iF-1,jF-1,kF)-FH(iF+1,jF-1,kF)-FH(iF-1,jF+1,kF)+FH(iF+1,jF+1,kF));
|
||||
fxz[p]=Sdxdz*(FH(iF-1,jF,kF-1)-FH(iF+1,jF,kF-1)-FH(iF-1,jF,kF+1)+FH(iF+1,jF,kF+1));
|
||||
fyz[p]=Sdydz*(FH(iF,jF-1,kF-1)-FH(iF,jF+1,kF-1)-FH(iF,jF-1,kF+1)+FH(iF,jF+1,kF+1));
|
||||
}}}}
|
||||
/* 4th-order pass */
|
||||
if(has4){for(int k0=k4_lo;k0<=k4_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j4_lo;j0<=j4_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i4_lo;i0<=i4_hi;++i0){bool in6=has6&&i0>=i6_lo&&i0<=i6_hi&&j0>=j6_lo&&j0<=j6_hi&&k0>=k6_lo&&k0<=k6_hi;if(in6)continue;
|
||||
const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Fdxdx*(-FH(iF-2,jF,kF)+F16*FH(iF-1,jF,kF)-F30*FH(iF,jF,kF)-FH(iF+2,jF,kF)+F16*FH(iF+1,jF,kF));
|
||||
fyy[p]=Fdydy*(-FH(iF,jF-2,kF)+F16*FH(iF,jF-1,kF)-F30*FH(iF,jF,kF)-FH(iF,jF+2,kF)+F16*FH(iF,jF+1,kF));
|
||||
fzz[p]=Fdzdz*(-FH(iF,jF,kF-2)+F16*FH(iF,jF,kF-1)-F30*FH(iF,jF,kF)-FH(iF,jF,kF+2)+F16*FH(iF,jF,kF+1));
|
||||
{const double t_jm2=(FH(iF-2,jF-2,kF)-F8*FH(iF-1,jF-2,kF)+F8*FH(iF+1,jF-2,kF)-FH(iF+2,jF-2,kF));
|
||||
const double t_jm1=(FH(iF-2,jF-1,kF)-F8*FH(iF-1,jF-1,kF)+F8*FH(iF+1,jF-1,kF)-FH(iF+2,jF-1,kF));
|
||||
const double t_jp1=(FH(iF-2,jF+1,kF)-F8*FH(iF-1,jF+1,kF)+F8*FH(iF+1,jF+1,kF)-FH(iF+2,jF+1,kF));
|
||||
const double t_jp2=(FH(iF-2,jF+2,kF)-F8*FH(iF-1,jF+2,kF)+F8*FH(iF+1,jF+2,kF)-FH(iF+2,jF+2,kF));
|
||||
fxy[p]=Fdxdy*(t_jm2-F8*t_jm1+F8*t_jp1-t_jp2);}
|
||||
{const double t_km2=(FH(iF-2,jF,kF-2)-F8*FH(iF-1,jF,kF-2)+F8*FH(iF+1,jF,kF-2)-FH(iF+2,jF,kF-2));
|
||||
const double t_km1=(FH(iF-2,jF,kF-1)-F8*FH(iF-1,jF,kF-1)+F8*FH(iF+1,jF,kF-1)-FH(iF+2,jF,kF-1));
|
||||
const double t_kp1=(FH(iF-2,jF,kF+1)-F8*FH(iF-1,jF,kF+1)+F8*FH(iF+1,jF,kF+1)-FH(iF+2,jF,kF+1));
|
||||
const double t_kp2=(FH(iF-2,jF,kF+2)-F8*FH(iF-1,jF,kF+2)+F8*FH(iF+1,jF,kF+2)-FH(iF+2,jF,kF+2));
|
||||
fxz[p]=Fdxdz*(t_km2-F8*t_km1+F8*t_kp1-t_kp2);}
|
||||
{const double t_km2=(FH(iF,jF-2,kF-2)-F8*FH(iF,jF-1,kF-2)+F8*FH(iF,jF+1,kF-2)-FH(iF,jF+2,kF-2));
|
||||
const double t_km1=(FH(iF,jF-2,kF-1)-F8*FH(iF,jF-1,kF-1)+F8*FH(iF,jF+1,kF-1)-FH(iF,jF+2,kF-1));
|
||||
const double t_kp1=(FH(iF,jF-2,kF+1)-F8*FH(iF,jF-1,kF+1)+F8*FH(iF,jF+1,kF+1)-FH(iF,jF+2,kF+1));
|
||||
const double t_kp2=(FH(iF,jF-2,kF+2)-F8*FH(iF,jF-1,kF+2)+F8*FH(iF,jF+1,kF+2)-FH(iF,jF+2,kF+2));
|
||||
fyz[p]=Fdydz*(t_km2-F8*t_km1+F8*t_kp1-t_kp2);}
|
||||
}}}}
|
||||
/* 6th-order pass */
|
||||
if(has6){for(int k0=k6_lo;k0<=k6_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j6_lo;j0<=j6_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i6_lo;i0<=i6_hi;++i0){if(has8&&i0>=i8_lo&&i0<=i8_hi&&j0>=j8_lo&&j0<=j8_hi&&k0>=k8_lo&&k0<=k8_hi)continue;
|
||||
const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Xdxdx*(TWO*FH(iF-3,jF,kF)-F27*FH(iF-2,jF,kF)+F270*FH(iF-1,jF,kF)-F490*FH(iF,jF,kF)+F270*FH(iF+1,jF,kF)-F27*FH(iF+2,jF,kF)+TWO*FH(iF+3,jF,kF));
|
||||
fyy[p]=Xdydy*(TWO*FH(iF,jF-3,kF)-F27*FH(iF,jF-2,kF)+F270*FH(iF,jF-1,kF)-F490*FH(iF,jF,kF)+F270*FH(iF,jF+1,kF)-F27*FH(iF,jF+2,kF)+TWO*FH(iF,jF+3,kF));
|
||||
fzz[p]=Xdzdz*(TWO*FH(iF,jF,kF-3)-F27*FH(iF,jF,kF-2)+F270*FH(iF,jF,kF-1)-F490*FH(iF,jF,kF)+F270*FH(iF,jF,kF+1)-F27*FH(iF,jF,kF+2)+TWO*FH(iF,jF,kF+3));
|
||||
#define XS6_8(JF,KFDUMMY) (-FH(iF-3,JF,KFDUMMY)+F9*FH(iF-2,JF,KFDUMMY)-F45*FH(iF-1,JF,KFDUMMY)+F45*FH(iF+1,JF,KFDUMMY)-F9*FH(iF+2,JF,KFDUMMY)+FH(iF+3,JF,KFDUMMY))
|
||||
fxy[p]=Xdxdy*(-XS6_8(jF-3,kF)+F9*XS6_8(jF-2,kF)-F45*XS6_8(jF-1,kF)+F45*XS6_8(jF+1,kF)-F9*XS6_8(jF+2,kF)+XS6_8(jF+3,kF));
|
||||
fxz[p]=Xdxdz*(-XS6_8(jF,kF-3)+F9*XS6_8(jF,kF-2)-F45*XS6_8(jF,kF-1)+F45*XS6_8(jF,kF+1)-F9*XS6_8(jF,kF+2)+XS6_8(jF,kF+3));
|
||||
#undef XS6_8
|
||||
#define YS6_8(JF,KFDUMMY) (-FH(iF,JF-3,KFDUMMY)+F9*FH(iF,JF-2,KFDUMMY)-F45*FH(iF,JF-1,KFDUMMY)+F45*FH(iF,JF+1,KFDUMMY)-F9*FH(iF,JF+2,KFDUMMY)+FH(iF,JF+3,KFDUMMY))
|
||||
fyz[p]=Xdydz*(-YS6_8(jF,kF-3)+F9*YS6_8(jF,kF-2)-F45*YS6_8(jF,kF-1)+F45*YS6_8(jF,kF+1)-F9*YS6_8(jF,kF+2)+YS6_8(jF,kF+3));
|
||||
#undef YS6_8
|
||||
}}}}
|
||||
/* 8th-order pass */
|
||||
if(has8){for(int k0=k8_lo;k0<=k8_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j8_lo;j0<=j8_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i8_lo;i0<=i8_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fxx[p]=Edxdx*(-(double)9*FH(iF-4,jF,kF)+F128*FH(iF-3,jF,kF)-F1008*FH(iF-2,jF,kF)+F8064*FH(iF-1,jF,kF)-F14350*FH(iF,jF,kF)+F8064*FH(iF+1,jF,kF)-F1008*FH(iF+2,jF,kF)+F128*FH(iF+3,jF,kF)-(double)9*FH(iF+4,jF,kF));
|
||||
fyy[p]=Edydy*(-(double)9*FH(iF,jF-4,kF)+F128*FH(iF,jF-3,kF)-F1008*FH(iF,jF-2,kF)+F8064*FH(iF,jF-1,kF)-F14350*FH(iF,jF,kF)+F8064*FH(iF,jF+1,kF)-F1008*FH(iF,jF+2,kF)+F128*FH(iF,jF+3,kF)-(double)9*FH(iF,jF+4,kF));
|
||||
fzz[p]=Edzdz*(-(double)9*FH(iF,jF,kF-4)+F128*FH(iF,jF,kF-3)-F1008*FH(iF,jF,kF-2)+F8064*FH(iF,jF,kF-1)-F14350*FH(iF,jF,kF)+F8064*FH(iF,jF,kF+1)-F1008*FH(iF,jF,kF+2)+F128*FH(iF,jF,kF+3)-(double)9*FH(iF,jF,kF+4));
|
||||
#define XS8(JF,KFDUMMY) (+(double)3*FH(iF-4,JF,KFDUMMY)-F32*FH(iF-3,JF,KFDUMMY)+F168*FH(iF-2,JF,KFDUMMY)-F672*FH(iF-1,JF,KFDUMMY)+F672*FH(iF+1,JF,KFDUMMY)-F168*FH(iF+2,JF,KFDUMMY)+F32*FH(iF+3,JF,KFDUMMY)-(double)3*FH(iF+4,JF,KFDUMMY))
|
||||
fxy[p]=Edxdy*(+(double)3*XS8(jF-4,kF)-F32*XS8(jF-3,kF)+F168*XS8(jF-2,kF)-F672*XS8(jF-1,kF)+F672*XS8(jF+1,kF)-F168*XS8(jF+2,kF)+F32*XS8(jF+3,kF)-(double)3*XS8(jF+4,kF));
|
||||
fxz[p]=Edxdz*(+(double)3*XS8(jF,kF-4)-F32*XS8(jF,kF-3)+F168*XS8(jF,kF-2)-F672*XS8(jF,kF-1)+F672*XS8(jF,kF+1)-F168*XS8(jF,kF+2)+F32*XS8(jF,kF+3)-(double)3*XS8(jF,kF+4));
|
||||
#undef XS8
|
||||
#define YS8(JF,KFDUMMY) (+(double)3*FH(iF,JF-4,KFDUMMY)-F32*FH(iF,JF-3,KFDUMMY)+F168*FH(iF,JF-2,KFDUMMY)-F672*FH(iF,JF-1,KFDUMMY)+F672*FH(iF,JF+1,KFDUMMY)-F168*FH(iF,JF+2,KFDUMMY)+F32*FH(iF,JF+3,KFDUMMY)-(double)3*FH(iF,JF+4,KFDUMMY))
|
||||
fyz[p]=Edydz*(+(double)3*YS8(jF,kF-4)-F32*YS8(jF,kF-3)+F168*YS8(jF,kF-2)-F672*YS8(jF,kF-1)+F672*YS8(jF,kF+1)-F168*YS8(jF,kF+2)+F32*YS8(jF,kF+3)-(double)3*YS8(jF,kF+4));
|
||||
#undef YS8
|
||||
}}}}
|
||||
#undef FH
|
||||
return;
|
||||
}
|
||||
#else
|
||||
#error "fdderivs_sh_c.C: unsupported ghost_width"
|
||||
#endif
|
||||
}
|
||||
107
AMSS_NCKU_source/fdderivs_shc_c.C
Normal file
107
AMSS_NCKU_source/fdderivs_shc_c.C
Normal file
@@ -0,0 +1,107 @@
|
||||
#include "macrodef.h"
|
||||
#include "share_func.h"
|
||||
#include <cstddef>
|
||||
|
||||
/* Forward declarations — Fortran-mangled names from shell C kernels */
|
||||
extern "C" {
|
||||
void fderivs_sh_(const int ex[3], const double *f,
|
||||
double *fx, double *fy, double *fz,
|
||||
const double *X, const double *Y, const double *Z,
|
||||
double SYM1, double SYM2, double SYM3,
|
||||
int Symmetry, int onoff, int sst);
|
||||
|
||||
void fdderivs_sh_(const int ex[3], const double *f,
|
||||
double *fxx, double *fxy, double *fxz,
|
||||
double *fyy, double *fyz, double *fzz,
|
||||
const double *X, const double *Y, const double *Z,
|
||||
double SYM1, double SYM2, double SYM3,
|
||||
int Symmetry, int onoff, int sst);
|
||||
|
||||
void fdderivs_shc_(int *ex,
|
||||
double *f,
|
||||
double *fxx, double *fxy, double *fxz,
|
||||
double *fyy, double *fyz, double *fzz,
|
||||
double *crho, double *sigma, double *R,
|
||||
double &SYM1, double &SYM2, double &SYM3,
|
||||
int &Symmetry, int &Lev, int &sst,
|
||||
double *drhodx, double *drhody, double *drhodz,
|
||||
double *dsigmadx, double *dsigmady, double *dsigmadz,
|
||||
double *dRdx, double *dRdy, double *dRdz,
|
||||
double *drhodxx, double *drhodxy, double *drhodxz,
|
||||
double *drhodyy, double *drhodyz, double *drhodzz,
|
||||
double *dsigmadxx, double *dsigmadxy, double *dsigmadxz,
|
||||
double *dsigmadyy, double *dsigmadyz, double *dsigmadzz,
|
||||
double *dRdxx, double *dRdxy, double *dRdxz,
|
||||
double *dRdyy, double *dRdyz, double *dRdzz)
|
||||
{
|
||||
const int ex3[3] = { ex[0], ex[1], ex[2] };
|
||||
const size_t n = (size_t)ex[0] * (size_t)ex[1] * (size_t)ex[2];
|
||||
|
||||
double *gx = (double*)malloc(n * sizeof(double));
|
||||
double *gy = (double*)malloc(n * sizeof(double));
|
||||
double *gz = (double*)malloc(n * sizeof(double));
|
||||
double *gxx = (double*)malloc(n * sizeof(double));
|
||||
double *gxy = (double*)malloc(n * sizeof(double));
|
||||
double *gxz = (double*)malloc(n * sizeof(double));
|
||||
double *gyy = (double*)malloc(n * sizeof(double));
|
||||
double *gyz = (double*)malloc(n * sizeof(double));
|
||||
double *gzz = (double*)malloc(n * sizeof(double));
|
||||
|
||||
if (!gx||!gy||!gz||!gxx||!gxy||!gxz||!gyy||!gyz||!gzz) {
|
||||
free(gx);free(gy);free(gz);free(gxx);free(gxy);free(gxz);free(gyy);free(gyz);free(gzz);
|
||||
return;
|
||||
}
|
||||
|
||||
fderivs_sh_(ex3, f, gx, gy, gz, crho, sigma, R, SYM1, SYM2, SYM3, Symmetry, Lev, sst);
|
||||
fdderivs_sh_(ex3, f, gxx, gxy, gxz, gyy, gyz, gzz, crho, sigma, R, SYM1, SYM2, SYM3, Symmetry, Lev, sst);
|
||||
|
||||
for (size_t i = 0; i < n; ++i) {
|
||||
const double rx=drhodx[i], ry=drhody[i], rz=drhodz[i];
|
||||
const double sx=dsigmadx[i], sy=dsigmady[i], sz=dsigmadz[i];
|
||||
const double Rx=dRdx[i], Ry=dRdy[i], Rz=dRdz[i];
|
||||
const double rxx=drhodxx[i], rxy=drhodxy[i], rxz=drhodxz[i];
|
||||
const double ryy=drhodyy[i], ryz=drhodyz[i], rzz=drhodzz[i];
|
||||
const double sxx=dsigmadxx[i], sxy=dsigmadxy[i], sxz=dsigmadxz[i];
|
||||
const double syy=dsigmadyy[i], syz=dsigmadyz[i], szz=dsigmadzz[i];
|
||||
const double Rxx=dRdxx[i], Rxy=dRdxy[i], Rxz=dRdxz[i];
|
||||
const double Ryy=dRdyy[i], Ryz=dRdyz[i], Rzz=dRdzz[i];
|
||||
|
||||
const double Gr=gx[i], Gs=gy[i], GR=gz[i];
|
||||
const double Grr=gxx[i], Grs=gxy[i], GrR=gxz[i];
|
||||
const double Gss=gyy[i], GsR=gyz[i], GRR=gzz[i];
|
||||
|
||||
/* fxx */
|
||||
fxx[i] = rx*rx*Grr + sx*sx*Gss + Rx*Rx*GRR
|
||||
+ 2.0*(rx*sx*Grs + rx*Rx*GrR + sx*Rx*GsR)
|
||||
+ rxx*Gr + sxx*Gs + Rxx*GR;
|
||||
|
||||
/* fxy */
|
||||
fxy[i] = rx*ry*Grr + sx*sy*Gss + Rx*Ry*GRR
|
||||
+ rx*sy*Grs + ry*sx*Grs + rx*Ry*GrR + ry*Rx*GrR + sx*Ry*GsR + sy*Rx*GsR
|
||||
+ rxy*Gr + sxy*Gs + Rxy*GR;
|
||||
|
||||
/* fxz */
|
||||
fxz[i] = rx*rz*Grr + sx*sz*Gss + Rx*Rz*GRR
|
||||
+ rx*sz*Grs + rz*sx*Grs + rx*Rz*GrR + rz*Rx*GrR + sx*Rz*GsR + sz*Rx*GsR
|
||||
+ rxz*Gr + sxz*Gs + Rxz*GR;
|
||||
|
||||
/* fyy */
|
||||
fyy[i] = ry*ry*Grr + sy*sy*Gss + Ry*Ry*GRR
|
||||
+ 2.0*(ry*sy*Grs + ry*Ry*GrR + sy*Ry*GsR)
|
||||
+ ryy*Gr + syy*Gs + Ryy*GR;
|
||||
|
||||
/* fyz */
|
||||
fyz[i] = ry*rz*Grr + sy*sz*Gss + Ry*Rz*GRR
|
||||
+ ry*sz*Grs + rz*sy*Grs + ry*Rz*GrR + rz*Ry*GrR + sy*Rz*GsR + sz*Ry*GsR
|
||||
+ ryz*Gr + syz*Gs + Ryz*GR;
|
||||
|
||||
/* fzz */
|
||||
fzz[i] = rz*rz*Grr + sz*sz*Gss + Rz*Rz*GRR
|
||||
+ 2.0*(rz*sz*Grs + rz*Rz*GrR + sz*Rz*GsR)
|
||||
+ rzz*Gr + szz*Gs + Rzz*GR;
|
||||
}
|
||||
|
||||
free(gx);free(gy);free(gz);free(gxx);free(gxy);free(gxz);free(gyy);free(gyz);free(gzz);
|
||||
}
|
||||
|
||||
} // extern "C"
|
||||
@@ -1,14 +1,18 @@
|
||||
#include "macrodef.h"
|
||||
#include "tool.h"
|
||||
|
||||
/*
|
||||
* C 版 fderivs
|
||||
* C 版 fderivs — first derivatives df/dx, df/dy, df/dz.
|
||||
*
|
||||
* Fortran:
|
||||
* subroutine fderivs(ex,f,fx,fy,fz,X,Y,Z,SYM1,SYM2,SYM3,symmetry,onoff)
|
||||
* Finite difference order is selected at compile time via the ghost_width macro
|
||||
* (defined in macrodef.fh):
|
||||
* ghost_width = 2 → 2nd-order
|
||||
* ghost_width = 3 → 4th-order
|
||||
* ghost_width = 4 → 6th-order
|
||||
* ghost_width = 5 → 8th-order
|
||||
*
|
||||
* 约定：
|
||||
* f, fx, fy, fz: ex1*ex2*ex3，按 idx_ex 布局
|
||||
* X: ex1, Y: ex2, Z: ex3
|
||||
* Multi-pass overwrite strategy: compute the widest (lowest-order) stencil first,
|
||||
* then overwrite interior regions with progressively higher-order stencils.
|
||||
*/
|
||||
void fderivs(const int ex[3],
|
||||
const double *f,
|
||||
@@ -17,151 +21,596 @@ void fderivs(const int ex[3],
|
||||
double SYM1, double SYM2, double SYM3,
|
||||
int Symmetry, int onoff)
|
||||
{
|
||||
(void)onoff; // Fortran 里没用到
|
||||
(void)onoff;
|
||||
|
||||
const double ZEO = 0.0, ONE = 1.0;
|
||||
const double TWO = 2.0, EIT = 8.0;
|
||||
const double F12 = 12.0;
|
||||
const double ZEO = 0.0, ONE = 1.0, TWO = 2.0, EIT = 8.0;
|
||||
const double F9 = 9.0, F12 = 12.0, F45 = 45.0, F60 = 60.0;
|
||||
const double F32 = 32.0, F168 = 168.0, F672 = 672.0, F840 = 840.0;
|
||||
|
||||
const int NO_SYMM = 0, EQ_SYMM = 1; // OCTANT=2 在本子程序里不直接用
|
||||
const int NO_SYMM = 0, EQ_SYMM = 1;
|
||||
|
||||
const int ex1 = ex[0], ex2 = ex[1], ex3 = ex[2];
|
||||
|
||||
// dX = X(2)-X(1) -> C: X[1]-X[0]
|
||||
const double dX = X[1] - X[0];
|
||||
const double dY = Y[1] - Y[0];
|
||||
const double dZ = Z[1] - Z[0];
|
||||
|
||||
// Fortran 1-based bounds
|
||||
const int imaxF = ex1;
|
||||
const int jmaxF = ex2;
|
||||
const int kmaxF = ex3;
|
||||
const int imaxF = ex1, jmaxF = ex2, kmaxF = ex3;
|
||||
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -1;
|
||||
const int gw = ghost_width; // compile-time constant
|
||||
|
||||
// SoA(1:3) = SYM1,SYM2,SYM3
|
||||
const double SoA[3] = { SYM1, SYM2, SYM3 };
|
||||
#if (ghost_width == 2)
|
||||
/* ---- 2nd-order ------------------------------------------------------ */
|
||||
{
|
||||
const int ord = 1; // symmetry_bd ord = ghost_width - 1
|
||||
|
||||
// fh: (ex1+2)*(ex2+2)*(ex3+2) because ord=2
|
||||
const size_t nx = (size_t)ex1 + 2;
|
||||
const size_t ny = (size_t)ex2 + 2;
|
||||
const size_t nz = (size_t)ex3 + 2;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
static double *fh = NULL;
|
||||
static size_t cap = 0;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = 0;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = 0;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = 0;
|
||||
|
||||
if (fh_size > cap) {
|
||||
free(fh);
|
||||
fh = (double*)aligned_alloc(64, fh_size * sizeof(double));
|
||||
cap = fh_size;
|
||||
}
|
||||
// double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
const double SoA[3] = { SYM1, SYM2, SYM3 };
|
||||
|
||||
// call symmetry_bd(2,ex,f,fh,SoA)
|
||||
symmetry_bd(2, ex, f, fh, SoA);
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
const double d12dx = ONE / F12 / dX;
|
||||
const double d12dy = ONE / F12 / dY;
|
||||
const double d12dz = ONE / F12 / dZ;
|
||||
static double *fh_buf = NULL;
|
||||
static size_t cap = 0;
|
||||
if (fh_size > cap) {
|
||||
free(fh_buf);
|
||||
fh_buf = (double*)aligned_alloc(64, fh_size * sizeof(double));
|
||||
cap = fh_size;
|
||||
}
|
||||
double *fh = fh_buf;
|
||||
if (!fh) return;
|
||||
|
||||
const double d2dx = ONE / TWO / dX;
|
||||
const double d2dy = ONE / TWO / dY;
|
||||
const double d2dz = ONE / TWO / dZ;
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
// fx = fy = fz = 0
|
||||
const size_t all = (size_t)ex1 * (size_t)ex2 * (size_t)ex3;
|
||||
for (size_t p = 0; p < all; ++p) {
|
||||
fx[p] = ZEO;
|
||||
fy[p] = ZEO;
|
||||
fz[p] = ZEO;
|
||||
}
|
||||
const double d2dx = ONE / TWO / dX;
|
||||
const double d2dy = ONE / TWO / dY;
|
||||
const double d2dz = ONE / TWO / dZ;
|
||||
|
||||
/*
|
||||
* 两段式：
|
||||
* 1) 先在二阶可用区域计算二阶模板
|
||||
* 2) 再在高阶可用区域覆盖为四阶模板
|
||||
*
|
||||
* 与原 if/elseif 逻辑等价，但减少逐点分支判断。
|
||||
*/
|
||||
const int i2_lo = (iminF > 0) ? iminF : 0;
|
||||
const int j2_lo = (jminF > 0) ? jminF : 0;
|
||||
const int k2_lo = (kminF > 0) ? kminF : 0;
|
||||
const int i2_hi = ex1 - 2;
|
||||
const int j2_hi = ex2 - 2;
|
||||
const int k2_hi = ex3 - 2;
|
||||
const size_t all = (size_t)ex1 * (size_t)ex2 * (size_t)ex3;
|
||||
for (size_t p = 0; p < all; ++p) {
|
||||
fx[p] = ZEO; fy[p] = ZEO; fz[p] = ZEO;
|
||||
}
|
||||
|
||||
const int i4_lo = (iminF + 1 > 0) ? (iminF + 1) : 0;
|
||||
const int j4_lo = (jminF + 1 > 0) ? (jminF + 1) : 0;
|
||||
const int k4_lo = (kminF + 1 > 0) ? (kminF + 1) : 0;
|
||||
const int i4_hi = ex1 - 3;
|
||||
const int j4_hi = ex2 - 3;
|
||||
const int k4_hi = ex3 - 3;
|
||||
/* 2nd-order pass: [-1, 0, +1] / (2*dx) */
|
||||
const int i2_lo = (iminF > 0) ? iminF : 0;
|
||||
const int j2_lo = (jminF > 0) ? jminF : 0;
|
||||
const int k2_lo = (kminF > 0) ? kminF : 0;
|
||||
const int i2_hi = ex1 - 2;
|
||||
const int j2_hi = ex2 - 2;
|
||||
const int k2_hi = ex3 - 2;
|
||||
|
||||
if (i2_lo <= i2_hi && j2_lo <= j2_hi && k2_lo <= k2_hi) {
|
||||
for (int k0 = k2_lo; k0 <= k2_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j2_lo; j0 <= j2_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i2_lo; i0 <= i2_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
if (i2_lo <= i2_hi && j2_lo <= j2_hi && k2_lo <= k2_hi) {
|
||||
for (int k0 = k2_lo; k0 <= k2_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j2_lo; j0 <= j2_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i2_lo; i0 <= i2_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d2dx * (
|
||||
-fh[idx_fh_F_ord2(iF - 1, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF + 1, jF, kF, ex)]
|
||||
);
|
||||
fx[p] = d2dx * (
|
||||
-fh[idx_fh_F_ord1(iF - 1, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord1(iF + 1, jF, kF, ex)]
|
||||
);
|
||||
|
||||
fy[p] = d2dy * (
|
||||
-fh[idx_fh_F_ord2(iF, jF - 1, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF, jF + 1, kF, ex)]
|
||||
);
|
||||
fy[p] = d2dy * (
|
||||
-fh[idx_fh_F_ord1(iF, jF - 1, kF, ex)] +
|
||||
fh[idx_fh_F_ord1(iF, jF + 1, kF, ex)]
|
||||
);
|
||||
|
||||
fz[p] = d2dz * (
|
||||
-fh[idx_fh_F_ord2(iF, jF, kF - 1, ex)] +
|
||||
fh[idx_fh_F_ord2(iF, jF, kF + 1, ex)]
|
||||
);
|
||||
fz[p] = d2dz * (
|
||||
-fh[idx_fh_F_ord1(iF, jF, kF - 1, ex)] +
|
||||
fh[idx_fh_F_ord1(iF, jF, kF + 1, ex)]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 3)
|
||||
/* ---- 4th-order (original code) ------------------------------------ */
|
||||
{
|
||||
const int ord = 2; // symmetry_bd ord
|
||||
|
||||
if (i4_lo <= i4_hi && j4_lo <= j4_hi && k4_lo <= k4_hi) {
|
||||
for (int k0 = k4_lo; k0 <= k4_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j4_lo; j0 <= j4_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i4_lo; i0 <= i4_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -1;
|
||||
|
||||
fx[p] = d12dx * (
|
||||
fh[idx_fh_F_ord2(iF - 2, jF, kF, ex)] -
|
||||
EIT * fh[idx_fh_F_ord2(iF - 1, jF, kF, ex)] +
|
||||
EIT * fh[idx_fh_F_ord2(iF + 1, jF, kF, ex)] -
|
||||
fh[idx_fh_F_ord2(iF + 2, jF, kF, ex)]
|
||||
);
|
||||
const double SoA[3] = { SYM1, SYM2, SYM3 };
|
||||
|
||||
fy[p] = d12dy * (
|
||||
fh[idx_fh_F_ord2(iF, jF - 2, kF, ex)] -
|
||||
EIT * fh[idx_fh_F_ord2(iF, jF - 1, kF, ex)] +
|
||||
EIT * fh[idx_fh_F_ord2(iF, jF + 1, kF, ex)] -
|
||||
fh[idx_fh_F_ord2(iF, jF + 2, kF, ex)]
|
||||
);
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
fz[p] = d12dz * (
|
||||
fh[idx_fh_F_ord2(iF, jF, kF - 2, ex)] -
|
||||
EIT * fh[idx_fh_F_ord2(iF, jF, kF - 1, ex)] +
|
||||
EIT * fh[idx_fh_F_ord2(iF, jF, kF + 1, ex)] -
|
||||
fh[idx_fh_F_ord2(iF, jF, kF + 2, ex)]
|
||||
);
|
||||
static double *fh_buf = NULL;
|
||||
static size_t cap = 0;
|
||||
if (fh_size > cap) {
|
||||
free(fh_buf);
|
||||
fh_buf = (double*)aligned_alloc(64, fh_size * sizeof(double));
|
||||
cap = fh_size;
|
||||
}
|
||||
double *fh = fh_buf;
|
||||
if (!fh) return;
|
||||
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
const double d12dx = ONE / F12 / dX;
|
||||
const double d12dy = ONE / F12 / dY;
|
||||
const double d12dz = ONE / F12 / dZ;
|
||||
const double d2dx = ONE / TWO / dX;
|
||||
const double d2dy = ONE / TWO / dY;
|
||||
const double d2dz = ONE / TWO / dZ;
|
||||
|
||||
const size_t all = (size_t)ex1 * (size_t)ex2 * (size_t)ex3;
|
||||
for (size_t p = 0; p < all; ++p) {
|
||||
fx[p] = ZEO; fy[p] = ZEO; fz[p] = ZEO;
|
||||
}
|
||||
|
||||
const int i2_lo = (iminF > 0) ? iminF : 0;
|
||||
const int j2_lo = (jminF > 0) ? jminF : 0;
|
||||
const int k2_lo = (kminF > 0) ? kminF : 0;
|
||||
const int i2_hi = ex1 - 2;
|
||||
const int j2_hi = ex2 - 2;
|
||||
const int k2_hi = ex3 - 2;
|
||||
|
||||
const int i4_lo = (iminF + 1 > 0) ? (iminF + 1) : 0;
|
||||
const int j4_lo = (jminF + 1 > 0) ? (jminF + 1) : 0;
|
||||
const int k4_lo = (kminF + 1 > 0) ? (kminF + 1) : 0;
|
||||
const int i4_hi = ex1 - 3;
|
||||
const int j4_hi = ex2 - 3;
|
||||
const int k4_hi = ex3 - 3;
|
||||
|
||||
if (i2_lo <= i2_hi && j2_lo <= j2_hi && k2_lo <= k2_hi) {
|
||||
for (int k0 = k2_lo; k0 <= k2_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j2_lo; j0 <= j2_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i2_lo; i0 <= i2_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d2dx * (
|
||||
-fh[idx_fh_F_ord2(iF - 1, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF + 1, jF, kF, ex)]
|
||||
);
|
||||
|
||||
fy[p] = d2dy * (
|
||||
-fh[idx_fh_F_ord2(iF, jF - 1, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF, jF + 1, kF, ex)]
|
||||
);
|
||||
|
||||
fz[p] = d2dz * (
|
||||
-fh[idx_fh_F_ord2(iF, jF, kF - 1, ex)] +
|
||||
fh[idx_fh_F_ord2(iF, jF, kF + 1, ex)]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// free(fh);
|
||||
if (i4_lo <= i4_hi && j4_lo <= j4_hi && k4_lo <= k4_hi) {
|
||||
for (int k0 = k4_lo; k0 <= k4_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j4_lo; j0 <= j4_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i4_lo; i0 <= i4_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d12dx * (
|
||||
fh[idx_fh_F_ord2(iF - 2, jF, kF, ex)] -
|
||||
EIT * fh[idx_fh_F_ord2(iF - 1, jF, kF, ex)] +
|
||||
EIT * fh[idx_fh_F_ord2(iF + 1, jF, kF, ex)] -
|
||||
fh[idx_fh_F_ord2(iF + 2, jF, kF, ex)]
|
||||
);
|
||||
|
||||
fy[p] = d12dy * (
|
||||
fh[idx_fh_F_ord2(iF, jF - 2, kF, ex)] -
|
||||
EIT * fh[idx_fh_F_ord2(iF, jF - 1, kF, ex)] +
|
||||
EIT * fh[idx_fh_F_ord2(iF, jF + 1, kF, ex)] -
|
||||
fh[idx_fh_F_ord2(iF, jF + 2, kF, ex)]
|
||||
);
|
||||
|
||||
fz[p] = d12dz * (
|
||||
fh[idx_fh_F_ord2(iF, jF, kF - 2, ex)] -
|
||||
EIT * fh[idx_fh_F_ord2(iF, jF, kF - 1, ex)] +
|
||||
EIT * fh[idx_fh_F_ord2(iF, jF, kF + 1, ex)] -
|
||||
fh[idx_fh_F_ord2(iF, jF, kF + 2, ex)]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 4)
|
||||
/* ---- 6th-order ----------------------------------------------------- */
|
||||
{
|
||||
const int ord = 3;
|
||||
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -2;
|
||||
|
||||
const double SoA[3] = { SYM1, SYM2, SYM3 };
|
||||
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
static double *fh_buf = NULL;
|
||||
static size_t cap = 0;
|
||||
if (fh_size > cap) {
|
||||
free(fh_buf);
|
||||
fh_buf = (double*)aligned_alloc(64, fh_size * sizeof(double));
|
||||
cap = fh_size;
|
||||
}
|
||||
double *fh = fh_buf;
|
||||
if (!fh) return;
|
||||
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
/* Denominators */
|
||||
const double d60dx = ONE / F60 / dX;
|
||||
const double d60dy = ONE / F60 / dY;
|
||||
const double d60dz = ONE / F60 / dZ;
|
||||
const double d12dx = ONE / F12 / dX;
|
||||
const double d12dy = ONE / F12 / dY;
|
||||
const double d12dz = ONE / F12 / dZ;
|
||||
const double d2dx = ONE / TWO / dX;
|
||||
const double d2dy = ONE / TWO / dY;
|
||||
const double d2dz = ONE / TWO / dZ;
|
||||
|
||||
const size_t all = (size_t)ex1 * (size_t)ex2 * (size_t)ex3;
|
||||
for (size_t p = 0; p < all; ++p) {
|
||||
fx[p] = ZEO; fy[p] = ZEO; fz[p] = ZEO;
|
||||
}
|
||||
|
||||
/* 2nd-order pass: 3pt, widest */
|
||||
const int i2_lo = (iminF > 0) ? iminF : 0;
|
||||
const int j2_lo = (jminF > 0) ? jminF : 0;
|
||||
const int k2_lo = (kminF > 0) ? kminF : 0;
|
||||
const int i2_hi = ex1 - 2;
|
||||
const int j2_hi = ex2 - 2;
|
||||
const int k2_hi = ex3 - 2;
|
||||
|
||||
/* 4th-order pass: 5pt */
|
||||
const int i4_lo = (iminF + 1 > 0) ? (iminF + 1) : 0;
|
||||
const int j4_lo = (jminF + 1 > 0) ? (jminF + 1) : 0;
|
||||
const int k4_lo = (kminF + 1 > 0) ? (kminF + 1) : 0;
|
||||
const int i4_hi = ex1 - 3;
|
||||
const int j4_hi = ex2 - 3;
|
||||
const int k4_hi = ex3 - 3;
|
||||
|
||||
/* 6th-order pass: 7pt, narrowest interior */
|
||||
const int i6_lo = (iminF + 2 > 0) ? (iminF + 2) : 0;
|
||||
const int j6_lo = (jminF + 2 > 0) ? (jminF + 2) : 0;
|
||||
const int k6_lo = (kminF + 2 > 0) ? (kminF + 2) : 0;
|
||||
const int i6_hi = ex1 - 4;
|
||||
const int j6_hi = ex2 - 4;
|
||||
const int k6_hi = ex3 - 4;
|
||||
|
||||
/* 2nd-order */
|
||||
if (i2_lo <= i2_hi && j2_lo <= j2_hi && k2_lo <= k2_hi) {
|
||||
for (int k0 = k2_lo; k0 <= k2_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j2_lo; j0 <= j2_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i2_lo; i0 <= i2_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d2dx * (
|
||||
-fh[idx_fh_F(iF - 1, jF, kF, ex)] +
|
||||
fh[idx_fh_F(iF + 1, jF, kF, ex)]);
|
||||
fy[p] = d2dy * (
|
||||
-fh[idx_fh_F(iF, jF - 1, kF, ex)] +
|
||||
fh[idx_fh_F(iF, jF + 1, kF, ex)]);
|
||||
fz[p] = d2dz * (
|
||||
-fh[idx_fh_F(iF, jF, kF - 1, ex)] +
|
||||
fh[idx_fh_F(iF, jF, kF + 1, ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 4th-order overwrite */
|
||||
if (i4_lo <= i4_hi && j4_lo <= j4_hi && k4_lo <= k4_hi) {
|
||||
for (int k0 = k4_lo; k0 <= k4_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j4_lo; j0 <= j4_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i4_lo; i0 <= i4_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d12dx * (
|
||||
fh[idx_fh_F(iF - 2, jF, kF, ex)] -
|
||||
EIT * fh[idx_fh_F(iF - 1, jF, kF, ex)] +
|
||||
EIT * fh[idx_fh_F(iF + 1, jF, kF, ex)] -
|
||||
fh[idx_fh_F(iF + 2, jF, kF, ex)]);
|
||||
|
||||
fy[p] = d12dy * (
|
||||
fh[idx_fh_F(iF, jF - 2, kF, ex)] -
|
||||
EIT * fh[idx_fh_F(iF, jF - 1, kF, ex)] +
|
||||
EIT * fh[idx_fh_F(iF, jF + 1, kF, ex)] -
|
||||
fh[idx_fh_F(iF, jF + 2, kF, ex)]);
|
||||
|
||||
fz[p] = d12dz * (
|
||||
fh[idx_fh_F(iF, jF, kF - 2, ex)] -
|
||||
EIT * fh[idx_fh_F(iF, jF, kF - 1, ex)] +
|
||||
EIT * fh[idx_fh_F(iF, jF, kF + 1, ex)] -
|
||||
fh[idx_fh_F(iF, jF, kF + 2, ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 6th-order overwrite: [-1,+9,-45,0,+45,-9,+1] / (60*dx) */
|
||||
if (i6_lo <= i6_hi && j6_lo <= j6_hi && k6_lo <= k6_hi) {
|
||||
for (int k0 = k6_lo; k0 <= k6_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j6_lo; j0 <= j6_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i6_lo; i0 <= i6_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d60dx * (
|
||||
-fh[idx_fh_F(iF - 3, jF, kF, ex)] +
|
||||
F9 * fh[idx_fh_F(iF - 2, jF, kF, ex)] -
|
||||
F45 * fh[idx_fh_F(iF - 1, jF, kF, ex)] +
|
||||
F45 * fh[idx_fh_F(iF + 1, jF, kF, ex)] -
|
||||
F9 * fh[idx_fh_F(iF + 2, jF, kF, ex)] +
|
||||
fh[idx_fh_F(iF + 3, jF, kF, ex)]);
|
||||
|
||||
fy[p] = d60dy * (
|
||||
-fh[idx_fh_F(iF, jF - 3, kF, ex)] +
|
||||
F9 * fh[idx_fh_F(iF, jF - 2, kF, ex)] -
|
||||
F45 * fh[idx_fh_F(iF, jF - 1, kF, ex)] +
|
||||
F45 * fh[idx_fh_F(iF, jF + 1, kF, ex)] -
|
||||
F9 * fh[idx_fh_F(iF, jF + 2, kF, ex)] +
|
||||
fh[idx_fh_F(iF, jF + 3, kF, ex)]);
|
||||
|
||||
fz[p] = d60dz * (
|
||||
-fh[idx_fh_F(iF, jF, kF - 3, ex)] +
|
||||
F9 * fh[idx_fh_F(iF, jF, kF - 2, ex)] -
|
||||
F45 * fh[idx_fh_F(iF, jF, kF - 1, ex)] +
|
||||
F45 * fh[idx_fh_F(iF, jF, kF + 1, ex)] -
|
||||
F9 * fh[idx_fh_F(iF, jF, kF + 2, ex)] +
|
||||
fh[idx_fh_F(iF, jF, kF + 3, ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 5)
|
||||
/* ---- 8th-order ----------------------------------------------------- */
|
||||
{
|
||||
const int ord = 5;
|
||||
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -3;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -3;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -3;
|
||||
|
||||
const double SoA[3] = { SYM1, SYM2, SYM3 };
|
||||
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
static double *fh_buf = NULL;
|
||||
static size_t cap = 0;
|
||||
if (fh_size > cap) {
|
||||
free(fh_buf);
|
||||
fh_buf = (double*)aligned_alloc(64, fh_size * sizeof(double));
|
||||
cap = fh_size;
|
||||
}
|
||||
double *fh = fh_buf;
|
||||
if (!fh) return;
|
||||
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
const double d840dx = ONE / F840 / dX;
|
||||
const double d840dy = ONE / F840 / dY;
|
||||
const double d840dz = ONE / F840 / dZ;
|
||||
const double d60dx = ONE / F60 / dX;
|
||||
const double d60dy = ONE / F60 / dY;
|
||||
const double d60dz = ONE / F60 / dZ;
|
||||
const double d12dx = ONE / F12 / dX;
|
||||
const double d12dy = ONE / F12 / dY;
|
||||
const double d12dz = ONE / F12 / dZ;
|
||||
const double d2dx = ONE / TWO / dX;
|
||||
const double d2dy = ONE / TWO / dY;
|
||||
const double d2dz = ONE / TWO / dZ;
|
||||
|
||||
const size_t all = (size_t)ex1 * (size_t)ex2 * (size_t)ex3;
|
||||
for (size_t p = 0; p < all; ++p) {
|
||||
fx[p] = ZEO; fy[p] = ZEO; fz[p] = ZEO;
|
||||
}
|
||||
|
||||
/* 2nd: 3pt, widest */
|
||||
const int i2_lo = (iminF > 0) ? iminF : 0;
|
||||
const int j2_lo = (jminF > 0) ? jminF : 0;
|
||||
const int k2_lo = (kminF > 0) ? kminF : 0;
|
||||
const int i2_hi = ex1 - 2;
|
||||
const int j2_hi = ex2 - 2;
|
||||
const int k2_hi = ex3 - 2;
|
||||
|
||||
/* 4th: 5pt */
|
||||
const int i4_lo = (iminF + 1 > 0) ? (iminF + 1) : 0;
|
||||
const int j4_lo = (jminF + 1 > 0) ? (jminF + 1) : 0;
|
||||
const int k4_lo = (kminF + 1 > 0) ? (kminF + 1) : 0;
|
||||
const int i4_hi = ex1 - 3;
|
||||
const int j4_hi = ex2 - 3;
|
||||
const int k4_hi = ex3 - 3;
|
||||
|
||||
/* 6th: 7pt */
|
||||
const int i6_lo = (iminF + 2 > 0) ? (iminF + 2) : 0;
|
||||
const int j6_lo = (jminF + 2 > 0) ? (jminF + 2) : 0;
|
||||
const int k6_lo = (kminF + 2 > 0) ? (kminF + 2) : 0;
|
||||
const int i6_hi = ex1 - 4;
|
||||
const int j6_hi = ex2 - 4;
|
||||
const int k6_hi = ex3 - 4;
|
||||
|
||||
/* 8th: 9pt, narrowest */
|
||||
const int i8_lo = (iminF + 3 > 0) ? (iminF + 3) : 0;
|
||||
const int j8_lo = (jminF + 3 > 0) ? (jminF + 3) : 0;
|
||||
const int k8_lo = (kminF + 3 > 0) ? (kminF + 3) : 0;
|
||||
const int i8_hi = ex1 - 5;
|
||||
const int j8_hi = ex2 - 5;
|
||||
const int k8_hi = ex3 - 5;
|
||||
|
||||
if (i2_lo <= i2_hi && j2_lo <= j2_hi && k2_lo <= k2_hi) {
|
||||
for (int k0 = k2_lo; k0 <= k2_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j2_lo; j0 <= j2_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i2_lo; i0 <= i2_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d2dx * (
|
||||
-fh[idx_fh_F_ord5(iF - 1, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord5(iF + 1, jF, kF, ex)]);
|
||||
fy[p] = d2dy * (
|
||||
-fh[idx_fh_F_ord5(iF, jF - 1, kF, ex)] +
|
||||
fh[idx_fh_F_ord5(iF, jF + 1, kF, ex)]);
|
||||
fz[p] = d2dz * (
|
||||
-fh[idx_fh_F_ord5(iF, jF, kF - 1, ex)] +
|
||||
fh[idx_fh_F_ord5(iF, jF, kF + 1, ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (i4_lo <= i4_hi && j4_lo <= j4_hi && k4_lo <= k4_hi) {
|
||||
for (int k0 = k4_lo; k0 <= k4_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j4_lo; j0 <= j4_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i4_lo; i0 <= i4_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d12dx * (
|
||||
fh[idx_fh_F_ord5(iF - 2, jF, kF, ex)] -
|
||||
EIT * fh[idx_fh_F_ord5(iF - 1, jF, kF, ex)] +
|
||||
EIT * fh[idx_fh_F_ord5(iF + 1, jF, kF, ex)] -
|
||||
fh[idx_fh_F_ord5(iF + 2, jF, kF, ex)]);
|
||||
|
||||
fy[p] = d12dy * (
|
||||
fh[idx_fh_F_ord5(iF, jF - 2, kF, ex)] -
|
||||
EIT * fh[idx_fh_F_ord5(iF, jF - 1, kF, ex)] +
|
||||
EIT * fh[idx_fh_F_ord5(iF, jF + 1, kF, ex)] -
|
||||
fh[idx_fh_F_ord5(iF, jF + 2, kF, ex)]);
|
||||
|
||||
fz[p] = d12dz * (
|
||||
fh[idx_fh_F_ord5(iF, jF, kF - 2, ex)] -
|
||||
EIT * fh[idx_fh_F_ord5(iF, jF, kF - 1, ex)] +
|
||||
EIT * fh[idx_fh_F_ord5(iF, jF, kF + 1, ex)] -
|
||||
fh[idx_fh_F_ord5(iF, jF, kF + 2, ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (i6_lo <= i6_hi && j6_lo <= j6_hi && k6_lo <= k6_hi) {
|
||||
for (int k0 = k6_lo; k0 <= k6_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j6_lo; j0 <= j6_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i6_lo; i0 <= i6_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d60dx * (
|
||||
-fh[idx_fh_F_ord5(iF - 3, jF, kF, ex)] +
|
||||
F9 * fh[idx_fh_F_ord5(iF - 2, jF, kF, ex)] -
|
||||
F45 * fh[idx_fh_F_ord5(iF - 1, jF, kF, ex)] +
|
||||
F45 * fh[idx_fh_F_ord5(iF + 1, jF, kF, ex)] -
|
||||
F9 * fh[idx_fh_F_ord5(iF + 2, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord5(iF + 3, jF, kF, ex)]);
|
||||
|
||||
fy[p] = d60dy * (
|
||||
-fh[idx_fh_F_ord5(iF, jF - 3, kF, ex)] +
|
||||
F9 * fh[idx_fh_F_ord5(iF, jF - 2, kF, ex)] -
|
||||
F45 * fh[idx_fh_F_ord5(iF, jF - 1, kF, ex)] +
|
||||
F45 * fh[idx_fh_F_ord5(iF, jF + 1, kF, ex)] -
|
||||
F9 * fh[idx_fh_F_ord5(iF, jF + 2, kF, ex)] +
|
||||
fh[idx_fh_F_ord5(iF, jF + 3, kF, ex)]);
|
||||
|
||||
fz[p] = d60dz * (
|
||||
-fh[idx_fh_F_ord5(iF, jF, kF - 3, ex)] +
|
||||
F9 * fh[idx_fh_F_ord5(iF, jF, kF - 2, ex)] -
|
||||
F45 * fh[idx_fh_F_ord5(iF, jF, kF - 1, ex)] +
|
||||
F45 * fh[idx_fh_F_ord5(iF, jF, kF + 1, ex)] -
|
||||
F9 * fh[idx_fh_F_ord5(iF, jF, kF + 2, ex)] +
|
||||
fh[idx_fh_F_ord5(iF, jF, kF + 3, ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 8th-order overwrite: [+3,-32,+168,-672,0,+672,-168,+32,-3] / (840*dx) */
|
||||
if (i8_lo <= i8_hi && j8_lo <= j8_hi && k8_lo <= k8_hi) {
|
||||
for (int k0 = k8_lo; k0 <= k8_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j8_lo; j0 <= j8_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i8_lo; i0 <= i8_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
fx[p] = d840dx * (
|
||||
+(double)3 * fh[idx_fh_F_ord5(iF - 4, jF, kF, ex)] -
|
||||
F32 * fh[idx_fh_F_ord5(iF - 3, jF, kF, ex)] +
|
||||
F168 * fh[idx_fh_F_ord5(iF - 2, jF, kF, ex)] -
|
||||
F672 * fh[idx_fh_F_ord5(iF - 1, jF, kF, ex)] +
|
||||
F672 * fh[idx_fh_F_ord5(iF + 1, jF, kF, ex)] -
|
||||
F168 * fh[idx_fh_F_ord5(iF + 2, jF, kF, ex)] +
|
||||
F32 * fh[idx_fh_F_ord5(iF + 3, jF, kF, ex)] -
|
||||
(double)3 * fh[idx_fh_F_ord5(iF + 4, jF, kF, ex)]);
|
||||
|
||||
fy[p] = d840dy * (
|
||||
+(double)3 * fh[idx_fh_F_ord5(iF, jF - 4, kF, ex)] -
|
||||
F32 * fh[idx_fh_F_ord5(iF, jF - 3, kF, ex)] +
|
||||
F168 * fh[idx_fh_F_ord5(iF, jF - 2, kF, ex)] -
|
||||
F672 * fh[idx_fh_F_ord5(iF, jF - 1, kF, ex)] +
|
||||
F672 * fh[idx_fh_F_ord5(iF, jF + 1, kF, ex)] -
|
||||
F168 * fh[idx_fh_F_ord5(iF, jF + 2, kF, ex)] +
|
||||
F32 * fh[idx_fh_F_ord5(iF, jF + 3, kF, ex)] -
|
||||
(double)3 * fh[idx_fh_F_ord5(iF, jF + 4, kF, ex)]);
|
||||
|
||||
fz[p] = d840dz * (
|
||||
+(double)3 * fh[idx_fh_F_ord5(iF, jF, kF - 4, ex)] -
|
||||
F32 * fh[idx_fh_F_ord5(iF, jF, kF - 3, ex)] +
|
||||
F168 * fh[idx_fh_F_ord5(iF, jF, kF - 2, ex)] -
|
||||
F672 * fh[idx_fh_F_ord5(iF, jF, kF - 1, ex)] +
|
||||
F672 * fh[idx_fh_F_ord5(iF, jF, kF + 1, ex)] -
|
||||
F168 * fh[idx_fh_F_ord5(iF, jF, kF + 2, ex)] +
|
||||
F32 * fh[idx_fh_F_ord5(iF, jF, kF + 3, ex)] -
|
||||
(double)3 * fh[idx_fh_F_ord5(iF, jF, kF + 4, ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
#else
|
||||
#error "fderivs_c.C: unsupported ghost_width (must be 2, 3, 4, or 5)"
|
||||
#endif
|
||||
}
|
||||
|
||||
234
AMSS_NCKU_source/fderivs_sh_c.C
Normal file
234
AMSS_NCKU_source/fderivs_sh_c.C
Normal file
@@ -0,0 +1,234 @@
|
||||
#include "macrodef.h"
|
||||
#include "share_func.h"
|
||||
|
||||
/*
|
||||
* C 版 fderivs_sh — first derivatives on shell patch in (rho, sigma, R) coords.
|
||||
*
|
||||
* Same stencil coefficients as Cartesian fderivs, but:
|
||||
* - Uses symmetry_stbd (ghost on BOTH sides of x/y, none in z)
|
||||
* - fh buffer: (-ord+1:ex+ord) in x/y, (1:ex) in z
|
||||
* - SoA is 2-element only (x/y), no z-symmetry
|
||||
* - sst parameter (shell surface type, not used in stencil computation)
|
||||
*/
|
||||
extern "C" void fderivs_sh_(const int ex[3],
|
||||
const double *f,
|
||||
double *fx, double *fy, double *fz,
|
||||
const double *X, const double *Y, const double *Z,
|
||||
double SYM1, double SYM2, double SYM3,
|
||||
int Symmetry, int onoff, int sst)
|
||||
{
|
||||
(void)SYM3; (void)onoff; (void)sst;
|
||||
|
||||
const double ZEO = 0.0, ONE = 1.0, TWO = 2.0, EIT = 8.0;
|
||||
const double F9 = 9.0, F12 = 12.0, F45 = 45.0, F60 = 60.0;
|
||||
const double F32 = 32.0, F168 = 168.0, F672 = 672.0, F840 = 840.0;
|
||||
|
||||
const int NO_SYMM = 0, EQ_SYMM = 1, OCTANT = 2;
|
||||
const int ex1 = ex[0], ex2 = ex[1], ex3 = ex[2];
|
||||
const double dX = X[1] - X[0];
|
||||
const double dY = Y[1] - Y[0];
|
||||
const double dZ = Z[1] - Z[0];
|
||||
const int imaxF = ex1, jmaxF = ex2, kmaxF = ex3;
|
||||
const double SoA[2] = { SYM1, SYM2 };
|
||||
|
||||
#if (ghost_width == 2)
|
||||
{
|
||||
const int ord = 1;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry == OCTANT && fabs(X[0]) < dX) iminF = 0;
|
||||
if (Symmetry == OCTANT && fabs(Y[0]) < dY) jminF = 0;
|
||||
if ((sst==2||sst==4) && fabs(Y[0]) < dY) jminF = 0; // EQ reflection
|
||||
|
||||
const size_t nx = (size_t)ex1 + 2 * ord;
|
||||
const size_t ny = (size_t)ex2 + 2 * ord;
|
||||
const size_t nz = (size_t)ex3;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
static double *fh_buf = NULL; static size_t cap = 0;
|
||||
if (fh_size > cap) { free(fh_buf); fh_buf = (double*)aligned_alloc(64, fh_size*sizeof(double)); cap = fh_size; }
|
||||
double *fh = fh_buf; if (!fh) return;
|
||||
symmetry_stbd(ord, ex, f, fh, SoA);
|
||||
|
||||
const double d2dx = ONE/TWO/dX, d2dy = ONE/TWO/dY, d2dz = ONE/TWO/dZ;
|
||||
const size_t all = (size_t)ex1*ex2*ex3;
|
||||
for (size_t p=0;p<all;++p) { fx[p]=ZEO; fy[p]=ZEO; fz[p]=ZEO; }
|
||||
|
||||
const int i2_lo=(iminF>0)?iminF:0, j2_lo=(jminF>0)?jminF:0, k2_lo=1;
|
||||
const int i2_hi=ex1-2, j2_hi=ex2-2, k2_hi=ex3-2;
|
||||
if (i2_lo<=i2_hi&&j2_lo<=j2_hi&&k2_lo<=k2_hi) {
|
||||
for (int k0=k2_lo;k0<=k2_hi;++k0) { const int kF=k0+1;
|
||||
for (int j0=j2_lo;j0<=j2_hi;++j0) { const int jF=j0+1;
|
||||
for (int i0=i2_lo;i0<=i2_hi;++i0) { const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d2dx*(-fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)]);
|
||||
fy[p]=d2dy*(-fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)]);
|
||||
fz[p]=d2dz*(-fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)]);
|
||||
}}}
|
||||
}
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 3)
|
||||
{
|
||||
const int ord = 2;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry == OCTANT && fabs(X[0]) < dX) iminF = -1;
|
||||
if (Symmetry == OCTANT && fabs(Y[0]) < dY) jminF = -1;
|
||||
if ((sst==2||sst==4) && fabs(Y[0]) < dY) jminF = -1;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord, ny=(size_t)ex2+2*ord, nz=(size_t)ex3;
|
||||
const size_t fh_size=nx*ny*nz;
|
||||
static double *fh_buf=NULL; static size_t cap=0;
|
||||
if (fh_size>cap){free(fh_buf);fh_buf=(double*)aligned_alloc(64,fh_size*sizeof(double));cap=fh_size;}
|
||||
double *fh=fh_buf; if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const double d12dx=ONE/F12/dX, d12dy=ONE/F12/dY, d12dz=ONE/F12/dZ;
|
||||
const double d2dx=ONE/TWO/dX, d2dy=ONE/TWO/dY, d2dz=ONE/TWO/dZ;
|
||||
const size_t all=(size_t)ex1*ex2*ex3;
|
||||
for(size_t p=0;p<all;++p){fx[p]=ZEO;fy[p]=ZEO;fz[p]=ZEO;}
|
||||
|
||||
const int i2_lo=(iminF>0)?iminF:0, j2_lo=(jminF>0)?jminF:0, k2_lo=1;
|
||||
const int i2_hi=ex1-2, j2_hi=ex2-2, k2_hi=ex3-2;
|
||||
const int i4_lo=(iminF+1>0)?iminF+1:0, j4_lo=(jminF+1>0)?jminF+1:0, k4_lo=2;
|
||||
const int i4_hi=ex1-3, j4_hi=ex2-3, k4_hi=ex3-3;
|
||||
|
||||
if (i2_lo<=i2_hi&&j2_lo<=j2_hi&&k2_lo<=k2_hi) {
|
||||
for(int k0=k2_lo;k0<=k2_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j2_lo;j0<=j2_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i2_lo;i0<=i2_hi;++i0){const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d2dx*(-fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)]);
|
||||
fy[p]=d2dy*(-fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)]);
|
||||
fz[p]=d2dz*(-fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)]);
|
||||
}}}
|
||||
}
|
||||
if (i4_lo<=i4_hi&&j4_lo<=j4_hi&&k4_lo<=k4_hi) {
|
||||
for(int k0=k4_lo;k0<=k4_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j4_lo;j0<=j4_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i4_lo;i0<=i4_hi;++i0){const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d12dx*(fh[idx_fh_stbd(iF-2,jF,kF,ord,ex)]-EIT*fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+EIT*fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)]-fh[idx_fh_stbd(iF+2,jF,kF,ord,ex)]);
|
||||
fy[p]=d12dy*(fh[idx_fh_stbd(iF,jF-2,kF,ord,ex)]-EIT*fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+EIT*fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)]-fh[idx_fh_stbd(iF,jF+2,kF,ord,ex)]);
|
||||
fz[p]=d12dz*(fh[idx_fh_stbd(iF,jF,kF-2,ord,ex)]-EIT*fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+EIT*fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)]-fh[idx_fh_stbd(iF,jF,kF+2,ord,ex)]);
|
||||
}}}
|
||||
}
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 4)
|
||||
{
|
||||
const int ord = 3;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=-2;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=-2;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=-2;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3;
|
||||
const size_t fh_size=nx*ny*nz;
|
||||
static double *fh_buf=NULL;static size_t cap=0;
|
||||
if(fh_size>cap){free(fh_buf);fh_buf=(double*)aligned_alloc(64,fh_size*sizeof(double));cap=fh_size;}
|
||||
double *fh=fh_buf;if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const double d60dx=ONE/F60/dX,d60dy=ONE/F60/dY,d60dz=ONE/F60/dZ;
|
||||
const double d12dx=ONE/F12/dX,d12dy=ONE/F12/dY,d12dz=ONE/F12/dZ;
|
||||
const double d2dx=ONE/TWO/dX,d2dy=ONE/TWO/dY,d2dz=ONE/TWO/dZ;
|
||||
const size_t all=(size_t)ex1*ex2*ex3;
|
||||
for(size_t p=0;p<all;++p){fx[p]=ZEO;fy[p]=ZEO;fz[p]=ZEO;}
|
||||
|
||||
const int i2_lo=(iminF>0)?iminF:0,j2_lo=(jminF>0)?jminF:0,k2_lo=1,i2_hi=ex1-2,j2_hi=ex2-2,k2_hi=ex3-2;
|
||||
const int i4_lo=(iminF+1>0)?iminF+1:0,j4_lo=(jminF+1>0)?jminF+1:0,k4_lo=2,i4_hi=ex1-3,j4_hi=ex2-3,k4_hi=ex3-3;
|
||||
const int i6_lo=(iminF+2>0)?iminF+2:0,j6_lo=(jminF+2>0)?jminF+2:0,k6_lo=3,i6_hi=ex1-4,j6_hi=ex2-4,k6_hi=ex3-4;
|
||||
|
||||
if(i2_lo<=i2_hi&&j2_lo<=j2_hi&&k2_lo<=k2_hi){
|
||||
for(int k0=k2_lo;k0<=k2_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j2_lo;j0<=j2_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i2_lo;i0<=i2_hi;++i0){const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d2dx*(-fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)]);
|
||||
fy[p]=d2dy*(-fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)]);
|
||||
fz[p]=d2dz*(-fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)]);
|
||||
}}}
|
||||
}
|
||||
if(i4_lo<=i4_hi&&j4_lo<=j4_hi&&k4_lo<=k4_hi){
|
||||
for(int k0=k4_lo;k0<=k4_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j4_lo;j0<=j4_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i4_lo;i0<=i4_hi;++i0){const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d12dx*(fh[idx_fh_stbd(iF-2,jF,kF,ord,ex)]-EIT*fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+EIT*fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)]-fh[idx_fh_stbd(iF+2,jF,kF,ord,ex)]);
|
||||
fy[p]=d12dy*(fh[idx_fh_stbd(iF,jF-2,kF,ord,ex)]-EIT*fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+EIT*fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)]-fh[idx_fh_stbd(iF,jF+2,kF,ord,ex)]);
|
||||
fz[p]=d12dz*(fh[idx_fh_stbd(iF,jF,kF-2,ord,ex)]-EIT*fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+EIT*fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)]-fh[idx_fh_stbd(iF,jF,kF+2,ord,ex)]);
|
||||
}}}
|
||||
}
|
||||
if(i6_lo<=i6_hi&&j6_lo<=j6_hi&&k6_lo<=k6_hi){
|
||||
for(int k0=k6_lo;k0<=k6_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j6_lo;j0<=j6_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i6_lo;i0<=i6_hi;++i0){const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d60dx*(-fh[idx_fh_stbd(iF-3,jF,kF,ord,ex)]+F9*fh[idx_fh_stbd(iF-2,jF,kF,ord,ex)]-F45*fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+F45*fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)]-F9*fh[idx_fh_stbd(iF+2,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+3,jF,kF,ord,ex)]);
|
||||
fy[p]=d60dy*(-fh[idx_fh_stbd(iF,jF-3,kF,ord,ex)]+F9*fh[idx_fh_stbd(iF,jF-2,kF,ord,ex)]-F45*fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+F45*fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)]-F9*fh[idx_fh_stbd(iF,jF+2,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+3,kF,ord,ex)]);
|
||||
fz[p]=d60dz*(-fh[idx_fh_stbd(iF,jF,kF-3,ord,ex)]+F9*fh[idx_fh_stbd(iF,jF,kF-2,ord,ex)]-F45*fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+F45*fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)]-F9*fh[idx_fh_stbd(iF,jF,kF+2,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+3,ord,ex)]);
|
||||
}}}
|
||||
}
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 5)
|
||||
{
|
||||
const int ord = 4;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=-3;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=-3;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=-3;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3;
|
||||
const size_t fh_size=nx*ny*nz;
|
||||
static double *fh_buf=NULL;static size_t cap=0;
|
||||
if(fh_size>cap){free(fh_buf);fh_buf=(double*)aligned_alloc(64,fh_size*sizeof(double));cap=fh_size;}
|
||||
double *fh=fh_buf;if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const double d840dx=ONE/F840/dX,d840dy=ONE/F840/dY,d840dz=ONE/F840/dZ;
|
||||
const double d60dx=ONE/F60/dX,d60dy=ONE/F60/dY,d60dz=ONE/F60/dZ;
|
||||
const double d12dx=ONE/F12/dX,d12dy=ONE/F12/dY,d12dz=ONE/F12/dZ;
|
||||
const double d2dx=ONE/TWO/dX,d2dy=ONE/TWO/dY,d2dz=ONE/TWO/dZ;
|
||||
const size_t all=(size_t)ex1*ex2*ex3;
|
||||
for(size_t p=0;p<all;++p){fx[p]=ZEO;fy[p]=ZEO;fz[p]=ZEO;}
|
||||
|
||||
const int i2_lo=(iminF>0)?iminF:0,j2_lo=(jminF>0)?jminF:0,k2_lo=1,i2_hi=ex1-2,j2_hi=ex2-2,k2_hi=ex3-2;
|
||||
const int i4_lo=(iminF+1>0)?iminF+1:0,j4_lo=(jminF+1>0)?jminF+1:0,k4_lo=2,i4_hi=ex1-3,j4_hi=ex2-3,k4_hi=ex3-3;
|
||||
const int i6_lo=(iminF+2>0)?iminF+2:0,j6_lo=(jminF+2>0)?jminF+2:0,k6_lo=3,i6_hi=ex1-4,j6_hi=ex2-4,k6_hi=ex3-4;
|
||||
const int i8_lo=(iminF+3>0)?iminF+3:0,j8_lo=(jminF+3>0)?jminF+3:0,k8_lo=4,i8_hi=ex1-5,j8_hi=ex2-5,k8_hi=ex3-5;
|
||||
|
||||
#define FH_S(iF,jF,kF) fh[idx_fh_stbd(iF,jF,kF,ord,ex)]
|
||||
if(i2_lo<=i2_hi&&j2_lo<=j2_hi&&k2_lo<=k2_hi){for(int k0=k2_lo;k0<=k2_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j2_lo;j0<=j2_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i2_lo;i0<=i2_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d2dx*(-FH_S(iF-1,jF,kF)+FH_S(iF+1,jF,kF));
|
||||
fy[p]=d2dy*(-FH_S(iF,jF-1,kF)+FH_S(iF,jF+1,kF));
|
||||
fz[p]=d2dz*(-FH_S(iF,jF,kF-1)+FH_S(iF,jF,kF+1));}}}}
|
||||
|
||||
if(i4_lo<=i4_hi&&j4_lo<=j4_hi&&k4_lo<=k4_hi){for(int k0=k4_lo;k0<=k4_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j4_lo;j0<=j4_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i4_lo;i0<=i4_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d12dx*(FH_S(iF-2,jF,kF)-EIT*FH_S(iF-1,jF,kF)+EIT*FH_S(iF+1,jF,kF)-FH_S(iF+2,jF,kF));
|
||||
fy[p]=d12dy*(FH_S(iF,jF-2,kF)-EIT*FH_S(iF,jF-1,kF)+EIT*FH_S(iF,jF+1,kF)-FH_S(iF,jF+2,kF));
|
||||
fz[p]=d12dz*(FH_S(iF,jF,kF-2)-EIT*FH_S(iF,jF,kF-1)+EIT*FH_S(iF,jF,kF+1)-FH_S(iF,jF,kF+2));}}}}
|
||||
|
||||
if(i6_lo<=i6_hi&&j6_lo<=j6_hi&&k6_lo<=k6_hi){for(int k0=k6_lo;k0<=k6_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j6_lo;j0<=j6_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i6_lo;i0<=i6_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d60dx*(-FH_S(iF-3,jF,kF)+F9*FH_S(iF-2,jF,kF)-F45*FH_S(iF-1,jF,kF)+F45*FH_S(iF+1,jF,kF)-F9*FH_S(iF+2,jF,kF)+FH_S(iF+3,jF,kF));
|
||||
fy[p]=d60dy*(-FH_S(iF,jF-3,kF)+F9*FH_S(iF,jF-2,kF)-F45*FH_S(iF,jF-1,kF)+F45*FH_S(iF,jF+1,kF)-F9*FH_S(iF,jF+2,kF)+FH_S(iF,jF+3,kF));
|
||||
fz[p]=d60dz*(-FH_S(iF,jF,kF-3)+F9*FH_S(iF,jF,kF-2)-F45*FH_S(iF,jF,kF-1)+F45*FH_S(iF,jF,kF+1)-F9*FH_S(iF,jF,kF+2)+FH_S(iF,jF,kF+3));}}}}
|
||||
|
||||
if(i8_lo<=i8_hi&&j8_lo<=j8_hi&&k8_lo<=k8_hi){for(int k0=k8_lo;k0<=k8_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j8_lo;j0<=j8_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i8_lo;i0<=i8_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
fx[p]=d840dx*(+(double)3*FH_S(iF-4,jF,kF)-F32*FH_S(iF-3,jF,kF)+F168*FH_S(iF-2,jF,kF)-F672*FH_S(iF-1,jF,kF)+F672*FH_S(iF+1,jF,kF)-F168*FH_S(iF+2,jF,kF)+F32*FH_S(iF+3,jF,kF)-(double)3*FH_S(iF+4,jF,kF));
|
||||
fy[p]=d840dy*(+(double)3*FH_S(iF,jF-4,kF)-F32*FH_S(iF,jF-3,kF)+F168*FH_S(iF,jF-2,kF)-F672*FH_S(iF,jF-1,kF)+F672*FH_S(iF,jF+1,kF)-F168*FH_S(iF,jF+2,kF)+F32*FH_S(iF,jF+3,kF)-(double)3*FH_S(iF,jF+4,kF));
|
||||
fz[p]=d840dz*(+(double)3*FH_S(iF,jF,kF-4)-F32*FH_S(iF,jF,kF-3)+F168*FH_S(iF,jF,kF-2)-F672*FH_S(iF,jF,kF-1)+F672*FH_S(iF,jF,kF+1)-F168*FH_S(iF,jF,kF+2)+F32*FH_S(iF,jF,kF+3)-(double)3*FH_S(iF,jF,kF+4));}}}}
|
||||
#undef FH_S
|
||||
return;
|
||||
}
|
||||
#else
|
||||
#error "fderivs_sh_c.C: unsupported ghost_width"
|
||||
#endif
|
||||
}
|
||||
54
AMSS_NCKU_source/fderivs_shc_c.C
Normal file
54
AMSS_NCKU_source/fderivs_shc_c.C
Normal file
@@ -0,0 +1,54 @@
|
||||
#include "macrodef.h"
|
||||
#include "share_func.h"
|
||||
#include <cstddef>
|
||||
|
||||
/*
|
||||
* fderivs_shc — shell first derivatives converted to Cartesian via chain rule.
|
||||
*
|
||||
* Calls fderivs_sh internally, then:
|
||||
* fx = drhodx * df/drho + dsigmadx * df/dsigma + dRdx * df/dR
|
||||
* fy = drhody * df/drho + dsigmady * df/dsigma + dRdy * df/dR
|
||||
* fz = drhodz * df/drho + dsigmadz * df/dsigma + dRdz * df/dR
|
||||
*/
|
||||
|
||||
// Forward declaration (defined in fderivs_sh_c.C with extern "C" name fderivs_sh_)
|
||||
extern "C" {
|
||||
void fderivs_sh_(const int ex[3], const double *f,
|
||||
double *fx, double *fy, double *fz,
|
||||
const double *X, const double *Y, const double *Z,
|
||||
double SYM1, double SYM2, double SYM3,
|
||||
int Symmetry, int onoff, int sst);
|
||||
|
||||
void fderivs_shc_(int *ex,
|
||||
double *f,
|
||||
double *fx, double *fy, double *fz,
|
||||
double *crho, double *sigma, double *R,
|
||||
double &SYM1, double &SYM2, double &SYM3,
|
||||
int &Symmetry, int &Lev, int &sst,
|
||||
double *drhodx, double *drhody, double *drhodz,
|
||||
double *dsigmadx, double *dsigmady, double *dsigmadz,
|
||||
double *dRdx, double *dRdy, double *dRdz)
|
||||
{
|
||||
const int ex3[3] = { ex[0], ex[1], ex[2] };
|
||||
const size_t n = (size_t)ex[0] * (size_t)ex[1] * (size_t)ex[2];
|
||||
|
||||
// Temporary shell-coordinate derivatives
|
||||
double *gx = (double*)malloc(n * sizeof(double));
|
||||
double *gy = (double*)malloc(n * sizeof(double));
|
||||
double *gz = (double*)malloc(n * sizeof(double));
|
||||
if (!gx || !gy || !gz) { free(gx); free(gy); free(gz); return; }
|
||||
|
||||
// Compute shell-coordinate derivatives
|
||||
fderivs_sh_(ex3, f, gx, gy, gz, crho, sigma, R, SYM1, SYM2, SYM3, Symmetry, Lev, sst);
|
||||
|
||||
// Chain rule to Cartesian
|
||||
for (size_t i = 0; i < n; ++i) {
|
||||
fx[i] = drhodx[i] * gx[i] + dsigmadx[i] * gy[i] + dRdx[i] * gz[i];
|
||||
fy[i] = drhody[i] * gx[i] + dsigmady[i] * gy[i] + dRdy[i] * gz[i];
|
||||
fz[i] = drhodz[i] * gx[i] + dsigmadz[i] * gy[i] + dRdz[i] * gz[i];
|
||||
}
|
||||
|
||||
free(gx); free(gy); free(gz);
|
||||
}
|
||||
|
||||
} // extern "C"
|
||||
@@ -17,8 +17,8 @@ using namespace std;
|
||||
#include <math.h>
|
||||
#endif
|
||||
|
||||
// Intel oneMKL LAPACK interface
|
||||
#include <mkl_lapacke.h>
|
||||
// LAPACKE interface (AOCL for AOCC, oneMKL for Intel)
|
||||
#include <lapacke.h>
|
||||
/* Linear equation solution using Intel oneMKL LAPACK.
|
||||
a[0..n-1][0..n-1] is the input matrix. b[0..n-1] is input
|
||||
containing the right-hand side vectors. On output a is
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#ifndef GPU_MEM_H_
|
||||
#define GPU_MEM_H_
|
||||
#include "macrodef.fh"
|
||||
#include "macrodef.h"
|
||||
|
||||
#ifdef WithShell
|
||||
struct Metass
|
||||
@@ -48,6 +48,8 @@ struct Meta
|
||||
double * Gamx_rhs,*Gamy_rhs,*Gamz_rhs;//out
|
||||
double * Lap_rhs, *betax_rhs, *betay_rhs, *betaz_rhs;//out
|
||||
double * dtSfx_rhs,*dtSfy_rhs,*dtSfz_rhs;//out
|
||||
double * TZ; //in (Z4C)
|
||||
double * TZ_rhs; //out (Z4C)
|
||||
double * rho,*Sx,*Sy,*Sz ; //in
|
||||
double * Sxx,*Sxy,*Sxz,*Syy,*Syz,*Szz; //in
|
||||
|
||||
@@ -132,6 +134,8 @@ __constant__ double SYM = 1.0;
|
||||
__constant__ double ANTI = -1.0;
|
||||
__constant__ double FF = 0.75;
|
||||
__constant__ double eta = 2.0;
|
||||
__constant__ double kappa1_c = 0.02;
|
||||
__constant__ double kappa2_c = 0.0;
|
||||
__constant__ double F1o3;
|
||||
__constant__ double F2o3;
|
||||
__constant__ double F3o2 = 1.5;
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
#include "macrodef.h"
|
||||
#include "tool.h"
|
||||
|
||||
/*
|
||||
* C 版 kodis
|
||||
* C 版 kodis — Kreiss-Oliger numerical dissipation (Cartesian patches).
|
||||
*
|
||||
* Fortran signature:
|
||||
* subroutine kodis(ex,X,Y,Z,f,f_rhs,SoA,Symmetry,eps)
|
||||
* The KO operator is (D₊D₋)^r applied to f_rhs with alternating sign (-1)^(r-1).
|
||||
*
|
||||
* 约定：
|
||||
* X: ex1, Y: ex2, Z: ex3
|
||||
* f, f_rhs: ex1*ex2*ex3 按 idx_ex 布局
|
||||
* SoA[3]
|
||||
* eps: double
|
||||
* FD order → r → cof=2^(2r) mapping:
|
||||
* ghost_width=2 (2nd) → r=2, cof=16, sign=-
|
||||
* ghost_width=3 (4th) → r=3, cof=64, sign=+
|
||||
* ghost_width=4 (6th) → r=4, cof=256, sign=-
|
||||
* ghost_width=5 (8th) → r=5, cof=1024,sign=+
|
||||
*/
|
||||
void kodis(const int ex[3],
|
||||
const double *X, const double *Y, const double *Z,
|
||||
@@ -18,100 +18,304 @@ void kodis(const int ex[3],
|
||||
const double SoA[3],
|
||||
int Symmetry, double eps)
|
||||
{
|
||||
const double ONE = 1.0, SIX = 6.0, FIT = 15.0, TWT = 20.0;
|
||||
const double cof = 64.0; // 2^6
|
||||
const int NO_SYMM = 0, OCTANT = 2;
|
||||
|
||||
const double ZEO = 0.0;
|
||||
const int ex1 = ex[0], ex2 = ex[1], ex3 = ex[2];
|
||||
|
||||
// Fortran: dX = X(2)-X(1) -> C: X[1]-X[0]
|
||||
const double dX = X[1] - X[0];
|
||||
const double dY = Y[1] - Y[0];
|
||||
const double dZ = Z[1] - Z[0];
|
||||
(void)ONE; // ONE 在原 Fortran 里只是参数，这里不一定用得上
|
||||
|
||||
// Fortran: imax=ex(1) 等是 1-based 上界
|
||||
const int imaxF = ex1;
|
||||
const int jmaxF = ex2;
|
||||
const int kmaxF = ex3;
|
||||
const int imaxF = ex1, jmaxF = ex2, kmaxF = ex3;
|
||||
|
||||
// Fortran: imin=jmin=kmin=1，某些对称情况变 -2
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
#if (ghost_width == 2)
|
||||
/* ---- r=2, cof=16, sign=-, 5pt stencil ----------------------------- */
|
||||
{
|
||||
const int ord = 2;
|
||||
const int r = 2;
|
||||
const double cof = 16.0;
|
||||
const double F4 = 4.0, F6 = 6.0;
|
||||
const int NO_SYMM = 0, EQ_SYMM = 1;
|
||||
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -2;
|
||||
if (Symmetry == OCTANT && fabs(X[0]) < dX) iminF = -2;
|
||||
if (Symmetry == OCTANT && fabs(Y[0]) < dY) jminF = -2;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -1;
|
||||
|
||||
// 分配 fh：大小 (ex1+3)*(ex2+3)*(ex3+3)，对应 ord=3
|
||||
const size_t nx = (size_t)ex1 + 3;
|
||||
const size_t ny = (size_t)ex2 + 3;
|
||||
const size_t nz = (size_t)ex3 + 3;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
|
||||
// Fortran: call symmetry_bd(3,ex,f,fh,SoA)
|
||||
symmetry_bd(3, ex, f, fh, SoA);
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
/*
|
||||
* Fortran loops:
|
||||
* do k=1,ex3
|
||||
* do j=1,ex2
|
||||
* do i=1,ex1
|
||||
*
|
||||
* C: k0=0..ex3-1, j0=0..ex2-1, i0=0..ex1-1
|
||||
* 并定义 Fortran index: iF=i0+1, ...
|
||||
*/
|
||||
// 收紧循环范围：只遍历满足 iF±3/jF±3/kF±3 条件的内部点
|
||||
// iF-3 >= iminF => iF >= iminF+3 => i0 >= iminF+2 (因为 iF=i0+1)
|
||||
// iF+3 <= imaxF => iF <= imaxF-3 => i0 <= imaxF-4
|
||||
const int i0_lo = (iminF + 2 > 0) ? iminF + 2 : 0;
|
||||
const int j0_lo = (jminF + 2 > 0) ? jminF + 2 : 0;
|
||||
const int k0_lo = (kminF + 2 > 0) ? kminF + 2 : 0;
|
||||
const int i0_hi = imaxF - 4; // inclusive
|
||||
const int j0_hi = jmaxF - 4;
|
||||
const int k0_hi = kmaxF - 4;
|
||||
/* i±2 must be valid: i-2 >= iminF && i+2 <= imaxF
|
||||
C 0-based: i0 >= iminF+1, i0 <= ex1-3 */
|
||||
const int i0_lo = (iminF + 1 > 0) ? (iminF + 1) : 0;
|
||||
const int j0_lo = (jminF + 1 > 0) ? (jminF + 1) : 0;
|
||||
const int k0_lo = (kminF + 1 > 0) ? (kminF + 1) : 0;
|
||||
const int i0_hi = imaxF - 3;
|
||||
const int j0_hi = jmaxF - 3;
|
||||
const int k0_hi = kmaxF - 3;
|
||||
|
||||
if (i0_lo > i0_hi || j0_lo > j0_hi || k0_lo > k0_hi) {
|
||||
if (!(i0_lo > i0_hi || j0_lo > j0_hi || k0_lo > k0_hi)) {
|
||||
for (int k0 = k0_lo; k0 <= k0_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j0_lo; j0 <= j0_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i0_lo; i0 <= i0_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
const double Dx = (
|
||||
(fh[idx_fh_F_ord2(iF - 2, jF, kF, ex)] + fh[idx_fh_F_ord2(iF + 2, jF, kF, ex)]) -
|
||||
F4 * (fh[idx_fh_F_ord2(iF - 1, jF, kF, ex)] + fh[idx_fh_F_ord2(iF + 1, jF, kF, ex)]) +
|
||||
F6 * fh[idx_fh_F_ord2(iF, jF, kF, ex)]
|
||||
) / dX;
|
||||
|
||||
const double Dy = (
|
||||
(fh[idx_fh_F_ord2(iF, jF - 2, kF, ex)] + fh[idx_fh_F_ord2(iF, jF + 2, kF, ex)]) -
|
||||
F4 * (fh[idx_fh_F_ord2(iF, jF - 1, kF, ex)] + fh[idx_fh_F_ord2(iF, jF + 1, kF, ex)]) +
|
||||
F6 * fh[idx_fh_F_ord2(iF, jF, kF, ex)]
|
||||
) / dY;
|
||||
|
||||
const double Dz = (
|
||||
(fh[idx_fh_F_ord2(iF, jF, kF - 2, ex)] + fh[idx_fh_F_ord2(iF, jF, kF + 2, ex)]) -
|
||||
F4 * (fh[idx_fh_F_ord2(iF, jF, kF - 1, ex)] + fh[idx_fh_F_ord2(iF, jF, kF + 1, ex)]) +
|
||||
F6 * fh[idx_fh_F_ord2(iF, jF, kF, ex)]
|
||||
) / dZ;
|
||||
|
||||
f_rhs[p] -= (eps / cof) * (Dx + Dy + Dz); /* sign=- */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 3)
|
||||
/* ---- r=3, cof=64, sign=+, 7pt stencil (current default) ---------- */
|
||||
{
|
||||
const int ord = 3;
|
||||
const int r = 3;
|
||||
const double cof = 64.0;
|
||||
const double SIX = 6.0, FIT = 15.0, TWT = 20.0;
|
||||
const int NO_SYMM = 0, OCTANT = 2;
|
||||
|
||||
for (int k0 = k0_lo; k0 <= k0_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j0_lo; j0 <= j0_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i0_lo; i0 <= i0_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -2;
|
||||
if (Symmetry == OCTANT && fabs(X[0]) < dX) iminF = -2;
|
||||
if (Symmetry == OCTANT && fabs(Y[0]) < dY) jminF = -2;
|
||||
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
// 三个方向各一份同型的 7 点组合（实际上是对称的 6th-order dissipation/filter 核）
|
||||
const double Dx_term =
|
||||
( (fh[idx_fh_F(iF - 3, jF, kF, ex)] + fh[idx_fh_F(iF + 3, jF, kF, ex)]) -
|
||||
SIX * (fh[idx_fh_F(iF - 2, jF, kF, ex)] + fh[idx_fh_F(iF + 2, jF, kF, ex)]) +
|
||||
FIT * (fh[idx_fh_F(iF - 1, jF, kF, ex)] + fh[idx_fh_F(iF + 1, jF, kF, ex)]) -
|
||||
TWT * fh[idx_fh_F(iF , jF, kF, ex)] ) / dX;
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
|
||||
const double Dy_term =
|
||||
( (fh[idx_fh_F(iF, jF - 3, kF, ex)] + fh[idx_fh_F(iF, jF + 3, kF, ex)]) -
|
||||
SIX * (fh[idx_fh_F(iF, jF - 2, kF, ex)] + fh[idx_fh_F(iF, jF + 2, kF, ex)]) +
|
||||
FIT * (fh[idx_fh_F(iF, jF - 1, kF, ex)] + fh[idx_fh_F(iF, jF + 1, kF, ex)]) -
|
||||
TWT * fh[idx_fh_F(iF, jF , kF, ex)] ) / dY;
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
const double Dz_term =
|
||||
( (fh[idx_fh_F(iF, jF, kF - 3, ex)] + fh[idx_fh_F(iF, jF, kF + 3, ex)]) -
|
||||
SIX * (fh[idx_fh_F(iF, jF, kF - 2, ex)] + fh[idx_fh_F(iF, jF, kF + 2, ex)]) +
|
||||
FIT * (fh[idx_fh_F(iF, jF, kF - 1, ex)] + fh[idx_fh_F(iF, jF, kF + 1, ex)]) -
|
||||
TWT * fh[idx_fh_F(iF, jF, kF , ex)] ) / dZ;
|
||||
const int i0_lo = (iminF + 2 > 0) ? iminF + 2 : 0;
|
||||
const int j0_lo = (jminF + 2 > 0) ? jminF + 2 : 0;
|
||||
const int k0_lo = (kminF + 2 > 0) ? kminF + 2 : 0;
|
||||
const int i0_hi = imaxF - 4;
|
||||
const int j0_hi = jmaxF - 4;
|
||||
const int k0_hi = kmaxF - 4;
|
||||
|
||||
// Fortran:
|
||||
// f_rhs(i,j,k) = f_rhs(i,j,k) + eps/cof*(Dx_term + Dy_term + Dz_term)
|
||||
f_rhs[p] += (eps / cof) * (Dx_term + Dy_term + Dz_term);
|
||||
if (!(i0_lo > i0_hi || j0_lo > j0_hi || k0_lo > k0_hi)) {
|
||||
for (int k0 = k0_lo; k0 <= k0_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j0_lo; j0 <= j0_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i0_lo; i0 <= i0_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
const double Dx = (
|
||||
(fh[idx_fh_F(iF - 3, jF, kF, ex)] + fh[idx_fh_F(iF + 3, jF, kF, ex)]) -
|
||||
SIX * (fh[idx_fh_F(iF - 2, jF, kF, ex)] + fh[idx_fh_F(iF + 2, jF, kF, ex)]) +
|
||||
FIT * (fh[idx_fh_F(iF - 1, jF, kF, ex)] + fh[idx_fh_F(iF + 1, jF, kF, ex)]) -
|
||||
TWT * fh[idx_fh_F(iF, jF, kF, ex)]
|
||||
) / dX;
|
||||
|
||||
const double Dy = (
|
||||
(fh[idx_fh_F(iF, jF - 3, kF, ex)] + fh[idx_fh_F(iF, jF + 3, kF, ex)]) -
|
||||
SIX * (fh[idx_fh_F(iF, jF - 2, kF, ex)] + fh[idx_fh_F(iF, jF + 2, kF, ex)]) +
|
||||
FIT * (fh[idx_fh_F(iF, jF - 1, kF, ex)] + fh[idx_fh_F(iF, jF + 1, kF, ex)]) -
|
||||
TWT * fh[idx_fh_F(iF, jF, kF, ex)]
|
||||
) / dY;
|
||||
|
||||
const double Dz = (
|
||||
(fh[idx_fh_F(iF, jF, kF - 3, ex)] + fh[idx_fh_F(iF, jF, kF + 3, ex)]) -
|
||||
SIX * (fh[idx_fh_F(iF, jF, kF - 2, ex)] + fh[idx_fh_F(iF, jF, kF + 2, ex)]) +
|
||||
FIT * (fh[idx_fh_F(iF, jF, kF - 1, ex)] + fh[idx_fh_F(iF, jF, kF + 1, ex)]) -
|
||||
TWT * fh[idx_fh_F(iF, jF, kF, ex)]
|
||||
) / dZ;
|
||||
|
||||
f_rhs[p] += (eps / cof) * (Dx + Dy + Dz); /* sign=+ */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 4)
|
||||
/* ---- r=4, cof=256, sign=-, 9pt stencil ---------------------------- */
|
||||
{
|
||||
const int ord = 4;
|
||||
const int r = 4;
|
||||
const double cof = 256.0;
|
||||
const double F8 = 8.0, F28 = 28.0, F56 = 56.0, F70 = 70.0;
|
||||
const int NO_SYMM = 0, EQ_SYMM = 1;
|
||||
|
||||
free(fh);
|
||||
}
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -3;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -3;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -3;
|
||||
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
/* i±4 valid: i-4>=iminF → i0>=iminF+3, i+4<=imaxF → i0<=ex1-5 */
|
||||
const int i0_lo = (iminF + 3 > 0) ? iminF + 3 : 0;
|
||||
const int j0_lo = (jminF + 3 > 0) ? jminF + 3 : 0;
|
||||
const int k0_lo = (kminF + 3 > 0) ? kminF + 3 : 0;
|
||||
const int i0_hi = imaxF - 5;
|
||||
const int j0_hi = jmaxF - 5;
|
||||
const int k0_hi = kmaxF - 5;
|
||||
|
||||
if (!(i0_lo > i0_hi || j0_lo > j0_hi || k0_lo > k0_hi)) {
|
||||
for (int k0 = k0_lo; k0 <= k0_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j0_lo; j0 <= j0_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i0_lo; i0 <= i0_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
/* Stencil: [1,-8,28,-56,70,-56,28,-8,1] */
|
||||
const double Dx = (
|
||||
(fh[idx_fh_F_ord4(iF - 4, jF, kF, ex)] + fh[idx_fh_F_ord4(iF + 4, jF, kF, ex)]) -
|
||||
F8 * (fh[idx_fh_F_ord4(iF - 3, jF, kF, ex)] + fh[idx_fh_F_ord4(iF + 3, jF, kF, ex)]) +
|
||||
F28* (fh[idx_fh_F_ord4(iF - 2, jF, kF, ex)] + fh[idx_fh_F_ord4(iF + 2, jF, kF, ex)]) -
|
||||
F56* (fh[idx_fh_F_ord4(iF - 1, jF, kF, ex)] + fh[idx_fh_F_ord4(iF + 1, jF, kF, ex)]) +
|
||||
F70* fh[idx_fh_F_ord4(iF, jF, kF, ex)]
|
||||
) / dX;
|
||||
|
||||
const double Dy = (
|
||||
(fh[idx_fh_F_ord4(iF, jF - 4, kF, ex)] + fh[idx_fh_F_ord4(iF, jF + 4, kF, ex)]) -
|
||||
F8 * (fh[idx_fh_F_ord4(iF, jF - 3, kF, ex)] + fh[idx_fh_F_ord4(iF, jF + 3, kF, ex)]) +
|
||||
F28* (fh[idx_fh_F_ord4(iF, jF - 2, kF, ex)] + fh[idx_fh_F_ord4(iF, jF + 2, kF, ex)]) -
|
||||
F56* (fh[idx_fh_F_ord4(iF, jF - 1, kF, ex)] + fh[idx_fh_F_ord4(iF, jF + 1, kF, ex)]) +
|
||||
F70* fh[idx_fh_F_ord4(iF, jF, kF, ex)]
|
||||
) / dY;
|
||||
|
||||
const double Dz = (
|
||||
(fh[idx_fh_F_ord4(iF, jF, kF - 4, ex)] + fh[idx_fh_F_ord4(iF, jF, kF + 4, ex)]) -
|
||||
F8 * (fh[idx_fh_F_ord4(iF, jF, kF - 3, ex)] + fh[idx_fh_F_ord4(iF, jF, kF + 3, ex)]) +
|
||||
F28* (fh[idx_fh_F_ord4(iF, jF, kF - 2, ex)] + fh[idx_fh_F_ord4(iF, jF, kF + 2, ex)]) -
|
||||
F56* (fh[idx_fh_F_ord4(iF, jF, kF - 1, ex)] + fh[idx_fh_F_ord4(iF, jF, kF + 1, ex)]) +
|
||||
F70* fh[idx_fh_F_ord4(iF, jF, kF, ex)]
|
||||
) / dZ;
|
||||
|
||||
f_rhs[p] -= (eps / cof) * (Dx + Dy + Dz); /* sign=- */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 5)
|
||||
/* ---- r=5, cof=1024, sign=+, 11pt stencil ------------------------- */
|
||||
{
|
||||
const int ord = 5;
|
||||
const int r = 5;
|
||||
const double cof = 1024.0;
|
||||
const double F10 = 10.0, F45 = 45.0, F120 = 120.0;
|
||||
const double F210 = 210.0, F252 = 252.0;
|
||||
const int NO_SYMM = 0, EQ_SYMM = 1;
|
||||
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -4;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -4;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -4;
|
||||
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
/* i±5 valid: i0>=iminF+4, i0<=ex1-6 */
|
||||
const int i0_lo = (iminF + 4 > 0) ? iminF + 4 : 0;
|
||||
const int j0_lo = (jminF + 4 > 0) ? jminF + 4 : 0;
|
||||
const int k0_lo = (kminF + 4 > 0) ? kminF + 4 : 0;
|
||||
const int i0_hi = imaxF - 6;
|
||||
const int j0_hi = jmaxF - 6;
|
||||
const int k0_hi = kmaxF - 6;
|
||||
|
||||
if (!(i0_lo > i0_hi || j0_lo > j0_hi || k0_lo > k0_hi)) {
|
||||
for (int k0 = k0_lo; k0 <= k0_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j0_lo; j0 <= j0_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i0_lo; i0 <= i0_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
/* Stencil: [1,-10,45,-120,210,-252,210,-120,45,-10,1] */
|
||||
const double Dx = (
|
||||
(fh[idx_fh_F_ord5(iF - 5, jF, kF, ex)] + fh[idx_fh_F_ord5(iF + 5, jF, kF, ex)]) -
|
||||
F10 * (fh[idx_fh_F_ord5(iF - 4, jF, kF, ex)] + fh[idx_fh_F_ord5(iF + 4, jF, kF, ex)]) +
|
||||
F45 * (fh[idx_fh_F_ord5(iF - 3, jF, kF, ex)] + fh[idx_fh_F_ord5(iF + 3, jF, kF, ex)]) -
|
||||
F120* (fh[idx_fh_F_ord5(iF - 2, jF, kF, ex)] + fh[idx_fh_F_ord5(iF + 2, jF, kF, ex)]) +
|
||||
F210* (fh[idx_fh_F_ord5(iF - 1, jF, kF, ex)] + fh[idx_fh_F_ord5(iF + 1, jF, kF, ex)]) -
|
||||
F252* fh[idx_fh_F_ord5(iF, jF, kF, ex)]
|
||||
) / dX;
|
||||
|
||||
const double Dy = (
|
||||
(fh[idx_fh_F_ord5(iF, jF - 5, kF, ex)] + fh[idx_fh_F_ord5(iF, jF + 5, kF, ex)]) -
|
||||
F10 * (fh[idx_fh_F_ord5(iF, jF - 4, kF, ex)] + fh[idx_fh_F_ord5(iF, jF + 4, kF, ex)]) +
|
||||
F45 * (fh[idx_fh_F_ord5(iF, jF - 3, kF, ex)] + fh[idx_fh_F_ord5(iF, jF + 3, kF, ex)]) -
|
||||
F120* (fh[idx_fh_F_ord5(iF, jF - 2, kF, ex)] + fh[idx_fh_F_ord5(iF, jF + 2, kF, ex)]) +
|
||||
F210* (fh[idx_fh_F_ord5(iF, jF - 1, kF, ex)] + fh[idx_fh_F_ord5(iF, jF + 1, kF, ex)]) -
|
||||
F252* fh[idx_fh_F_ord5(iF, jF, kF, ex)]
|
||||
) / dY;
|
||||
|
||||
const double Dz = (
|
||||
(fh[idx_fh_F_ord5(iF, jF, kF - 5, ex)] + fh[idx_fh_F_ord5(iF, jF, kF + 5, ex)]) -
|
||||
F10 * (fh[idx_fh_F_ord5(iF, jF, kF - 4, ex)] + fh[idx_fh_F_ord5(iF, jF, kF + 4, ex)]) +
|
||||
F45 * (fh[idx_fh_F_ord5(iF, jF, kF - 3, ex)] + fh[idx_fh_F_ord5(iF, jF, kF + 3, ex)]) -
|
||||
F120* (fh[idx_fh_F_ord5(iF, jF, kF - 2, ex)] + fh[idx_fh_F_ord5(iF, jF, kF + 2, ex)]) +
|
||||
F210* (fh[idx_fh_F_ord5(iF, jF, kF - 1, ex)] + fh[idx_fh_F_ord5(iF, jF, kF + 1, ex)]) -
|
||||
F252* fh[idx_fh_F_ord5(iF, jF, kF, ex)]
|
||||
) / dZ;
|
||||
|
||||
f_rhs[p] += (eps / cof) * (Dx + Dy + Dz); /* sign=+ */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#else
|
||||
#error "kodiss_c.C: unsupported ghost_width (must be 2, 3, 4, or 5)"
|
||||
#endif
|
||||
}
|
||||
|
||||
136
AMSS_NCKU_source/kodiss_sh_c.C
Normal file
136
AMSS_NCKU_source/kodiss_sh_c.C
Normal file
@@ -0,0 +1,136 @@
|
||||
#include "macrodef.h"
|
||||
#include "share_func.h"
|
||||
|
||||
/*
|
||||
* kodis_sh — Kreiss-Oliger dissipation on shell patches.
|
||||
* Same stencil coefficients as Cartesian kodis. Uses symmetry_stbd.
|
||||
*/
|
||||
extern "C" void kodis_sh_(const int ex[3],
|
||||
const double *X, const double *Y, const double *Z,
|
||||
const double *f, double *f_rhs,
|
||||
const double SoAi[2],
|
||||
int Symmetry, double eps, int sst)
|
||||
{
|
||||
(void)sst;
|
||||
const double ZEO=0.0;
|
||||
const int ex1=ex[0], ex2=ex[1], ex3=ex[2];
|
||||
const double dX=X[1]-X[0], dY=Y[1]-Y[0], dZ=Z[1]-Z[0];
|
||||
const int imaxF=ex1, jmaxF=ex2, kmaxF=ex3;
|
||||
const double SoA[2]={SoAi[0],SoAi[1]};
|
||||
|
||||
#if (ghost_width == 2)
|
||||
{
|
||||
const int ord=2, r=2;
|
||||
const double cof=16.0, F4=4.0, F6=6.0;
|
||||
const int NO_SYMM=0, OCTANT=2;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=-1;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=-1;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=-1;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3,fh_size=nx*ny*nz;
|
||||
double *fh=(double*)malloc(fh_size*sizeof(double));if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const int i0_lo=(iminF+1>0)?iminF+1:0,j0_lo=(jminF+1>0)?jminF+1:0,k0_lo=2;
|
||||
const int i0_hi=imaxF-3,j0_hi=jmaxF-3,k0_hi=kmaxF-3;
|
||||
if(!(i0_lo>i0_hi||j0_lo>j0_hi||k0_lo>k0_hi)){
|
||||
for(int k0=k0_lo;k0<=k0_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j0_lo;j0<=j0_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i0_lo;i0<=i0_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
const double Dx=((fh[idx_fh_stbd(iF-2,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+2,jF,kF,ord,ex)])-F4*(fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)])+F6*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dX;
|
||||
const double Dy=((fh[idx_fh_stbd(iF,jF-2,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+2,kF,ord,ex)])-F4*(fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)])+F6*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dY;
|
||||
const double Dz=((fh[idx_fh_stbd(iF,jF,kF-2,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+2,ord,ex)])-F4*(fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)])+F6*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dZ;
|
||||
f_rhs[p]-=(eps/cof)*(Dx+Dy+Dz);
|
||||
}}}
|
||||
}
|
||||
free(fh);return;
|
||||
}
|
||||
#elif (ghost_width == 3)
|
||||
{
|
||||
const int ord=3, r=3;
|
||||
const double cof=64.0,SIX=6.0,FIT=15.0,TWT=20.0;
|
||||
const int NO_SYMM=0,OCTANT=2;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=-2;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=-2;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=-2;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3,fh_size=nx*ny*nz;
|
||||
double *fh=(double*)malloc(fh_size*sizeof(double));if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const int i0_lo=(iminF+2>0)?iminF+2:0,j0_lo=(jminF+2>0)?jminF+2:0,k0_lo=3;
|
||||
const int i0_hi=imaxF-4,j0_hi=jmaxF-4,k0_hi=kmaxF-4;
|
||||
if(!(i0_lo>i0_hi||j0_lo>j0_hi||k0_lo>k0_hi)){
|
||||
for(int k0=k0_lo;k0<=k0_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j0_lo;j0<=j0_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i0_lo;i0<=i0_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
const double Dx=((fh[idx_fh_stbd(iF-3,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+3,jF,kF,ord,ex)])-SIX*(fh[idx_fh_stbd(iF-2,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+2,jF,kF,ord,ex)])+FIT*(fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)])-TWT*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dX;
|
||||
const double Dy=((fh[idx_fh_stbd(iF,jF-3,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+3,kF,ord,ex)])-SIX*(fh[idx_fh_stbd(iF,jF-2,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+2,kF,ord,ex)])+FIT*(fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)])-TWT*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dY;
|
||||
const double Dz=((fh[idx_fh_stbd(iF,jF,kF-3,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+3,ord,ex)])-SIX*(fh[idx_fh_stbd(iF,jF,kF-2,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+2,ord,ex)])+FIT*(fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)])-TWT*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dZ;
|
||||
f_rhs[p]+=(eps/cof)*(Dx+Dy+Dz);
|
||||
}}}
|
||||
}
|
||||
free(fh);return;
|
||||
}
|
||||
#elif (ghost_width == 4)
|
||||
{
|
||||
const int ord=4, r=4;
|
||||
const double cof=256.0,F8=8.0,F28=28.0,F56=56.0,F70=70.0;
|
||||
const int NO_SYMM=0,OCTANT=2;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=-3;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=-3;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=-3;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3,fh_size=nx*ny*nz;
|
||||
double *fh=(double*)malloc(fh_size*sizeof(double));if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const int i0_lo=(iminF+3>0)?iminF+3:0,j0_lo=(jminF+3>0)?jminF+3:0,k0_lo=4;
|
||||
const int i0_hi=imaxF-5,j0_hi=jmaxF-5,k0_hi=kmaxF-5;
|
||||
if(!(i0_lo>i0_hi||j0_lo>j0_hi||k0_lo>k0_hi)){
|
||||
for(int k0=k0_lo;k0<=k0_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j0_lo;j0<=j0_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i0_lo;i0<=i0_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
const double Dx=((fh[idx_fh_stbd(iF-4,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+4,jF,kF,ord,ex)])-F8*(fh[idx_fh_stbd(iF-3,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+3,jF,kF,ord,ex)])+F28*(fh[idx_fh_stbd(iF-2,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+2,jF,kF,ord,ex)])-F56*(fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)])+F70*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dX;
|
||||
const double Dy=((fh[idx_fh_stbd(iF,jF-4,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+4,kF,ord,ex)])-F8*(fh[idx_fh_stbd(iF,jF-3,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+3,kF,ord,ex)])+F28*(fh[idx_fh_stbd(iF,jF-2,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+2,kF,ord,ex)])-F56*(fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)])+F70*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dY;
|
||||
const double Dz=((fh[idx_fh_stbd(iF,jF,kF-4,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+4,ord,ex)])-F8*(fh[idx_fh_stbd(iF,jF,kF-3,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+3,ord,ex)])+F28*(fh[idx_fh_stbd(iF,jF,kF-2,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+2,ord,ex)])-F56*(fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)])+F70*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dZ;
|
||||
f_rhs[p]-=(eps/cof)*(Dx+Dy+Dz);
|
||||
}}}
|
||||
}
|
||||
free(fh);return;
|
||||
}
|
||||
#elif (ghost_width == 5)
|
||||
{
|
||||
const int ord=5, r=5;
|
||||
const double cof=1024.0,F10=10.0,F45k=45.0,F120=120.0,F210=210.0,F252=252.0;
|
||||
const int NO_SYMM=0,OCTANT=2;
|
||||
int iminF=1,jminF=1,kminF=1;
|
||||
if(Symmetry==OCTANT&&fabs(X[0])<dX)iminF=-4;
|
||||
if(Symmetry==OCTANT&&fabs(Y[0])<dY)jminF=-4;
|
||||
if((sst==2||sst==4)&&fabs(Y[0])<dY)jminF=-4;
|
||||
|
||||
const size_t nx=(size_t)ex1+2*ord,ny=(size_t)ex2+2*ord,nz=(size_t)ex3,fh_size=nx*ny*nz;
|
||||
double *fh=(double*)malloc(fh_size*sizeof(double));if(!fh)return;
|
||||
symmetry_stbd(ord,ex,f,fh,SoA);
|
||||
|
||||
const int i0_lo=(iminF+4>0)?iminF+4:0,j0_lo=(jminF+4>0)?jminF+4:0,k0_lo=5;
|
||||
const int i0_hi=imaxF-6,j0_hi=jmaxF-6,k0_hi=kmaxF-6;
|
||||
if(!(i0_lo>i0_hi||j0_lo>j0_hi||k0_lo>k0_hi)){
|
||||
for(int k0=k0_lo;k0<=k0_hi;++k0){const int kF=k0+1;
|
||||
for(int j0=j0_lo;j0<=j0_hi;++j0){const int jF=j0+1;
|
||||
for(int i0=i0_lo;i0<=i0_hi;++i0){const int iF=i0+1;const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
const double Dx=((fh[idx_fh_stbd(iF-5,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+5,jF,kF,ord,ex)])-F10*(fh[idx_fh_stbd(iF-4,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+4,jF,kF,ord,ex)])+F45k*(fh[idx_fh_stbd(iF-3,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+3,jF,kF,ord,ex)])-F120*(fh[idx_fh_stbd(iF-2,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+2,jF,kF,ord,ex)])+F210*(fh[idx_fh_stbd(iF-1,jF,kF,ord,ex)]+fh[idx_fh_stbd(iF+1,jF,kF,ord,ex)])-F252*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dX;
|
||||
const double Dy=((fh[idx_fh_stbd(iF,jF-5,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+5,kF,ord,ex)])-F10*(fh[idx_fh_stbd(iF,jF-4,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+4,kF,ord,ex)])+F45k*(fh[idx_fh_stbd(iF,jF-3,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+3,kF,ord,ex)])-F120*(fh[idx_fh_stbd(iF,jF-2,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+2,kF,ord,ex)])+F210*(fh[idx_fh_stbd(iF,jF-1,kF,ord,ex)]+fh[idx_fh_stbd(iF,jF+1,kF,ord,ex)])-F252*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dY;
|
||||
const double Dz=((fh[idx_fh_stbd(iF,jF,kF-5,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+5,ord,ex)])-F10*(fh[idx_fh_stbd(iF,jF,kF-4,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+4,ord,ex)])+F45k*(fh[idx_fh_stbd(iF,jF,kF-3,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+3,ord,ex)])-F120*(fh[idx_fh_stbd(iF,jF,kF-2,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+2,ord,ex)])+F210*(fh[idx_fh_stbd(iF,jF,kF-1,ord,ex)]+fh[idx_fh_stbd(iF,jF,kF+1,ord,ex)])-F252*fh[idx_fh_stbd(iF,jF,kF,ord,ex)])/dZ;
|
||||
f_rhs[p]+=(eps/cof)*(Dx+Dy+Dz);
|
||||
}}}
|
||||
}
|
||||
free(fh);return;
|
||||
}
|
||||
#else
|
||||
#error "kodiss_sh_c.C: unsupported ghost_width"
|
||||
#endif
|
||||
}
|
||||
@@ -1,14 +1,13 @@
|
||||
#include "macrodef.h"
|
||||
#include "tool.h"
|
||||
|
||||
/*
|
||||
* 你需要提供 symmetry_bd 的 C 版本（或 Fortran 绑到 C 的接口）。
|
||||
* Fortran: call symmetry_bd(3,ex,f,fh,SoA)
|
||||
* C 版 lopsided — upwind (lopsided) advection derivatives.
|
||||
*
|
||||
* 约定：
|
||||
* nghost = 3
|
||||
* ex[3] = {ex1,ex2,ex3}
|
||||
* f = 原始网格 (ex1*ex2*ex3)
|
||||
* fh = 扩展网格 ((ex1+3)*(ex2+3)*(ex3+3))，对应 Fortran 的 (-2:ex1, ...)
|
||||
* SoA[3] = 输入参数
|
||||
* Adds advection terms to f_rhs for all three spatial directions.
|
||||
* Uses sign-biased (one-sided) stencils with centered fallbacks.
|
||||
*
|
||||
* For lopsided, symmetry_bd ord = ghost_width (same as kodiss).
|
||||
*/
|
||||
void lopsided(const int ex[3],
|
||||
const double *X, const double *Y, const double *Z,
|
||||
@@ -16,240 +15,577 @@ void lopsided(const int ex[3],
|
||||
const double *Sfx, const double *Sfy, const double *Sfz,
|
||||
int Symmetry, const double SoA[3])
|
||||
{
|
||||
const double ZEO = 0.0, ONE = 1.0, F3 = 3.0;
|
||||
const double TWO = 2.0, F6 = 6.0, F18 = 18.0;
|
||||
const double F12 = 12.0, F10 = 10.0, EIT = 8.0;
|
||||
|
||||
const int NO_SYMM = 0, EQ_SYMM = 1, OCTANT = 2;
|
||||
(void)OCTANT; // 这里和 Fortran 一样只是定义了不用也没关系
|
||||
const double ZEO = 0.0, ONE = 1.0;
|
||||
const double TWO = 2.0, F6 = 6.0, EIT = 8.0;
|
||||
const double F3 = 3.0, F4 = 4.0, F5 = 5.0, F10 = 10.0, F12 = 12.0, F18 = 18.0;
|
||||
const double F9 = 9.0, F45 = 45.0, F60 = 60.0;
|
||||
const double F2 = 2.0, F15 = 15.0, F24 = 24.0, F30 = 30.0, F35 = 35.0;
|
||||
const double F50 = 50.0, F77 = 77.0, F80 = 80.0, F100 = 100.0, F150 = 150.0;
|
||||
const double F32 = 32.0, F168 = 168.0, F672 = 672.0, F840 = 840.0;
|
||||
const double F140=140.0, F378=378.0, F420=420.0, F1050=1050.0;
|
||||
|
||||
const int NO_SYMM = 0, EQ_SYMM = 1;
|
||||
const int ex1 = ex[0], ex2 = ex[1], ex3 = ex[2];
|
||||
|
||||
// 对应 Fortran: dX = X(2)-X(1) （Fortran 1-based）
|
||||
// C: X[1]-X[0]
|
||||
const double dX = X[1] - X[0];
|
||||
const double dY = Y[1] - Y[0];
|
||||
const double dZ = Z[1] - Z[0];
|
||||
|
||||
const double d12dx = ONE / F12 / dX;
|
||||
const double d12dy = ONE / F12 / dY;
|
||||
const double d12dz = ONE / F12 / dZ;
|
||||
#if (ghost_width == 2)
|
||||
/* ---- 2nd-order lopsided --------------------------------------------- */
|
||||
{
|
||||
const int ord = 2;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -1;
|
||||
|
||||
// Fortran 里算了 d2dx/d2dy/d2dz 但本 subroutine 里没用到（保持一致也算出来）
|
||||
const double d2dx = ONE / TWO / dX;
|
||||
const double d2dy = ONE / TWO / dY;
|
||||
const double d2dz = ONE / TWO / dZ;
|
||||
(void)d2dx; (void)d2dy; (void)d2dz;
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
// Fortran:
|
||||
// imax = ex(1); jmax = ex(2); kmax = ex(3)
|
||||
const int imaxF = ex1;
|
||||
const int jmaxF = ex2;
|
||||
const int kmaxF = ex3;
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
// Fortran:
|
||||
// imin=jmin=kmin=1; 若满足对称条件则设为 -2
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -2;
|
||||
const double d2dx = ONE / TWO / dX;
|
||||
const double d2dy = ONE / TWO / dY;
|
||||
const double d2dz = ONE / TWO / dZ;
|
||||
|
||||
// 分配 fh：大小 (ex1+3)*(ex2+3)*(ex3+3)
|
||||
const size_t nx = (size_t)ex1 + 3;
|
||||
const size_t ny = (size_t)ex2 + 3;
|
||||
const size_t nz = (size_t)ex3 + 3;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
const int imaxF = ex1, jmaxF = ex2, kmaxF = ex3;
|
||||
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return; // 内存不足：直接返回（你也可以改成 abort/报错）
|
||||
for (int k0 = 0; k0 <= ex3 - 2; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = 0; j0 <= ex2 - 2; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = 0; i0 <= ex1 - 2; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
// Fortran: call symmetry_bd(3,ex,f,fh,SoA)
|
||||
symmetry_bd(3, ex, f, fh, SoA);
|
||||
|
||||
/*
|
||||
* Fortran 主循环：
|
||||
* do k=1,ex(3)-1
|
||||
* do j=1,ex(2)-1
|
||||
* do i=1,ex(1)-1
|
||||
*
|
||||
* 转成 C 0-based：
|
||||
* k0 = 0..ex3-2, j0 = 0..ex2-2, i0 = 0..ex1-2
|
||||
*
|
||||
* 并且 Fortran 里的 i/j/k 在 fh 访问时，仍然是 Fortran 索引值：
|
||||
* iF=i0+1, jF=j0+1, kF=k0+1
|
||||
*/
|
||||
for (int k0 = 0; k0 <= ex3 - 2; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = 0; j0 <= ex2 - 2; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = 0; i0 <= ex1 - 2; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
// ---------------- x direction ----------------
|
||||
const double sfx = Sfx[p];
|
||||
if (sfx > ZEO) {
|
||||
// Fortran: if(i+3 <= imax)
|
||||
// iF+3 <= ex1 <=> i0+4 <= ex1 <=> i0 <= ex1-4
|
||||
if (i0 <= ex1 - 4) {
|
||||
f_rhs[p] += sfx * d12dx *
|
||||
(-F3 * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF , jF, kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF + 2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF + 3, jF, kF, ex)]);
|
||||
/* x-direction */
|
||||
const double sfx = Sfx[p];
|
||||
if (sfx > ZEO) {
|
||||
if (i0 <= ex1 - 3) // i+2 <= imax
|
||||
f_rhs[p] += sfx * d2dx * (
|
||||
-F3*fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
F4*fh[idx_fh_F_ord2(iF+1, jF, kF, ex)] -
|
||||
fh[idx_fh_F_ord2(iF+2, jF, kF, ex)]);
|
||||
else if (i0 <= ex1 - 2) // i+1 <= imax
|
||||
f_rhs[p] += sfx * d2dx * (
|
||||
-fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF+1, jF, kF, ex)]);
|
||||
} else if (sfx < ZEO) {
|
||||
if ((i0 - 1) >= iminF) // i-2 >= imin
|
||||
f_rhs[p] -= sfx * d2dx * (
|
||||
-F3*fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
F4*fh[idx_fh_F_ord2(iF-1, jF, kF, ex)] -
|
||||
fh[idx_fh_F_ord2(iF-2, jF, kF, ex)]);
|
||||
else if (i0 >= iminF) // i-1 >= imin
|
||||
f_rhs[p] -= sfx * d2dx * (
|
||||
-fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF-1, jF, kF, ex)]);
|
||||
}
|
||||
// elseif(i+2 <= imax) <=> i0 <= ex1-3
|
||||
else if (i0 <= ex1 - 3) {
|
||||
f_rhs[p] += sfx * d12dx *
|
||||
( fh[idx_fh_F(iF - 2, jF, kF, ex)]
|
||||
-EIT * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
+EIT * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
- fh[idx_fh_F(iF + 2, jF, kF, ex)]);
|
||||
}
|
||||
// elseif(i+1 <= imax) <=> i0 <= ex1-2（循环里总成立）
|
||||
else if (i0 <= ex1 - 2) {
|
||||
f_rhs[p] -= sfx * d12dx *
|
||||
(-F3 * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF , jF, kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF - 2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF - 3, jF, kF, ex)]);
|
||||
}
|
||||
} else if (sfx < ZEO) {
|
||||
// Fortran: if(i-3 >= imin)
|
||||
// (iF-3) >= iminF <=> (i0-2) >= iminF
|
||||
if ((i0 - 2) >= iminF) {
|
||||
f_rhs[p] -= sfx * d12dx *
|
||||
(-F3 * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF , jF, kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF - 2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF - 3, jF, kF, ex)]);
|
||||
}
|
||||
// elseif(i-2 >= imin) <=> (i0-1) >= iminF
|
||||
else if ((i0 - 1) >= iminF) {
|
||||
f_rhs[p] += sfx * d12dx *
|
||||
( fh[idx_fh_F(iF - 2, jF, kF, ex)]
|
||||
-EIT * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
+EIT * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
- fh[idx_fh_F(iF + 2, jF, kF, ex)]);
|
||||
}
|
||||
// elseif(i-1 >= imin) <=> i0 >= iminF
|
||||
else if (i0 >= iminF) {
|
||||
f_rhs[p] += sfx * d12dx *
|
||||
(-F3 * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF , jF, kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF + 2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF + 3, jF, kF, ex)]);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- y direction ----------------
|
||||
const double sfy = Sfy[p];
|
||||
if (sfy > ZEO) {
|
||||
// jF+3 <= ex2 <=> j0+4 <= ex2 <=> j0 <= ex2-4
|
||||
if (j0 <= ex2 - 4) {
|
||||
f_rhs[p] += sfy * d12dy *
|
||||
(-F3 * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF , kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF + 2, kF, ex)]
|
||||
+ fh[idx_fh_F(iF, jF + 3, kF, ex)]);
|
||||
} else if (j0 <= ex2 - 3) {
|
||||
f_rhs[p] += sfy * d12dy *
|
||||
( fh[idx_fh_F(iF, jF - 2, kF, ex)]
|
||||
-EIT * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
+EIT * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
- fh[idx_fh_F(iF, jF + 2, kF, ex)]);
|
||||
} else if (j0 <= ex2 - 2) {
|
||||
f_rhs[p] -= sfy * d12dy *
|
||||
(-F3 * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF , kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF - 2, kF, ex)]
|
||||
+ fh[idx_fh_F(iF, jF - 3, kF, ex)]);
|
||||
/* y-direction */
|
||||
const double sfy = Sfy[p];
|
||||
if (sfy > ZEO) {
|
||||
if (j0 <= ex2-3)
|
||||
f_rhs[p] += sfy * d2dy * (
|
||||
-F3*fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
F4*fh[idx_fh_F_ord2(iF, jF+1, kF, ex)] -
|
||||
fh[idx_fh_F_ord2(iF, jF+2, kF, ex)]);
|
||||
else if (j0 <= ex2-2)
|
||||
f_rhs[p] += sfy * d2dy * (
|
||||
-fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF, jF+1, kF, ex)]);
|
||||
} else if (sfy < ZEO) {
|
||||
if ((j0-1) >= jminF)
|
||||
f_rhs[p] -= sfy * d2dy * (
|
||||
-F3*fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
F4*fh[idx_fh_F_ord2(iF, jF-1, kF, ex)] -
|
||||
fh[idx_fh_F_ord2(iF, jF-2, kF, ex)]);
|
||||
else if (j0 >= jminF)
|
||||
f_rhs[p] -= sfy * d2dy * (
|
||||
-fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF, jF-1, kF, ex)]);
|
||||
}
|
||||
} else if (sfy < ZEO) {
|
||||
if ((j0 - 2) >= jminF) {
|
||||
f_rhs[p] -= sfy * d12dy *
|
||||
(-F3 * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF , kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF - 2, kF, ex)]
|
||||
+ fh[idx_fh_F(iF, jF - 3, kF, ex)]);
|
||||
} else if ((j0 - 1) >= jminF) {
|
||||
f_rhs[p] += sfy * d12dy *
|
||||
( fh[idx_fh_F(iF, jF - 2, kF, ex)]
|
||||
-EIT * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
+EIT * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
- fh[idx_fh_F(iF, jF + 2, kF, ex)]);
|
||||
} else if (j0 >= jminF) {
|
||||
f_rhs[p] += sfy * d12dy *
|
||||
(-F3 * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF , kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF + 2, kF, ex)]
|
||||
+ fh[idx_fh_F(iF, jF + 3, kF, ex)]);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- z direction ----------------
|
||||
const double sfz = Sfz[p];
|
||||
if (sfz > ZEO) {
|
||||
if (k0 <= ex3 - 4) {
|
||||
f_rhs[p] += sfz * d12dz *
|
||||
(-F3 * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF, kF , ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF, kF + 2, ex)]
|
||||
+ fh[idx_fh_F(iF, jF, kF + 3, ex)]);
|
||||
} else if (k0 <= ex3 - 3) {
|
||||
f_rhs[p] += sfz * d12dz *
|
||||
( fh[idx_fh_F(iF, jF, kF - 2, ex)]
|
||||
-EIT * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
+EIT * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
- fh[idx_fh_F(iF, jF, kF + 2, ex)]);
|
||||
} else if (k0 <= ex3 - 2) {
|
||||
f_rhs[p] -= sfz * d12dz *
|
||||
(-F3 * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF, kF , ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF, kF - 2, ex)]
|
||||
+ fh[idx_fh_F(iF, jF, kF - 3, ex)]);
|
||||
}
|
||||
} else if (sfz < ZEO) {
|
||||
if ((k0 - 2) >= kminF) {
|
||||
f_rhs[p] -= sfz * d12dz *
|
||||
(-F3 * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF, kF , ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF, kF - 2, ex)]
|
||||
+ fh[idx_fh_F(iF, jF, kF - 3, ex)]);
|
||||
} else if ((k0 - 1) >= kminF) {
|
||||
f_rhs[p] += sfz * d12dz *
|
||||
( fh[idx_fh_F(iF, jF, kF - 2, ex)]
|
||||
-EIT * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
+EIT * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
- fh[idx_fh_F(iF, jF, kF + 2, ex)]);
|
||||
} else if (k0 >= kminF) {
|
||||
f_rhs[p] += sfz * d12dz *
|
||||
(-F3 * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF, kF , ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF, kF + 2, ex)]
|
||||
+ fh[idx_fh_F(iF, jF, kF + 3, ex)]);
|
||||
/* z-direction */
|
||||
const double sfz = Sfz[p];
|
||||
if (sfz > ZEO) {
|
||||
if (k0 <= ex3-3)
|
||||
f_rhs[p] += sfz * d2dz * (
|
||||
-F3*fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
F4*fh[idx_fh_F_ord2(iF, jF, kF+1, ex)] -
|
||||
fh[idx_fh_F_ord2(iF, jF, kF+2, ex)]);
|
||||
else if (k0 <= ex3-2)
|
||||
f_rhs[p] += sfz * d2dz * (
|
||||
-fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF, jF, kF+1, ex)]);
|
||||
} else if (sfz < ZEO) {
|
||||
if ((k0-1) >= kminF)
|
||||
f_rhs[p] -= sfz * d2dz * (
|
||||
-F3*fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
F4*fh[idx_fh_F_ord2(iF, jF, kF-1, ex)] -
|
||||
fh[idx_fh_F_ord2(iF, jF, kF-2, ex)]);
|
||||
else if (k0 >= kminF)
|
||||
f_rhs[p] -= sfz * d2dz * (
|
||||
-fh[idx_fh_F_ord2(iF, jF, kF, ex)] +
|
||||
fh[idx_fh_F_ord2(iF, jF, kF-1, ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
free(fh);
|
||||
#elif (ghost_width == 3)
|
||||
/* ---- 4th-order lopsided (original code) ---------------------------- */
|
||||
{
|
||||
const int ord = 3;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -2;
|
||||
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
const double d12dx = ONE / F12 / dX;
|
||||
const double d12dy = ONE / F12 / dY;
|
||||
const double d12dz = ONE / F12 / dZ;
|
||||
|
||||
const int imaxF = ex1, jmaxF = ex2, kmaxF = ex3;
|
||||
|
||||
for (int k0 = 0; k0 <= ex3 - 2; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = 0; j0 <= ex2 - 2; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = 0; i0 <= ex1 - 2; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
const double sfx = Sfx[p];
|
||||
if (sfx > ZEO) {
|
||||
if (i0 <= ex1 - 4) // i+3 <= imax
|
||||
f_rhs[p] += sfx * d12dx * (
|
||||
-F3 *fh[idx_fh_F(iF-1, jF, kF, ex)]
|
||||
-F10*fh[idx_fh_F(iF, jF, kF, ex)]
|
||||
+F18*fh[idx_fh_F(iF+1, jF, kF, ex)]
|
||||
-F6 *fh[idx_fh_F(iF+2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF+3, jF, kF, ex)]);
|
||||
else if (i0 <= ex1 - 3) // i+2 <= imax
|
||||
f_rhs[p] += sfx * d12dx * (
|
||||
fh[idx_fh_F(iF-2, jF, kF, ex)]
|
||||
-EIT*fh[idx_fh_F(iF-1, jF, kF, ex)]
|
||||
+EIT*fh[idx_fh_F(iF+1, jF, kF, ex)]
|
||||
- fh[idx_fh_F(iF+2, jF, kF, ex)]);
|
||||
else if (i0 <= ex1 - 2) // i+1 <= imax → mirrored
|
||||
f_rhs[p] -= sfx * d12dx * (
|
||||
-F3 *fh[idx_fh_F(iF+1, jF, kF, ex)]
|
||||
-F10*fh[idx_fh_F(iF, jF, kF, ex)]
|
||||
+F18*fh[idx_fh_F(iF-1, jF, kF, ex)]
|
||||
-F6 *fh[idx_fh_F(iF-2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF-3, jF, kF, ex)]);
|
||||
} else if (sfx < ZEO) {
|
||||
if ((i0 - 2) >= iminF) // i-3 >= imin
|
||||
f_rhs[p] -= sfx * d12dx * (
|
||||
-F3 *fh[idx_fh_F(iF+1, jF, kF, ex)]
|
||||
-F10*fh[idx_fh_F(iF, jF, kF, ex)]
|
||||
+F18*fh[idx_fh_F(iF-1, jF, kF, ex)]
|
||||
-F6 *fh[idx_fh_F(iF-2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF-3, jF, kF, ex)]);
|
||||
else if ((i0 - 1) >= iminF) // i-2 >= imin
|
||||
f_rhs[p] += sfx * d12dx * (
|
||||
fh[idx_fh_F(iF-2, jF, kF, ex)]
|
||||
-EIT*fh[idx_fh_F(iF-1, jF, kF, ex)]
|
||||
+EIT*fh[idx_fh_F(iF+1, jF, kF, ex)]
|
||||
- fh[idx_fh_F(iF+2, jF, kF, ex)]);
|
||||
else if (i0 >= iminF) // i-1 >= imin → mirrored
|
||||
f_rhs[p] += sfx * d12dx * (
|
||||
-F3 *fh[idx_fh_F(iF-1, jF, kF, ex)]
|
||||
-F10*fh[idx_fh_F(iF, jF, kF, ex)]
|
||||
+F18*fh[idx_fh_F(iF+1, jF, kF, ex)]
|
||||
-F6 *fh[idx_fh_F(iF+2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF+3, jF, kF, ex)]);
|
||||
}
|
||||
|
||||
const double sfy = Sfy[p];
|
||||
if (sfy > ZEO) {
|
||||
if (j0 <= ex2-4)
|
||||
f_rhs[p] += sfy * d12dy * (
|
||||
-F3*fh[idx_fh_F(iF,jF-1,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]
|
||||
+F18*fh[idx_fh_F(iF,jF+1,kF,ex)]-F6*fh[idx_fh_F(iF,jF+2,kF,ex)]
|
||||
+fh[idx_fh_F(iF,jF+3,kF,ex)]);
|
||||
else if (j0 <= ex2-3)
|
||||
f_rhs[p] += sfy * d12dy * (fh[idx_fh_F(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F(iF,jF+1,kF,ex)]-fh[idx_fh_F(iF,jF+2,kF,ex)]);
|
||||
else if (j0 <= ex2-2)
|
||||
f_rhs[p] -= sfy * d12dy * (
|
||||
-F3*fh[idx_fh_F(iF,jF+1,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]
|
||||
+F18*fh[idx_fh_F(iF,jF-1,kF,ex)]-F6*fh[idx_fh_F(iF,jF-2,kF,ex)]
|
||||
+fh[idx_fh_F(iF,jF-3,kF,ex)]);
|
||||
} else if (sfy < ZEO) {
|
||||
if ((j0-2) >= jminF)
|
||||
f_rhs[p] -= sfy * d12dy * (
|
||||
-F3*fh[idx_fh_F(iF,jF+1,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]
|
||||
+F18*fh[idx_fh_F(iF,jF-1,kF,ex)]-F6*fh[idx_fh_F(iF,jF-2,kF,ex)]
|
||||
+fh[idx_fh_F(iF,jF-3,kF,ex)]);
|
||||
else if ((j0-1) >= jminF)
|
||||
f_rhs[p] += sfy * d12dy * (fh[idx_fh_F(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F(iF,jF+1,kF,ex)]-fh[idx_fh_F(iF,jF+2,kF,ex)]);
|
||||
else if (j0 >= jminF)
|
||||
f_rhs[p] += sfy * d12dy * (
|
||||
-F3*fh[idx_fh_F(iF,jF-1,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]
|
||||
+F18*fh[idx_fh_F(iF,jF+1,kF,ex)]-F6*fh[idx_fh_F(iF,jF+2,kF,ex)]
|
||||
+fh[idx_fh_F(iF,jF+3,kF,ex)]);
|
||||
}
|
||||
|
||||
const double sfz = Sfz[p];
|
||||
if (sfz > ZEO) {
|
||||
if (k0 <= ex3-4)
|
||||
f_rhs[p] += sfz * d12dz * (
|
||||
-F3*fh[idx_fh_F(iF,jF,kF-1,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]
|
||||
+F18*fh[idx_fh_F(iF,jF,kF+1,ex)]-F6*fh[idx_fh_F(iF,jF,kF+2,ex)]
|
||||
+fh[idx_fh_F(iF,jF,kF+3,ex)]);
|
||||
else if (k0 <= ex3-3)
|
||||
f_rhs[p] += sfz * d12dz * (fh[idx_fh_F(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F(iF,jF,kF+1,ex)]-fh[idx_fh_F(iF,jF,kF+2,ex)]);
|
||||
else if (k0 <= ex3-2)
|
||||
f_rhs[p] -= sfz * d12dz * (
|
||||
-F3*fh[idx_fh_F(iF,jF,kF+1,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]
|
||||
+F18*fh[idx_fh_F(iF,jF,kF-1,ex)]-F6*fh[idx_fh_F(iF,jF,kF-2,ex)]
|
||||
+fh[idx_fh_F(iF,jF,kF-3,ex)]);
|
||||
} else if (sfz < ZEO) {
|
||||
if ((k0-2) >= kminF)
|
||||
f_rhs[p] -= sfz * d12dz * (
|
||||
-F3*fh[idx_fh_F(iF,jF,kF+1,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]
|
||||
+F18*fh[idx_fh_F(iF,jF,kF-1,ex)]-F6*fh[idx_fh_F(iF,jF,kF-2,ex)]
|
||||
+fh[idx_fh_F(iF,jF,kF-3,ex)]);
|
||||
else if ((k0-1) >= kminF)
|
||||
f_rhs[p] += sfz * d12dz * (fh[idx_fh_F(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F(iF,jF,kF+1,ex)]-fh[idx_fh_F(iF,jF,kF+2,ex)]);
|
||||
else if (k0 >= kminF)
|
||||
f_rhs[p] += sfz * d12dz * (
|
||||
-F3*fh[idx_fh_F(iF,jF,kF-1,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]
|
||||
+F18*fh[idx_fh_F(iF,jF,kF+1,ex)]-F6*fh[idx_fh_F(iF,jF,kF+2,ex)]
|
||||
+fh[idx_fh_F(iF,jF,kF+3,ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 4)
|
||||
/* ---- 6th-order lopsided --------------------------------------------- */
|
||||
{
|
||||
const int ord = 4;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -3;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -3;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -3;
|
||||
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
const double d60dx = ONE / F60 / dX;
|
||||
const double d60dy = ONE / F60 / dY;
|
||||
const double d60dz = ONE / F60 / dZ;
|
||||
const double d12dx = ONE / F12 / dX;
|
||||
const double d12dy = ONE / F12 / dY;
|
||||
const double d12dz = ONE / F12 / dZ;
|
||||
const double d2dx = ONE / TWO / dX;
|
||||
const double d2dy = ONE / TWO / dY;
|
||||
const double d2dz = ONE / TWO / dZ;
|
||||
|
||||
const int imaxF = ex1, jmaxF = ex2, kmaxF = ex3;
|
||||
|
||||
for (int k0 = 0; k0 <= ex3 - 2; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = 0; j0 <= ex2 - 2; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = 0; i0 <= ex1 - 2; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
/* ---- x-direction ---- */
|
||||
const double sfx = Sfx[p];
|
||||
if (sfx > ZEO) {
|
||||
/* Primary biased: 2*f(i-2)-24*f(i-1)-35*f(i)+80*f(i+1)-30*f(i+2)+8*f(i+3)-f(i+4) */
|
||||
if (i0 <= ex1-5 && (i0-1)>=iminF) // i+4<=imax && i-2>=imin
|
||||
f_rhs[p] += sfx * d60dx * (
|
||||
+F2*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]-F24*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]
|
||||
-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]
|
||||
-F30*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF+3,jF,kF,ex)]
|
||||
-fh[idx_fh_F_ord4(iF+4,jF,kF,ex)]);
|
||||
/* Boundary-adapted: -10*f(i-1)-77*f(i)+150*f(i+1)-100*f(i+2)+50*f(i+3)-15*f(i+4)+2*f(i+5) */
|
||||
else if (i0 <= ex1-6 && i0 >= iminF) // i+5<=imax && i-1>=imin
|
||||
f_rhs[p] += sfx * d60dx * (
|
||||
-F10*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]
|
||||
+F150*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-F100*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]
|
||||
+F50*fh[idx_fh_F_ord4(iF+3,jF,kF,ex)]-F15*fh[idx_fh_F_ord4(iF+4,jF,kF,ex)]
|
||||
+F2*fh[idx_fh_F_ord4(iF+5,jF,kF,ex)]);
|
||||
/* Centered fallbacks */
|
||||
else if (i0 <= ex1-4 && (i0-2)>=iminF) // 6th: i+3<=imax && i-3>=imin
|
||||
f_rhs[p] += sfx * d60dx * (
|
||||
-fh[idx_fh_F_ord4(iF-3,jF,kF,ex)]+F9*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]
|
||||
-F45*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+F45*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]
|
||||
-F9*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+3,jF,kF,ex)]);
|
||||
else if (i0 <= ex1-3 && (i0-1)>=iminF) // 4th
|
||||
f_rhs[p] += sfx * d12dx * (
|
||||
fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]-EIT*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]
|
||||
+EIT*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]);
|
||||
else if (i0 <= ex1-2 && i0>=iminF) // 2nd
|
||||
f_rhs[p] += sfx * d2dx * (
|
||||
-fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]);
|
||||
} else if (sfx < ZEO) {
|
||||
if ((i0-3)>=iminF && i0<=ex1-3) // i-4>=imin && i+2<=imax
|
||||
f_rhs[p] -= sfx * d60dx * (
|
||||
+F2*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]-F24*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]
|
||||
-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]
|
||||
-F30*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF-3,jF,kF,ex)]
|
||||
-fh[idx_fh_F_ord4(iF-4,jF,kF,ex)]);
|
||||
else if ((i0-4)>=iminF && i0<=ex1-2) // i-5>=imin && i+1<=imax
|
||||
f_rhs[p] -= sfx * d60dx * (
|
||||
-F10*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]
|
||||
+F150*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]-F100*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]
|
||||
+F50*fh[idx_fh_F_ord4(iF-3,jF,kF,ex)]-F15*fh[idx_fh_F_ord4(iF-4,jF,kF,ex)]
|
||||
+F2*fh[idx_fh_F_ord4(iF-5,jF,kF,ex)]);
|
||||
else if ((i0-2)>=iminF && i0<=ex1-4) // 6th centered
|
||||
f_rhs[p] += sfx * d60dx * (
|
||||
-fh[idx_fh_F_ord4(iF-3,jF,kF,ex)]+F9*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]
|
||||
-F45*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+F45*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]
|
||||
-F9*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+3,jF,kF,ex)]);
|
||||
else if ((i0-1)>=iminF && i0<=ex1-3) // 4th
|
||||
f_rhs[p] += sfx * d12dx * (
|
||||
fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]-EIT*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]
|
||||
+EIT*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]);
|
||||
else if (i0>=iminF && i0<=ex1-2) // 2nd
|
||||
f_rhs[p] += sfx * d2dx * (
|
||||
-fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]);
|
||||
}
|
||||
|
||||
/* ---- y-direction ---- */
|
||||
const double sfy = Sfy[p];
|
||||
if (sfy > ZEO) {
|
||||
if (j0<=ex2-5 && (j0-1)>=jminF)
|
||||
f_rhs[p] += sfy * d60dy*(F2*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-F24*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F30*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF+3,kF,ex)]-fh[idx_fh_F_ord4(iF,jF+4,kF,ex)]);
|
||||
else if (j0<=ex2-6 && j0>=jminF)
|
||||
f_rhs[p] += sfy * d60dy*(-F10*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F100*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]+F50*fh[idx_fh_F_ord4(iF,jF+3,kF,ex)]-F15*fh[idx_fh_F_ord4(iF,jF+4,kF,ex)]+F2*fh[idx_fh_F_ord4(iF,jF+5,kF,ex)]);
|
||||
else if (j0<=ex2-4 && (j0-2)>=jminF)
|
||||
f_rhs[p] += sfy * d60dy*(-fh[idx_fh_F_ord4(iF,jF-3,kF,ex)]+F9*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-F45*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+F45*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F9*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+3,kF,ex)]);
|
||||
else if (j0<=ex2-3 && (j0-1)>=jminF)
|
||||
f_rhs[p] += sfy * d12dy*(fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]);
|
||||
else if (j0<=ex2-2 && j0>=jminF)
|
||||
f_rhs[p] += sfy * d2dy*(-fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]);
|
||||
} else if (sfy < ZEO) {
|
||||
if ((j0-3)>=jminF && j0<=ex2-3)
|
||||
f_rhs[p] -= sfy * d60dy*(F2*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]-F24*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]-F30*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF-3,kF,ex)]-fh[idx_fh_F_ord4(iF,jF-4,kF,ex)]);
|
||||
else if ((j0-4)>=jminF && j0<=ex2-2)
|
||||
f_rhs[p] -= sfy * d60dy*(-F10*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]-F100*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]+F50*fh[idx_fh_F_ord4(iF,jF-3,kF,ex)]-F15*fh[idx_fh_F_ord4(iF,jF-4,kF,ex)]+F2*fh[idx_fh_F_ord4(iF,jF-5,kF,ex)]);
|
||||
else if ((j0-2)>=jminF && j0<=ex2-4)
|
||||
f_rhs[p] += sfy * d60dy*(-fh[idx_fh_F_ord4(iF,jF-3,kF,ex)]+F9*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-F45*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+F45*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F9*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+3,kF,ex)]);
|
||||
else if ((j0-1)>=jminF && j0<=ex2-3)
|
||||
f_rhs[p] += sfy * d12dy*(fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]);
|
||||
else if (j0>=jminF && j0<=ex2-2)
|
||||
f_rhs[p] += sfy * d2dy*(-fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]);
|
||||
}
|
||||
|
||||
/* ---- z-direction ---- */
|
||||
const double sfz = Sfz[p];
|
||||
if (sfz > ZEO) {
|
||||
if (k0<=ex3-5 && (k0-1)>=kminF)
|
||||
f_rhs[p] += sfz * d60dz*(F2*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-F24*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F30*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF,kF+3,ex)]-fh[idx_fh_F_ord4(iF,jF,kF+4,ex)]);
|
||||
else if (k0<=ex3-6 && k0>=kminF)
|
||||
f_rhs[p] += sfz * d60dz*(-F10*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F100*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]+F50*fh[idx_fh_F_ord4(iF,jF,kF+3,ex)]-F15*fh[idx_fh_F_ord4(iF,jF,kF+4,ex)]+F2*fh[idx_fh_F_ord4(iF,jF,kF+5,ex)]);
|
||||
else if (k0<=ex3-4 && (k0-2)>=kminF)
|
||||
f_rhs[p] += sfz * d60dz*(-fh[idx_fh_F_ord4(iF,jF,kF-3,ex)]+F9*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-F45*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+F45*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F9*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+3,ex)]);
|
||||
else if (k0<=ex3-3 && (k0-1)>=kminF)
|
||||
f_rhs[p] += sfz * d12dz*(fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]);
|
||||
else if (k0<=ex3-2 && k0>=kminF)
|
||||
f_rhs[p] += sfz * d2dz*(-fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]);
|
||||
} else if (sfz < ZEO) {
|
||||
if ((k0-3)>=kminF && k0<=ex3-3)
|
||||
f_rhs[p] -= sfz * d60dz*(F2*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]-F24*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]-F30*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF,kF-3,ex)]-fh[idx_fh_F_ord4(iF,jF,kF-4,ex)]);
|
||||
else if ((k0-4)>=kminF && k0<=ex3-2)
|
||||
f_rhs[p] -= sfz * d60dz*(-F10*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]-F100*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]+F50*fh[idx_fh_F_ord4(iF,jF,kF-3,ex)]-F15*fh[idx_fh_F_ord4(iF,jF,kF-4,ex)]+F2*fh[idx_fh_F_ord4(iF,jF,kF-5,ex)]);
|
||||
else if ((k0-2)>=kminF && k0<=ex3-4)
|
||||
f_rhs[p] += sfz * d60dz*(-fh[idx_fh_F_ord4(iF,jF,kF-3,ex)]+F9*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-F45*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+F45*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F9*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+3,ex)]);
|
||||
else if ((k0-1)>=kminF && k0<=ex3-3)
|
||||
f_rhs[p] += sfz * d12dz*(fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]);
|
||||
else if (k0>=kminF && k0<=ex3-2)
|
||||
f_rhs[p] += sfz * d2dz*(-fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 5)
|
||||
/* ---- 8th-order lopsided --------------------------------------------- */
|
||||
{
|
||||
const int ord = 5;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -4;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -4;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -4;
|
||||
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
const double d840dx = ONE / F840 / dX;
|
||||
const double d840dy = ONE / F840 / dY;
|
||||
const double d840dz = ONE / F840 / dZ;
|
||||
const double d60dx = ONE / F60 / dX;
|
||||
const double d60dy = ONE / F60 / dY;
|
||||
const double d60dz = ONE / F60 / dZ;
|
||||
const double d12dx = ONE / F12 / dX;
|
||||
const double d12dy = ONE / F12 / dY;
|
||||
const double d12dz = ONE / F12 / dZ;
|
||||
const double d2dx = ONE / TWO / dX;
|
||||
const double d2dy = ONE / TWO / dY;
|
||||
const double d2dz = ONE / TWO / dZ;
|
||||
|
||||
const int imaxF = ex1, jmaxF = ex2, kmaxF = ex3;
|
||||
|
||||
for (int k0 = 0; k0 <= ex3 - 2; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = 0; j0 <= ex2 - 2; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = 0; i0 <= ex1 - 2; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
const double sfx = Sfx[p];
|
||||
if (sfx > ZEO) {
|
||||
/* 8th biased: -5*f(i-3)+60*f(i-2)-420*f(i-1)-378*f(i)+1050*f(i+1)-420*f(i+2)+140*f(i+3)-30*f(i+4)+3*f(i+5) */
|
||||
if (i0 <= ex1-6 && (i0-2)>=iminF) // i+5<=imax && i-3>=imin
|
||||
f_rhs[p] += sfx * d840dx * (
|
||||
-F5*fh[idx_fh_F_ord5(iF-3,jF,kF,ex)]+F60*fh[idx_fh_F_ord5(iF-2,jF,kF,ex)]
|
||||
-F420*fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]-F378*fh[idx_fh_F_ord5(iF,jF,kF,ex)]
|
||||
+F1050*fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]-F420*fh[idx_fh_F_ord5(iF+2,jF,kF,ex)]
|
||||
+F140*fh[idx_fh_F_ord5(iF+3,jF,kF,ex)]-F30*fh[idx_fh_F_ord5(iF+4,jF,kF,ex)]
|
||||
+F3*fh[idx_fh_F_ord5(iF+5,jF,kF,ex)]);
|
||||
/* 8th centered: +3*f(i-4)-32*f(i-3)+168*f(i-2)-672*f(i-1)+672*f(i+1)-168*f(i+2)+32*f(i+3)-3*f(i+4) */
|
||||
else if (i0 <= ex1-5 && (i0-3)>=iminF)
|
||||
f_rhs[p] += sfx * d840dx * (
|
||||
+F3*fh[idx_fh_F_ord5(iF-4,jF,kF,ex)]-F32*fh[idx_fh_F_ord5(iF-3,jF,kF,ex)]
|
||||
+F168*fh[idx_fh_F_ord5(iF-2,jF,kF,ex)]-F672*fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]
|
||||
+F672*fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]-F168*fh[idx_fh_F_ord5(iF+2,jF,kF,ex)]
|
||||
+F32*fh[idx_fh_F_ord5(iF+3,jF,kF,ex)]-F3*fh[idx_fh_F_ord5(iF+4,jF,kF,ex)]);
|
||||
else if (i0 <= ex1-4 && (i0-2)>=iminF) // 6th centered
|
||||
f_rhs[p] += sfx * d60dx * (
|
||||
-fh[idx_fh_F_ord5(iF-3,jF,kF,ex)]+F9*fh[idx_fh_F_ord5(iF-2,jF,kF,ex)]
|
||||
-F45*fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]+F45*fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]
|
||||
-F9*fh[idx_fh_F_ord5(iF+2,jF,kF,ex)]+fh[idx_fh_F_ord5(iF+3,jF,kF,ex)]);
|
||||
else if (i0 <= ex1-3 && (i0-1)>=iminF) // 4th centered
|
||||
f_rhs[p] += sfx * d12dx * (
|
||||
fh[idx_fh_F_ord5(iF-2,jF,kF,ex)]-EIT*fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]
|
||||
+EIT*fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]-fh[idx_fh_F_ord5(iF+2,jF,kF,ex)]);
|
||||
else if (i0 <= ex1-2 && i0>=iminF) // 2nd centered
|
||||
f_rhs[p] += sfx * d2dx * (
|
||||
-fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]+fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]);
|
||||
} else if (sfx < ZEO) {
|
||||
if ((i0-4)>=iminF && i0<=ex1-4)
|
||||
f_rhs[p] -= sfx * d840dx * (
|
||||
-F5*fh[idx_fh_F_ord5(iF+3,jF,kF,ex)]+F60*fh[idx_fh_F_ord5(iF+2,jF,kF,ex)]
|
||||
-F420*fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]-F378*fh[idx_fh_F_ord5(iF,jF,kF,ex)]
|
||||
+F1050*fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]-F420*fh[idx_fh_F_ord5(iF-2,jF,kF,ex)]
|
||||
+F140*fh[idx_fh_F_ord5(iF-3,jF,kF,ex)]-F30*fh[idx_fh_F_ord5(iF-4,jF,kF,ex)]
|
||||
+F3*fh[idx_fh_F_ord5(iF-5,jF,kF,ex)]);
|
||||
else if ((i0-3)>=iminF && i0<=ex1-5) // 8th centered
|
||||
f_rhs[p] += sfx * d840dx * (
|
||||
+F3*fh[idx_fh_F_ord5(iF-4,jF,kF,ex)]-F32*fh[idx_fh_F_ord5(iF-3,jF,kF,ex)]
|
||||
+F168*fh[idx_fh_F_ord5(iF-2,jF,kF,ex)]-F672*fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]
|
||||
+F672*fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]-F168*fh[idx_fh_F_ord5(iF+2,jF,kF,ex)]
|
||||
+F32*fh[idx_fh_F_ord5(iF+3,jF,kF,ex)]-F3*fh[idx_fh_F_ord5(iF+4,jF,kF,ex)]);
|
||||
else if ((i0-2)>=iminF && i0<=ex1-4) // 6th centered
|
||||
f_rhs[p] += sfx * d60dx * (
|
||||
-fh[idx_fh_F_ord5(iF-3,jF,kF,ex)]+F9*fh[idx_fh_F_ord5(iF-2,jF,kF,ex)]
|
||||
-F45*fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]+F45*fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]
|
||||
-F9*fh[idx_fh_F_ord5(iF+2,jF,kF,ex)]+fh[idx_fh_F_ord5(iF+3,jF,kF,ex)]);
|
||||
else if ((i0-1)>=iminF && i0<=ex1-3) // 4th centered
|
||||
f_rhs[p] += sfx * d12dx * (
|
||||
fh[idx_fh_F_ord5(iF-2,jF,kF,ex)]-EIT*fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]
|
||||
+EIT*fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]-fh[idx_fh_F_ord5(iF+2,jF,kF,ex)]);
|
||||
else if (i0>=iminF && i0<=ex1-2) // 2nd centered
|
||||
f_rhs[p] += sfx * d2dx * (
|
||||
-fh[idx_fh_F_ord5(iF-1,jF,kF,ex)]+fh[idx_fh_F_ord5(iF+1,jF,kF,ex)]);
|
||||
}
|
||||
|
||||
const double sfy = Sfy[p];
|
||||
if (sfy > ZEO) {
|
||||
if (j0<=ex2-6 && (j0-2)>=jminF)
|
||||
f_rhs[p] += sfy * d840dy*(-F5*fh[idx_fh_F_ord5(iF,jF-3,kF,ex)]+F60*fh[idx_fh_F_ord5(iF,jF-2,kF,ex)]-F420*fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]-F378*fh[idx_fh_F_ord5(iF,jF,kF,ex)]+F1050*fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]-F420*fh[idx_fh_F_ord5(iF,jF+2,kF,ex)]+F140*fh[idx_fh_F_ord5(iF,jF+3,kF,ex)]-F30*fh[idx_fh_F_ord5(iF,jF+4,kF,ex)]+F3*fh[idx_fh_F_ord5(iF,jF+5,kF,ex)]);
|
||||
else if (j0<=ex2-5 && (j0-3)>=jminF)
|
||||
f_rhs[p] += sfy * d840dy*(+F3*fh[idx_fh_F_ord5(iF,jF-4,kF,ex)]-F32*fh[idx_fh_F_ord5(iF,jF-3,kF,ex)]+F168*fh[idx_fh_F_ord5(iF,jF-2,kF,ex)]-F672*fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]+F672*fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]-F168*fh[idx_fh_F_ord5(iF,jF+2,kF,ex)]+F32*fh[idx_fh_F_ord5(iF,jF+3,kF,ex)]-F3*fh[idx_fh_F_ord5(iF,jF+4,kF,ex)]);
|
||||
else if (j0<=ex2-4 && (j0-2)>=jminF)
|
||||
f_rhs[p] += sfy * d60dy*(-fh[idx_fh_F_ord5(iF,jF-3,kF,ex)]+F9*fh[idx_fh_F_ord5(iF,jF-2,kF,ex)]-F45*fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]+F45*fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]-F9*fh[idx_fh_F_ord5(iF,jF+2,kF,ex)]+fh[idx_fh_F_ord5(iF,jF+3,kF,ex)]);
|
||||
else if (j0<=ex2-3 && (j0-1)>=jminF)
|
||||
f_rhs[p] += sfy * d12dy*(fh[idx_fh_F_ord5(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]-fh[idx_fh_F_ord5(iF,jF+2,kF,ex)]);
|
||||
else if (j0<=ex2-2 && j0>=jminF)
|
||||
f_rhs[p] += sfy * d2dy*(-fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]+fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]);
|
||||
} else if (sfy < ZEO) {
|
||||
if ((j0-4)>=jminF && j0<=ex2-4)
|
||||
f_rhs[p] -= sfy * d840dy*(-F5*fh[idx_fh_F_ord5(iF,jF+3,kF,ex)]+F60*fh[idx_fh_F_ord5(iF,jF+2,kF,ex)]-F420*fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]-F378*fh[idx_fh_F_ord5(iF,jF,kF,ex)]+F1050*fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]-F420*fh[idx_fh_F_ord5(iF,jF-2,kF,ex)]+F140*fh[idx_fh_F_ord5(iF,jF-3,kF,ex)]-F30*fh[idx_fh_F_ord5(iF,jF-4,kF,ex)]+F3*fh[idx_fh_F_ord5(iF,jF-5,kF,ex)]);
|
||||
else if ((j0-3)>=jminF && j0<=ex2-5)
|
||||
f_rhs[p] += sfy * d840dy*(+F3*fh[idx_fh_F_ord5(iF,jF-4,kF,ex)]-F32*fh[idx_fh_F_ord5(iF,jF-3,kF,ex)]+F168*fh[idx_fh_F_ord5(iF,jF-2,kF,ex)]-F672*fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]+F672*fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]-F168*fh[idx_fh_F_ord5(iF,jF+2,kF,ex)]+F32*fh[idx_fh_F_ord5(iF,jF+3,kF,ex)]-F3*fh[idx_fh_F_ord5(iF,jF+4,kF,ex)]);
|
||||
else if ((j0-2)>=jminF && j0<=ex2-4)
|
||||
f_rhs[p] += sfy * d60dy*(-fh[idx_fh_F_ord5(iF,jF-3,kF,ex)]+F9*fh[idx_fh_F_ord5(iF,jF-2,kF,ex)]-F45*fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]+F45*fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]-F9*fh[idx_fh_F_ord5(iF,jF+2,kF,ex)]+fh[idx_fh_F_ord5(iF,jF+3,kF,ex)]);
|
||||
else if ((j0-1)>=jminF && j0<=ex2-3)
|
||||
f_rhs[p] += sfy * d12dy*(fh[idx_fh_F_ord5(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]-fh[idx_fh_F_ord5(iF,jF+2,kF,ex)]);
|
||||
else if (j0>=jminF && j0<=ex2-2)
|
||||
f_rhs[p] += sfy * d2dy*(-fh[idx_fh_F_ord5(iF,jF-1,kF,ex)]+fh[idx_fh_F_ord5(iF,jF+1,kF,ex)]);
|
||||
}
|
||||
|
||||
const double sfz = Sfz[p];
|
||||
if (sfz > ZEO) {
|
||||
if (k0<=ex3-6 && (k0-2)>=kminF)
|
||||
f_rhs[p] += sfz * d840dz*(-F5*fh[idx_fh_F_ord5(iF,jF,kF-3,ex)]+F60*fh[idx_fh_F_ord5(iF,jF,kF-2,ex)]-F420*fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]-F378*fh[idx_fh_F_ord5(iF,jF,kF,ex)]+F1050*fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]-F420*fh[idx_fh_F_ord5(iF,jF,kF+2,ex)]+F140*fh[idx_fh_F_ord5(iF,jF,kF+3,ex)]-F30*fh[idx_fh_F_ord5(iF,jF,kF+4,ex)]+F3*fh[idx_fh_F_ord5(iF,jF,kF+5,ex)]);
|
||||
else if (k0<=ex3-5 && (k0-3)>=kminF)
|
||||
f_rhs[p] += sfz * d840dz*(+F3*fh[idx_fh_F_ord5(iF,jF,kF-4,ex)]-F32*fh[idx_fh_F_ord5(iF,jF,kF-3,ex)]+F168*fh[idx_fh_F_ord5(iF,jF,kF-2,ex)]-F672*fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]+F672*fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]-F168*fh[idx_fh_F_ord5(iF,jF,kF+2,ex)]+F32*fh[idx_fh_F_ord5(iF,jF,kF+3,ex)]-F3*fh[idx_fh_F_ord5(iF,jF,kF+4,ex)]);
|
||||
else if (k0<=ex3-4 && (k0-2)>=kminF)
|
||||
f_rhs[p] += sfz * d60dz*(-fh[idx_fh_F_ord5(iF,jF,kF-3,ex)]+F9*fh[idx_fh_F_ord5(iF,jF,kF-2,ex)]-F45*fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]+F45*fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]-F9*fh[idx_fh_F_ord5(iF,jF,kF+2,ex)]+fh[idx_fh_F_ord5(iF,jF,kF+3,ex)]);
|
||||
else if (k0<=ex3-3 && (k0-1)>=kminF)
|
||||
f_rhs[p] += sfz * d12dz*(fh[idx_fh_F_ord5(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]-fh[idx_fh_F_ord5(iF,jF,kF+2,ex)]);
|
||||
else if (k0<=ex3-2 && k0>=kminF)
|
||||
f_rhs[p] += sfz * d2dz*(-fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]+fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]);
|
||||
} else if (sfz < ZEO) {
|
||||
if ((k0-4)>=kminF && k0<=ex3-4)
|
||||
f_rhs[p] -= sfz * d840dz*(-F5*fh[idx_fh_F_ord5(iF,jF,kF+3,ex)]+F60*fh[idx_fh_F_ord5(iF,jF,kF+2,ex)]-F420*fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]-F378*fh[idx_fh_F_ord5(iF,jF,kF,ex)]+F1050*fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]-F420*fh[idx_fh_F_ord5(iF,jF,kF-2,ex)]+F140*fh[idx_fh_F_ord5(iF,jF,kF-3,ex)]-F30*fh[idx_fh_F_ord5(iF,jF,kF-4,ex)]+F3*fh[idx_fh_F_ord5(iF,jF,kF-5,ex)]);
|
||||
else if ((k0-3)>=kminF && k0<=ex3-5)
|
||||
f_rhs[p] += sfz * d840dz*(+F3*fh[idx_fh_F_ord5(iF,jF,kF-4,ex)]-F32*fh[idx_fh_F_ord5(iF,jF,kF-3,ex)]+F168*fh[idx_fh_F_ord5(iF,jF,kF-2,ex)]-F672*fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]+F672*fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]-F168*fh[idx_fh_F_ord5(iF,jF,kF+2,ex)]+F32*fh[idx_fh_F_ord5(iF,jF,kF+3,ex)]-F3*fh[idx_fh_F_ord5(iF,jF,kF+4,ex)]);
|
||||
else if ((k0-2)>=kminF && k0<=ex3-4)
|
||||
f_rhs[p] += sfz * d60dz*(-fh[idx_fh_F_ord5(iF,jF,kF-3,ex)]+F9*fh[idx_fh_F_ord5(iF,jF,kF-2,ex)]-F45*fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]+F45*fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]-F9*fh[idx_fh_F_ord5(iF,jF,kF+2,ex)]+fh[idx_fh_F_ord5(iF,jF,kF+3,ex)]);
|
||||
else if ((k0-1)>=kminF && k0<=ex3-3)
|
||||
f_rhs[p] += sfz * d12dz*(fh[idx_fh_F_ord5(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]-fh[idx_fh_F_ord5(iF,jF,kF+2,ex)]);
|
||||
else if (k0>=kminF && k0<=ex3-2)
|
||||
f_rhs[p] += sfz * d2dz*(-fh[idx_fh_F_ord5(iF,jF,kF-1,ex)]+fh[idx_fh_F_ord5(iF,jF,kF+1,ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#else
|
||||
#error "lopsided_c.C: unsupported ghost_width (must be 2, 3, 4, or 5)"
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,8 +1,17 @@
|
||||
#include "macrodef.h"
|
||||
#include "tool.h"
|
||||
|
||||
/*
|
||||
* Combined advection (lopsided) + KO dissipation (kodis).
|
||||
* Uses one shared symmetry_bd buffer per call.
|
||||
* C 版 lopsided_kodis — combined upwind advection + KO dissipation.
|
||||
* Uses one shared symmetry_bd buffer (ord = ghost_width for both components)
|
||||
* where a stable merged stencil is available. The 8th-order path delegates to
|
||||
* the separate lopsided + kodis kernels, matching the original Fortran flow.
|
||||
*
|
||||
* FD order selection via ghost_width:
|
||||
* 2 → 2nd-order advection + r=2 KO (cof=16, sign=-)
|
||||
* 3 → 4th-order advection + r=3 KO (cof=64, sign=+)
|
||||
* 4 → 6th-order advection + r=4 KO (cof=256, sign=-)
|
||||
* 5 → 8th-order advection + r=5 KO (cof=1024, sign=+)
|
||||
*/
|
||||
void lopsided_kodis(const int ex[3],
|
||||
const double *X, const double *Y, const double *Z,
|
||||
@@ -10,239 +19,286 @@ void lopsided_kodis(const int ex[3],
|
||||
const double *Sfx, const double *Sfy, const double *Sfz,
|
||||
int Symmetry, const double SoA[3], double eps)
|
||||
{
|
||||
const double ZEO = 0.0, ONE = 1.0, F3 = 3.0;
|
||||
const double F6 = 6.0, F18 = 18.0;
|
||||
const double F12 = 12.0, F10 = 10.0, EIT = 8.0;
|
||||
const double SIX = 6.0, FIT = 15.0, TWT = 20.0;
|
||||
const double cof = 64.0; // 2^6
|
||||
const double ZEO = 0.0, ONE = 1.0;
|
||||
const double TWO = 2.0, F6 = 6.0, EIT = 8.0;
|
||||
const double F3 = 3.0, F4 = 4.0, F5 = 5.0, F10 = 10.0, F12 = 12.0, F18 = 18.0;
|
||||
const double F9 = 9.0, F45 = 45.0, F60 = 60.0;
|
||||
const double F2 = 2.0, F15 = 15.0, F24 = 24.0, F30 = 30.0, F35 = 35.0;
|
||||
const double F50 = 50.0, F77 = 77.0, F80 = 80.0, F100 = 100.0, F150 = 150.0;
|
||||
const double F32 = 32.0, F168 = 168.0, F672 = 672.0, F840 = 840.0;
|
||||
const double F140=140.0, F378=378.0, F420=420.0, F1050=1050.0;
|
||||
|
||||
const int NO_SYMM = 0, EQ_SYMM = 1;
|
||||
|
||||
const int ex1 = ex[0], ex2 = ex[1], ex3 = ex[2];
|
||||
|
||||
const double dX = X[1] - X[0];
|
||||
const double dY = Y[1] - Y[0];
|
||||
const double dZ = Z[1] - Z[0];
|
||||
|
||||
const double d12dx = ONE / F12 / dX;
|
||||
const double d12dy = ONE / F12 / dY;
|
||||
const double d12dz = ONE / F12 / dZ;
|
||||
const int imaxF = ex1, jmaxF = ex2, kmaxF = ex3;
|
||||
|
||||
const int imaxF = ex1;
|
||||
const int jmaxF = ex2;
|
||||
const int kmaxF = ex3;
|
||||
#if (ghost_width == 2)
|
||||
{
|
||||
const int ord = 2;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -1;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -1;
|
||||
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -2;
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
double *fh = (double*)malloc(nx*ny*nz*sizeof(double));
|
||||
if (!fh) return;
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
// fh for Fortran-style domain (-2:ex1,-2:ex2,-2:ex3)
|
||||
const size_t nx = (size_t)ex1 + 3;
|
||||
const size_t ny = (size_t)ex2 + 3;
|
||||
const size_t nz = (size_t)ex3 + 3;
|
||||
const size_t fh_size = nx * ny * nz;
|
||||
const double d2dx = ONE/TWO/dX, d2dy = ONE/TWO/dY, d2dz = ONE/TWO/dZ;
|
||||
|
||||
double *fh = (double*)malloc(fh_size * sizeof(double));
|
||||
if (!fh) return;
|
||||
/* ---- advection (2nd-order) ---- */
|
||||
for (int k0 = 0; k0 <= ex3-2; ++k0) {
|
||||
const int kF = k0+1;
|
||||
for (int j0 = 0; j0 <= ex2-2; ++j0) {
|
||||
const int jF = j0+1;
|
||||
for (int i0 = 0; i0 <= ex1-2; ++i0) {
|
||||
const int iF = i0+1;
|
||||
const size_t p = idx_ex(i0,j0,k0,ex);
|
||||
|
||||
symmetry_bd(3, ex, f, fh, SoA);
|
||||
|
||||
// Advection (same stencil logic as lopsided_c.C)
|
||||
for (int k0 = 0; k0 <= ex3 - 2; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = 0; j0 <= ex2 - 2; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = 0; i0 <= ex1 - 2; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
|
||||
const double sfx = Sfx[p];
|
||||
if (sfx > ZEO) {
|
||||
if (i0 <= ex1 - 4) {
|
||||
f_rhs[p] += sfx * d12dx *
|
||||
(-F3 * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF , jF, kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF + 2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF + 3, jF, kF, ex)]);
|
||||
} else if (i0 <= ex1 - 3) {
|
||||
f_rhs[p] += sfx * d12dx *
|
||||
( fh[idx_fh_F(iF - 2, jF, kF, ex)]
|
||||
-EIT * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
+EIT * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
- fh[idx_fh_F(iF + 2, jF, kF, ex)]);
|
||||
} else if (i0 <= ex1 - 2) {
|
||||
f_rhs[p] -= sfx * d12dx *
|
||||
(-F3 * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF , jF, kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF - 2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF - 3, jF, kF, ex)]);
|
||||
const double sfx = Sfx[p];
|
||||
if (sfx > ZEO) {
|
||||
if (i0<=ex1-3) f_rhs[p] += sfx*d2dx*(-F3*fh[idx_fh_F_ord2(iF,jF,kF,ex)]+F4*fh[idx_fh_F_ord2(iF+1,jF,kF,ex)]-fh[idx_fh_F_ord2(iF+2,jF,kF,ex)]);
|
||||
else if (i0<=ex1-2) f_rhs[p] += sfx*d2dx*(-fh[idx_fh_F_ord2(iF,jF,kF,ex)]+fh[idx_fh_F_ord2(iF+1,jF,kF,ex)]);
|
||||
} else if (sfx < ZEO) {
|
||||
if ((i0-1)>=iminF) f_rhs[p] -= sfx*d2dx*(-F3*fh[idx_fh_F_ord2(iF,jF,kF,ex)]+F4*fh[idx_fh_F_ord2(iF-1,jF,kF,ex)]-fh[idx_fh_F_ord2(iF-2,jF,kF,ex)]);
|
||||
else if (i0>=iminF) f_rhs[p] -= sfx*d2dx*(-fh[idx_fh_F_ord2(iF,jF,kF,ex)]+fh[idx_fh_F_ord2(iF-1,jF,kF,ex)]);
|
||||
}
|
||||
} else if (sfx < ZEO) {
|
||||
if ((i0 - 2) >= iminF) {
|
||||
f_rhs[p] -= sfx * d12dx *
|
||||
(-F3 * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF , jF, kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF - 2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF - 3, jF, kF, ex)]);
|
||||
} else if ((i0 - 1) >= iminF) {
|
||||
f_rhs[p] += sfx * d12dx *
|
||||
( fh[idx_fh_F(iF - 2, jF, kF, ex)]
|
||||
-EIT * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
+EIT * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
- fh[idx_fh_F(iF + 2, jF, kF, ex)]);
|
||||
} else if (i0 >= iminF) {
|
||||
f_rhs[p] += sfx * d12dx *
|
||||
(-F3 * fh[idx_fh_F(iF - 1, jF, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF , jF, kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF + 1, jF, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF + 2, jF, kF, ex)]
|
||||
+ fh[idx_fh_F(iF + 3, jF, kF, ex)]);
|
||||
const double sfy = Sfy[p];
|
||||
if (sfy > ZEO) {
|
||||
if (j0<=ex2-3) f_rhs[p] += sfy*d2dy*(-F3*fh[idx_fh_F_ord2(iF,jF,kF,ex)]+F4*fh[idx_fh_F_ord2(iF,jF+1,kF,ex)]-fh[idx_fh_F_ord2(iF,jF+2,kF,ex)]);
|
||||
else if (j0<=ex2-2) f_rhs[p] += sfy*d2dy*(-fh[idx_fh_F_ord2(iF,jF,kF,ex)]+fh[idx_fh_F_ord2(iF,jF+1,kF,ex)]);
|
||||
} else if (sfy < ZEO) {
|
||||
if ((j0-1)>=jminF) f_rhs[p] -= sfy*d2dy*(-F3*fh[idx_fh_F_ord2(iF,jF,kF,ex)]+F4*fh[idx_fh_F_ord2(iF,jF-1,kF,ex)]-fh[idx_fh_F_ord2(iF,jF-2,kF,ex)]);
|
||||
else if (j0>=jminF) f_rhs[p] -= sfy*d2dy*(-fh[idx_fh_F_ord2(iF,jF,kF,ex)]+fh[idx_fh_F_ord2(iF,jF-1,kF,ex)]);
|
||||
}
|
||||
}
|
||||
|
||||
const double sfy = Sfy[p];
|
||||
if (sfy > ZEO) {
|
||||
if (j0 <= ex2 - 4) {
|
||||
f_rhs[p] += sfy * d12dy *
|
||||
(-F3 * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF , kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF + 2, kF, ex)]
|
||||
+ fh[idx_fh_F(iF, jF + 3, kF, ex)]);
|
||||
} else if (j0 <= ex2 - 3) {
|
||||
f_rhs[p] += sfy * d12dy *
|
||||
( fh[idx_fh_F(iF, jF - 2, kF, ex)]
|
||||
-EIT * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
+EIT * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
- fh[idx_fh_F(iF, jF + 2, kF, ex)]);
|
||||
} else if (j0 <= ex2 - 2) {
|
||||
f_rhs[p] -= sfy * d12dy *
|
||||
(-F3 * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF , kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF - 2, kF, ex)]
|
||||
+ fh[idx_fh_F(iF, jF - 3, kF, ex)]);
|
||||
}
|
||||
} else if (sfy < ZEO) {
|
||||
if ((j0 - 2) >= jminF) {
|
||||
f_rhs[p] -= sfy * d12dy *
|
||||
(-F3 * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF , kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF - 2, kF, ex)]
|
||||
+ fh[idx_fh_F(iF, jF - 3, kF, ex)]);
|
||||
} else if ((j0 - 1) >= jminF) {
|
||||
f_rhs[p] += sfy * d12dy *
|
||||
( fh[idx_fh_F(iF, jF - 2, kF, ex)]
|
||||
-EIT * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
+EIT * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
- fh[idx_fh_F(iF, jF + 2, kF, ex)]);
|
||||
} else if (j0 >= jminF) {
|
||||
f_rhs[p] += sfy * d12dy *
|
||||
(-F3 * fh[idx_fh_F(iF, jF - 1, kF, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF , kF, ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF + 1, kF, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF + 2, kF, ex)]
|
||||
+ fh[idx_fh_F(iF, jF + 3, kF, ex)]);
|
||||
}
|
||||
}
|
||||
|
||||
const double sfz = Sfz[p];
|
||||
if (sfz > ZEO) {
|
||||
if (k0 <= ex3 - 4) {
|
||||
f_rhs[p] += sfz * d12dz *
|
||||
(-F3 * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF, kF , ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF, kF + 2, ex)]
|
||||
+ fh[idx_fh_F(iF, jF, kF + 3, ex)]);
|
||||
} else if (k0 <= ex3 - 3) {
|
||||
f_rhs[p] += sfz * d12dz *
|
||||
( fh[idx_fh_F(iF, jF, kF - 2, ex)]
|
||||
-EIT * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
+EIT * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
- fh[idx_fh_F(iF, jF, kF + 2, ex)]);
|
||||
} else if (k0 <= ex3 - 2) {
|
||||
f_rhs[p] -= sfz * d12dz *
|
||||
(-F3 * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF, kF , ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF, kF - 2, ex)]
|
||||
+ fh[idx_fh_F(iF, jF, kF - 3, ex)]);
|
||||
}
|
||||
} else if (sfz < ZEO) {
|
||||
if ((k0 - 2) >= kminF) {
|
||||
f_rhs[p] -= sfz * d12dz *
|
||||
(-F3 * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF, kF , ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF, kF - 2, ex)]
|
||||
+ fh[idx_fh_F(iF, jF, kF - 3, ex)]);
|
||||
} else if ((k0 - 1) >= kminF) {
|
||||
f_rhs[p] += sfz * d12dz *
|
||||
( fh[idx_fh_F(iF, jF, kF - 2, ex)]
|
||||
-EIT * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
+EIT * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
- fh[idx_fh_F(iF, jF, kF + 2, ex)]);
|
||||
} else if (k0 >= kminF) {
|
||||
f_rhs[p] += sfz * d12dz *
|
||||
(-F3 * fh[idx_fh_F(iF, jF, kF - 1, ex)]
|
||||
-F10 * fh[idx_fh_F(iF, jF, kF , ex)]
|
||||
+F18 * fh[idx_fh_F(iF, jF, kF + 1, ex)]
|
||||
-F6 * fh[idx_fh_F(iF, jF, kF + 2, ex)]
|
||||
+ fh[idx_fh_F(iF, jF, kF + 3, ex)]);
|
||||
const double sfz = Sfz[p];
|
||||
if (sfz > ZEO) {
|
||||
if (k0<=ex3-3) f_rhs[p] += sfz*d2dz*(-F3*fh[idx_fh_F_ord2(iF,jF,kF,ex)]+F4*fh[idx_fh_F_ord2(iF,jF,kF+1,ex)]-fh[idx_fh_F_ord2(iF,jF,kF+2,ex)]);
|
||||
else if (k0<=ex3-2) f_rhs[p] += sfz*d2dz*(-fh[idx_fh_F_ord2(iF,jF,kF,ex)]+fh[idx_fh_F_ord2(iF,jF,kF+1,ex)]);
|
||||
} else if (sfz < ZEO) {
|
||||
if ((k0-1)>=kminF) f_rhs[p] -= sfz*d2dz*(-F3*fh[idx_fh_F_ord2(iF,jF,kF,ex)]+F4*fh[idx_fh_F_ord2(iF,jF,kF-1,ex)]-fh[idx_fh_F_ord2(iF,jF,kF-2,ex)]);
|
||||
else if (k0>=kminF) f_rhs[p] -= sfz*d2dz*(-fh[idx_fh_F_ord2(iF,jF,kF,ex)]+fh[idx_fh_F_ord2(iF,jF,kF-1,ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ---- KO dissipation (r=2, cof=16, sign=-) ---- */
|
||||
if (eps > ZEO) {
|
||||
const double cof = 16.0;
|
||||
const double F4k = 4.0, F6k = 6.0;
|
||||
const int i0_lo = (iminF+1>0)?iminF+1:0, j0_lo=(jminF+1>0)?jminF+1:0, k0_lo=(kminF+1>0)?kminF+1:0;
|
||||
const int i0_hi=imaxF-3, j0_hi=jmaxF-3, k0_hi=kmaxF-3;
|
||||
if (!(i0_lo>i0_hi||j0_lo>j0_hi||k0_lo>k0_hi)) {
|
||||
for (int k0=k0_lo;k0<=k0_hi;++k0) { const int kF=k0+1;
|
||||
for (int j0=j0_lo;j0<=j0_hi;++j0) { const int jF=j0+1;
|
||||
for (int i0=i0_lo;i0<=i0_hi;++i0) { const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
const double Dx=((fh[idx_fh_F_ord2(iF-2,jF,kF,ex)]+fh[idx_fh_F_ord2(iF+2,jF,kF,ex)])-F4k*(fh[idx_fh_F_ord2(iF-1,jF,kF,ex)]+fh[idx_fh_F_ord2(iF+1,jF,kF,ex)])+F6k*fh[idx_fh_F_ord2(iF,jF,kF,ex)])/dX;
|
||||
const double Dy=((fh[idx_fh_F_ord2(iF,jF-2,kF,ex)]+fh[idx_fh_F_ord2(iF,jF+2,kF,ex)])-F4k*(fh[idx_fh_F_ord2(iF,jF-1,kF,ex)]+fh[idx_fh_F_ord2(iF,jF+1,kF,ex)])+F6k*fh[idx_fh_F_ord2(iF,jF,kF,ex)])/dY;
|
||||
const double Dz=((fh[idx_fh_F_ord2(iF,jF,kF-2,ex)]+fh[idx_fh_F_ord2(iF,jF,kF+2,ex)])-F4k*(fh[idx_fh_F_ord2(iF,jF,kF-1,ex)]+fh[idx_fh_F_ord2(iF,jF,kF+1,ex)])+F6k*fh[idx_fh_F_ord2(iF,jF,kF,ex)])/dZ;
|
||||
f_rhs[p] -= (eps/cof)*(Dx+Dy+Dz);
|
||||
}}}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 3)
|
||||
/* ---- 4th-order advection + r=3 KO (original code) ----------------- */
|
||||
{
|
||||
const int ord = 3;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -2;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -2;
|
||||
|
||||
// KO dissipation (same domain restriction as kodiss_c.C)
|
||||
if (eps > ZEO) {
|
||||
const int i0_lo = (iminF + 2 > 0) ? iminF + 2 : 0;
|
||||
const int j0_lo = (jminF + 2 > 0) ? jminF + 2 : 0;
|
||||
const int k0_lo = (kminF + 2 > 0) ? kminF + 2 : 0;
|
||||
const int i0_hi = imaxF - 4; // inclusive
|
||||
const int j0_hi = jmaxF - 4;
|
||||
const int k0_hi = kmaxF - 4;
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
double *fh = (double*)malloc(nx*ny*nz*sizeof(double));
|
||||
if (!fh) return;
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
if (!(i0_lo > i0_hi || j0_lo > j0_hi || k0_lo > k0_hi)) {
|
||||
for (int k0 = k0_lo; k0 <= k0_hi; ++k0) {
|
||||
const int kF = k0 + 1;
|
||||
for (int j0 = j0_lo; j0 <= j0_hi; ++j0) {
|
||||
const int jF = j0 + 1;
|
||||
for (int i0 = i0_lo; i0 <= i0_hi; ++i0) {
|
||||
const int iF = i0 + 1;
|
||||
const size_t p = idx_ex(i0, j0, k0, ex);
|
||||
const double d12dx = ONE/F12/dX, d12dy = ONE/F12/dY, d12dz = ONE/F12/dZ;
|
||||
|
||||
const double Dx_term =
|
||||
((fh[idx_fh_F(iF - 3, jF, kF, ex)] + fh[idx_fh_F(iF + 3, jF, kF, ex)]) -
|
||||
SIX * (fh[idx_fh_F(iF - 2, jF, kF, ex)] + fh[idx_fh_F(iF + 2, jF, kF, ex)]) +
|
||||
FIT * (fh[idx_fh_F(iF - 1, jF, kF, ex)] + fh[idx_fh_F(iF + 1, jF, kF, ex)]) -
|
||||
TWT * fh[idx_fh_F(iF, jF, kF, ex)]) / dX;
|
||||
/* ---- advection ---- */
|
||||
for (int k0 = 0; k0 <= ex3-2; ++k0) {
|
||||
const int kF = k0+1;
|
||||
for (int j0 = 0; j0 <= ex2-2; ++j0) {
|
||||
const int jF = j0+1;
|
||||
for (int i0 = 0; i0 <= ex1-2; ++i0) {
|
||||
const int iF = i0+1;
|
||||
const size_t p = idx_ex(i0,j0,k0,ex);
|
||||
|
||||
const double Dy_term =
|
||||
((fh[idx_fh_F(iF, jF - 3, kF, ex)] + fh[idx_fh_F(iF, jF + 3, kF, ex)]) -
|
||||
SIX * (fh[idx_fh_F(iF, jF - 2, kF, ex)] + fh[idx_fh_F(iF, jF + 2, kF, ex)]) +
|
||||
FIT * (fh[idx_fh_F(iF, jF - 1, kF, ex)] + fh[idx_fh_F(iF, jF + 1, kF, ex)]) -
|
||||
TWT * fh[idx_fh_F(iF, jF, kF, ex)]) / dY;
|
||||
|
||||
const double Dz_term =
|
||||
((fh[idx_fh_F(iF, jF, kF - 3, ex)] + fh[idx_fh_F(iF, jF, kF + 3, ex)]) -
|
||||
SIX * (fh[idx_fh_F(iF, jF, kF - 2, ex)] + fh[idx_fh_F(iF, jF, kF + 2, ex)]) +
|
||||
FIT * (fh[idx_fh_F(iF, jF, kF - 1, ex)] + fh[idx_fh_F(iF, jF, kF + 1, ex)]) -
|
||||
TWT * fh[idx_fh_F(iF, jF, kF, ex)]) / dZ;
|
||||
|
||||
f_rhs[p] += (eps / cof) * (Dx_term + Dy_term + Dz_term);
|
||||
const double sfx = Sfx[p];
|
||||
if (sfx > ZEO) {
|
||||
if (i0 <= ex1-4)
|
||||
f_rhs[p] += sfx*d12dx*(-F3*fh[idx_fh_F(iF-1,jF,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF+1,jF,kF,ex)]-F6*fh[idx_fh_F(iF+2,jF,kF,ex)]+fh[idx_fh_F(iF+3,jF,kF,ex)]);
|
||||
else if (i0 <= ex1-3)
|
||||
f_rhs[p] += sfx*d12dx*(fh[idx_fh_F(iF-2,jF,kF,ex)]-EIT*fh[idx_fh_F(iF-1,jF,kF,ex)]+EIT*fh[idx_fh_F(iF+1,jF,kF,ex)]-fh[idx_fh_F(iF+2,jF,kF,ex)]);
|
||||
else if (i0 <= ex1-2)
|
||||
f_rhs[p] -= sfx*d12dx*(-F3*fh[idx_fh_F(iF+1,jF,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF-1,jF,kF,ex)]-F6*fh[idx_fh_F(iF-2,jF,kF,ex)]+fh[idx_fh_F(iF-3,jF,kF,ex)]);
|
||||
} else if (sfx < ZEO) {
|
||||
if ((i0-2) >= iminF)
|
||||
f_rhs[p] -= sfx*d12dx*(-F3*fh[idx_fh_F(iF+1,jF,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF-1,jF,kF,ex)]-F6*fh[idx_fh_F(iF-2,jF,kF,ex)]+fh[idx_fh_F(iF-3,jF,kF,ex)]);
|
||||
else if ((i0-1) >= iminF)
|
||||
f_rhs[p] += sfx*d12dx*(fh[idx_fh_F(iF-2,jF,kF,ex)]-EIT*fh[idx_fh_F(iF-1,jF,kF,ex)]+EIT*fh[idx_fh_F(iF+1,jF,kF,ex)]-fh[idx_fh_F(iF+2,jF,kF,ex)]);
|
||||
else if (i0 >= iminF)
|
||||
f_rhs[p] += sfx*d12dx*(-F3*fh[idx_fh_F(iF-1,jF,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF+1,jF,kF,ex)]-F6*fh[idx_fh_F(iF+2,jF,kF,ex)]+fh[idx_fh_F(iF+3,jF,kF,ex)]);
|
||||
}
|
||||
const double sfy = Sfy[p];
|
||||
if (sfy > ZEO) {
|
||||
if (j0<=ex2-4) f_rhs[p] += sfy*d12dy*(-F3*fh[idx_fh_F(iF,jF-1,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF,jF+1,kF,ex)]-F6*fh[idx_fh_F(iF,jF+2,kF,ex)]+fh[idx_fh_F(iF,jF+3,kF,ex)]);
|
||||
else if (j0<=ex2-3) f_rhs[p] += sfy*d12dy*(fh[idx_fh_F(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F(iF,jF+1,kF,ex)]-fh[idx_fh_F(iF,jF+2,kF,ex)]);
|
||||
else if (j0<=ex2-2) f_rhs[p] -= sfy*d12dy*(-F3*fh[idx_fh_F(iF,jF+1,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF,jF-1,kF,ex)]-F6*fh[idx_fh_F(iF,jF-2,kF,ex)]+fh[idx_fh_F(iF,jF-3,kF,ex)]);
|
||||
} else if (sfy < ZEO) {
|
||||
if ((j0-2)>=jminF) f_rhs[p] -= sfy*d12dy*(-F3*fh[idx_fh_F(iF,jF+1,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF,jF-1,kF,ex)]-F6*fh[idx_fh_F(iF,jF-2,kF,ex)]+fh[idx_fh_F(iF,jF-3,kF,ex)]);
|
||||
else if ((j0-1)>=jminF) f_rhs[p] += sfy*d12dy*(fh[idx_fh_F(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F(iF,jF+1,kF,ex)]-fh[idx_fh_F(iF,jF+2,kF,ex)]);
|
||||
else if (j0>=jminF) f_rhs[p] += sfy*d12dy*(-F3*fh[idx_fh_F(iF,jF-1,kF,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF,jF+1,kF,ex)]-F6*fh[idx_fh_F(iF,jF+2,kF,ex)]+fh[idx_fh_F(iF,jF+3,kF,ex)]);
|
||||
}
|
||||
const double sfz = Sfz[p];
|
||||
if (sfz > ZEO) {
|
||||
if (k0<=ex3-4) f_rhs[p] += sfz*d12dz*(-F3*fh[idx_fh_F(iF,jF,kF-1,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF,jF,kF+1,ex)]-F6*fh[idx_fh_F(iF,jF,kF+2,ex)]+fh[idx_fh_F(iF,jF,kF+3,ex)]);
|
||||
else if (k0<=ex3-3) f_rhs[p] += sfz*d12dz*(fh[idx_fh_F(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F(iF,jF,kF+1,ex)]-fh[idx_fh_F(iF,jF,kF+2,ex)]);
|
||||
else if (k0<=ex3-2) f_rhs[p] -= sfz*d12dz*(-F3*fh[idx_fh_F(iF,jF,kF+1,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF,jF,kF-1,ex)]-F6*fh[idx_fh_F(iF,jF,kF-2,ex)]+fh[idx_fh_F(iF,jF,kF-3,ex)]);
|
||||
} else if (sfz < ZEO) {
|
||||
if ((k0-2)>=kminF) f_rhs[p] -= sfz*d12dz*(-F3*fh[idx_fh_F(iF,jF,kF+1,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF,jF,kF-1,ex)]-F6*fh[idx_fh_F(iF,jF,kF-2,ex)]+fh[idx_fh_F(iF,jF,kF-3,ex)]);
|
||||
else if ((k0-1)>=kminF) f_rhs[p] += sfz*d12dz*(fh[idx_fh_F(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F(iF,jF,kF+1,ex)]-fh[idx_fh_F(iF,jF,kF+2,ex)]);
|
||||
else if (k0>=kminF) f_rhs[p] += sfz*d12dz*(-F3*fh[idx_fh_F(iF,jF,kF-1,ex)]-F10*fh[idx_fh_F(iF,jF,kF,ex)]+F18*fh[idx_fh_F(iF,jF,kF+1,ex)]-F6*fh[idx_fh_F(iF,jF,kF+2,ex)]+fh[idx_fh_F(iF,jF,kF+3,ex)]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
free(fh);
|
||||
/* ---- KO dissipation (r=3, cof=64, sign=+) ---- */
|
||||
if (eps > ZEO) {
|
||||
const double cof = 64.0;
|
||||
const double SIX = 6.0, FIT = 15.0, TWT = 20.0;
|
||||
const int i0_lo=(iminF+2>0)?iminF+2:0, j0_lo=(jminF+2>0)?jminF+2:0, k0_lo=(kminF+2>0)?kminF+2:0;
|
||||
const int i0_hi=imaxF-4, j0_hi=jmaxF-4, k0_hi=kmaxF-4;
|
||||
if (!(i0_lo>i0_hi||j0_lo>j0_hi||k0_lo>k0_hi)) {
|
||||
for (int k0=k0_lo;k0<=k0_hi;++k0) { const int kF=k0+1;
|
||||
for (int j0=j0_lo;j0<=j0_hi;++j0) { const int jF=j0+1;
|
||||
for (int i0=i0_lo;i0<=i0_hi;++i0) { const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
const double Dx=((fh[idx_fh_F(iF-3,jF,kF,ex)]+fh[idx_fh_F(iF+3,jF,kF,ex)])-SIX*(fh[idx_fh_F(iF-2,jF,kF,ex)]+fh[idx_fh_F(iF+2,jF,kF,ex)])+FIT*(fh[idx_fh_F(iF-1,jF,kF,ex)]+fh[idx_fh_F(iF+1,jF,kF,ex)])-TWT*fh[idx_fh_F(iF,jF,kF,ex)])/dX;
|
||||
const double Dy=((fh[idx_fh_F(iF,jF-3,kF,ex)]+fh[idx_fh_F(iF,jF+3,kF,ex)])-SIX*(fh[idx_fh_F(iF,jF-2,kF,ex)]+fh[idx_fh_F(iF,jF+2,kF,ex)])+FIT*(fh[idx_fh_F(iF,jF-1,kF,ex)]+fh[idx_fh_F(iF,jF+1,kF,ex)])-TWT*fh[idx_fh_F(iF,jF,kF,ex)])/dY;
|
||||
const double Dz=((fh[idx_fh_F(iF,jF,kF-3,ex)]+fh[idx_fh_F(iF,jF,kF+3,ex)])-SIX*(fh[idx_fh_F(iF,jF,kF-2,ex)]+fh[idx_fh_F(iF,jF,kF+2,ex)])+FIT*(fh[idx_fh_F(iF,jF,kF-1,ex)]+fh[idx_fh_F(iF,jF,kF+1,ex)])-TWT*fh[idx_fh_F(iF,jF,kF,ex)])/dZ;
|
||||
f_rhs[p] += (eps/cof)*(Dx+Dy+Dz);
|
||||
}}}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 4)
|
||||
{
|
||||
const int ord = 4;
|
||||
int iminF = 1, jminF = 1, kminF = 1;
|
||||
if (Symmetry > NO_SYMM && fabs(Z[0]) < dZ) kminF = -3;
|
||||
if (Symmetry > EQ_SYMM && fabs(X[0]) < dX) iminF = -3;
|
||||
if (Symmetry > EQ_SYMM && fabs(Y[0]) < dY) jminF = -3;
|
||||
|
||||
const size_t nx = (size_t)ex1 + ord;
|
||||
const size_t ny = (size_t)ex2 + ord;
|
||||
const size_t nz = (size_t)ex3 + ord;
|
||||
double *fh = (double*)malloc(nx*ny*nz*sizeof(double));
|
||||
if (!fh) return;
|
||||
symmetry_bd(ord, ex, f, fh, SoA);
|
||||
|
||||
const double d60dx=ONE/F60/dX, d60dy=ONE/F60/dY, d60dz=ONE/F60/dZ;
|
||||
const double d12dx=ONE/F12/dX, d12dy=ONE/F12/dY, d12dz=ONE/F12/dZ;
|
||||
const double d2dx=ONE/TWO/dX, d2dy=ONE/TWO/dY, d2dz=ONE/TWO/dZ;
|
||||
|
||||
/* ---- advection (6th-order lopsided) ---- */
|
||||
for (int k0=0;k0<=ex3-2;++k0) { const int kF=k0+1;
|
||||
for (int j0=0;j0<=ex2-2;++j0) { const int jF=j0+1;
|
||||
for (int i0=0;i0<=ex1-2;++i0) { const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
/* x */
|
||||
const double sfx=Sfx[p];
|
||||
if (sfx>ZEO) {
|
||||
if (i0<=ex1-5&&(i0-1)>=iminF) f_rhs[p]+=sfx*d60dx*(+F2*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]-F24*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-F30*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF+3,jF,kF,ex)]-fh[idx_fh_F_ord4(iF+4,jF,kF,ex)]);
|
||||
else if (i0<=ex1-6&&i0>=iminF) f_rhs[p]+=sfx*d60dx*(-F10*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-F100*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]+F50*fh[idx_fh_F_ord4(iF+3,jF,kF,ex)]-F15*fh[idx_fh_F_ord4(iF+4,jF,kF,ex)]+F2*fh[idx_fh_F_ord4(iF+5,jF,kF,ex)]);
|
||||
else if (i0<=ex1-4&&(i0-2)>=iminF) f_rhs[p]+=sfx*d60dx*(-fh[idx_fh_F_ord4(iF-3,jF,kF,ex)]+F9*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]-F45*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+F45*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-F9*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+3,jF,kF,ex)]);
|
||||
else if (i0<=ex1-3&&(i0-1)>=iminF) f_rhs[p]+=sfx*d12dx*(fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]-EIT*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]);
|
||||
else if (i0<=ex1-2&&i0>=iminF) f_rhs[p]+=sfx*d2dx*(-fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]);
|
||||
} else if (sfx<ZEO) {
|
||||
if ((i0-3)>=iminF&&i0<=ex1-3) f_rhs[p]-=sfx*d60dx*(+F2*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]-F24*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]-F30*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF-3,jF,kF,ex)]-fh[idx_fh_F_ord4(iF-4,jF,kF,ex)]);
|
||||
else if ((i0-4)>=iminF&&i0<=ex1-2) f_rhs[p]-=sfx*d60dx*(-F10*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]-F100*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]+F50*fh[idx_fh_F_ord4(iF-3,jF,kF,ex)]-F15*fh[idx_fh_F_ord4(iF-4,jF,kF,ex)]+F2*fh[idx_fh_F_ord4(iF-5,jF,kF,ex)]);
|
||||
else if ((i0-2)>=iminF&&i0<=ex1-4) f_rhs[p]+=sfx*d60dx*(-fh[idx_fh_F_ord4(iF-3,jF,kF,ex)]+F9*fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]-F45*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+F45*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-F9*fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+3,jF,kF,ex)]);
|
||||
else if ((i0-1)>=iminF&&i0<=ex1-3) f_rhs[p]+=sfx*d12dx*(fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]-EIT*fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]-fh[idx_fh_F_ord4(iF+2,jF,kF,ex)]);
|
||||
else if (i0>=iminF&&i0<=ex1-2) f_rhs[p]+=sfx*d2dx*(-fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+1,jF,kF,ex)]);
|
||||
}
|
||||
/* y */
|
||||
const double sfy=Sfy[p];
|
||||
if (sfy>ZEO) {
|
||||
if (j0<=ex2-5&&(j0-1)>=jminF) f_rhs[p]+=sfy*d60dy*(F2*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-F24*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F30*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF+3,kF,ex)]-fh[idx_fh_F_ord4(iF,jF+4,kF,ex)]);
|
||||
else if (j0<=ex2-6&&j0>=jminF) f_rhs[p]+=sfy*d60dy*(-F10*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F100*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]+F50*fh[idx_fh_F_ord4(iF,jF+3,kF,ex)]-F15*fh[idx_fh_F_ord4(iF,jF+4,kF,ex)]+F2*fh[idx_fh_F_ord4(iF,jF+5,kF,ex)]);
|
||||
else if (j0<=ex2-4&&(j0-2)>=jminF) f_rhs[p]+=sfy*d60dy*(-fh[idx_fh_F_ord4(iF,jF-3,kF,ex)]+F9*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-F45*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+F45*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F9*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+3,kF,ex)]);
|
||||
else if (j0<=ex2-3&&(j0-1)>=jminF) f_rhs[p]+=sfy*d12dy*(fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]);
|
||||
else if (j0<=ex2-2&&j0>=jminF) f_rhs[p]+=sfy*d2dy*(-fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]);
|
||||
} else if (sfy<ZEO) {
|
||||
if ((j0-3)>=jminF&&j0<=ex2-3) f_rhs[p]-=sfy*d60dy*(F2*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]-F24*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]-F30*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF-3,kF,ex)]-fh[idx_fh_F_ord4(iF,jF-4,kF,ex)]);
|
||||
else if ((j0-4)>=jminF&&j0<=ex2-2) f_rhs[p]-=sfy*d60dy*(-F10*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]-F100*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]+F50*fh[idx_fh_F_ord4(iF,jF-3,kF,ex)]-F15*fh[idx_fh_F_ord4(iF,jF-4,kF,ex)]+F2*fh[idx_fh_F_ord4(iF,jF-5,kF,ex)]);
|
||||
else if ((j0-2)>=jminF&&j0<=ex2-4) f_rhs[p]+=sfy*d60dy*(-fh[idx_fh_F_ord4(iF,jF-3,kF,ex)]+F9*fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-F45*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+F45*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-F9*fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+3,kF,ex)]);
|
||||
else if ((j0-1)>=jminF&&j0<=ex2-3) f_rhs[p]+=sfy*d12dy*(fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]-EIT*fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]-fh[idx_fh_F_ord4(iF,jF+2,kF,ex)]);
|
||||
else if (j0>=jminF&&j0<=ex2-2) f_rhs[p]+=sfy*d2dy*(-fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+1,kF,ex)]);
|
||||
}
|
||||
/* z */
|
||||
const double sfz=Sfz[p];
|
||||
if (sfz>ZEO) {
|
||||
if (k0<=ex3-5&&(k0-1)>=kminF) f_rhs[p]+=sfz*d60dz*(F2*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-F24*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F30*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF,kF+3,ex)]-fh[idx_fh_F_ord4(iF,jF,kF+4,ex)]);
|
||||
else if (k0<=ex3-6&&k0>=kminF) f_rhs[p]+=sfz*d60dz*(-F10*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F100*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]+F50*fh[idx_fh_F_ord4(iF,jF,kF+3,ex)]-F15*fh[idx_fh_F_ord4(iF,jF,kF+4,ex)]+F2*fh[idx_fh_F_ord4(iF,jF,kF+5,ex)]);
|
||||
else if (k0<=ex3-4&&(k0-2)>=kminF) f_rhs[p]+=sfz*d60dz*(-fh[idx_fh_F_ord4(iF,jF,kF-3,ex)]+F9*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-F45*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+F45*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F9*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+3,ex)]);
|
||||
else if (k0<=ex3-3&&(k0-1)>=kminF) f_rhs[p]+=sfz*d12dz*(fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]);
|
||||
else if (k0<=ex3-2&&k0>=kminF) f_rhs[p]+=sfz*d2dz*(-fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]);
|
||||
} else if (sfz<ZEO) {
|
||||
if ((k0-3)>=kminF&&k0<=ex3-3) f_rhs[p]-=sfz*d60dz*(F2*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]-F24*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F35*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F80*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]-F30*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF,kF-3,ex)]-fh[idx_fh_F_ord4(iF,jF,kF-4,ex)]);
|
||||
else if ((k0-4)>=kminF&&k0<=ex3-2) f_rhs[p]-=sfz*d60dz*(-F10*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F77*fh[idx_fh_F_ord4(iF,jF,kF,ex)]+F150*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]-F100*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]+F50*fh[idx_fh_F_ord4(iF,jF,kF-3,ex)]-F15*fh[idx_fh_F_ord4(iF,jF,kF-4,ex)]+F2*fh[idx_fh_F_ord4(iF,jF,kF-5,ex)]);
|
||||
else if ((k0-2)>=kminF&&k0<=ex3-4) f_rhs[p]+=sfz*d60dz*(-fh[idx_fh_F_ord4(iF,jF,kF-3,ex)]+F9*fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-F45*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+F45*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-F9*fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+3,ex)]);
|
||||
else if ((k0-1)>=kminF&&k0<=ex3-3) f_rhs[p]+=sfz*d12dz*(fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]-EIT*fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+EIT*fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]-fh[idx_fh_F_ord4(iF,jF,kF+2,ex)]);
|
||||
else if (k0>=kminF&&k0<=ex3-2) f_rhs[p]+=sfz*d2dz*(-fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+1,ex)]);
|
||||
}
|
||||
}}}
|
||||
|
||||
/* ---- KO dissipation (r=4, cof=256, sign=-) ---- */
|
||||
if (eps > ZEO) {
|
||||
const double cof = 256.0;
|
||||
const double F8k = 8.0, F28 = 28.0, F56 = 56.0, F70 = 70.0;
|
||||
const int i0_lo=(iminF+3>0)?iminF+3:0, j0_lo=(jminF+3>0)?jminF+3:0, k0_lo=(kminF+3>0)?kminF+3:0;
|
||||
const int i0_hi=imaxF-5, j0_hi=jmaxF-5, k0_hi=kmaxF-5;
|
||||
if (!(i0_lo>i0_hi||j0_lo>j0_hi||k0_lo>k0_hi)) {
|
||||
for (int k0=k0_lo;k0<=k0_hi;++k0) { const int kF=k0+1;
|
||||
for (int j0=j0_lo;j0<=j0_hi;++j0) { const int jF=j0+1;
|
||||
for (int i0=i0_lo;i0<=i0_hi;++i0) { const int iF=i0+1;
|
||||
const size_t p=idx_ex(i0,j0,k0,ex);
|
||||
const double Dx=((fh[idx_fh_F_ord4(iF-4,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+4,jF,kF,ex)])-F8k*(fh[idx_fh_F_ord4(iF-3,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+3,jF,kF,ex)])+F28*(fh[idx_fh_F_ord4(iF-2,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+2,jF,kF,ex)])-F56*(fh[idx_fh_F_ord4(iF-1,jF,kF,ex)]+fh[idx_fh_F_ord4(iF+1,jF,kF,ex)])+F70*fh[idx_fh_F_ord4(iF,jF,kF,ex)])/dX;
|
||||
const double Dy=((fh[idx_fh_F_ord4(iF,jF-4,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+4,kF,ex)])-F8k*(fh[idx_fh_F_ord4(iF,jF-3,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+3,kF,ex)])+F28*(fh[idx_fh_F_ord4(iF,jF-2,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+2,kF,ex)])-F56*(fh[idx_fh_F_ord4(iF,jF-1,kF,ex)]+fh[idx_fh_F_ord4(iF,jF+1,kF,ex)])+F70*fh[idx_fh_F_ord4(iF,jF,kF,ex)])/dY;
|
||||
const double Dz=((fh[idx_fh_F_ord4(iF,jF,kF-4,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+4,ex)])-F8k*(fh[idx_fh_F_ord4(iF,jF,kF-3,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+3,ex)])+F28*(fh[idx_fh_F_ord4(iF,jF,kF-2,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+2,ex)])-F56*(fh[idx_fh_F_ord4(iF,jF,kF-1,ex)]+fh[idx_fh_F_ord4(iF,jF,kF+1,ex)])+F70*fh[idx_fh_F_ord4(iF,jF,kF,ex)])/dZ;
|
||||
f_rhs[p] -= (eps/cof)*(Dx+Dy+Dz);
|
||||
}}}
|
||||
}
|
||||
}
|
||||
free(fh);
|
||||
return;
|
||||
}
|
||||
#elif (ghost_width == 5)
|
||||
{
|
||||
lopsided(ex, X, Y, Z, f, f_rhs, Sfx, Sfy, Sfz, Symmetry, SoA);
|
||||
if (eps > ZEO) kodis(ex, X, Y, Z, f, f_rhs, SoA, Symmetry, eps);
|
||||
return;
|
||||
}
|
||||
#else
|
||||
#error "lopsided_kodis_c.C: unsupported ghost_width (must be 2, 3, 4, or 5)"
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
|
||||
#define ABV 0
|
||||
|
||||
#define EScalar_CC 2
|
||||
#define EScalar_CC 2
|
||||
|
||||
#if 0
|
||||
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
|
||||
#define GaussInt
|
||||
|
||||
#define ABEtype 1
|
||||
#define ABEtype 0
|
||||
|
||||
//#define With_AHF
|
||||
#define Psi4type 0
|
||||
@@ -167,4 +167,3 @@
|
||||
#define TINY 1e-10
|
||||
|
||||
#endif /* MICRODEF_H */
|
||||
|
||||
|
||||
@@ -1,260 +1,293 @@
|
||||
|
||||
|
||||
include makefile.inc
|
||||
|
||||
## polint(ordn=6) kernel selector:
|
||||
## 1 (default): barycentric fast path
|
||||
## 0 : fallback to Neville path
|
||||
POLINT6_USE_BARY ?= 1
|
||||
POLINT6_FLAG = -DPOLINT6_USE_BARYCENTRIC=$(POLINT6_USE_BARY)
|
||||
|
||||
## ABE build flags selected by PGO_MODE (set in makefile.inc, default: opt)
|
||||
## make -> opt (PGO-guided, maximum performance)
|
||||
## make PGO_MODE=instrument -> instrument (Phase 1: collect fresh profile data)
|
||||
PROFDATA = /home/$(shell whoami)/AMSS-NCKU/pgo_profile/default.profdata
|
||||
|
||||
ifeq ($(TOOLCHAIN),intel)
|
||||
OMP_FLAG = -qopenmp
|
||||
|
||||
ifeq ($(PGO_MODE),instrument)
|
||||
## Intel Phase 1: instrumentation — omit -ipo/-fp-model fast=2 for faster build and numerical stability
|
||||
CXXAPPFLAGS = -O3 -xHost -fma -fprofile-instr-generate -ipo \
|
||||
-Dfortran3 -Dnewc $(MKL_INC) $(INTERP_LB_FLAGS)
|
||||
f90appflags = -O3 -xHost -fma -fprofile-instr-generate -ipo \
|
||||
-align array64byte -fpp $(MKL_INC) $(POLINT6_FLAG)
|
||||
else
|
||||
## opt (default): maximum performance with PGO profile data -fprofile-instr-use=$(PROFDATA) \
|
||||
## PGO has been turned off, now tested and found to be negative optimization
|
||||
## INTERP_LB_FLAGS has been turned off too, now tested and found to be negative optimization
|
||||
|
||||
|
||||
CXXAPPFLAGS = -O3 -xHost -fp-model fast=2 -fma -ipo \
|
||||
-Dfortran3 -Dnewc $(MKL_INC) $(INTERP_LB_FLAGS)
|
||||
f90appflags = -O3 -xHost -fp-model fast=2 -fma -ipo \
|
||||
-align array64byte -fpp $(MKL_INC) $(POLINT6_FLAG)
|
||||
endif
|
||||
|
||||
TP_OPTFLAGS = -O3 -xHost -fp-model fast=2 -fma -ipo \
|
||||
-fprofile-instr-use=$(TP_PROFDATA) \
|
||||
-Dfortran3 -Dnewc $(MKL_INC)
|
||||
else
|
||||
## NVHPC defaults: mpicc/mpicxx/mpifort wrappers
|
||||
## PGO_MODE is ignored in this branch.
|
||||
OMP_FLAG = -mp
|
||||
CXXAPPFLAGS = -O3 -tp=host -Mcache_align -Mfma \
|
||||
-Dfortran3 -Dnewc $(MKL_INC) $(INTERP_LB_FLAGS)
|
||||
f90appflags = -O3 -tp=host -Mcache_align -Mfma -Mpreprocess \
|
||||
$(MKL_INC) $(POLINT6_FLAG)
|
||||
TP_OPTFLAGS = -O3 -tp=host -Mcache_align -Mfma \
|
||||
-Dfortran3 -Dnewc $(MKL_INC)
|
||||
endif
|
||||
|
||||
.SUFFIXES: .o .f90 .C .for .cu
|
||||
|
||||
.f90.o:
|
||||
$(f90) $(f90appflags) -c $< -o $@
|
||||
|
||||
.C.o:
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
.for.o:
|
||||
$(f77) -c $< -o $@
|
||||
|
||||
|
||||
|
||||
include makefile.inc
|
||||
|
||||
-include AMSS_NCKU_build.mk
|
||||
|
||||
ABE_TYPE ?= $(shell awk '/^[[:space:]]*\#define[[:space:]]+ABEtype/ {print $$3; exit}' macrodef.h 2>/dev/null)
|
||||
|
||||
ifeq ($(USE_TRANSFER_CACHE),auto)
|
||||
ifeq ($(ABE_TYPE),0)
|
||||
EFFECTIVE_USE_TRANSFER_CACHE = 1
|
||||
else
|
||||
EFFECTIVE_USE_TRANSFER_CACHE = 0
|
||||
endif
|
||||
else
|
||||
EFFECTIVE_USE_TRANSFER_CACHE = $(USE_TRANSFER_CACHE)
|
||||
endif
|
||||
|
||||
ifeq ($(USE_CXX_ESCALAR_KERNEL),1)
|
||||
ifeq ($(ABE_TYPE),1)
|
||||
EFFECTIVE_USE_CXX_ESCALAR_KERNEL = 1
|
||||
else
|
||||
EFFECTIVE_USE_CXX_ESCALAR_KERNEL = 0
|
||||
endif
|
||||
else
|
||||
EFFECTIVE_USE_CXX_ESCALAR_KERNEL = 0
|
||||
endif
|
||||
|
||||
ifeq ($(EFFECTIVE_USE_CXX_ESCALAR_KERNEL),1)
|
||||
ifeq ($(USE_CXX_KERNELS),0)
|
||||
$(error USE_CXX_ESCALAR_KERNEL=1 requires USE_CXX_KERNELS=1 because bssn_escalar_rhs_c.C reuses the C BSSN kernel)
|
||||
endif
|
||||
endif
|
||||
|
||||
ifeq ($(USE_CXX_EM_KERNEL),1)
|
||||
ifeq ($(ABE_TYPE),3)
|
||||
EFFECTIVE_USE_CXX_EM_KERNEL = 1
|
||||
else
|
||||
EFFECTIVE_USE_CXX_EM_KERNEL = 0
|
||||
endif
|
||||
else
|
||||
EFFECTIVE_USE_CXX_EM_KERNEL = 0
|
||||
endif
|
||||
|
||||
ifeq ($(EFFECTIVE_USE_CXX_EM_KERNEL),1)
|
||||
ifeq ($(USE_CXX_KERNELS),0)
|
||||
$(error USE_CXX_EM_KERNEL=1 requires USE_CXX_KERNELS=1 because bssn_em_rhs_c.C reuses the C BSSN kernel)
|
||||
endif
|
||||
endif
|
||||
|
||||
EM_KERNEL_FLAG = -DBSSN_USE_EM_C_KERNEL=$(EFFECTIVE_USE_CXX_EM_KERNEL)
|
||||
|
||||
## polint(ordn=6) kernel selector:
|
||||
## 1 (default): barycentric fast path
|
||||
## 0 : fallback to Neville path
|
||||
POLINT6_USE_BARY ?= 1
|
||||
POLINT6_FLAG = -DPOLINT6_USE_BARYCENTRIC=$(POLINT6_USE_BARY)
|
||||
TRANSFER_CACHE_FLAG = -DBSSN_USE_TRANSFER_CACHE=$(EFFECTIVE_USE_TRANSFER_CACHE)
|
||||
ESCALAR_KERNEL_FLAG = -DBSSN_USE_ESCALAR_C_KERNEL=$(EFFECTIVE_USE_CXX_ESCALAR_KERNEL)
|
||||
|
||||
## ABE build flags selected by PGO_MODE (set in makefile.inc, default: opt)
|
||||
## make -> opt (PGO-guided, maximum performance)
|
||||
## make PGO_MODE=instrument -> instrument (Phase 1: collect fresh profile data)
|
||||
PROFDATA = /home/$(shell whoami)/AMSS-NCKU/pgo_profile/default.profdata
|
||||
|
||||
ifeq ($(PGO_MODE),instrument)
|
||||
## Phase 1: instrumentation — omit -ipo/-fp-model fast=2 for faster build and numerical stability
|
||||
CXXAPPFLAGS = -O3 -xHost -fma -fprofile-instr-generate -ipo \
|
||||
-Dfortran3 -Dnewc -I${MKLROOT}/include $(INTERP_LB_FLAGS) \
|
||||
$(TRANSFER_CACHE_FLAG) $(ESCALAR_KERNEL_FLAG) $(EM_KERNEL_FLAG)
|
||||
f90appflags = -O3 -xHost -fma -fprofile-instr-generate -ipo \
|
||||
-align array64byte -fpp -I${MKLROOT}/include $(POLINT6_FLAG)
|
||||
else
|
||||
## opt (default): maximum performance with PGO profile data -fprofile-instr-use=$(PROFDATA) \
|
||||
## PGO has been turned off, now tested and found to be negative optimization
|
||||
## INTERP_LB_FLAGS has been turned off too, now tested and found to be negative optimization
|
||||
|
||||
|
||||
CXXAPPFLAGS = -O3 -xHost -fp-model fast=2 -fma -ipo \
|
||||
-Dfortran3 -Dnewc -I${MKLROOT}/include $(INTERP_LB_FLAGS) \
|
||||
$(TRANSFER_CACHE_FLAG) $(ESCALAR_KERNEL_FLAG) $(EM_KERNEL_FLAG)
|
||||
f90appflags = -O3 -xHost -fp-model fast=2 -fma -ipo \
|
||||
-align array64byte -fpp -I${MKLROOT}/include $(POLINT6_FLAG)
|
||||
endif
|
||||
|
||||
.SUFFIXES: .o .f90 .C .for .cu
|
||||
|
||||
.f90.o:
|
||||
$(f90) $(f90appflags) -c $< -o $@
|
||||
|
||||
.C.o:
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
# ShellPatch.C uses OpenMP for setupintintstuff search loops
|
||||
ShellPatch.o: ShellPatch.C
|
||||
${CXX} $(CXXAPPFLAGS) $(OMP_FLAG) -c $< $(filein) -o $@
|
||||
|
||||
.for.o:
|
||||
$(f77) -c $< -o $@
|
||||
|
||||
.cu.o:
|
||||
$(Cu) $(CUDA_APP_FLAGS) -c $< -o $@ $(CUDA_LIB_PATH)
|
||||
|
||||
# CUDA rewrite of BSSN RHS (drop-in replacement for bssn_rhs_c + stencil helpers)
|
||||
bssn_rhs_cuda.o: bssn_rhs_cuda.cu bssn_rhs.h macrodef.h
|
||||
$(Cu) $(CUDA_APP_FLAGS) -c $< -o $@ $(CUDA_LIB_PATH)
|
||||
|
||||
# CUDA rewrite of Z4C Cartesian RHS
|
||||
z4c_rhs_cuda.o: z4c_rhs_cuda.cu z4c_rhs_cuda.h bssn_rhs.h macrodef.h ricci_gamma.h
|
||||
$(Cu) $(CUDA_APP_FLAGS) -c $< -o $@ $(CUDA_LIB_PATH)
|
||||
|
||||
# C rewrite of BSSN RHS kernel and helpers
|
||||
bssn_rhs_c.o: bssn_rhs_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
fderivs_c.o: fderivs_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
fdderivs_c.o: fdderivs_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
kodiss_c.o: kodiss_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
lopsided_c.o: lopsided_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
lopsided_kodis_c.o: lopsided_kodis_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
z4c_rhs_c.o: z4c_rhs_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
#interp_lb_profile.o: interp_lb_profile.C interp_lb_profile.h
|
||||
# ${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
TwoPunctures.o: TwoPunctures.C
|
||||
${CXX} $(TP_OPTFLAGS) $(OMP_FLAG) -c $< -o $@
|
||||
|
||||
TwoPunctureABE.o: TwoPunctureABE.C
|
||||
${CXX} $(TP_OPTFLAGS) $(OMP_FLAG) -c $< -o $@
|
||||
|
||||
# Input files
|
||||
|
||||
## CUDA BSSN RHS switch
|
||||
## 1 : use the rewritten CUDA bssn_rhs backend
|
||||
## 0 : keep the normal CPU/Fortran selection below
|
||||
USE_CUDA_BSSN ?= 0
|
||||
USE_CUDA_Z4C ?= 0
|
||||
|
||||
CXXAPPFLAGS += -DUSE_CUDA_BSSN=$(USE_CUDA_BSSN)
|
||||
CUDA_APP_FLAGS += -DUSE_CUDA_BSSN=$(USE_CUDA_BSSN)
|
||||
CXXAPPFLAGS += -DUSE_CUDA_Z4C=$(USE_CUDA_Z4C)
|
||||
CUDA_APP_FLAGS += -DUSE_CUDA_Z4C=$(USE_CUDA_Z4C)
|
||||
|
||||
## Kernel implementation switch (set USE_CXX_KERNELS=0 to fall back to Fortran)
|
||||
ifeq ($(USE_CXX_KERNELS),0)
|
||||
# Fortran mode: no C rewrite files; bssn_rhs.o is included via F90FILES below
|
||||
CFILES_CPU =
|
||||
else
|
||||
# C++ mode (default): C rewrite of bssn_rhs and helper kernels
|
||||
CFILES_CPU = bssn_rhs_c.o fderivs_c.o fdderivs_c.o kodiss_c.o lopsided_c.o lopsided_kodis_c.o
|
||||
endif
|
||||
|
||||
CFILES_CUDA_BSSN = bssn_rhs_cuda.o
|
||||
|
||||
ifeq ($(USE_CUDA_BSSN),1)
|
||||
CFILES = $(CFILES_CUDA_BSSN)
|
||||
else
|
||||
CFILES = $(CFILES_CPU)
|
||||
endif
|
||||
|
||||
ifeq ($(USE_CUDA_Z4C),1)
|
||||
CFILES += z4c_rhs_cuda.o
|
||||
Z4C_F90_OBJ =
|
||||
else ifeq ($(USE_CXX_Z4C_KERNELS),1)
|
||||
CFILES += z4c_rhs_c.o
|
||||
Z4C_F90_OBJ =
|
||||
else
|
||||
Z4C_F90_OBJ = Z4c_rhs.o
|
||||
endif
|
||||
|
||||
## RK4 kernel switch (independent from USE_CXX_KERNELS)
|
||||
ifeq ($(USE_CXX_RK4),1)
|
||||
RK4_C_OBJ = rungekutta4_rout_c.o
|
||||
RK4_F90_OBJ =
|
||||
else
|
||||
RK4_C_OBJ =
|
||||
RK4_F90_OBJ = rungekutta4_rout.o
|
||||
endif
|
||||
|
||||
CFILES += $(RK4_C_OBJ)
|
||||
ABE_CUDA_CFILES = $(CFILES_CUDA_BSSN) z4c_rhs_cuda.o $(RK4_C_OBJ)
|
||||
|
||||
ABE_LDLIBS = $(LDLIBS)
|
||||
ifeq ($(USE_CUDA_BSSN),1)
|
||||
ABE_LDLIBS += -lcudart $(CUDA_LIB_PATH)
|
||||
endif
|
||||
ifeq ($(USE_CUDA_Z4C),1)
|
||||
ABE_LDLIBS += -lcudart $(CUDA_LIB_PATH)
|
||||
endif
|
||||
|
||||
C++FILES = ABE.o Ansorg.o Block.o misc.o monitor.o Parallel.o MPatch.o var.o\
|
||||
cgh.o bssn_class.o surface_integral.o ShellPatch.o\
|
||||
bssnEScalar_class.o perf.o Z4c_class.o NullShellPatch.o\
|
||||
bssnEM_class.o cpbc_util.o z4c_rhs_point.o checkpoint.o\
|
||||
Parallel_bam.o scalar_class.o transpbh.o NullShellPatch2.o\
|
||||
NullShellPatch2_Evo.o writefile_f.o interp_lb_profile.o
|
||||
|
||||
#C++FILES_GPU = ABE.o Ansorg.o Block.o misc.o monitor.o Parallel.o MPatch.o var.o\
|
||||
cgh.o surface_integral.o ShellPatch.o\
|
||||
bssnEScalar_class.o perf.o Z4c_class.o NullShellPatch.o\
|
||||
bssnEM_class.o cpbc_util.o z4c_rhs_point.o checkpoint.o\
|
||||
Parallel_bam.o scalar_class.o transpbh.o NullShellPatch2.o\
|
||||
NullShellPatch2_Evo.o \
|
||||
bssn_gpu_class.o bssn_step_gpu.o bssn_macro.o writefile_f.o
|
||||
|
||||
F90FILES_BASE = enforce_algebra.o fmisc.o initial_puncture.o prolongrestrict.o\
|
||||
prolongrestrict_cell.o prolongrestrict_vertex.o\
|
||||
$(RK4_F90_OBJ) diff_new.o kodiss.o kodiss_sh.o\
|
||||
lopsidediff.o sommerfeld_rout.o getnp4.o diff_new_sh.o\
|
||||
shellfunctions.o bssn_rhs_ss.o Set_Rho_ADM.o\
|
||||
getnp4EScalar.o bssnEScalar_rhs.o bssn_constraint.o ricci_gamma.o\
|
||||
fadmquantites_bssn.o $(Z4C_F90_OBJ) Z4c_rhs_ss.o point_diff_new_sh.o\
|
||||
cpbc.o getnp4old.o NullEvol.o initial_null.o initial_maxwell.o\
|
||||
getnpem2.o empart.o NullNews.o fourdcurvature.o\
|
||||
bssn2adm.o adm_constraint.o adm_ricci_gamma.o\
|
||||
scalar_rhs.o initial_scalar.o NullEvol2.o initial_null2.o\
|
||||
NullNews2.o tool_f.o
|
||||
|
||||
ifeq ($(USE_CXX_KERNELS),0)
|
||||
# Fortran mode: include original bssn_rhs.o
|
||||
F90FILES = $(F90FILES_BASE) bssn_rhs.o
|
||||
else
|
||||
# C++ mode (default): bssn_rhs.o replaced by C++ kernel
|
||||
F90FILES = $(F90FILES_BASE)
|
||||
endif
|
||||
|
||||
F77FILES = zbesh.o
|
||||
|
||||
AHFDOBJS = expansion.o expansion_Jacobian.o patch.o coords.o patch_info.o patch_interp.o patch_system.o \
|
||||
tgrid.o fd_grid.o ghost_zone.o array.o round.o norm.o fuzzy.o error_exit.o miscfp.o \
|
||||
linear_map.o cpm_map.o BH_diagnostics.o setup.o horizon_sequence.o find_horizons.o \
|
||||
initial_guess.o Newton.o Jacobian.o ilucg.o IntPnts0.o IntPnts.o
|
||||
|
||||
TwoPunctureFILES = TwoPunctureABE.o TwoPunctures.o
|
||||
|
||||
#CUDAFILES = bssn_gpu.o bssn_gpu_rhs_ss.o
|
||||
|
||||
# file dependences
|
||||
$(C++FILES) $(C++FILES_GPU) $(F90FILES) $(CFILES) $(ABE_CUDA_CFILES) $(AHFDOBJS) $(CUDAFILES): macrodef.fh
|
||||
|
||||
$(C++FILES): Block.h enforce_algebra.h fmisc.h initial_puncture.h macrodef.h\
|
||||
misc.h monitor.h MyList.h Parallel.h MPatch.h prolongrestrict.h\
|
||||
rungekutta4_rout.h var.h bssn_class.h bssn_rhs.h sommerfeld_rout.h\
|
||||
cgh.h surface_integral.h ShellPatch.h shellfunctions.h perf.h\
|
||||
fadmquantites_bssn.h cpbc.h getnp4.h initial_null.h NullEvol.h\
|
||||
NullShellPatch.h initial_maxwell.h bssnEM_class.h getnpem2.h\
|
||||
empart.h NullNews.h kodiss.h Parallel_bam.h ricci_gamma.h\
|
||||
initial_null2.h NullShellPatch2.h
|
||||
|
||||
#$(C++FILES_GPU): Block.h enforce_algebra.h fmisc.h initial_puncture.h macrodef.h\
|
||||
misc.h monitor.h MyList.h Parallel.h MPatch.h prolongrestrict.h\
|
||||
rungekutta4_rout.h var.h bssn_rhs.h sommerfeld_rout.h\
|
||||
cgh.h surface_integral.h ShellPatch.h shellfunctions.h perf.h\
|
||||
fadmquantites_bssn.h cpbc.h getnp4.h initial_null.h NullEvol.h\
|
||||
NullShellPatch.h initial_maxwell.h bssnEM_class.h getnpem2.h\
|
||||
empart.h NullNews.h kodiss.h Parallel_bam.h ricci_gamma.h\
|
||||
initial_null2.h NullShellPatch2.h \
|
||||
bssn_gpu_class.h bssn_macro.h
|
||||
|
||||
$(AHFDOBJS): cctk.h cctk_Config.h cctk_Types.h cctk_Constants.h myglobal.h
|
||||
|
||||
$(C++FILES) $(C++FILES_GPU) $(CFILES) $(ABE_CUDA_CFILES) $(AHFDOBJS) $(CUDAFILES): macrodef.h
|
||||
|
||||
TwoPunctureFILES: TwoPunctures.h
|
||||
|
||||
$(CUDAFILES): bssn_gpu.h gpu_mem.h gpu_rhsSS_mem.h
|
||||
|
||||
misc.o : zbesh.o
|
||||
|
||||
# projects
|
||||
ABE: $(C++FILES) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS)
|
||||
$(CLINKER) $(CXXAPPFLAGS) -o $@ $(C++FILES) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS) $(ABE_LDLIBS)
|
||||
|
||||
ABE_CUDA: USE_CUDA_BSSN=1
|
||||
ABE_CUDA: USE_CUDA_Z4C=1
|
||||
ABE_CUDA: $(C++FILES) $(ABE_CUDA_CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS)
|
||||
$(CLINKER) $(CXXAPPFLAGS) -o $@ $(C++FILES) $(ABE_CUDA_CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS) $(LDLIBS) -lcudart $(CUDA_LIB_PATH)
|
||||
|
||||
#ABEGPU: $(C++FILES_GPU) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS) $(CUDAFILES)
|
||||
# $(CLINKER) $(CXXAPPFLAGS) -o $@ $(C++FILES_GPU) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS) $(CUDAFILES) $(LDLIBS)
|
||||
|
||||
TwoPunctureABE: $(TwoPunctureFILES)
|
||||
$(CLINKER) $(TP_OPTFLAGS) $(OMP_FLAG) -o $@ $(TwoPunctureFILES) $(LDLIBS)
|
||||
|
||||
clean:
|
||||
rm *.o ABE ABE_CUDA ABEGPU TwoPunctureABE make.log -f
|
||||
# C rewrite of BSSN RHS kernel and helpers
|
||||
bssn_rhs_c.o: bssn_rhs_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
fderivs_c.o: fderivs_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
fdderivs_c.o: fdderivs_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
kodiss_c.o: kodiss_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
lopsided_c.o: lopsided_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
lopsided_kodis_c.o: lopsided_kodis_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
# C rewrite of shell-patch derivative kernels
|
||||
fderivs_sh_c.o: fderivs_sh_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
fdderivs_sh_c.o: fdderivs_sh_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
fderivs_shc_c.o: fderivs_shc_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
fdderivs_shc_c.o: fdderivs_shc_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
kodiss_sh_c.o: kodiss_sh_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
|
||||
bssn_em_rhs_c.o: bssn_em_rhs_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
z4c_rhs_c.o: z4c_rhs_c.C
|
||||
${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
#interp_lb_profile.o: interp_lb_profile.C interp_lb_profile.h
|
||||
# ${CXX} $(CXXAPPFLAGS) -c $< $(filein) -o $@
|
||||
|
||||
## TwoPunctureABE uses fixed optimal flags with its own PGO profile, independent of CXXAPPFLAGS
|
||||
TP_PROFDATA = /home/$(shell whoami)/AMSS-NCKU/pgo_profile/TwoPunctureABE.profdata
|
||||
TP_OPTFLAGS = -O3 -xHost -fp-model fast=2 -fma -ipo \
|
||||
-fprofile-instr-use=$(TP_PROFDATA) \
|
||||
-Dfortran3 -Dnewc -I${MKLROOT}/include
|
||||
|
||||
TwoPunctures.o: TwoPunctures.C
|
||||
${CXX} $(TP_OPTFLAGS) -qopenmp -c $< -o $@
|
||||
|
||||
TwoPunctureABE.o: TwoPunctureABE.C
|
||||
${CXX} $(TP_OPTFLAGS) -qopenmp -c $< -o $@
|
||||
|
||||
# Input files
|
||||
|
||||
## Kernel implementation switch (set USE_CXX_KERNELS=0 to fall back to Fortran)
|
||||
ifeq ($(USE_CXX_KERNELS),0)
|
||||
# Fortran mode: no C rewrite files; bssn_rhs.o is included via F90FILES below
|
||||
CFILES =
|
||||
else
|
||||
# C++ mode (default): C rewrite of bssn/bssn-escalar rhs and helper kernels
|
||||
CFILES = bssn_rhs_c.o fderivs_c.o fdderivs_c.o kodiss_c.o lopsided_c.o lopsided_kodis_c.o
|
||||
ifeq ($(EFFECTIVE_USE_CXX_ESCALAR_KERNEL),1)
|
||||
CFILES += bssn_escalar_rhs_c.o
|
||||
endif
|
||||
ifeq ($(EFFECTIVE_USE_CXX_EM_KERNEL),1)
|
||||
CFILES += bssn_em_rhs_c.o
|
||||
endif
|
||||
endif
|
||||
|
||||
ifeq ($(USE_CXX_Z4C_KERNELS),1)
|
||||
CFILES += z4c_rhs_c.o
|
||||
Z4C_F90_OBJ =
|
||||
else
|
||||
Z4C_F90_OBJ = Z4c_rhs.o
|
||||
endif
|
||||
|
||||
## RK4 kernel switch (independent from USE_CXX_KERNELS)
|
||||
ifeq ($(USE_CXX_RK4),1)
|
||||
CFILES += rungekutta4_rout_c.o
|
||||
RK4_F90_OBJ =
|
||||
else
|
||||
RK4_F90_OBJ = rungekutta4_rout.o
|
||||
endif
|
||||
|
||||
## Shell-patch derivative kernel switch (independent from USE_CXX_KERNELS)
|
||||
## 1 : use C++ rewrite of shell derivative functions (experimental)
|
||||
## 0 : use original Fortran diff_new_sh.o and kodiss_sh.o (default)
|
||||
USE_CXX_SHELL_KERNELS ?= 0
|
||||
ifeq ($(USE_CXX_SHELL_KERNELS),1)
|
||||
CFILES += fderivs_sh_c.o fdderivs_sh_c.o fderivs_shc_c.o fdderivs_shc_c.o kodiss_sh_c.o
|
||||
SH_F90_OBJ =
|
||||
else
|
||||
SH_F90_OBJ = diff_new_sh.o kodiss_sh.o point_diff_new_sh.o
|
||||
endif
|
||||
|
||||
C++FILES = ABE.o Ansorg.o Block.o misc.o monitor.o Parallel.o MPatch.o var.o\
|
||||
cgh.o bssn_class.o surface_integral.o ShellPatch.o\
|
||||
bssnEScalar_class.o perf.o Z4c_class.o NullShellPatch.o\
|
||||
bssnEM_class.o cpbc_util.o z4c_rhs_point.o checkpoint.o\
|
||||
Parallel_bam.o scalar_class.o transpbh.o NullShellPatch2.o\
|
||||
NullShellPatch2_Evo.o writefile_f.o interp_lb_profile.o
|
||||
|
||||
C++FILES_GPU = ABE.o Ansorg.o Block.o misc.o monitor.o Parallel.o MPatch.o var.o\
|
||||
cgh.o surface_integral.o ShellPatch.o\
|
||||
bssnEScalar_class.o perf.o Z4c_class.o NullShellPatch.o\
|
||||
bssnEM_class.o cpbc_util.o z4c_rhs_point.o checkpoint.o\
|
||||
Parallel_bam.o scalar_class.o transpbh.o NullShellPatch2.o\
|
||||
NullShellPatch2_Evo.o \
|
||||
bssn_gpu_class.o bssn_step_gpu.o bssn_macro.o writefile_f.o
|
||||
|
||||
F90FILES_BASE = enforce_algebra.o fmisc.o initial_puncture.o prolongrestrict.o\
|
||||
prolongrestrict_cell.o prolongrestrict_vertex.o\
|
||||
$(RK4_F90_OBJ) diff_new.o kodiss.o\
|
||||
lopsidediff.o sommerfeld_rout.o getnp4.o $(SH_F90_OBJ)\
|
||||
shellfunctions.o bssn_rhs_ss.o Set_Rho_ADM.o\
|
||||
getnp4EScalar.o bssnEScalar_rhs.o bssn_constraint.o ricci_gamma.o\
|
||||
fadmquantites_bssn.o $(Z4C_F90_OBJ) Z4c_rhs_ss.o\
|
||||
cpbc.o getnp4old.o NullEvol.o initial_null.o initial_maxwell.o\
|
||||
getnpem2.o empart.o NullNews.o fourdcurvature.o\
|
||||
bssn2adm.o adm_constraint.o adm_ricci_gamma.o\
|
||||
scalar_rhs.o initial_scalar.o NullEvol2.o initial_null2.o\
|
||||
NullNews2.o tool_f.o
|
||||
|
||||
ifeq ($(USE_CXX_KERNELS),0)
|
||||
# Fortran mode: include original bssn_rhs.o
|
||||
F90FILES = $(F90FILES_BASE) bssn_rhs.o
|
||||
else
|
||||
# C++ mode (default): bssn_rhs.o replaced by C++ kernel
|
||||
F90FILES = $(F90FILES_BASE)
|
||||
endif
|
||||
|
||||
F77FILES = zbesh.o
|
||||
|
||||
AHFDOBJS = expansion.o expansion_Jacobian.o patch.o coords.o patch_info.o patch_interp.o patch_system.o \
|
||||
tgrid.o fd_grid.o ghost_zone.o array.o round.o norm.o fuzzy.o error_exit.o miscfp.o \
|
||||
linear_map.o cpm_map.o BH_diagnostics.o setup.o horizon_sequence.o find_horizons.o \
|
||||
initial_guess.o Newton.o Jacobian.o ilucg.o IntPnts0.o IntPnts.o
|
||||
|
||||
TwoPunctureFILES = TwoPunctureABE.o TwoPunctures.o
|
||||
|
||||
CUDAFILES = bssn_gpu.o bssn_gpu_rhs_ss.o
|
||||
|
||||
# file dependences
|
||||
$(C++FILES) $(C++FILES_GPU) $(F90FILES) $(CFILES) $(AHFDOBJS) $(CUDAFILES): macrodef.fh
|
||||
|
||||
$(C++FILES): Block.h enforce_algebra.h fmisc.h initial_puncture.h macrodef.h\
|
||||
misc.h monitor.h MyList.h Parallel.h MPatch.h prolongrestrict.h\
|
||||
rungekutta4_rout.h var.h bssn_class.h bssn_rhs.h sommerfeld_rout.h\
|
||||
cgh.h surface_integral.h ShellPatch.h shellfunctions.h perf.h\
|
||||
fadmquantites_bssn.h cpbc.h getnp4.h initial_null.h NullEvol.h\
|
||||
NullShellPatch.h initial_maxwell.h bssnEM_class.h getnpem2.h\
|
||||
empart.h NullNews.h kodiss.h Parallel_bam.h ricci_gamma.h\
|
||||
initial_null2.h NullShellPatch2.h
|
||||
|
||||
$(C++FILES_GPU): Block.h enforce_algebra.h fmisc.h initial_puncture.h macrodef.h\
|
||||
misc.h monitor.h MyList.h Parallel.h MPatch.h prolongrestrict.h\
|
||||
rungekutta4_rout.h var.h bssn_rhs.h sommerfeld_rout.h\
|
||||
cgh.h surface_integral.h ShellPatch.h shellfunctions.h perf.h\
|
||||
fadmquantites_bssn.h cpbc.h getnp4.h initial_null.h NullEvol.h\
|
||||
NullShellPatch.h initial_maxwell.h bssnEM_class.h getnpem2.h\
|
||||
empart.h NullNews.h kodiss.h Parallel_bam.h ricci_gamma.h\
|
||||
initial_null2.h NullShellPatch2.h \
|
||||
bssn_gpu_class.h bssn_macro.h
|
||||
|
||||
$(AHFDOBJS): cctk.h cctk_Config.h cctk_Types.h cctk_Constants.h myglobal.h
|
||||
|
||||
$(C++FILES) $(C++FILES_GPU) $(CFILES) $(AHFDOBJS) $(CUDAFILES): macrodef.h
|
||||
|
||||
TwoPunctureFILES: TwoPunctures.h
|
||||
|
||||
$(CUDAFILES): bssn_gpu.h gpu_mem.h gpu_rhsSS_mem.h
|
||||
|
||||
misc.o : zbesh.o
|
||||
|
||||
# projects
|
||||
ABE: $(C++FILES) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS)
|
||||
$(CLINKER) $(CXXAPPFLAGS) -o $@ $(C++FILES) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS) $(LDLIBS)
|
||||
|
||||
ABEGPU: $(C++FILES_GPU) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS) $(CUDAFILES)
|
||||
$(CLINKER) $(CXXAPPFLAGS) -o $@ $(C++FILES_GPU) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS) $(CUDAFILES) $(LDLIBS)
|
||||
|
||||
TwoPunctureABE: $(TwoPunctureFILES)
|
||||
$(CLINKER) $(TP_OPTFLAGS) -qopenmp -o $@ $(TwoPunctureFILES) $(LDLIBS)
|
||||
|
||||
clean:
|
||||
rm *.o ABE ABEGPU TwoPunctureABE make.log -f
|
||||
|
||||
@@ -1,7 +1,28 @@
|
||||
## Toolchain selection
|
||||
## nvhpc : NVIDIA HPC SDK + CUDA-aware MPI (default)
|
||||
## intel : Intel oneAPI toolchain (legacy path)
|
||||
TOOLCHAIN ?= nvhpc
|
||||
## GCC version (commented out)
|
||||
## filein = -I/usr/include -I/usr/lib/x86_64-linux-gnu/mpich/include -I/usr/lib/x86_64-linux-gnu/openmpi/lib/ -I/usr/lib/gcc/x86_64-linux-gnu/11/ -I/usr/include/c++/11/
|
||||
## filein = -I/usr/include/ -I/usr/include/openmpi-x86_64/ -I/usr/lib/x86_64-linux-gnu/openmpi/include/ -I/usr/lib/x86_64-linux-gnu/openmpi/lib/ -I/usr/lib/gcc/x86_64-linux-gnu/11/ -I/usr/include/c++/11/
|
||||
## LDLIBS = -L/usr/lib/x86_64-linux-gnu -L/usr/lib64 -L/usr/lib/gcc/x86_64-linux-gnu/11 -lgfortran -lmpi -lgfortran
|
||||
|
||||
## Intel oneAPI version with oneMKL (Optimized for performance)
|
||||
filein = -I/usr/include/ -I${MKLROOT}/include
|
||||
|
||||
## Using sequential MKL (OpenMP disabled for better single-threaded performance)
|
||||
## Added -lifcore for Intel Fortran runtime and -limf for Intel math library
|
||||
LDLIBS = -L${MKLROOT}/lib -lmkl_intel_lp64 -lmkl_sequential -lmkl_core -lifcore -limf -lpthread -lm -ldl -liomp5
|
||||
|
||||
## Memory allocator switch
|
||||
## 1 (default) : link Intel oneTBB allocator (libtbbmalloc)
|
||||
## 0 : use system default allocator (ptmalloc)
|
||||
USE_TBBMALLOC ?= 1
|
||||
TBBMALLOC_SO ?= /home/intel/oneapi/2025.3/lib/libtbbmalloc.so
|
||||
ifneq ($(wildcard $(TBBMALLOC_SO)),)
|
||||
TBBMALLOC_LIBS = -Wl,--no-as-needed $(TBBMALLOC_SO) -Wl,--as-needed
|
||||
else
|
||||
TBBMALLOC_LIBS = -Wl,--no-as-needed -ltbbmalloc -Wl,--as-needed
|
||||
endif
|
||||
ifeq ($(USE_TBBMALLOC),1)
|
||||
LDLIBS := $(TBBMALLOC_LIBS) $(LDLIBS)
|
||||
endif
|
||||
|
||||
## PGO build mode switch (ABE only; TwoPunctureABE always uses opt flags)
|
||||
## opt : (default) maximum performance with PGO profile-guided optimization
|
||||
@@ -22,14 +43,6 @@ else
|
||||
INTERP_LB_FLAGS =
|
||||
endif
|
||||
|
||||
MKLROOT ?= /home/intel/oneapi/mkl/latest
|
||||
MKL_LIBDIR ?= $(MKLROOT)/lib/intel64
|
||||
MKL_INC ?= -I$(MKLROOT)/include
|
||||
|
||||
NVHPC_ROOT ?= /home/nvidia/hpc_sdk/Linux_x86_64/25.11
|
||||
CUDA_HOME ?= $(NVHPC_ROOT)/cuda
|
||||
CUDA_ARCH ?= sm_80
|
||||
|
||||
## Kernel implementation switch
|
||||
## 1 (default) : use C++ rewrite of bssn_rhs and helper kernels (faster)
|
||||
## 0 : fall back to original Fortran kernels
|
||||
@@ -40,52 +53,36 @@ USE_CXX_KERNELS ?= 1
|
||||
## 0 : use original Fortran Z4c_rhs.o
|
||||
USE_CXX_Z4C_KERNELS ?= 1
|
||||
|
||||
## BSSN-EScalar RHS switch
|
||||
## 1 (default) : use BSSN-EScalar C wrapper on the normal patch path
|
||||
## 0 : keep the original Fortran BSSN-EScalar RHS for precision-safe runs
|
||||
## Note: this requires USE_CXX_KERNELS=1 because the wrapper reuses the C BSSN kernel.
|
||||
USE_CXX_ESCALAR_KERNEL ?= 1
|
||||
|
||||
## BSSN-EM RHS switch
|
||||
## 1 : use BSSN-EM C kernel (bssn_em_rhs_c.C) on the normal patch path
|
||||
## 0 : keep the original Fortran empart.f90 RHS for the EM fields (default)
|
||||
## Note: experimental, requires USE_CXX_KERNELS=1
|
||||
USE_CXX_EM_KERNEL ?= 0
|
||||
|
||||
## Cached transfer switch
|
||||
## auto (default): enable for BSSN vacuum, keep other paths on the safe uncached path
|
||||
## 1 : force cached Sync/Restrict/OutBd transfer on evolution hot paths
|
||||
## 0 : force the original uncached transfer path
|
||||
USE_TRANSFER_CACHE ?= auto
|
||||
|
||||
## RK4 kernel implementation switch
|
||||
## 1 (default) : use C/C++ rewrite of rungekutta4_rout (for optimization experiments)
|
||||
## 0 : use original Fortran rungekutta4_rout.o
|
||||
USE_CXX_RK4 ?= 1
|
||||
|
||||
## Memory allocator switch
|
||||
## 1 (default) : link Intel oneTBB allocator (libtbbmalloc)
|
||||
## 0 : use system default allocator (ptmalloc)
|
||||
USE_TBBMALLOC ?= 1
|
||||
TBBMALLOC_SO ?= /home/intel/oneapi/2025.3/lib/libtbbmalloc.so
|
||||
ifneq ($(wildcard $(TBBMALLOC_SO)),)
|
||||
TBBMALLOC_LIBS = -Wl,--no-as-needed $(TBBMALLOC_SO) -Wl,--as-needed
|
||||
else
|
||||
TBBMALLOC_LIBS = -Wl,--no-as-needed -ltbbmalloc -Wl,--as-needed
|
||||
endif
|
||||
|
||||
ifeq ($(TOOLCHAIN),intel)
|
||||
f90 = ifx
|
||||
f77 = ifx
|
||||
CXX = icpx
|
||||
CC = icx
|
||||
CLINKER = mpiicpx
|
||||
filein = -I/usr/include/ $(MKL_INC) -I$(CUDA_HOME)/include
|
||||
LDLIBS = -L$(MKL_LIBDIR) -Wl,-rpath,$(MKL_LIBDIR) \
|
||||
-lmkl_intel_lp64 -lmkl_sequential -lmkl_core \
|
||||
-lifcore -limf -liomp5 -lpthread -lm -ldl \
|
||||
-L$(CUDA_HOME)/lib64 -Wl,-rpath,$(CUDA_HOME)/lib64 -lcuda -lcudart
|
||||
else ifeq ($(TOOLCHAIN),nvhpc)
|
||||
f90 = mpifort
|
||||
f77 = mpifort
|
||||
CXX = mpicxx
|
||||
CC = mpicc
|
||||
CLINKER = mpicxx
|
||||
|
||||
filein = -I/usr/include/ $(MKL_INC) -I$(CUDA_HOME)/include
|
||||
LDLIBS = -L$(MKL_LIBDIR) -Wl,-rpath,$(MKL_LIBDIR) \
|
||||
-lmkl_intel_lp64 -lmkl_sequential -lmkl_core \
|
||||
-lpthread -lm -ldl \
|
||||
-L$(CUDA_HOME)/lib64 -Wl,-rpath,$(CUDA_HOME)/lib64 -lcuda -lcudart \
|
||||
-fortranlibs
|
||||
endif
|
||||
|
||||
ifeq ($(USE_TBBMALLOC),1)
|
||||
LDLIBS := $(TBBMALLOC_LIBS) $(LDLIBS)
|
||||
endif
|
||||
|
||||
Cu = $(NVHPC_ROOT)/compilers/bin/nvcc
|
||||
CUDA_LIB_PATH = -L$(CUDA_HOME)/lib64 -I$(CUDA_HOME)/include
|
||||
CUDA_APP_FLAGS = -c -g -O3 --ptxas-options=-v -Dfortran3 -Dnewc -arch=$(CUDA_ARCH)
|
||||
Cu = nvcc
|
||||
CUDA_LIB_PATH = -L/usr/lib/cuda/lib64 -I/usr/include -I/usr/lib/cuda/include
|
||||
#CUDA_APP_FLAGS = -c -g -O3 --ptxas-options=-v -arch compute_13 -code compute_13,sm_13 -Dfortran3 -Dnewc
|
||||
CUDA_APP_FLAGS = -c -g -O3 --ptxas-options=-v -Dfortran3 -Dnewc
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
|
||||
#ifdef newc
|
||||
#include <cstdio>
|
||||
using namespace std;
|
||||
#ifdef newc
|
||||
#include <cstdio>
|
||||
#include <sstream>
|
||||
using namespace std;
|
||||
#else
|
||||
#include <stdio.h>
|
||||
#endif
|
||||
@@ -77,16 +78,17 @@ monitor::monitor(const char fname[], int myrank, string head)
|
||||
parameters::str_par.insert(map<string, string>::value_type("output dir", out_dir));
|
||||
}
|
||||
// considering checkpoint run
|
||||
char filename[50];
|
||||
sprintf(filename, "%s/%s", out_dir.c_str(), fname);
|
||||
int i = 1;
|
||||
while ((access(filename, F_OK)) != -1)
|
||||
{
|
||||
sprintf(filename, "%s/%d_%s", out_dir.c_str(), i, fname);
|
||||
i++;
|
||||
}
|
||||
|
||||
outfile.open(filename, ios::trunc);
|
||||
string filename = out_dir + "/" + fname;
|
||||
int i = 1;
|
||||
while ((access(filename.c_str(), F_OK)) != -1)
|
||||
{
|
||||
stringstream ss;
|
||||
ss << out_dir << "/" << i << "_" << fname;
|
||||
filename = ss.str();
|
||||
i++;
|
||||
}
|
||||
|
||||
outfile.open(filename.c_str(), ios::trunc);
|
||||
|
||||
time_t tnow;
|
||||
time(&tnow);
|
||||
@@ -107,16 +109,17 @@ monitor::monitor(const char fname[], int myrank, const int out_rank, string head
|
||||
if (I_Print)
|
||||
{
|
||||
// considering checkpoint run
|
||||
char filename[50];
|
||||
sprintf(filename, "%s/%s", out_dir.c_str(), fname);
|
||||
int i = 1;
|
||||
while ((access(filename, F_OK)) != -1)
|
||||
{
|
||||
sprintf(filename, "%s/%d_%s", out_dir.c_str(), i, fname);
|
||||
i++;
|
||||
}
|
||||
|
||||
outfile.open(filename, ios::trunc);
|
||||
string filename = out_dir + "/" + fname;
|
||||
int i = 1;
|
||||
while ((access(filename.c_str(), F_OK)) != -1)
|
||||
{
|
||||
stringstream ss;
|
||||
ss << out_dir << "/" << i << "_" << fname;
|
||||
filename = ss.str();
|
||||
i++;
|
||||
}
|
||||
|
||||
outfile.open(filename.c_str(), ios::trunc);
|
||||
|
||||
time_t tnow;
|
||||
time(&tnow);
|
||||
|
||||
@@ -46,6 +46,45 @@ static inline size_t idx_fh_F(int iF, int jF, int kF, const int ex[3]) {
|
||||
return (size_t)ii + (size_t)jj * (size_t)nx + (size_t)kk * (size_t)nx * (size_t)ny;
|
||||
}
|
||||
|
||||
/*
|
||||
* fh 对应 Fortran: fh(0:ex1, 0:ex2, 0:ex3)
|
||||
* ord=1 => shift=0
|
||||
* iF/jF/kF 为 Fortran 索引 (0..ex)
|
||||
*/
|
||||
static inline size_t idx_fh_F_ord1(int iF, int jF, int kF, const int ex[3]) {
|
||||
const int nx = ex[0] + 1; // ex1 + ord
|
||||
const int ny = ex[1] + 1;
|
||||
return (size_t)iF + (size_t)jF * (size_t)nx + (size_t)kF * (size_t)nx * (size_t)ny;
|
||||
}
|
||||
|
||||
/*
|
||||
* fh 对应 Fortran: fh(-3:ex1, -3:ex2, -3:ex3)
|
||||
* ord=4 => shift=3
|
||||
*/
|
||||
static inline size_t idx_fh_F_ord4(int iF, int jF, int kF, const int ex[3]) {
|
||||
const int shift = 3;
|
||||
const int nx = ex[0] + 4; // ex1 + ord
|
||||
const int ny = ex[1] + 4;
|
||||
const int ii = iF + shift; // 0..ex1+3
|
||||
const int jj = jF + shift; // 0..ex2+3
|
||||
const int kk = kF + shift; // 0..ex3+3
|
||||
return (size_t)ii + (size_t)jj * (size_t)nx + (size_t)kk * (size_t)nx * (size_t)ny;
|
||||
}
|
||||
|
||||
/*
|
||||
* fh 对应 Fortran: fh(-4:ex1, -4:ex2, -4:ex3)
|
||||
* ord=5 => shift=4
|
||||
*/
|
||||
static inline size_t idx_fh_F_ord5(int iF, int jF, int kF, const int ex[3]) {
|
||||
const int shift = 4;
|
||||
const int nx = ex[0] + 5; // ex1 + ord
|
||||
const int ny = ex[1] + 5;
|
||||
const int ii = iF + shift; // 0..ex1+4
|
||||
const int jj = jF + shift; // 0..ex2+4
|
||||
const int kk = kF + shift; // 0..ex3+4
|
||||
return (size_t)ii + (size_t)jj * (size_t)nx + (size_t)kk * (size_t)nx * (size_t)ny;
|
||||
}
|
||||
|
||||
/*
|
||||
* func: (1..extc1, 1..extc2, 1..extc3) 1-based in Fortran
|
||||
* funcc: (-ord+1..extc1, -ord+1..extc2, -ord+1..extc3) in Fortran
|
||||
@@ -231,7 +270,10 @@ static inline void symmetry_bd(int ord,
|
||||
{
|
||||
if (ord <= 0) return;
|
||||
|
||||
/* Fast paths used by current C kernels: ord=2 (derivs), ord=3 (lopsided/KO). */
|
||||
if (ord == 1) {
|
||||
symmetry_bd_impl(1, 0, extc, func, funcc, SoA);
|
||||
return;
|
||||
}
|
||||
if (ord == 2) {
|
||||
symmetry_bd_impl(2, 1, extc, func, funcc, SoA);
|
||||
return;
|
||||
@@ -240,7 +282,91 @@ static inline void symmetry_bd(int ord,
|
||||
symmetry_bd_impl(3, 2, extc, func, funcc, SoA);
|
||||
return;
|
||||
}
|
||||
if (ord == 4) {
|
||||
symmetry_bd_impl(4, 3, extc, func, funcc, SoA);
|
||||
return;
|
||||
}
|
||||
|
||||
symmetry_bd_impl(ord, ord - 1, extc, func, funcc, SoA);
|
||||
}
|
||||
|
||||
/*
|
||||
* symmetry_stbd — shell-patch (staggered boundary) ghost fill.
|
||||
*
|
||||
* Fortran: funcc(-ord+1:extc1+ord, -ord+1:extc2+ord, extc3)
|
||||
* Only 2 SoA values (x/y). No z symmetry fill.
|
||||
* Ghost on BOTH positive and negative sides of x and y.
|
||||
* Reflection uses i+2 (skips boundary) instead of i+1.
|
||||
* nx = extc1 + 2*ord, ny = extc2 + 2*ord
|
||||
*/
|
||||
static inline void symmetry_stbd(int ord,
|
||||
const int extc[3],
|
||||
const double *func,
|
||||
double *funcc,
|
||||
const double SoA[2])
|
||||
{
|
||||
const int extc1 = extc[0], extc2 = extc[1], extc3 = extc[2];
|
||||
const int nx = extc1 + 2 * ord;
|
||||
const int ny = extc2 + 2 * ord;
|
||||
const int sh = ord - 1;
|
||||
const size_t snx = (size_t)nx;
|
||||
const size_t splane = snx * (size_t)ny;
|
||||
|
||||
/* 1) Copy interior: funcc(1:extc1, 1:extc2, 1:extc3) = func */
|
||||
for (int k0 = 0; k0 < extc3; ++k0) {
|
||||
const double *src = func + (size_t)k0 * (size_t)extc2 * (size_t)extc1;
|
||||
const size_t kbase = (size_t)k0 * splane;
|
||||
for (int j0 = 0; j0 < extc2; ++j0) {
|
||||
double *dst = funcc + kbase + (size_t)(sh + j0 + 1) * snx + (size_t)(sh + 1);
|
||||
const double *s = src + (size_t)j0 * (size_t)extc1;
|
||||
for (int i0 = 0; i0 < extc1; ++i0) dst[i0] = s[i0];
|
||||
}
|
||||
}
|
||||
|
||||
/* 2) x-direction ghost fill */
|
||||
const double s1 = SoA[0];
|
||||
for (int k0 = 0; k0 < extc3; ++k0) {
|
||||
const size_t kbase = (size_t)k0 * splane;
|
||||
for (int j0 = 0; j0 < extc2; ++j0) {
|
||||
const size_t off = kbase + (size_t)(sh + j0 + 1) * snx;
|
||||
/* left side: funcc(-i) = funcc(i+2) * s1 */
|
||||
for (int i = 0; i < ord; ++i) {
|
||||
funcc[off + (size_t)(sh - i)] = funcc[off + (size_t)(sh + i + 2)] * s1;
|
||||
/* right side: funcc(extc1+1+i) = funcc(extc1-1-i) * s1 */
|
||||
funcc[off + (size_t)(sh + extc1 + 1 + i)] = funcc[off + (size_t)(sh + extc1 - 1 - i)] * s1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 3) y-direction ghost fill */
|
||||
const double s2 = SoA[1];
|
||||
for (int i = 0; i < nx; ++i) {
|
||||
for (int k0 = 0; k0 < extc3; ++k0) {
|
||||
const size_t kbase = (size_t)k0 * splane;
|
||||
/* bottom: funcc(:,-i,:) = funcc(:,i+2,:) * s2 */
|
||||
for (int jj = 0; jj < ord; ++jj) {
|
||||
funcc[kbase + (size_t)(sh - jj) * snx + (size_t)i] =
|
||||
funcc[kbase + (size_t)(sh + jj + 2) * snx + (size_t)i] * s2;
|
||||
/* top: funcc(:,extc2+1+jj,:) = funcc(:,extc2-1-jj,:) * s2 */
|
||||
funcc[kbase + (size_t)(sh + extc2 + 1 + jj) * snx + (size_t)i] =
|
||||
funcc[kbase + (size_t)(sh + extc2 - 1 - jj) * snx + (size_t)i] * s2;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Indexing for shell fh buffer: Fortran fh(-ord+1:extc1+ord, -ord+1:extc2+ord, extc3)
|
||||
* C 0-based: ii = iF + ord - 1
|
||||
* nx = extc1 + 2*ord, ny = extc2 + 2*ord
|
||||
*/
|
||||
static inline size_t idx_fh_stbd(int iF, int jF, int kF, int ord, const int extc[3]) {
|
||||
const int sh = ord - 1;
|
||||
const int nx = extc[0] + 2 * ord;
|
||||
const int ny = extc[1] + 2 * ord;
|
||||
const int ii = iF + sh;
|
||||
const int jj = jF + sh;
|
||||
const int kk = kF - 1; // Fortran 1-based kF → C 0-based
|
||||
return (size_t)ii + (size_t)jj * (size_t)nx + (size_t)kk * (size_t)nx * (size_t)ny;
|
||||
}
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -53,14 +53,6 @@ int z4c_cuda_pack_state_batch_to_host_buffer(void *block_tag,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int z4c_cuda_pack_state_batch_to_host_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int z4c_cuda_unpack_state_batch_from_host_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *host_buffer,
|
||||
@@ -68,14 +60,6 @@ int z4c_cuda_unpack_state_batch_from_host_buffer(void *block_tag,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int z4c_cuda_unpack_state_batch_from_host_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *host_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int z4c_cuda_pack_state_batch_to_device_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
@@ -83,14 +67,6 @@ int z4c_cuda_pack_state_batch_to_device_buffer(void *block_tag,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int z4c_cuda_pack_state_batch_to_device_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int z4c_cuda_unpack_state_batch_from_device_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
@@ -98,78 +74,6 @@ int z4c_cuda_unpack_state_batch_from_device_buffer(void *block_tag,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int z4c_cuda_unpack_state_batch_from_device_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int i0, int j0, int k0,
|
||||
int sx, int sy, int sz);
|
||||
|
||||
int z4c_cuda_pack_state_segments_to_device_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int segment_count,
|
||||
const int *segment_meta);
|
||||
|
||||
int z4c_cuda_pack_state_segments_to_device_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int segment_count,
|
||||
const int *segment_meta);
|
||||
|
||||
int z4c_cuda_unpack_state_segments_from_device_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int segment_count,
|
||||
const int *segment_meta);
|
||||
|
||||
int z4c_cuda_unpack_state_segments_from_device_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int segment_count,
|
||||
const int *segment_meta);
|
||||
|
||||
int z4c_cuda_restrict_state_segments_to_device_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int segment_count,
|
||||
const int *segment_meta,
|
||||
const double *state_soa);
|
||||
|
||||
int z4c_cuda_restrict_state_segments_to_device_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int segment_count,
|
||||
const int *segment_meta,
|
||||
const double *state_soa);
|
||||
|
||||
int z4c_cuda_prolong_state_segments_to_device_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int segment_count,
|
||||
const int *segment_meta,
|
||||
const double *state_soa);
|
||||
|
||||
int z4c_cuda_prolong_state_segments_to_device_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int segment_count,
|
||||
const int *segment_meta,
|
||||
const double *state_soa);
|
||||
|
||||
int z4c_cuda_restrict_state_batch_to_device_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
@@ -178,15 +82,6 @@ int z4c_cuda_restrict_state_batch_to_device_buffer(void *block_tag,
|
||||
int fi0, int fj0, int fk0,
|
||||
const double *state_soa);
|
||||
|
||||
int z4c_cuda_restrict_state_batch_to_device_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int fi0, int fj0, int fk0,
|
||||
const double *state_soa);
|
||||
|
||||
int z4c_cuda_prolong_state_batch_to_device_buffer(void *block_tag,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
@@ -196,16 +91,6 @@ int z4c_cuda_prolong_state_batch_to_device_buffer(void *block_tag,
|
||||
int lbc_i, int lbc_j, int lbc_k,
|
||||
const double *state_soa);
|
||||
|
||||
int z4c_cuda_prolong_state_batch_to_device_buffer_for_host_views(void *block_tag,
|
||||
double **state_host_key,
|
||||
int state_count,
|
||||
double *device_buffer,
|
||||
int *ex,
|
||||
int sx, int sy, int sz,
|
||||
int ii0, int jj0, int kk0,
|
||||
int lbc_i, int lbc_j, int lbc_k,
|
||||
const double *state_soa);
|
||||
|
||||
int z4c_cuda_download_state_subset(void *block_tag,
|
||||
int *ex,
|
||||
int subset_count,
|
||||
@@ -218,36 +103,7 @@ int z4c_cuda_upload_state_subset(void *block_tag,
|
||||
const int *state_indices,
|
||||
double **state_host_in);
|
||||
|
||||
int z4c_cuda_compute_constraints_resident(void *block_tag,
|
||||
int *ex, double *X, double *Y, double *Z,
|
||||
int Symmetry, double eps, int co,
|
||||
double **constraint_host_out);
|
||||
|
||||
int z4c_cuda_interp_state_point3(void *block_tag,
|
||||
int *ex,
|
||||
int state0,
|
||||
int state1,
|
||||
int state2,
|
||||
double x0,
|
||||
double y0,
|
||||
double z0,
|
||||
double dx,
|
||||
double dy,
|
||||
double dz,
|
||||
double px,
|
||||
double py,
|
||||
double pz,
|
||||
int ordn,
|
||||
int symmetry,
|
||||
const double *soa3,
|
||||
double *out3);
|
||||
|
||||
int z4c_cuda_download_constraint_outputs(int *ex,
|
||||
double **constraint_host_out);
|
||||
|
||||
int z4c_cuda_has_resident_state(void *block_tag);
|
||||
int z4c_cuda_resident_state_matches(void *block_tag,
|
||||
double **state_host_key);
|
||||
|
||||
void z4c_cuda_release_step_ctx(void *block_tag);
|
||||
|
||||
|
||||
@@ -138,25 +138,58 @@ def _stop_cuda_mps(runtime_env):
|
||||
|
||||
def _gpu_runtime_env():
|
||||
runtime_env = os.environ.copy()
|
||||
finite_difference = str(getattr(input_data, "Finite_Diffenence_Method", "4th-order")).strip()
|
||||
|
||||
defaults = {
|
||||
"AMSS_EVOLVE_TIMING": "1",
|
||||
"AMSS_ESCALAR_STEP_TIMING": "0",
|
||||
"AMSS_INTERP_FAST": "1",
|
||||
"AMSS_INTERP_GPU": "1",
|
||||
"AMSS_ANALYSIS_MAP_EVERY": "1000000",
|
||||
"AMSS_CUDA_AWARE_MPI": "1",
|
||||
"AMSS_CUDA_KEEP_RESIDENT_AFTER_STEP": "1",
|
||||
"AMSS_CUDA_Z4C_KEEP_RESIDENT_AFTER_STEP": "1",
|
||||
"AMSS_CUDA_KEEP_ALL_LEVELS": "1",
|
||||
"AMSS_CUDA_Z4C_AMR_DEVICE": "0",
|
||||
"AMSS_CUDA_AMR_RESTRICT_DEVICE": "1",
|
||||
"AMSS_CUDA_ESCALAR_KEEP_RESIDENT_AFTER_STEP": "1",
|
||||
"AMSS_CUDA_ESCALAR_KEEP_ALL_LEVELS": "1",
|
||||
"AMSS_CUDA_EM_CACHE_SOURCES": "1",
|
||||
"AMSS_CUDA_EM_ZERO_FASTPATH": "1",
|
||||
"AMSS_EM_ZERO_ANALYSIS_FASTPATH": "1",
|
||||
"AMSS_EM_ZERO_RESIDENT_DOWNLOAD_FASTPATH": "1",
|
||||
"AMSS_CUDA_AMR_HOST_STAGED": "1",
|
||||
"AMSS_CUDA_AMR_RESTRICT_DEVICE": "0",
|
||||
"AMSS_CUDA_AMR_RESTRICT_BATCH": "0",
|
||||
"AMSS_CUDA_DEVICE_SEGMENT_BATCH": "0",
|
||||
"AMSS_CUDA_PIN_ESCALAR_TRANSFERS": "0",
|
||||
"AMSS_ESCALAR_GPU_RK": "0",
|
||||
"AMSS_CUDA_UNCACHED_DEVICE_BUFFERS": "1",
|
||||
"AMSS_SHELL_FAST_INTERP": "0",
|
||||
"AMSS_SHELL_PARALLEL_INTERP": "0",
|
||||
"AMSS_SHELL_CUDA_INTERP": "0",
|
||||
}
|
||||
if finite_difference in ("2nd-order", "8th-order"):
|
||||
defaults.update({
|
||||
"AMSS_INTERP_FAST": "0",
|
||||
"AMSS_INTERP_GPU": "0",
|
||||
"AMSS_CUDA_AWARE_MPI": "0",
|
||||
})
|
||||
if finite_difference == "8th-order" and getattr(input_data, "Equation_Class", "") == "BSSN-EM":
|
||||
defaults.update({
|
||||
"AMSS_CUDA_AMR_RESTRICT_DEVICE": "1",
|
||||
"AMSS_CUDA_AMR_RESTRICT_BATCH": "1",
|
||||
"AMSS_CUDA_DEVICE_SEGMENT_BATCH": "1",
|
||||
})
|
||||
if getattr(input_data, "basic_grid_set", "") == "Shell-Patch":
|
||||
defaults.update({
|
||||
"AMSS_CUDA_AWARE_MPI": "0",
|
||||
"AMSS_SHELL_FAST_INTERP": "1",
|
||||
"AMSS_SHELL_PARALLEL_INTERP": "1",
|
||||
"AMSS_SHELL_INTERP_THREADS": "16",
|
||||
})
|
||||
if getattr(input_data, "Equation_Class", "") in ("BSSN", "BSSN-EScalar", "Z4C"):
|
||||
defaults["AMSS_CUDA_AMR_RESTRICT_DEVICE"] = "1"
|
||||
if getattr(input_data, "Equation_Class", "") == "Z4C":
|
||||
defaults["AMSS_CUDA_Z4C_KEEP_RESIDENT_AFTER_STEP"] = "0"
|
||||
defaults["AMSS_CUDA_KEEP_ALL_LEVELS"] = "0"
|
||||
defaults.update({
|
||||
"AMSS_Z4C_CUDA_RESIDENT": "1",
|
||||
"AMSS_CONSTRAINT_OUT_EVERY": "1000000",
|
||||
})
|
||||
for key, value in defaults.items():
|
||||
runtime_env.setdefault(key, value)
|
||||
|
||||
@@ -268,29 +301,58 @@ def run_ABE():
|
||||
mpi_env = None
|
||||
started_mps = False
|
||||
|
||||
mpi_processes = int(input_data.MPI_processes)
|
||||
if (input_data.GPU_Calculation == "yes" and
|
||||
getattr(input_data, "Equation_Class", "") == "Z4C"):
|
||||
z4c_env_np = os.environ.get("AMSS_Z4C_GPU_MPI_PROCESSES")
|
||||
if z4c_env_np and int(z4c_env_np) > 0:
|
||||
mpi_processes = int(z4c_env_np)
|
||||
elif mpi_processes < 4:
|
||||
mpi_processes = 4
|
||||
if (input_data.GPU_Calculation == "yes" and
|
||||
getattr(input_data, "basic_grid_set", "") == "Shell-Patch"):
|
||||
shell_env_np = os.environ.get("AMSS_SHELL_GPU_MPI_PROCESSES")
|
||||
if shell_env_np and int(shell_env_np) > 0:
|
||||
mpi_processes = int(shell_env_np)
|
||||
elif mpi_processes < 4:
|
||||
mpi_processes = 4
|
||||
|
||||
if (input_data.GPU_Calculation == "no"):
|
||||
mpi_command = NUMACTL_CPU_BIND + " mpirun -np " + str(input_data.MPI_processes) + " ./ABE"
|
||||
mpi_command = NUMACTL_CPU_BIND + " mpirun -np " + str(mpi_processes) + " ./ABE"
|
||||
#mpi_command = " mpirun -np " + str(input_data.MPI_processes) + " ./ABE"
|
||||
mpi_command_outfile = "ABE_out.log"
|
||||
elif (input_data.GPU_Calculation == "yes"):
|
||||
mpi_command = NUMACTL_CPU_BIND + " mpirun -np " + str(input_data.MPI_processes) + " ./ABE_CUDA"
|
||||
mpi_command = NUMACTL_CPU_BIND + " I_MPI_OFFLOAD=1 I_MPI_OFFLOAD_IPC=0 mpirun -np " + str(mpi_processes) + " ./ABE_CUDA"
|
||||
mpi_command_outfile = "ABEGPU_out.log"
|
||||
mpi_env = _gpu_runtime_env()
|
||||
started_mps = _start_cuda_mps_if_requested(mpi_env)
|
||||
print(" GPU optimized runtime switches:")
|
||||
print(f" MPI processes={mpi_processes}")
|
||||
print(f" AMSS_INTERP_FAST={mpi_env.get('AMSS_INTERP_FAST', '')}")
|
||||
print(f" AMSS_INTERP_GPU={mpi_env.get('AMSS_INTERP_GPU', '')}")
|
||||
print(f" AMSS_ANALYSIS_MAP_EVERY={mpi_env.get('AMSS_ANALYSIS_MAP_EVERY', '')}")
|
||||
print(f" AMSS_EVOLVE_TIMING={mpi_env.get('AMSS_EVOLVE_TIMING', '')}")
|
||||
print(f" AMSS_ESCALAR_STEP_TIMING={mpi_env.get('AMSS_ESCALAR_STEP_TIMING', '')}")
|
||||
print(f" AMSS_CUDA_AWARE_MPI={mpi_env.get('AMSS_CUDA_AWARE_MPI', '')}")
|
||||
print(f" AMSS_CUDA_KEEP_RESIDENT_AFTER_STEP={mpi_env.get('AMSS_CUDA_KEEP_RESIDENT_AFTER_STEP', '')}")
|
||||
print(f" AMSS_CUDA_Z4C_KEEP_RESIDENT_AFTER_STEP={mpi_env.get('AMSS_CUDA_Z4C_KEEP_RESIDENT_AFTER_STEP', '')}")
|
||||
print(f" AMSS_CUDA_KEEP_ALL_LEVELS={mpi_env.get('AMSS_CUDA_KEEP_ALL_LEVELS', '')}")
|
||||
print(f" AMSS_CUDA_Z4C_AMR_DEVICE={mpi_env.get('AMSS_CUDA_Z4C_AMR_DEVICE', '')}")
|
||||
print(f" AMSS_CUDA_ESCALAR_KEEP_RESIDENT_AFTER_STEP={mpi_env.get('AMSS_CUDA_ESCALAR_KEEP_RESIDENT_AFTER_STEP', '')}")
|
||||
print(f" AMSS_CUDA_ESCALAR_KEEP_ALL_LEVELS={mpi_env.get('AMSS_CUDA_ESCALAR_KEEP_ALL_LEVELS', '')}")
|
||||
print(f" AMSS_CUDA_EM_CACHE_SOURCES={mpi_env.get('AMSS_CUDA_EM_CACHE_SOURCES', '')}")
|
||||
print(f" AMSS_CUDA_EM_ZERO_FASTPATH={mpi_env.get('AMSS_CUDA_EM_ZERO_FASTPATH', '')}")
|
||||
print(f" AMSS_EM_ZERO_ANALYSIS_FASTPATH={mpi_env.get('AMSS_EM_ZERO_ANALYSIS_FASTPATH', '')}")
|
||||
print(f" AMSS_EM_ZERO_RESIDENT_DOWNLOAD_FASTPATH={mpi_env.get('AMSS_EM_ZERO_RESIDENT_DOWNLOAD_FASTPATH', '')}")
|
||||
print(f" AMSS_CUDA_AMR_HOST_STAGED={mpi_env.get('AMSS_CUDA_AMR_HOST_STAGED', '')}")
|
||||
print(f" AMSS_CUDA_AMR_RESTRICT_DEVICE={mpi_env.get('AMSS_CUDA_AMR_RESTRICT_DEVICE', '')}")
|
||||
print(f" AMSS_CUDA_AMR_RESTRICT_BATCH={mpi_env.get('AMSS_CUDA_AMR_RESTRICT_BATCH', '')}")
|
||||
print(f" AMSS_CUDA_DEVICE_SEGMENT_BATCH={mpi_env.get('AMSS_CUDA_DEVICE_SEGMENT_BATCH', '')}")
|
||||
print(f" AMSS_CUDA_PIN_ESCALAR_TRANSFERS={mpi_env.get('AMSS_CUDA_PIN_ESCALAR_TRANSFERS', '')}")
|
||||
print(f" AMSS_ESCALAR_GPU_RK={mpi_env.get('AMSS_ESCALAR_GPU_RK', '')}")
|
||||
print(f" AMSS_CUDA_UNCACHED_DEVICE_BUFFERS={mpi_env.get('AMSS_CUDA_UNCACHED_DEVICE_BUFFERS', '')}")
|
||||
print(f" AMSS_SHELL_FAST_INTERP={mpi_env.get('AMSS_SHELL_FAST_INTERP', '')}")
|
||||
print(f" AMSS_SHELL_PARALLEL_INTERP={mpi_env.get('AMSS_SHELL_PARALLEL_INTERP', '')}")
|
||||
print(f" AMSS_SHELL_CUDA_INTERP={mpi_env.get('AMSS_SHELL_CUDA_INTERP', '')}")
|
||||
print(f" AMSS_SHELL_INTERP_THREADS={mpi_env.get('AMSS_SHELL_INTERP_THREADS', '')}")
|
||||
print(f" AMSS_Z4C_CUDA_RESIDENT={mpi_env.get('AMSS_Z4C_CUDA_RESIDENT', '')}")
|
||||
print(f" AMSS_CONSTRAINT_OUT_EVERY={mpi_env.get('AMSS_CONSTRAINT_OUT_EVERY', '')}")
|
||||
if "CUDA_MPS_PIPE_DIRECTORY" in mpi_env:
|
||||
print(f" CUDA_MPS_PIPE_DIRECTORY={mpi_env['CUDA_MPS_PIPE_DIRECTORY']}")
|
||||
|
||||
|
||||
@@ -808,10 +808,10 @@ def generate_ADMmass_plot( outdir, figure_outdir, detector_number_i ):
|
||||
|
||||
## Plot constraint violation for each grid level
|
||||
|
||||
def generate_constraint_check_plot( outdir, figure_outdir, input_level_number ):
|
||||
|
||||
# path to data file
|
||||
file0 = os.path.join(outdir, "bssn_constraint.dat")
|
||||
def generate_constraint_check_plot( outdir, figure_outdir, input_level_number ):
|
||||
|
||||
# path to data file
|
||||
file0 = os.path.join(outdir, "bssn_constraint.dat")
|
||||
|
||||
if ( input_level_number == 0 ):
|
||||
print( )
|
||||
@@ -819,13 +819,26 @@ def generate_constraint_check_plot( outdir, figure_outdir, input_level_number ):
|
||||
print( )
|
||||
print( " corresponding data file = ", file0 )
|
||||
print( )
|
||||
|
||||
print( " Begin the constraint violation plot for grid level number = ", input_level_number )
|
||||
|
||||
# load the full data file (assumed whitespace-separated floats)
|
||||
data = numpy.loadtxt(file0)
|
||||
|
||||
# extract columns from the constraint data file
|
||||
|
||||
print( " Begin the constraint violation plot for grid level number = ", input_level_number )
|
||||
|
||||
if (not os.path.exists(file0)) or os.path.getsize(file0) == 0:
|
||||
if ( input_level_number == 0 ):
|
||||
print( " Constraint data file is empty; skip constraint violation plots" )
|
||||
print( )
|
||||
return
|
||||
|
||||
# load the full data file (assumed whitespace-separated floats)
|
||||
data = numpy.loadtxt(file0)
|
||||
data = numpy.atleast_2d(data)
|
||||
|
||||
if data.shape[1] < 8:
|
||||
if ( input_level_number == 0 ):
|
||||
print( " Constraint data file has insufficient columns; skip constraint violation plots" )
|
||||
print( )
|
||||
return
|
||||
|
||||
# extract columns from the constraint data file
|
||||
time = data[:,0]
|
||||
Constraint_H = data[:,1]
|
||||
Constraint_Px = data[:,2]
|
||||
|
||||
Reference in New Issue
Block a user