Migrate build system from Intel oneAPI to AMD AOCC/AOCL/OpenMPI

Replace Intel compilers (ifx/icpx/icx) with AOCC (flang/clang++/clang), Intel MPI (mpiicpx) with AOCC-built OpenMPI (mpicxx), and Intel MKL with AOCL BLIS/libFLAME. Replace -xHost with -march=znver4, -ipo with -flto, -fp-model fast=2 with -ffast-math, -qopenmp with -fopenmp. Remove PGO, TBB allocator, and Intel-specific runtime libraries. Fix MKL-specific includes in TwoPunctures.C and gaussj.C to use standard CBLAS/LAPACKE headers from AOCL. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
Fix BSSN build config selection
2026-04-28 02:19:00 +08:00 · 2026-04-27 18:42:34 +08:00 · 2026-04-27 15:32:27 +08:00 · 2026-04-27 14:50:59 +08:00 · 2026-04-25 02:02:01 +08:00 · 2026-04-25 01:41:55 +08:00
26 changed files with 4500 additions and 1891 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,6 @@
 __pycache__
 GW150914
-GW150914-origin
+GW150914*
 docs
 *.tmp
-
+.codex
--- a/AMSS_NCKU_Program.py
+++ b/AMSS_NCKU_Program.py
@@ -177,6 +177,9 @@ print( " AMSS-NCKU macro file macrodef.h has been generated. " )
 generate_macrodef.generate_macrodef_fh()
 print( " AMSS-NCKU macro file macrodef.fh has been generated. " )

+generate_macrodef.generate_build_config()
+print( " AMSS-NCKU build config AMSS_NCKU_build.mk has been generated. " )
+

 ##################################################################

@@ -219,9 +222,11 @@ shutil.copytree(AMSS_NCKU_source_path, AMSS_NCKU_source_copy)

 macrodef_h_path  = os.path.join(File_directory, "macrodef.h")
 macrodef_fh_path = os.path.join(File_directory, "macrodef.fh")
+build_config_path = os.path.join(File_directory, "AMSS_NCKU_build.mk")

 shutil.copy2(macrodef_h_path,  AMSS_NCKU_source_copy)
 shutil.copy2(macrodef_fh_path, AMSS_NCKU_source_copy)
+shutil.copy2(build_config_path, AMSS_NCKU_source_copy)

 # Notes on copying files:
 # shutil.copy2 preserves file metadata such as modification time.
--- a/AMSS_NCKU_Verify_ASC26.py
+++ b/AMSS_NCKU_Verify_ASC26.py
@@ -9,6 +9,11 @@ Verification Requirements:
   - Y Component RMS
   - Z Component RMS
 2. ADM constraint violation < 2 (Grid Level 0)
+3. The following figure PDFs must match GW150914-origin exactly after rasterization:
+   - ADM_Constraint_Grid_Level_0.pdf
+   - BH_Trajectory_21_XY.pdf
+   - BH_Trajectory_XY.pdf
+   The script also reports the percentage of differing pixels for each figure.

 RMS Calculation Method:
 - Computes trajectory deviation on the XY plane independently for BH1 and BH2
@@ -23,6 +28,10 @@ Reference: GW150914-origin (baseline simulation)
 import numpy as np
 import sys
 import os
+import shutil
+import subprocess
+import tempfile
+from PIL import Image

 # ANSI Color Codes
 class Color:
@@ -61,6 +70,132 @@ def load_constraint_data(filepath):
                data.append([float(x) for x in parts[:8]])
    return np.array(data)

+
+def resolve_figure_dir(path):
+    """Resolve the sibling figure directory from an output or figure path."""
+    normalized = os.path.normpath(path)
+    if os.path.basename(normalized) == "figure":
+        return normalized
+    return os.path.join(os.path.dirname(normalized), "figure")
+
+
+def render_pdf_to_images(pdf_path, dpi=150):
+    """Render a PDF to RGB images using Ghostscript."""
+    gs_path = shutil.which("gs")
+    if gs_path is None:
+        raise RuntimeError("Ghostscript executable 'gs' was not found in PATH")
+
+    with tempfile.TemporaryDirectory(prefix="amss_verify_pdf_") as temp_dir:
+        output_pattern = os.path.join(temp_dir, "page-%03d.ppm")
+        cmd = [
+            gs_path,
+            "-q",
+            "-dSAFER",
+            "-dBATCH",
+            "-dNOPAUSE",
+            "-sDEVICE=ppmraw",
+            f"-r{dpi}",
+            f"-o{output_pattern}",
+            pdf_path
+        ]
+
+        try:
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True)
+        except subprocess.CalledProcessError as exc:
+            message = exc.stderr.strip() or str(exc)
+            raise RuntimeError(f"Failed to render PDF '{pdf_path}': {message}") from exc
+
+        ppm_files = sorted(
+            os.path.join(temp_dir, filename)
+            for filename in os.listdir(temp_dir)
+            if filename.endswith(".ppm")
+        )
+
+        if not ppm_files:
+            raise RuntimeError(f"No rendered pages were produced for '{pdf_path}'")
+
+        images = []
+        for ppm_file in ppm_files:
+            with Image.open(ppm_file) as img:
+                images.append(np.array(img.convert("RGB"), dtype=np.uint8))
+
+        return images
+
+
+def compare_rendered_pages(ref_img, target_img):
+    """Return (different_pixels, total_pixels) for two rendered RGB pages."""
+    ref_h, ref_w = ref_img.shape[:2]
+    tgt_h, tgt_w = target_img.shape[:2]
+    total_pixels = max(ref_h, tgt_h) * max(ref_w, tgt_w)
+
+    if ref_h == tgt_h and ref_w == tgt_w:
+        different_pixels = int(np.count_nonzero(np.any(ref_img != target_img, axis=2)))
+        return different_pixels, total_pixels
+
+    diff_mask = np.ones((max(ref_h, tgt_h), max(ref_w, tgt_w)), dtype=bool)
+    overlap_h = min(ref_h, tgt_h)
+    overlap_w = min(ref_w, tgt_w)
+    overlap_diff = np.any(ref_img[:overlap_h, :overlap_w] != target_img[:overlap_h, :overlap_w], axis=2)
+    diff_mask[:overlap_h, :overlap_w] = overlap_diff
+    different_pixels = int(np.count_nonzero(diff_mask))
+    return different_pixels, total_pixels
+
+
+def compare_pdf_images(ref_pdf, target_pdf, dpi=150, threshold_percent=0.001):
+    """Compare two PDFs by rasterizing them and counting differing pixels."""
+    ref_pages = render_pdf_to_images(ref_pdf, dpi=dpi)
+    target_pages = render_pdf_to_images(target_pdf, dpi=dpi)
+
+    total_pixels = 0
+    different_pixels = 0
+    max_pages = max(len(ref_pages), len(target_pages))
+
+    for page_idx in range(max_pages):
+        if page_idx < len(ref_pages) and page_idx < len(target_pages):
+            page_diff, page_total = compare_rendered_pages(ref_pages[page_idx], target_pages[page_idx])
+        else:
+            existing_page = ref_pages[page_idx] if page_idx < len(ref_pages) else target_pages[page_idx]
+            page_total = existing_page.shape[0] * existing_page.shape[1]
+            page_diff = page_total
+
+        total_pixels += page_total
+        different_pixels += page_diff
+
+    diff_percent = (different_pixels / total_pixels * 100.0) if total_pixels else 0.0
+    return {
+        "different_pixels": different_pixels,
+        "total_pixels": total_pixels,
+        "diff_percent": diff_percent,
+        "pages_ref": len(ref_pages),
+        "pages_target": len(target_pages),
+        "passed": diff_percent < threshold_percent
+    }
+
+
+def compare_required_figures(reference_figure_dir, target_figure_dir):
+    """Compare the required GW150914 figure PDFs."""
+    figure_names = [
+        "ADM_Constraint_Grid_Level_0.pdf",
+        "BH_Trajectory_21_XY.pdf",
+        "BH_Trajectory_XY.pdf"
+    ]
+
+    results = []
+    for figure_name in figure_names:
+        ref_pdf = os.path.join(reference_figure_dir, figure_name)
+        target_pdf = os.path.join(target_figure_dir, figure_name)
+
+        if not os.path.exists(ref_pdf):
+            raise FileNotFoundError(f"Reference figure not found: {ref_pdf}")
+        if not os.path.exists(target_pdf):
+            raise FileNotFoundError(f"Target figure not found: {target_pdf}")
+
+        comparison = compare_pdf_images(ref_pdf, target_pdf)
+        comparison["name"] = figure_name
+        results.append(comparison)
+
+    return results
+
 def calculate_all_rms_errors(bh_data_ref, bh_data_target):
    """
    Calculate 3D Vector RMS and component-wise RMS (X, Y, Z) independently.
@@ -184,18 +319,45 @@ def print_constraint_results(results, threshold=2.0):
    return passed


-def print_summary(rms_passed, constraint_passed):
+def print_figure_results(results, threshold_percent=0.001):
+    print(f"\n{Color.BOLD}3. Figure Pixel Comparison (PDF Rasterization){Color.RESET}")
+    print("-" * 65)
+    print(f"   Requirement: < {threshold_percent:.3f}% differing pixels\n")
+
+    all_passed = True
+    for result in results:
+        passed = result["passed"]
+        all_passed = all_passed and passed
+        status = get_status_text(passed)
+        print(f"   {result['name']:32}: {result['diff_percent']:10.6f}%   |   Status: {status}")
+
+        if result["pages_ref"] != result["pages_target"]:
+            print(f"   {'':32}  pages(ref/target): {result['pages_ref']}/{result['pages_target']}")
+
+    return all_passed
+
+
+def print_figure_error(error_message):
+    print(f"\n{Color.BOLD}3. Figure Pixel Comparison (PDF Rasterization){Color.RESET}")
+    print("-" * 65)
+    print(f"   {Color.RED}Error: {error_message}{Color.RESET}")
+    return False
+
+
+def print_summary(rms_passed, constraint_passed, figure_passed):
    print("\n" + Color.BLUE + Color.BOLD + "=" * 65 + Color.RESET)
    print(Color.BOLD + "Verification Summary" + Color.RESET)
    print(Color.BLUE + Color.BOLD + "=" * 65 + Color.RESET)

-    all_passed = rms_passed and constraint_passed
+    all_passed = rms_passed and constraint_passed and figure_passed
    
    res_rms = get_status_text(rms_passed)
    res_con = get_status_text(constraint_passed)
+    res_fig = get_status_text(figure_passed)

    print(f"   [1] Comprehensive RMS check:      {res_rms}")
    print(f"   [2] ADM constraint check:         {res_con}")
+    print(f"   [3] Figure pixel comparison:      {res_fig}")
    
    final_status = f"{Color.GREEN}{Color.BOLD}ALL CHECKS PASSED{Color.RESET}" if all_passed else f"{Color.RED}{Color.BOLD}SOME CHECKS FAILED{Color.RESET}"
    print(f"\n   Overall result: {final_status}")
@@ -212,6 +374,8 @@ def main():

    script_dir = os.path.dirname(os.path.abspath(__file__))
    reference_dir = os.path.join(script_dir, "GW150914-origin/AMSS_NCKU_output")
+    target_figure_dir = resolve_figure_dir(target_dir)
+    reference_figure_dir = os.path.join(script_dir, "GW150914-origin/figure")

    bh_file_ref = os.path.join(reference_dir, "bssn_BH.dat")
    bh_file_target = os.path.join(target_dir, "bssn_BH.dat")
@@ -230,6 +394,8 @@ def main():
    print_header()
    print(f"\n{Color.BOLD}Reference (Baseline):{Color.RESET} {Color.BLUE}{reference_dir}{Color.RESET}")
    print(f"{Color.BOLD}Target (Optimized):  {Color.RESET} {Color.BLUE}{target_dir}{Color.RESET}")
+    print(f"{Color.BOLD}Reference Figures:   {Color.RESET} {Color.BLUE}{reference_figure_dir}{Color.RESET}")
+    print(f"{Color.BOLD}Target Figures:      {Color.RESET} {Color.BLUE}{target_figure_dir}{Color.RESET}")

    bh_data_ref = load_bh_trajectory(bh_file_ref)
    bh_data_target = load_bh_trajectory(bh_file_target)
@@ -243,7 +409,13 @@ def main():
    constraint_results = analyze_constraint_violation(constraint_data)
    constraint_passed = print_constraint_results(constraint_results)

-    all_passed = print_summary(rms_passed, constraint_passed)
+    try:
+        figure_results = compare_required_figures(reference_figure_dir, target_figure_dir)
+        figure_passed = print_figure_results(figure_results)
+    except (FileNotFoundError, RuntimeError) as exc:
+        figure_passed = print_figure_error(str(exc))
+
+    all_passed = print_summary(rms_passed, constraint_passed, figure_passed)
    sys.exit(0 if all_passed else 1)

 if __name__ == "__main__":
--- a/AMSS_NCKU_source/Parallel.C
+++ b/AMSS_NCKU_source/Parallel.C
@@ -5,6 +5,42 @@
 #include "misc.h"
 #include "parameters.h"

+namespace
+{
+enum { MAX_DATA_PACKER_VARS = 64 };
+
+int expand_var_list_pack_info(MyList<var> *src_list, MyList<var> *dst_list,
+                              int *src_sgfn, int *dst_sgfn, double **src_soa)
+{
+  int count = 0;
+  MyList<var> *src_it = src_list;
+  MyList<var> *dst_it = dst_list;
+
+  while (src_it && dst_it)
+  {
+    if (count >= MAX_DATA_PACKER_VARS)
+    {
+      cout << "Parallel::data_packer: too many variables in communication list." << endl;
+      MPI_Abort(MPI_COMM_WORLD, 1);
+    }
+    src_sgfn[count] = src_it->data->sgfn;
+    dst_sgfn[count] = dst_it->data->sgfn;
+    src_soa[count] = src_it->data->SoA;
+    count++;
+    src_it = src_it->next;
+    dst_it = dst_it->next;
+  }
+
+  if (src_it || dst_it)
+  {
+    cout << "error in short data packer, var lists does not match." << endl;
+    MPI_Abort(MPI_COMM_WORLD, 1);
+  }
+
+  return count;
+}
+}
+
 int Parallel::partition1(int &nx, int split_size, int min_width, int cpusize, int shape) // special for 1 diemnsion
 {
  nx = Mymax(1, shape / min_width);
@@ -3730,21 +3766,10 @@ int Parallel::data_packer(double *data, MyList<Parallel::gridseg> *src, MyList<P
  if (!src || !dst)
    return size_out;

-  MyList<var> *varls, *varld;
-
-  varls = VarLists;
-  varld = VarListd;
-  while (varls && varld)
-  {
-    varls = varls->next;
-    varld = varld->next;
-  }
-
-  if (varls || varld)
-  {
-    cout << "error in short data packer, var lists does not match." << endl;
-    MPI_Abort(MPI_COMM_WORLD, 1);
-  }
+  int src_sgfn[MAX_DATA_PACKER_VARS];
+  int dst_sgfn[MAX_DATA_PACKER_VARS];
+  double *src_soa[MAX_DATA_PACKER_VARS];
+  const int var_count = expand_var_list_pack_info(VarLists, VarListd, src_sgfn, dst_sgfn, src_soa);

  int type; /* 1 copy, 2 restrict, 3 prolong */
  if (src->data->Bg->lev == dst->data->Bg->lev)
@@ -3756,44 +3781,58 @@ int Parallel::data_packer(double *data, MyList<Parallel::gridseg> *src, MyList<P

  while (src && dst)
  {
-    if ((dir == PACK && dst->data->Bg->rank == rank_in && src->data->Bg->rank == myrank) ||
-        (dir == UNPACK && src->data->Bg->rank == rank_in && dst->data->Bg->rank == myrank))
-    {
-      varls = VarLists;
-      varld = VarListd;
-      while (varls && varld)
+    const bool rank_match =
+        (dir == PACK && dst->data->Bg->rank == rank_in && src->data->Bg->rank == myrank) ||
+        (dir == UNPACK && src->data->Bg->rank == rank_in && dst->data->Bg->rank == myrank);
+
+    if (rank_match)
    {
+      const int segment_size = dst->data->shape[0] * dst->data->shape[1] * dst->data->shape[2];
+      int offset = size_out;
+
      if (data)
      {
        if (dir == PACK)
+        {
          switch (type)
          {
-              // attention must be paied to the difference between src's llb,uub and dst's llb,uub
            case 1:
-              f_copy(DIM, dst->data->llb, dst->data->uub, dst->data->shape, data + size_out,
-                     src->data->Bg->bbox, src->data->Bg->bbox + dim, src->data->Bg->shape, src->data->Bg->fgfs[varls->data->sgfn],
-                     dst->data->llb, dst->data->uub);
+              for (int iv = 0; iv < var_count; iv++, offset += segment_size)
+                f_copy(DIM, dst->data->llb, dst->data->uub, dst->data->shape, data + offset,
+                       src->data->Bg->bbox, src->data->Bg->bbox + dim, src->data->Bg->shape,
+                       src->data->Bg->fgfs[src_sgfn[iv]], dst->data->llb, dst->data->uub);
              break;
            case 2:
-              f_restrict3(DIM, dst->data->llb, dst->data->uub, dst->data->shape, data + size_out,
-                          src->data->Bg->bbox, src->data->Bg->bbox + dim, src->data->Bg->shape, src->data->Bg->fgfs[varls->data->sgfn],
-                          dst->data->llb, dst->data->uub, varls->data->SoA, Symmetry);
+              for (int iv = 0; iv < var_count; iv++, offset += segment_size)
+                f_restrict3(DIM, dst->data->llb, dst->data->uub, dst->data->shape, data + offset,
+                            src->data->Bg->bbox, src->data->Bg->bbox + dim, src->data->Bg->shape,
+                            src->data->Bg->fgfs[src_sgfn[iv]], dst->data->llb, dst->data->uub,
+                            src_soa[iv], Symmetry);
              break;
            case 3:
-              f_prolong3(DIM, src->data->Bg->bbox, src->data->Bg->bbox + dim, src->data->Bg->shape, src->data->Bg->fgfs[varls->data->sgfn],
-                         dst->data->llb, dst->data->uub, dst->data->shape, data + size_out,
-                         dst->data->llb, dst->data->uub, varls->data->SoA, Symmetry);
+              for (int iv = 0; iv < var_count; iv++, offset += segment_size)
+                f_prolong3(DIM, src->data->Bg->bbox, src->data->Bg->bbox + dim, src->data->Bg->shape,
+                           src->data->Bg->fgfs[src_sgfn[iv]], dst->data->llb, dst->data->uub,
+                           dst->data->shape, data + offset, dst->data->llb, dst->data->uub,
+                           src_soa[iv], Symmetry);
+              break;
+            default:
+              break;
          }
-          if (dir == UNPACK) // from target data to corresponding grid
-            f_copy(DIM, dst->data->Bg->bbox, dst->data->Bg->bbox + dim, dst->data->Bg->shape, dst->data->Bg->fgfs[varld->data->sgfn],
-                   dst->data->llb, dst->data->uub, dst->data->shape, data + size_out,
-                   dst->data->llb, dst->data->uub);
        }
-        size_out += dst->data->shape[0] * dst->data->shape[1] * dst->data->shape[2];
-        varls = varls->next;
-        varld = varld->next;
+        else
+        {
+          for (int iv = 0; iv < var_count; iv++, offset += segment_size)
+            f_copy(DIM, dst->data->Bg->bbox, dst->data->Bg->bbox + dim, dst->data->Bg->shape,
+                   dst->data->Bg->fgfs[dst_sgfn[iv]], dst->data->llb, dst->data->uub,
+                   dst->data->shape, data + offset, dst->data->llb, dst->data->uub);
        }
      }
+
+      size_out = offset + ((!data) ? segment_size * var_count : 0);
+      if (data)
+        size_out = offset;
+    }
    dst = dst->next;
    src = src->next;
  }
@@ -3819,21 +3858,10 @@ int Parallel::data_packermix(double *data, MyList<Parallel::gridseg> *src, MyLis
  if (!src || !dst)
    return size_out;

-  MyList<var> *varls, *varld;
-
-  varls = VarLists;
-  varld = VarListd;
-  while (varls && varld)
-  {
-    varls = varls->next;
-    varld = varld->next;
-  }
-
-  if (varls || varld)
-  {
-    cout << "error in short data packer, var lists does not match." << endl;
-    MPI_Abort(MPI_COMM_WORLD, 1);
-  }
+  int src_sgfn[MAX_DATA_PACKER_VARS];
+  int dst_sgfn[MAX_DATA_PACKER_VARS];
+  double *src_soa[MAX_DATA_PACKER_VARS];
+  const int var_count = expand_var_list_pack_info(VarLists, VarListd, src_sgfn, dst_sgfn, src_soa);

  int type; /* 1 copy, 2 restrict, 3 prolong */
  if (src->data->Bg->lev == dst->data->Bg->lev)
@@ -3851,31 +3879,42 @@ int Parallel::data_packermix(double *data, MyList<Parallel::gridseg> *src, MyLis

  while (src && dst)
  {
-    if ((dir == PACK && dst->data->Bg->rank == rank_in && src->data->Bg->rank == myrank) ||
-        (dir == UNPACK && src->data->Bg->rank == rank_in && dst->data->Bg->rank == myrank))
-    {
-      varls = VarLists;
-      varld = VarListd;
-      while (varls && varld)
+    const bool rank_match =
+        (dir == PACK && dst->data->Bg->rank == rank_in && src->data->Bg->rank == myrank) ||
+        (dir == UNPACK && src->data->Bg->rank == rank_in && dst->data->Bg->rank == myrank);
+
+    if (rank_match)
    {
+      const int segment_size =
+          (src->data->shape[0] + 2 * ghost_width) *
+          (src->data->shape[1] + 2 * ghost_width) *
+          (src->data->shape[2] + 2 * ghost_width);
+      int offset = size_out;
+
      if (data)
      {
        if (dir == PACK)
-            f_prolongcopy3(DIM, src->data->Bg->bbox, src->data->Bg->bbox + dim, src->data->Bg->shape, src->data->Bg->fgfs[varls->data->sgfn],
-                           dst->data->llb, dst->data->uub, src->data->shape, data + size_out,
-                           src->data->llb, src->data->uub, varls->data->SoA, Symmetry);
-          if (dir == UNPACK) // from target data to corresponding grid
-            f_prolongmix3(DIM, dst->data->Bg->bbox, dst->data->Bg->bbox + dim, dst->data->Bg->shape, dst->data->Bg->fgfs[varld->data->sgfn],
-                          src->data->llb, src->data->uub, src->data->shape, data + size_out,
-                          dst->data->llb, dst->data->uub, varls->data->SoA, Symmetry, dst->data->illb, dst->data->iuub);
+        {
+          for (int iv = 0; iv < var_count; iv++, offset += segment_size)
+            f_prolongcopy3(DIM, src->data->Bg->bbox, src->data->Bg->bbox + dim, src->data->Bg->shape,
+                           src->data->Bg->fgfs[src_sgfn[iv]], dst->data->llb, dst->data->uub,
+                           src->data->shape, data + offset, src->data->llb, src->data->uub,
+                           src_soa[iv], Symmetry);
        }
-        // the symmetry problem should be dealt in prolongcopy3,
-        // so we always have ghost_width for both sides
-        size_out += (src->data->shape[0] + 2 * ghost_width) * (src->data->shape[1] + 2 * ghost_width) * (src->data->shape[2] + 2 * ghost_width);
-        varls = varls->next;
-        varld = varld->next;
+        else
+        {
+          for (int iv = 0; iv < var_count; iv++, offset += segment_size)
+            f_prolongmix3(DIM, dst->data->Bg->bbox, dst->data->Bg->bbox + dim, dst->data->Bg->shape,
+                          dst->data->Bg->fgfs[dst_sgfn[iv]], src->data->llb, src->data->uub,
+                          src->data->shape, data + offset, dst->data->llb, dst->data->uub,
+                          src_soa[iv], Symmetry, dst->data->illb, dst->data->iuub);
        }
      }
+
+      size_out = offset + ((!data) ? segment_size * var_count : 0);
+      if (data)
+        size_out = offset;
+    }
    dst = dst->next;
    src = src->next;
  }
@@ -5284,6 +5323,41 @@ double Parallel::L2Norm(Patch *Pat, var *vf)

  return tvf;
 }
+void Parallel::L2Norm7(Patch *Pat, var **vf, double *norms)
+{
+  int myrank;
+  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
+
+  double tvf[7], dtvf[7];
+  int BDW = ghost_width;
+  for (int i = 0; i < 7; i++)
+    dtvf[i] = 0;
+
+  MyList<Block> *BP = Pat->blb;
+  while (BP)
+  {
+    Block *cg = BP->data;
+    if (myrank == cg->rank)
+    {
+      f_l2normhelper7(cg->shape, cg->X[0], cg->X[1], cg->X[2],
+                      Pat->bbox[0], Pat->bbox[1], Pat->bbox[2],
+                      Pat->bbox[3], Pat->bbox[4], Pat->bbox[5],
+                      cg->fgfs[vf[0]->sgfn], cg->fgfs[vf[1]->sgfn], cg->fgfs[vf[2]->sgfn],
+                      cg->fgfs[vf[3]->sgfn], cg->fgfs[vf[4]->sgfn], cg->fgfs[vf[5]->sgfn],
+                      cg->fgfs[vf[6]->sgfn], tvf, BDW);
+      for (int i = 0; i < 7; i++)
+        dtvf[i] += tvf[i];
+    }
+    if (BP == Pat->ble)
+      break;
+    BP = BP->next;
+  }
+
+  MPI_Allreduce(dtvf, tvf, 7, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
+
+  for (int i = 0; i < 7; i++)
+    norms[i] = sqrt(tvf[i]);
+}
 double Parallel::L2Norm(Patch *Pat, var *vf, MPI_Comm Comm_here)
 {
  int myrank;
@@ -5315,6 +5389,41 @@ double Parallel::L2Norm(Patch *Pat, var *vf, MPI_Comm Comm_here)

  return tvf;
 }
+void Parallel::L2Norm7(Patch *Pat, var **vf, double *norms, MPI_Comm Comm_here)
+{
+  int myrank;
+  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
+
+  double tvf[7], dtvf[7];
+  int BDW = ghost_width;
+  for (int i = 0; i < 7; i++)
+    dtvf[i] = 0;
+
+  MyList<Block> *BP = Pat->blb;
+  while (BP)
+  {
+    Block *cg = BP->data;
+    if (myrank == cg->rank)
+    {
+      f_l2normhelper7(cg->shape, cg->X[0], cg->X[1], cg->X[2],
+                      Pat->bbox[0], Pat->bbox[1], Pat->bbox[2],
+                      Pat->bbox[3], Pat->bbox[4], Pat->bbox[5],
+                      cg->fgfs[vf[0]->sgfn], cg->fgfs[vf[1]->sgfn], cg->fgfs[vf[2]->sgfn],
+                      cg->fgfs[vf[3]->sgfn], cg->fgfs[vf[4]->sgfn], cg->fgfs[vf[5]->sgfn],
+                      cg->fgfs[vf[6]->sgfn], tvf, BDW);
+      for (int i = 0; i < 7; i++)
+        dtvf[i] += tvf[i];
+    }
+    if (BP == Pat->ble)
+      break;
+    BP = BP->next;
+  }
+
+  MPI_Allreduce(dtvf, tvf, 7, MPI_DOUBLE, MPI_SUM, Comm_here);
+
+  for (int i = 0; i < 7; i++)
+    norms[i] = sqrt(tvf[i]);
+}
 void Parallel::checkgsl(MyList<Parallel::gridseg> *pp, bool first_only)
 {
  int myrank = 0;
--- a/AMSS_NCKU_source/Parallel.h
+++ b/AMSS_NCKU_source/Parallel.h
@@ -183,6 +183,7 @@ namespace Parallel
                         MyList<Parallel::gridseg> **out_src, MyList<Parallel::gridseg> **out_dst);
  void PeriodicBD(Patch *Pat, MyList<var> *VarList, int Symmetry);
  double L2Norm(Patch *Pat, var *vf);
+  void L2Norm7(Patch *Pat, var **vf, double *norms);
  void checkgsl(MyList<Parallel::gridseg> *pp, bool first_only);
  void checkvarl(MyList<var> *pp, bool first_only);
  MyList<Parallel::gridseg> *divide_gsl(MyList<Parallel::gridseg> *p, Patch *Pat);
@@ -218,6 +219,7 @@ namespace Parallel
  void checkpatchlist(MyList<Patch> *PatL, bool buflog);

  double L2Norm(Patch *Pat, var *vf, MPI_Comm Comm_here);
+  void L2Norm7(Patch *Pat, var **vf, double *norms, MPI_Comm Comm_here);
  bool PatList_Interp_Points(MyList<Patch> *PatL, MyList<var> *VarList,
                             int NN, double **XX,
                             double *Shellf, int Symmetry, MPI_Comm Comm_here);
--- a/AMSS_NCKU_source/ShellPatch.C
+++ b/AMSS_NCKU_source/ShellPatch.C
@@ -3472,6 +3472,43 @@ double ShellPatch::L2Norm(var *vf)

  return tvf;
 }
+void ShellPatch::L2Norm7(var **vf, double *norms)
+{
+  double tvf[7], dtvf[7];
+  int BDW = overghost;
+  for (int i = 0; i < 7; i++)
+    dtvf[i] = 0;
+
+  MyList<ss_patch> *sPp = PatL;
+  while (sPp)
+  {
+    MyList<Block> *Bp = sPp->data->blb;
+    while (Bp)
+    {
+      Block *cg = Bp->data;
+      if (myrank == cg->rank)
+      {
+        f_l2normhelper7(cg->shape, cg->X[0], cg->X[1], cg->X[2],
+                        sPp->data->bbox[0], sPp->data->bbox[1], sPp->data->bbox[2],
+                        sPp->data->bbox[3], sPp->data->bbox[4], sPp->data->bbox[5],
+                        cg->fgfs[vf[0]->sgfn], cg->fgfs[vf[1]->sgfn], cg->fgfs[vf[2]->sgfn],
+                        cg->fgfs[vf[3]->sgfn], cg->fgfs[vf[4]->sgfn], cg->fgfs[vf[5]->sgfn],
+                        cg->fgfs[vf[6]->sgfn], tvf, BDW);
+        for (int i = 0; i < 7; i++)
+          dtvf[i] += tvf[i];
+      }
+      if (Bp == sPp->data->ble)
+        break;
+      Bp = Bp->next;
+    }
+    sPp = sPp->next;
+  }
+
+  MPI_Allreduce(dtvf, tvf, 7, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
+
+  for (int i = 0; i < 7; i++)
+    norms[i] = sqrt(tvf[i]);
+}

 // find maximum of abstract value, XX store position for maximum, Shellf store maximum themselvs
 void ShellPatch::Find_Maximum(MyList<var> *VarList, double *XX,
--- a/AMSS_NCKU_source/ShellPatch.h
+++ b/AMSS_NCKU_source/ShellPatch.h
@@ -198,6 +198,7 @@ public:
   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);
 };

--- a/AMSS_NCKU_source/TwoPunctures.C
+++ b/AMSS_NCKU_source/TwoPunctures.C
@@ -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,
--- a/AMSS_NCKU_source/bssnEM_class.C
+++ b/AMSS_NCKU_source/bssnEM_class.C
@@ -258,6 +258,8 @@ void bssnEM_class::Initialize()
    PhysTime = StartTime;
    Setup_Black_Hole_position();
  }
+
+  setup_transfer_caches();
 }

 //================================================================================================
--- a/AMSS_NCKU_source/bssnEScalar_class.C
+++ b/AMSS_NCKU_source/bssnEScalar_class.C
@@ -26,6 +26,12 @@ using namespace std;
 #include "shellfunctions.h"
 #include "parameters.h"

+#if BSSN_USE_ESCALAR_C_KERNEL
+#define BSSN_ESCALAR_RHS f_compute_rhs_bssn_escalar_c
+#else
+#define BSSN_ESCALAR_RHS f_compute_rhs_bssn_escalar
+#endif
+
 #ifdef With_AHF
 #include "derivatives.h"
 #include "myglobal.h"
@@ -133,6 +139,9 @@ void bssnEScalar_class::Initialize()
    } 
   
  GH = new cgh(0, ngfs, Symmetry, pname, checkrun, ErrorMonitor);
+  ConstraintRefreshLevels = new int[GH->levels];
+  for (int il = 0; il < GH->levels; il++)
+    ConstraintRefreshLevels[il] = 0;
  if (checkrun)
    CheckPoint->readcheck_cgh(PhysTime, GH, myrank, nprocs, Symmetry);
  else
@@ -165,6 +174,8 @@ void bssnEScalar_class::Initialize()
    PhysTime = StartTime;
    Setup_Black_Hole_position();
  }
+
+  setup_transfer_caches();
 }

 //================================================================================================
@@ -230,6 +241,9 @@ void bssnEScalar_class::Read_Ansorg()
    }
    int BH_NM;
    double *Porg_here;
+    double *pmom_local;
+    double *spin_local;
+    double *mass_local;
    // read parameter from file
    {
      const int LEN = 256;
@@ -271,9 +285,9 @@ void bssnEScalar_class::Read_Ansorg()
    }

    Porg_here = new double[3 * BH_NM];
-    Pmom = new double[3 * BH_NM];
-    Spin = new double[3 * BH_NM];
-    Mass = new double[BH_NM];
+    pmom_local = new double[3 * BH_NM];
+    spin_local = new double[3 * BH_NM];
+    mass_local = new double[BH_NM];
    // read parameter from file
    {
      const int LEN = 256;
@@ -308,7 +322,7 @@ void bssnEScalar_class::Read_Ansorg()
        if (sgrp == "BSSN" && sind < BH_NM)
        {
          if (skey == "Mass")
-            Mass[sind] = atof(sval.c_str());
+            mass_local[sind] = atof(sval.c_str());
          else if (skey == "Porgx")
            Porg_here[sind * 3] = atof(sval.c_str());
          else if (skey == "Porgy")
@@ -316,17 +330,17 @@ void bssnEScalar_class::Read_Ansorg()
          else if (skey == "Porgz")
            Porg_here[sind * 3 + 2] = atof(sval.c_str());
          else if (skey == "Spinx")
-            Spin[sind * 3] = atof(sval.c_str());
+            spin_local[sind * 3] = atof(sval.c_str());
          else if (skey == "Spiny")
-            Spin[sind * 3 + 1] = atof(sval.c_str());
+            spin_local[sind * 3 + 1] = atof(sval.c_str());
          else if (skey == "Spinz")
-            Spin[sind * 3 + 2] = atof(sval.c_str());
+            spin_local[sind * 3 + 2] = atof(sval.c_str());
          else if (skey == "Pmomx")
-            Pmom[sind * 3] = atof(sval.c_str());
+            pmom_local[sind * 3] = atof(sval.c_str());
          else if (skey == "Pmomy")
-            Pmom[sind * 3 + 1] = atof(sval.c_str());
+            pmom_local[sind * 3 + 1] = atof(sval.c_str());
          else if (skey == "Pmomz")
-            Pmom[sind * 3 + 2] = atof(sval.c_str());
+            pmom_local[sind * 3 + 2] = atof(sval.c_str());
        }
      }
      inf.close();
@@ -362,7 +376,7 @@ void bssnEScalar_class::Read_Ansorg()
                                      cg->fgfs[Sfx0->sgfn], cg->fgfs[Sfy0->sgfn], cg->fgfs[Sfz0->sgfn],
                                      cg->fgfs[dtSfx0->sgfn], cg->fgfs[dtSfy0->sgfn], cg->fgfs[dtSfz0->sgfn],
                                      cg->fgfs[Sphi0->sgfn], cg->fgfs[Spi0->sgfn],
-                                      Mass, Porg_here, Pmom, Spin, BH_NM);
+                                      mass_local, Porg_here, pmom_local, spin_local, BH_NM);
          }
          if (BL == Pp->data->ble)
            break;
@@ -404,7 +418,7 @@ void bssnEScalar_class::Read_Ansorg()
                                       cg->fgfs[Sfx0->sgfn], cg->fgfs[Sfy0->sgfn], cg->fgfs[Sfz0->sgfn],
                                       cg->fgfs[dtSfx0->sgfn], cg->fgfs[dtSfy0->sgfn], cg->fgfs[dtSfz0->sgfn],
                                       cg->fgfs[Sphi0->sgfn], cg->fgfs[Spi0->sgfn],
-                                       Mass, Porg_here, Pmom, Spin, BH_NM);
+                                       mass_local, Porg_here, pmom_local, spin_local, BH_NM);
        }
        if (BL == Pp->data->ble)
          break;
@@ -415,6 +429,9 @@ void bssnEScalar_class::Read_Ansorg()
 #endif

    delete[] Porg_here;
+    delete[] pmom_local;
+    delete[] spin_local;
+    delete[] mass_local;
    // dump read_in initial data
    //   for(int lev=0;lev<GH->levels;lev++) Parallel::Dump_Data(GH->PatL[lev],StateList,0,PhysTime,dT);
  }
@@ -455,6 +472,9 @@ void bssnEScalar_class::Read_Pablo()
    }
    int BH_NM;
    double *Porg_here;
+    double *pmom_local;
+    double *spin_local;
+    double *mass_local;
    // read parameter from file
    {
      const int LEN = 256;
@@ -496,9 +516,9 @@ void bssnEScalar_class::Read_Pablo()
    }

    Porg_here = new double[3 * BH_NM];
-    Pmom = new double[3 * BH_NM];
-    Spin = new double[3 * BH_NM];
-    Mass = new double[BH_NM];
+    pmom_local = new double[3 * BH_NM];
+    spin_local = new double[3 * BH_NM];
+    mass_local = new double[BH_NM];
    // read parameter from file
    {
      const int LEN = 256;
@@ -533,7 +553,7 @@ void bssnEScalar_class::Read_Pablo()
        if (sgrp == "BSSN" && sind < BH_NM)
        {
          if (skey == "Mass")
-            Mass[sind] = atof(sval.c_str());
+            mass_local[sind] = atof(sval.c_str());
          else if (skey == "Porgx")
            Porg_here[sind * 3] = atof(sval.c_str());
          else if (skey == "Porgy")
@@ -541,17 +561,17 @@ void bssnEScalar_class::Read_Pablo()
          else if (skey == "Porgz")
            Porg_here[sind * 3 + 2] = atof(sval.c_str());
          else if (skey == "Spinx")
-            Spin[sind * 3] = atof(sval.c_str());
+            spin_local[sind * 3] = atof(sval.c_str());
          else if (skey == "Spiny")
-            Spin[sind * 3 + 1] = atof(sval.c_str());
+            spin_local[sind * 3 + 1] = atof(sval.c_str());
          else if (skey == "Spinz")
-            Spin[sind * 3 + 2] = atof(sval.c_str());
+            spin_local[sind * 3 + 2] = atof(sval.c_str());
          else if (skey == "Pmomx")
-            Pmom[sind * 3] = atof(sval.c_str());
+            pmom_local[sind * 3] = atof(sval.c_str());
          else if (skey == "Pmomy")
-            Pmom[sind * 3 + 1] = atof(sval.c_str());
+            pmom_local[sind * 3 + 1] = atof(sval.c_str());
          else if (skey == "Pmomz")
-            Pmom[sind * 3 + 2] = atof(sval.c_str());
+            pmom_local[sind * 3 + 2] = atof(sval.c_str());
        }
      }
      inf.close();
@@ -598,7 +618,7 @@ void bssnEScalar_class::Read_Pablo()
                                        cg->fgfs[Sfx0->sgfn], cg->fgfs[Sfy0->sgfn], cg->fgfs[Sfz0->sgfn],
                                        cg->fgfs[dtSfx0->sgfn], cg->fgfs[dtSfy0->sgfn], cg->fgfs[dtSfz0->sgfn],
                                        cg->fgfs[Sphi0->sgfn], cg->fgfs[Spi0->sgfn],
-                                        Mass, Porg_here, Pmom, Spin, BH_NM);
+                                        mass_local, Porg_here, pmom_local, spin_local, BH_NM);
            }
            if (BL == Pp->data->ble)
              break;
@@ -662,7 +682,7 @@ void bssnEScalar_class::Read_Pablo()
                                         cg->fgfs[Sfx0->sgfn], cg->fgfs[Sfy0->sgfn], cg->fgfs[Sfz0->sgfn],
                                         cg->fgfs[dtSfx0->sgfn], cg->fgfs[dtSfy0->sgfn], cg->fgfs[dtSfz0->sgfn],
                                         cg->fgfs[Sphi0->sgfn], cg->fgfs[Spi0->sgfn],
-                                         Mass, Porg_here, Pmom, Spin, BH_NM);
+                                         mass_local, Porg_here, pmom_local, spin_local, BH_NM);
          }
          if (BL == Pp->data->ble)
            break;
@@ -686,6 +706,9 @@ void bssnEScalar_class::Read_Pablo()
 #endif

    delete[] Porg_here;
+    delete[] pmom_local;
+    delete[] spin_local;
+    delete[] mass_local;
    if (flag && myrank == 0)
      MPI_Abort(MPI_COMM_WORLD, 1);
    // dump read_in initial data
@@ -739,7 +762,7 @@ void bssnEScalar_class::Step(int lev, int YN)
                     cg->fgfs[Ayy0->sgfn], cg->fgfs[Ayz0->sgfn], cg->fgfs[Azz0->sgfn]);
 #endif

-        if (f_compute_rhs_bssn_escalar(cg->shape, TRK4, cg->X[0], cg->X[1], cg->X[2],
+        if (BSSN_ESCALAR_RHS(cg->shape, TRK4, cg->X[0], cg->X[1], cg->X[2],
                                       cg->fgfs[phi0->sgfn], cg->fgfs[trK0->sgfn],
                                       cg->fgfs[gxx0->sgfn], cg->fgfs[gxy0->sgfn], cg->fgfs[gxz0->sgfn], 
                                       cg->fgfs[gyy0->sgfn], cg->fgfs[gyz0->sgfn], cg->fgfs[gzz0->sgfn],
@@ -993,7 +1016,8 @@ void bssnEScalar_class::Step(int lev, int YN)
  }
 #endif

-  Parallel::Sync(GH->PatL[lev], SynchList_pre, Symmetry);
+  Parallel::AsyncSyncState async_pre;
+  sync_predictor_start(lev, SynchList_pre, async_pre);

 #ifdef WithShell
  if (lev == 0)
@@ -1012,6 +1036,7 @@ void bssnEScalar_class::Step(int lev, int YN)
    }
  }
 #endif
+  sync_predictor_finish(lev, async_pre, SynchList_pre);

  // for black hole position
  if (BH_num > 0 && lev == GH->levels - 1)
@@ -1081,7 +1106,7 @@ void bssnEScalar_class::Step(int lev, int YN)
                         cg->fgfs[Ayy->sgfn], cg->fgfs[Ayz->sgfn], cg->fgfs[Azz->sgfn]);
 #endif

-          if (f_compute_rhs_bssn_escalar(cg->shape, TRK4, cg->X[0], cg->X[1], cg->X[2],
+          if (BSSN_ESCALAR_RHS(cg->shape, TRK4, cg->X[0], cg->X[1], cg->X[2],
                                         cg->fgfs[phi->sgfn], cg->fgfs[trK->sgfn],
                                         cg->fgfs[gxx->sgfn], cg->fgfs[gxy->sgfn], cg->fgfs[gxz->sgfn], 
                                         cg->fgfs[gyy->sgfn], cg->fgfs[gyz->sgfn], cg->fgfs[gzz->sgfn],
@@ -1349,7 +1374,8 @@ void bssnEScalar_class::Step(int lev, int YN)
    }
 #endif

-    Parallel::Sync(GH->PatL[lev], SynchList_cor, Symmetry);
+    Parallel::AsyncSyncState async_cor;
+    sync_corrector_start(lev, SynchList_cor, async_cor);

 #ifdef WithShell
    if (lev == 0)
@@ -1368,6 +1394,7 @@ void bssnEScalar_class::Step(int lev, int YN)
      }
    }
 #endif
+    sync_corrector_finish(lev, async_cor, SynchList_cor);
    // for black hole position
    if (BH_num > 0 && lev == GH->levels - 1)
    {
@@ -1835,8 +1862,11 @@ void bssnEScalar_class::AnalysisStuff_EScalar(int lev, double dT_lev)

 //================================================================================================

-void bssnEScalar_class::Interp_Constraint()
+void bssnEScalar_class::Interp_Constraint(bool infg)
 {
+  if (!infg)
+    return;
+
  // we do not support a_lev != 0 yet.
  if (a_lev > 0)
    return;
@@ -1858,7 +1888,7 @@ void bssnEScalar_class::Interp_Constraint()
          if (myrank == cg->rank)
          {
            if (lev > 0)
-              f_compute_rhs_bssn_escalar(cg->shape, TRK4, cg->X[0], cg->X[1], cg->X[2],
+              BSSN_ESCALAR_RHS(cg->shape, TRK4, cg->X[0], cg->X[1], cg->X[2],
                                         cg->fgfs[phi0->sgfn], cg->fgfs[trK0->sgfn],
                                         cg->fgfs[gxx0->sgfn], cg->fgfs[gxy0->sgfn], cg->fgfs[gxz0->sgfn], 
                                         cg->fgfs[gyy0->sgfn], cg->fgfs[gyz0->sgfn], cg->fgfs[gzz0->sgfn],
@@ -2078,7 +2108,7 @@ void bssnEScalar_class::Constraint_Out()
            if (myrank == cg->rank)
            {
              if (lev > 0)
-                f_compute_rhs_bssn_escalar(cg->shape, TRK4, cg->X[0], cg->X[1], cg->X[2],
+                BSSN_ESCALAR_RHS(cg->shape, TRK4, cg->X[0], cg->X[1], cg->X[2],
                                           cg->fgfs[phi0->sgfn], cg->fgfs[trK0->sgfn],
                                           cg->fgfs[gxx0->sgfn], cg->fgfs[gxy0->sgfn], cg->fgfs[gxz0->sgfn], 
                                           cg->fgfs[gyy0->sgfn], cg->fgfs[gyz0->sgfn], cg->fgfs[gzz0->sgfn],
--- a/AMSS_NCKU_source/bssnEScalar_class.h
+++ b/AMSS_NCKU_source/bssnEScalar_class.h
@@ -51,7 +51,7 @@ public:
     void Compute_Psi4(int lev);
     void Step(int lev, int YN);
     void AnalysisStuff_EScalar(int lev, double dT_lev);
-     void Interp_Constraint();
+     void Interp_Constraint(bool infg);
     void Constraint_Out(); 

 protected:
--- a/AMSS_NCKU_source/bssn_class.C
+++ b/AMSS_NCKU_source/bssn_class.C
--- a/AMSS_NCKU_source/bssn_class.h
+++ b/AMSS_NCKU_source/bssn_class.h
@@ -33,6 +33,14 @@ using namespace std;

 extern void setpbh(int iBHN, double **iPBH, double *iMass, int rBHN);

+#ifndef BSSN_USE_TRANSFER_CACHE
+#define BSSN_USE_TRANSFER_CACHE 1
+#endif
+
+#ifndef BSSN_USE_ESCALAR_C_KERNEL
+#define BSSN_USE_ESCALAR_C_KERNEL 1
+#endif
+
 class bssn_class
 {
 public:
@@ -48,6 +56,7 @@ public:
       double StartTime, TotalTime;
       double AnasTime, DumpTime, d2DumpTime, CheckTime;
       double LastAnas, LastConsOut;
+       int *ConstraintRefreshLevels;
       double Courant;
       double numepss, numepsb, numepsh;
       int Symmetry;
@@ -134,7 +143,7 @@ public:
       Parallel::SyncCache *sync_cache_outbd;      // cached OutBdLow2Hi in RestrictProlong

       monitor *ErrorMonitor, *Psi4Monitor, *BHMonitor, *MAPMonitor;
-       monitor *ConVMonitor;
+       monitor *ConVMonitor, *TimingMonitor;
       surface_integral *Waveshell;
       checkpoint *CheckPoint;

@@ -170,6 +179,17 @@ public:
       void testOutBd();
       
       bool check_Stdin_Abort(); 
+       bool use_transfer_cache() const;
+       void setup_transfer_caches();
+       void invalidate_transfer_caches();
+       void destroy_transfer_caches();
+       void sync_predictor_start(int lev, MyList<var> *VarList, Parallel::AsyncSyncState &async_state);
+       void sync_predictor_finish(int lev, Parallel::AsyncSyncState &async_state, MyList<var> *VarList);
+       void sync_corrector_start(int lev, MyList<var> *VarList, Parallel::AsyncSyncState &async_state);
+       void sync_corrector_finish(int lev, Parallel::AsyncSyncState &async_state, MyList<var> *VarList);
+       void sync_evolution(int lev, MyList<var> *VarList, Parallel::SyncCache *cache_array = 0);
+       void restrict_evolution(int lev, MyList<var> *src_var_list, MyList<var> *dst_var_list);
+       void outbdlow2hi_evolution(int lev, MyList<var> *src_var_list, MyList<var> *dst_var_list);

       virtual void Setup_Initial_Data_Cao();
       virtual void Setup_Initial_Data_Lousto();
--- a/AMSS_NCKU_source/bssn_escalar_rhs_c.C
+++ b/AMSS_NCKU_source/bssn_escalar_rhs_c.C
@@ -0,0 +1,169 @@
+#include "macrodef.h"
+#include "bssn_rhs.h"
+#include "share_func.h"
+#include "tool.h"
+#include <vector>
+
+namespace
+{
+    // Reuse the temporary workspace across block calls to avoid repeated heap churn
+    // in the EScalar wrapper. MPI ranks execute this path sequentially, so a single
+    // process-local buffer is sufficient here.
+    std::vector<double> g_escalar_tmp_store;
+}
+
+#ifdef fortran1
+#define f_frpotential frpotential
+#endif
+#ifdef fortran2
+#define f_frpotential FRPOTENTIAL
+#endif
+#ifdef fortran3
+#define f_frpotential frpotential_
+#endif
+
+extern "C"
+{
+    void f_frpotential(int *, double *, double *, double *);
+}
+
+int f_compute_rhs_bssn_escalar_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 *Sphi, double *Spi,
+                                 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 *Sphi_rhs, double *Spi_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)
+{
+    const int nx = ex[0], ny = ex[1], nz = ex[2];
+    const int all = nx * ny * nz;
+
+    const size_t workspace_size = size_t(all) * 17;
+    if (g_escalar_tmp_store.size() < workspace_size)
+        g_escalar_tmp_store.resize(workspace_size);
+
+    double *tmp_ptr = g_escalar_tmp_store.data();
+    auto alloc_tmp = [&](int n = 1) -> double *
+    {
+        double *ptr = tmp_ptr;
+        tmp_ptr += size_t(all) * n;
+        return ptr;
+    };
+
+    double *chix = alloc_tmp(), *chiy = alloc_tmp(), *chiz = alloc_tmp();
+    double *Kx = alloc_tmp(), *Ky = alloc_tmp(), *Kz = alloc_tmp();
+    double *fxx = alloc_tmp(), *fxy = alloc_tmp(), *fxz = alloc_tmp();
+    double *fyy = alloc_tmp(), *fyz = alloc_tmp(), *fzz = alloc_tmp();
+    double *Lapx = alloc_tmp(), *Lapy = alloc_tmp(), *Lapz = alloc_tmp();
+    double *V = alloc_tmp(), *dVdSphi = alloc_tmp();
+
+    const double ZEO = 0.0, ONE = 1.0, TWO = 2.0, HALF = 0.5;
+    const double SSS[3] = {1.0, 1.0, 1.0};
+
+    fderivs(ex, chi, chix, chiy, chiz, X, Y, Z, 1.0, 1.0, 1.0, Symmetry, Lev);
+    fderivs(ex, Lap, Lapx, Lapy, Lapz, X, Y, Z, 1.0, 1.0, 1.0, Symmetry, Lev);
+    fderivs(ex, Sphi, Kx, Ky, Kz, X, Y, Z, 1.0, 1.0, 1.0, Symmetry, Lev);
+    fdderivs(ex, Sphi, fxx, fxy, fxz, fyy, fyz, fzz, X, Y, Z, 1.0, 1.0, 1.0, Symmetry, Lev);
+
+    f_frpotential(ex, Sphi, V, dVdSphi);
+
+    for (int i = 0; i < all; ++i)
+    {
+        const double alpn1 = Lap[i] + ONE;
+        const double chin1 = chi[i] + ONE;
+        const double gxx = dxx[i] + ONE;
+        const double gyy = dyy[i] + ONE;
+        const double gzz = dzz[i] + ONE;
+        const double det = gxx * gyy * gzz + gxy[i] * gyz[i] * gxz[i] + gxz[i] * gxy[i] * gyz[i]
+                         - gxz[i] * gyy * gxz[i] - gxy[i] * gxy[i] * gzz - gxx * gyz[i] * gyz[i];
+        const double gupxx = (gyy * gzz - gyz[i] * gyz[i]) / det;
+        const double gupxy = -(gxy[i] * gzz - gyz[i] * gxz[i]) / det;
+        const double gupxz = (gxy[i] * gyz[i] - gyy * gxz[i]) / det;
+        const double gupyy = (gxx * gzz - gxz[i] * gxz[i]) / det;
+        const double gupyz = -(gxx * gyz[i] - gxy[i] * gxz[i]) / det;
+        const double gupzz = (gxx * gyy - gxy[i] * gxy[i]) / det;
+
+        Sphi_rhs[i] = alpn1 * Spi[i];
+
+        Spi_rhs[i] = gupxx * fxx[i] + gupyy * fyy[i] + gupzz * fzz[i]
+                   + TWO * (gupxy * fxy[i] + gupxz * fxz[i] + gupyz * fyz[i])
+                   - ((Gamx[i] + (gupxx * chix[i] + gupxy * chiy[i] + gupxz * chiz[i]) / TWO / chin1) * Kx[i]
+                   +  (Gamy[i] + (gupxy * chix[i] + gupyy * chiy[i] + gupyz * chiz[i]) / TWO / chin1) * Ky[i]
+                   +  (Gamz[i] + (gupxz * chix[i] + gupyz * chiy[i] + gupzz * chiz[i]) / TWO / chin1) * Kz[i]);
+
+        Spi_rhs[i] = Spi_rhs[i] * alpn1
+                   + gupxx * Lapx[i] * Kx[i] + gupxy * Lapx[i] * Ky[i] + gupxz * Lapx[i] * Kz[i]
+                   + gupxy * Lapy[i] * Kx[i] + gupyy * Lapy[i] * Ky[i] + gupyz * Lapy[i] * Kz[i]
+                   + gupxz * Lapz[i] * Kx[i] + gupyz * Lapz[i] * Ky[i] + gupzz * Lapz[i] * Kz[i];
+
+        Spi_rhs[i] = Spi_rhs[i] * chin1 + alpn1 * (trK[i] * Spi[i] - dVdSphi[i]);
+
+        rho[i] = chin1 * ((gupxx * Kx[i] * Kx[i] + gupyy * Ky[i] * Ky[i] + gupzz * Kz[i] * Kz[i]) * HALF
+               + gupxy * Kx[i] * Ky[i] + gupxz * Kx[i] * Kz[i] + gupyz * Ky[i] * Kz[i])
+               + Spi[i] * Spi[i] * HALF + V[i];
+        Sx[i] = -Spi[i] * Kx[i];
+        Sy[i] = -Spi[i] * Ky[i];
+        Sz[i] = -Spi[i] * Kz[i];
+
+        const double pressure = (rho[i] - Spi[i] * Spi[i]) / chin1;
+        Sxx[i] = Kx[i] * Kx[i] - pressure * gxx;
+        Sxy[i] = Kx[i] * Ky[i] - pressure * gxy[i];
+        Sxz[i] = Kx[i] * Kz[i] - pressure * gxz[i];
+        Syy[i] = Ky[i] * Ky[i] - pressure * gyy;
+        Syz[i] = Ky[i] * Kz[i] - pressure * gyz[i];
+        Szz[i] = Kz[i] * Kz[i] - pressure * gzz;
+    }
+
+    if (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))
+        return 1;
+
+    lopsided_kodis(ex, X, Y, Z, Sphi, Sphi_rhs, betax, betay, betaz, Symmetry, SSS, eps);
+    lopsided_kodis(ex, X, Y, Z, Spi, Spi_rhs, betax, betay, betaz, Symmetry, SSS, eps);
+
+    for (int i = 0; i < all; ++i)
+    {
+        if (Sphi_rhs[i] != Sphi_rhs[i] || Spi_rhs[i] != Spi_rhs[i] || rho[i] != rho[i])
+            return 1;
+    }
+
+    return 0;
+}
--- a/AMSS_NCKU_source/bssn_rhs.h
+++ b/AMSS_NCKU_source/bssn_rhs.h
@@ -32,6 +32,19 @@
 #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
@@ -54,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
--- a/AMSS_NCKU_source/bssn_rhs_c.C
+++ b/AMSS_NCKU_source/bssn_rhs_c.C
@@ -2,12 +2,88 @@
 #include "bssn_rhs.h"
 #include "share_func.h"
 #include "tool.h"
+#include <time.h>
 // 0-based i,j,k
 // #define IDX_F(i,j,k,nx,ny) ((i) + (j)*(nx) + (k)*(nx)*(ny))
 // ex(1)=nx, ex(2)=ny, ex(3)=nz

 // 用法：a[ IDX_F(i,j,k,nx,ny) ]

+#ifndef BSSN_KERNEL_FINE_TIMING
+#define BSSN_KERNEL_FINE_TIMING 0
+#endif
+
+#if BSSN_KERNEL_FINE_TIMING
+namespace rhs_kernel_timing
+{
+    enum Bucket
+    {
+        KB_SETUP_DERIVS = 0,
+        KB_GEOM_GAMMA,
+        KB_RICCI_METRIC,
+        KB_CHI_LAPSE,
+        KB_AIJ_TRK_GAUGE,
+        KB_KO_CONSTRAINT,
+        KB_COUNT
+    };
+
+    static double local_bucket_seconds[KB_COUNT];
+
+    static const char *bucket_labels[KB_COUNT] =
+    {
+        "setup_derivs",
+        "geom_gamma",
+        "ricci_metric",
+        "chi_lapse",
+        "aij_trk_gauge",
+        "ko_constraint"
+    };
+
+    static inline double now_seconds()
+    {
+        struct timespec ts;
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+        return double(ts.tv_sec) + 1.0e-9 * double(ts.tv_nsec);
+    }
+}
+
+extern "C" void f_bssn_rhs_kernel_timing_reset()
+{
+    for (int i = 0; i < rhs_kernel_timing::KB_COUNT; ++i)
+        rhs_kernel_timing::local_bucket_seconds[i] = 0.0;
+}
+
+extern "C" int f_bssn_rhs_kernel_timing_bucket_count()
+{
+    return rhs_kernel_timing::KB_COUNT;
+}
+
+extern "C" const double *f_bssn_rhs_kernel_timing_local_seconds()
+{
+    return rhs_kernel_timing::local_bucket_seconds;
+}
+
+extern "C" const char *f_bssn_rhs_kernel_timing_label(int bucket_index)
+{
+    if (bucket_index < 0 || bucket_index >= rhs_kernel_timing::KB_COUNT)
+        return "unknown";
+    return rhs_kernel_timing::bucket_labels[bucket_index];
+}
+
+#define RHS_KERNEL_TIMER_DECL(var_name) const double var_name = rhs_kernel_timing::now_seconds()
+#define RHS_KERNEL_TIMER_ADD(bucket_name, var_name) \
+    rhs_kernel_timing::local_bucket_seconds[int(rhs_kernel_timing::bucket_name)] += \
+        rhs_kernel_timing::now_seconds() - (var_name)
+#else
+extern "C" void f_bssn_rhs_kernel_timing_reset() {}
+extern "C" int f_bssn_rhs_kernel_timing_bucket_count() { return 0; }
+extern "C" const double *f_bssn_rhs_kernel_timing_local_seconds() { return 0; }
+extern "C" const char *f_bssn_rhs_kernel_timing_label(int) { return "disabled"; }
+
+#define RHS_KERNEL_TIMER_DECL(var_name)
+#define RHS_KERNEL_TIMER_ADD(bucket_name, var_name)
+#endif
+
 // C function that calculates the right-hand side for BSSN equations
 int f_compute_rhs_bssn(int *ex, double &T, 
                       double *X, double *Y, double *Z,
@@ -102,6 +178,7 @@ int f_compute_rhs_bssn(int *ex, double &T,
    dY = Y[1] - Y[0];
    dZ = Z[1] - Z[0];

+        RHS_KERNEL_TIMER_DECL(timer_setup_derivs);
        // 1ms //
        for(int i=0;i<all;i+=1){
            alpn1[i] = Lap[i] + 1.0;
@@ -141,6 +218,8 @@ int f_compute_rhs_bssn(int *ex, double &T,
                        (dxx[i] + ONE) * betaxz[i] + gxy[i] * betayz[i] + gyz[i] * betayx[i] 
                        + (dzz[i] + ONE) * betazx[i] - gxz[i] * betayy[i];                  
        }
+        RHS_KERNEL_TIMER_ADD(KB_SETUP_DERIVS, timer_setup_derivs);
+        RHS_KERNEL_TIMER_DECL(timer_geom_gamma);
        // Fused: inverse metric + Gamma constraint + Christoffel (3 loops -> 1)
        for(int i=0;i<all;i+=1){
            double det = (dxx[i] + ONE) * (dyy[i] + ONE) * (dzz[i] + ONE) + gxy[i] * gyz[i] * gxz[i] + gxz[i] * gxy[i] * gyz[i] -
@@ -283,9 +362,6 @@ int f_compute_rhs_bssn(int *ex, double &T,
                + ( gupxy[i]*gupyz[i] + gupyy[i]*gupxz[i] ) * Axy[i]
                + ( gupxy[i]*gupzz[i] + gupyz[i]*gupxz[i] ) * Axz[i]
                + ( gupyy[i]*gupzz[i] + gupyz[i]*gupyz[i] ) * Ayz[i];
-            Rxx[i] = axx; Ryy[i] = ayy; Rzz[i] = azz;
-            Rxy[i] = axy; Rxz[i] = axz; Ryz[i] = ayz;
-
            Gamx_rhs[i] = - TWO * ( Lapx[i]*axx + Lapy[i]*axy + Lapz[i]*axz ) +
                TWO * alpn1[i] * (
                -F3o2/chin1[i] * ( chix[i]*axx + chiy[i]*axy + chiz[i]*axz ) -
@@ -315,6 +391,8 @@ int f_compute_rhs_bssn(int *ex, double &T,
                            + TWO * ( Gamzxy[i]*axy + Gamzxz[i]*axz + Gamzyz[i]*ayz )
                        );
        }
+        RHS_KERNEL_TIMER_ADD(KB_GEOM_GAMMA, timer_geom_gamma);
+        RHS_KERNEL_TIMER_DECL(timer_ricci_metric);
        // 22.3ms //
        fdderivs(ex,betax,gxxx,gxyx,gxzx,gyyx,gyzx,gzzx,
        X,Y,Z,ANTI,SYM, SYM ,Symmetry,Lev);
@@ -332,7 +410,6 @@ int f_compute_rhs_bssn(int *ex, double &T,
            double lfxx = gxxx[i] + gxyy[i] + gxzz[i];
            double lfxy = gxyx[i] + gyyy[i] + gyzz[i];
            double lfxz = gxzx[i] + gyzy[i] + gzzz[i];
-            fxx[i] = lfxx; fxy[i] = lfxy; fxz[i] = lfxz;

            double gxa = gupxx[i]*Gamxxx[i] + gupyy[i]*Gamxyy[i] + gupzz[i]*Gamxzz[i]
                    + TWO * ( gupxy[i]*Gamxxy[i] + gupxz[i]*Gamxxz[i] + gupyz[i]*Gamxyz[i] );
@@ -686,69 +763,74 @@ int f_compute_rhs_bssn(int *ex, double &T,
                    + Gamxyz[i] * gzzx[i] + Gamyyz[i] * gzzy[i] + Gamzyz[i] * gzzz[i]
                );
        }
+        RHS_KERNEL_TIMER_ADD(KB_RICCI_METRIC, timer_ricci_metric);

+        RHS_KERNEL_TIMER_DECL(timer_chi_lapse);
        // 22.3ms //
            fdderivs(ex,chi,fxx,fxy,fxz,fyy,fyz,fzz,X,Y,Z,SYM,SYM,SYM,Symmetry,Lev);

        // 7ms //
        for (int i=0;i<all;i+=1) {
-            fxx[i] = fxx[i] - Gamxxx[i] * chix[i] - Gamyxx[i] * chiy[i] - Gamzxx[i] * chiz[i];
-            fxy[i] = fxy[i] - Gamxxy[i] * chix[i] - Gamyxy[i] * chiy[i] - Gamzxy[i] * chiz[i];
-            fxz[i] = fxz[i] - Gamxxz[i] * chix[i] - Gamyxz[i] * chiy[i] - Gamzxz[i] * chiz[i];
-            fyy[i] = fyy[i] - Gamxyy[i] * chix[i] - Gamyyy[i] * chiy[i] - Gamzyy[i] * chiz[i];
-            fyz[i] = fyz[i] - Gamxyz[i] * chix[i] - Gamyyz[i] * chiy[i] - Gamzyz[i] * chiz[i];
-            fzz[i] = fzz[i] - Gamxzz[i] * chix[i] - Gamyzz[i] * chiy[i] - Gamzzz[i] * chiz[i];
-            f[i] =
-                gupxx[i] * (fxx[i] - (F3o2 / chin1[i]) * chix[i] * chix[i])
-                + gupyy[i] * (fyy[i] - (F3o2 / chin1[i]) * chiy[i] * chiy[i])
-                + gupzz[i] * (fzz[i] - (F3o2 / chin1[i]) * chiz[i] * chiz[i])
-                + TWO * gupxy[i] * (fxy[i] - (F3o2 / chin1[i]) * chix[i] * chiy[i])
-                + TWO * gupxz[i] * (fxz[i] - (F3o2 / chin1[i]) * chix[i] * chiz[i])
-                + TWO * gupyz[i] * (fyz[i] - (F3o2 / chin1[i]) * chiy[i] * chiz[i]);
-            Rxx[i] = Rxx[i] + ( fxx[i] - (chix[i] * chix[i]) / (chin1[i] * TWO) + (dxx[i] + ONE) * f[i] ) / (chin1[i] * TWO);
-            Ryy[i] = Ryy[i] + ( fyy[i] - (chiy[i] * chiy[i]) / (chin1[i] * TWO) + (dyy[i] + ONE) * f[i] ) / (chin1[i] * TWO);
-            Rzz[i] = Rzz[i] + ( fzz[i] - (chiz[i] * chiz[i]) / (chin1[i] * TWO) + (dzz[i] + ONE) * f[i] ) / (chin1[i] * TWO);
+            const double inv_chin1 = ONE / chin1[i];
+            const double half_inv_chin1 = HALF * inv_chin1;
+            const double scaled_inv = F3o2 * inv_chin1;
+            const double cxx = fxx[i] - Gamxxx[i] * chix[i] - Gamyxx[i] * chiy[i] - Gamzxx[i] * chiz[i];
+            const double cxy = fxy[i] - Gamxxy[i] * chix[i] - Gamyxy[i] * chiy[i] - Gamzxy[i] * chiz[i];
+            const double cxz = fxz[i] - Gamxxz[i] * chix[i] - Gamyxz[i] * chiy[i] - Gamzxz[i] * chiz[i];
+            const double cyy = fyy[i] - Gamxyy[i] * chix[i] - Gamyyy[i] * chiy[i] - Gamzyy[i] * chiz[i];
+            const double cyz = fyz[i] - Gamxyz[i] * chix[i] - Gamyyz[i] * chiy[i] - Gamzyz[i] * chiz[i];
+            const double czz = fzz[i] - Gamxzz[i] * chix[i] - Gamyzz[i] * chiy[i] - Gamzzz[i] * chiz[i];
+            const double ricci_chi =
+                gupxx[i] * (cxx - scaled_inv * chix[i] * chix[i])
+                + gupyy[i] * (cyy - scaled_inv * chiy[i] * chiy[i])
+                + gupzz[i] * (czz - scaled_inv * chiz[i] * chiz[i])
+                + TWO * gupxy[i] * (cxy - scaled_inv * chix[i] * chiy[i])
+                + TWO * gupxz[i] * (cxz - scaled_inv * chix[i] * chiz[i])
+                + TWO * gupyz[i] * (cyz - scaled_inv * chiy[i] * chiz[i]);
+            f[i] = ricci_chi;
+            Rxx[i] = Rxx[i] + ( cxx - half_inv_chin1 * chix[i] * chix[i] + (dxx[i] + ONE) * ricci_chi ) * half_inv_chin1;
+            Ryy[i] = Ryy[i] + ( cyy - half_inv_chin1 * chiy[i] * chiy[i] + (dyy[i] + ONE) * ricci_chi ) * half_inv_chin1;
+            Rzz[i] = Rzz[i] + ( czz - half_inv_chin1 * chiz[i] * chiz[i] + (dzz[i] + ONE) * ricci_chi ) * half_inv_chin1;

-            Rxy[i] = Rxy[i] + ( fxy[i] - (chix[i] * chiy[i]) / (chin1[i] * TWO) + gxy[i] * f[i] ) / (chin1[i] * TWO);
-            Rxz[i] = Rxz[i] + ( fxz[i] - (chix[i] * chiz[i]) / (chin1[i] * TWO) + gxz[i] * f[i] ) / (chin1[i] * TWO);
-            Ryz[i] = Ryz[i] + ( fyz[i] - (chiy[i] * chiz[i]) / (chin1[i] * TWO) + gyz[i] * f[i] ) / (chin1[i] * TWO);
+            Rxy[i] = Rxy[i] + ( cxy - half_inv_chin1 * chix[i] * chiy[i] + gxy[i] * ricci_chi ) * half_inv_chin1;
+            Rxz[i] = Rxz[i] + ( cxz - half_inv_chin1 * chix[i] * chiz[i] + gxz[i] * ricci_chi ) * half_inv_chin1;
+            Ryz[i] = Ryz[i] + ( cyz - half_inv_chin1 * chiy[i] * chiz[i] + gyz[i] * ricci_chi ) * half_inv_chin1;
        }

        // 24ms //
        fdderivs(ex,Lap,fxx,fxy,fxz,fyy,fyz,fzz,X,Y,Z,SYM,SYM,SYM,Symmetry,Lev);
-        fderivs(ex,chi,dtSfx_rhs,dtSfy_rhs,dtSfz_rhs,X,Y,Z,SYM,SYM,SYM,Symmetry,Lev);

        // 6ms //
        for (int i=0;i<all;i+=1) {
-            /* gxxx,gxxy,gxxz (这里是“升指标后的chi导数/chi”那类量，你沿用原变量名即可) */
-            gxxx[i] = (gupxx[i] * chix[i] + gupxy[i] * chiy[i] + gupxz[i] * chiz[i]) / chin1[i];
-            gxxy[i] = (gupxy[i] * chix[i] + gupyy[i] * chiy[i] + gupyz[i] * chiz[i]) / chin1[i];
-            gxxz[i] = (gupxz[i] * chix[i] + gupyz[i] * chiy[i] + gupzz[i] * chiz[i]) / chin1[i];
+            const double inv_chin1 = ONE / chin1[i];
+            const double gchi_x = (gupxx[i] * chix[i] + gupxy[i] * chiy[i] + gupxz[i] * chiz[i]) * inv_chin1;
+            const double gchi_y = (gupxy[i] * chix[i] + gupyy[i] * chiy[i] + gupyz[i] * chiz[i]) * inv_chin1;
+            const double gchi_z = (gupxz[i] * chix[i] + gupyz[i] * chiy[i] + gupzz[i] * chiz[i]) * inv_chin1;

            /* Christoffel 修正项 */
-            Gamxxx[i] = Gamxxx[i] - ( ((chix[i] + chix[i]) / chin1[i]) - (dxx[i] + ONE) * gxxx[i] ) * HALF;
-            Gamyxx[i] = Gamyxx[i] - ( 0.0           - (dxx[i] + ONE) * gxxy[i] ) * HALF;  /* 原式只有 -gxx*gxxy */
-            Gamzxx[i] = Gamzxx[i] - ( 0.0           - (dxx[i] + ONE) * gxxz[i] ) * HALF;
+            Gamxxx[i] = Gamxxx[i] - ( ((chix[i] + chix[i]) * inv_chin1) - (dxx[i] + ONE) * gchi_x ) * HALF;
+            Gamyxx[i] = Gamyxx[i] - ( 0.0           - (dxx[i] + ONE) * gchi_y ) * HALF;  /* 原式只有 -gxx*gxxy */
+            Gamzxx[i] = Gamzxx[i] - ( 0.0           - (dxx[i] + ONE) * gchi_z ) * HALF;

-            Gamxyy[i] = Gamxyy[i] - ( 0.0           - (dyy[i] + ONE) * gxxx[i] ) * HALF;
-            Gamyyy[i] = Gamyyy[i] - ( ((chiy[i] + chiy[i]) / chin1[i]) - (dyy[i] + ONE) * gxxy[i] ) * HALF;
-            Gamzyy[i] = Gamzyy[i] - ( 0.0           - (dyy[i] + ONE) * gxxz[i] ) * HALF;
+            Gamxyy[i] = Gamxyy[i] - ( 0.0           - (dyy[i] + ONE) * gchi_x ) * HALF;
+            Gamyyy[i] = Gamyyy[i] - ( ((chiy[i] + chiy[i]) * inv_chin1) - (dyy[i] + ONE) * gchi_y ) * HALF;
+            Gamzyy[i] = Gamzyy[i] - ( 0.0           - (dyy[i] + ONE) * gchi_z ) * HALF;

-            Gamxzz[i] = Gamxzz[i] - ( 0.0           - (dzz[i] + ONE) * gxxx[i] ) * HALF;
-            Gamyzz[i] = Gamyzz[i] - ( 0.0           - (dzz[i] + ONE) * gxxy[i] ) * HALF;
-            Gamzzz[i] = Gamzzz[i] - ( ((chiz[i] + chiz[i]) / chin1[i]) - (dzz[i] + ONE) * gxxz[i] ) * HALF;
+            Gamxzz[i] = Gamxzz[i] - ( 0.0           - (dzz[i] + ONE) * gchi_x ) * HALF;
+            Gamyzz[i] = Gamyzz[i] - ( 0.0           - (dzz[i] + ONE) * gchi_y ) * HALF;
+            Gamzzz[i] = Gamzzz[i] - ( ((chiz[i] + chiz[i]) * inv_chin1) - (dzz[i] + ONE) * gchi_z ) * HALF;

-            Gamxxy[i] = Gamxxy[i] - ( ( chiy[i] / chin1[i])      - gxy[i] * gxxx[i] ) * HALF;
-            Gamyxy[i] = Gamyxy[i] - ( ( chix[i] / chin1[i])      - gxy[i] * gxxy[i] ) * HALF;
-            Gamzxy[i] = Gamzxy[i] - ( 0.0           - gxy[i] * gxxz[i] ) * HALF;
+            Gamxxy[i] = Gamxxy[i] - ( ( chiy[i] * inv_chin1)      - gxy[i] * gchi_x ) * HALF;
+            Gamyxy[i] = Gamyxy[i] - ( ( chix[i] * inv_chin1)      - gxy[i] * gchi_y ) * HALF;
+            Gamzxy[i] = Gamzxy[i] - ( 0.0           - gxy[i] * gchi_z ) * HALF;

-            Gamxxz[i] = Gamxxz[i] - ( ( chiz[i] / chin1[i])      - gxz[i] * gxxx[i] ) * HALF;
-            Gamyxz[i] = Gamyxz[i] - ( 0.0           - gxz[i] * gxxy[i] ) * HALF;
-            Gamzxz[i] = Gamzxz[i] - ( ( chix[i] / chin1[i])      - gxz[i] * gxxz[i] ) * HALF;
+            Gamxxz[i] = Gamxxz[i] - ( ( chiz[i] * inv_chin1)      - gxz[i] * gchi_x ) * HALF;
+            Gamyxz[i] = Gamyxz[i] - ( 0.0           - gxz[i] * gchi_y ) * HALF;
+            Gamzxz[i] = Gamzxz[i] - ( ( chix[i] * inv_chin1)      - gxz[i] * gchi_z ) * HALF;

-            Gamxyz[i] = Gamxyz[i] - ( 0.0           - gyz[i] * gxxx[i] ) * HALF;
-            Gamyyz[i] = Gamyyz[i] - ( ( chiz[i] / chin1[i])      - gyz[i] * gxxy[i] ) * HALF;
-            Gamzyz[i] = Gamzyz[i] - ( ( chiy[i] / chin1[i])      - gyz[i] * gxxz[i] ) * HALF;
+            Gamxyz[i] = Gamxyz[i] - ( 0.0           - gyz[i] * gchi_x ) * HALF;
+            Gamyyz[i] = Gamyyz[i] - ( ( chiz[i] * inv_chin1)      - gyz[i] * gchi_y ) * HALF;
+            Gamzyz[i] = Gamzyz[i] - ( ( chiy[i] * inv_chin1)      - gyz[i] * gchi_z ) * HALF;

            /* fxx..fyz 修正：减去 Γ * ∂Lap */
            fxx[i] = fxx[i] - Gamxxx[i] * Lapx[i] - Gamyxx[i] * Lapy[i] - Gamzxx[i] * Lapz[i];
@@ -762,6 +844,8 @@ int f_compute_rhs_bssn(int *ex, double &T,
            trK_rhs[i] =  gupxx[i] * fxx[i] + gupyy[i] * fyy[i] + gupzz[i] * fzz[i]
                    +  TWO * ( gupxy[i] * fxy[i] + gupxz[i] * fxz[i] + gupyz[i] * fyz[i] );
        }
+        RHS_KERNEL_TIMER_ADD(KB_CHI_LAPSE, timer_chi_lapse);
+        RHS_KERNEL_TIMER_DECL(timer_aij_trk_gauge);
        // 2.5ms //
        for (int i=0;i<all;i+=1) {
            const double divb = betaxx[i] + betayy[i] + betazz[i];
@@ -1062,6 +1146,8 @@ int f_compute_rhs_bssn(int *ex, double &T,
            dtSfz_rhs[i] = Gamz_rhs[i] - reta[i] * dtSfz[i];
            #endif
        }
+        RHS_KERNEL_TIMER_ADD(KB_AIJ_TRK_GAUGE, timer_aij_trk_gauge);
+        RHS_KERNEL_TIMER_DECL(timer_ko_constraint);
        // advection + KO dissipation with shared symmetry buffer
        lopsided_kodis(ex,X,Y,Z,dxx,gxx_rhs,betax,betay,betaz,Symmetry,SSS,eps);
        lopsided_kodis(ex,X,Y,Z,Gamz,Gamz_rhs,betax,betay,betaz,Symmetry,SSA,eps);
@@ -1193,6 +1279,7 @@ int f_compute_rhs_bssn(int *ex, double &T,
                movz_Res[i] = movz_Res[i] - F2o3*Kz[i] - F8*PI*Sz[i];
            }
        }
+        RHS_KERNEL_TIMER_ADD(KB_KO_CONSTRAINT, timer_ko_constraint);


            
--- a/AMSS_NCKU_source/fmisc.f90
+++ b/AMSS_NCKU_source/fmisc.f90
@@ -1514,6 +1514,81 @@ f_out = f_out*dX*dY*dZ
  return

  end subroutine l2normhelper
+!--------------------------------------------------------------------------------------
+  subroutine l2normhelper7(ex, X, Y, Z,xmin,ymin,zmin,xmax,ymax,zmax,&
+                           f1,f2,f3,f4,f5,f6,f7,f_out,gw)
+
+  implicit none
+!~~~~~~> Input parameters:
+  integer,intent(in ):: ex(1:3)
+  real*8, intent(in ):: X(1:ex(1)),Y(1:ex(2)),Z(1:ex(3)),xmin,ymin,zmin,xmax,ymax,zmax
+  integer,intent(in)::gw
+  real*8, dimension(ex(1),ex(2),ex(3)),intent(in) :: f1,f2,f3,f4,f5,f6,f7
+  real*8, intent(out) :: f_out(7)
+!~~~~~~> Other variables:
+
+  real*8            :: dX, dY, dZ
+  integer::imin,jmin,kmin
+  integer::imax,jmax,kmax
+  integer::i,j,k
+  real*8 :: s1,s2,s3,s4,s5,s6,s7
+
+  dX = X(2) - X(1)
+  dY = Y(2) - Y(1)
+  dZ = Z(2) - Z(1)
+
+! for ghost zone
+   imin = gw+1
+   jmin = gw+1
+   kmin = gw+1
+
+   imax = ex(1) - gw
+   jmax = ex(2) - gw
+   kmax = ex(3) - gw
+
+!for patch boundary (i.e., not ghost boundary)
+
+if(dabs(X(ex(1))-xmax) < dX) imax = ex(1)
+if(dabs(Y(ex(2))-ymax) < dY) jmax = ex(2)
+if(dabs(Z(ex(3))-zmax) < dZ) kmax = ex(3)
+if(dabs(X(1)-xmin) < dX) imin = 1
+if(dabs(Y(1)-ymin) < dY) jmin = 1
+if(dabs(Z(1)-zmin) < dZ) kmin = 1
+
+  s1 = 0.d0
+  s2 = 0.d0
+  s3 = 0.d0
+  s4 = 0.d0
+  s5 = 0.d0
+  s6 = 0.d0
+  s7 = 0.d0
+
+  do k=kmin,kmax
+    do j=jmin,jmax
+!DIR$ SIMD REDUCTION(+:s1,s2,s3,s4,s5,s6,s7)
+      do i=imin,imax
+        s1 = s1 + f1(i,j,k)*f1(i,j,k)
+        s2 = s2 + f2(i,j,k)*f2(i,j,k)
+        s3 = s3 + f3(i,j,k)*f3(i,j,k)
+        s4 = s4 + f4(i,j,k)*f4(i,j,k)
+        s5 = s5 + f5(i,j,k)*f5(i,j,k)
+        s6 = s6 + f6(i,j,k)*f6(i,j,k)
+        s7 = s7 + f7(i,j,k)*f7(i,j,k)
+      enddo
+    enddo
+  enddo
+
+  f_out(1) = s1*dX*dY*dZ
+  f_out(2) = s2*dX*dY*dZ
+  f_out(3) = s3*dX*dY*dZ
+  f_out(4) = s4*dX*dY*dZ
+  f_out(5) = s5*dX*dY*dZ
+  f_out(6) = s6*dX*dY*dZ
+  f_out(7) = s7*dX*dY*dZ
+
+  return
+
+  end subroutine l2normhelper7
 !--------------------------------------------------------------------------------------
 ! calculate L2norm especially for shell Blocks
  subroutine l2normhelper_sh(ex, X, Y, Z,xmin,ymin,zmin,xmax,ymax,zmax,&
--- a/AMSS_NCKU_source/fmisc.h
+++ b/AMSS_NCKU_source/fmisc.h
@@ -13,6 +13,7 @@
 #define f_global_interpind2d global_interpind2d
 #define f_global_interpind1d global_interpind1d
 #define f_l2normhelper l2normhelper
+#define f_l2normhelper7 l2normhelper7
 #define f_l2normhelper_sh l2normhelper_sh
 #define f_l2normhelper_sh_rms l2normhelper_sh_rms
 #define f_average average
@@ -42,6 +43,7 @@
 #define f_global_interpind2d GLOBAL_INTERPIND2D
 #define f_global_interpind1d GLOBAL_INTERPIND1D
 #define f_l2normhelper L2NORMHELPER
+#define f_l2normhelper7 L2NORMHELPER7
 #define f_l2normhelper_sh L2NORMHELPER_SH
 #define f_l2normhelper_sh_rms L2NORMHELPER_SH_RMS
 #define f_average AVERAGE
@@ -71,6 +73,7 @@
 #define f_global_interpind2d global_interpind2d_
 #define f_global_interpind1d global_interpind1d_
 #define f_l2normhelper l2normhelper_
+#define f_l2normhelper7 l2normhelper7_
 #define f_l2normhelper_sh l2normhelper_sh_
 #define f_l2normhelper_sh_rms l2normhelper_sh_rms_
 #define f_average average_
@@ -164,6 +167,15 @@ extern "C"
 						double *, double &, int &);
 }

+extern "C"
+{
+	void f_l2normhelper7(int *, double *, double *, double *,
+						 double &, double &, double &,
+						 double &, double &, double &,
+						 double *, double *, double *, double *,
+						 double *, double *, double *, double *, int &);
+}
+
 extern "C"
 {
 	void f_l2normhelper_sh(int *, double *, double *, double *,
--- a/AMSS_NCKU_source/gaussj.C
+++ b/AMSS_NCKU_source/gaussj.C
@@ -18,7 +18,7 @@ using namespace std;
 #endif

 // Intel oneMKL LAPACK interface
-#include <mkl_lapacke.h>
+#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
--- a/AMSS_NCKU_source/macrodef.h
+++ b/AMSS_NCKU_source/macrodef.h
@@ -29,6 +29,16 @@

 #define REGLEV 0

+#define BSSN_FINE_TIMING 0
+
+#define BSSN_FINE_TIMING_EVERY 1
+
+#define BSSN_FINE_TIMING_TOPN 8
+
+#define BSSN_KERNEL_FINE_TIMING 0
+
+#define BSSN_ENABLE_STDIN_ABORT_POLL 0
+
 //#define USE_GPU

 //#define CHECKDETAIL
@@ -88,6 +98,21 @@
 //     0: for every level;
 //     1: for all
 //
+// define BSSN_FINE_TIMING
+//     enable fine-grained per-timestep timing monitor
+//
+// define BSSN_FINE_TIMING_EVERY
+//     report timing every N coarse timesteps
+//
+// define BSSN_FINE_TIMING_TOPN
+//     number of hottest timing buckets shown in stdout
+//
+// define BSSN_KERNEL_FINE_TIMING
+//     enable split timing inside compute_rhs_bssn
+//
+// define BSSN_ENABLE_STDIN_ABORT_POLL
+//     poll stdin and broadcast abort flag every coarse step
+//
 // define USE_GPU
 //     use gpu or not
 //
@@ -142,4 +167,3 @@
 #define TINY 1e-10

 #endif   /* MICRODEF_H */
-
--- a/AMSS_NCKU_source/makefile
+++ b/AMSS_NCKU_source/makefile
@@ -2,34 +2,50 @@

 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
+
 ## 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)
-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)
-f90appflags = -O3 -xHost -fp-model fast=2 -fma -ipo \
-              -align array64byte -fpp -I${MKLROOT}/include $(POLINT6_FLAG)
-endif
+## AMD AOCC build flags optimized for EPYC Zen 4 (-march=znver4)
+CXXAPPFLAGS = -O3 -march=znver4 -ffast-math -flto \
+              -Dfortran3 -Dnewc -I$(AOCL_ROOT)/include $(INTERP_LB_FLAGS) \
+              $(TRANSFER_CACHE_FLAG) $(ESCALAR_KERNEL_FLAG)
+f90appflags = -O3 -march=znver4 -ffast-math -flto \
+              -cpp -I$(AOCL_ROOT)/include $(POLINT6_FLAG)

 .SUFFIXES: .o .f90 .C .for .cu

@@ -67,17 +83,15 @@ lopsided_kodis_c.o: lopsided_kodis_c.C
 #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
+## TwoPunctureABE uses fixed optimal flags (AMD AOCC, no PGO)
+TP_OPTFLAGS = -O3 -march=znver4 -ffast-math -flto \
+              -Dfortran3 -Dnewc -I$(AOCL_ROOT)/include

 TwoPunctures.o: TwoPunctures.C
-	${CXX} $(TP_OPTFLAGS) -qopenmp -c $< -o $@
+	${CXX} $(TP_OPTFLAGS) -fopenmp -c $< -o $@

 TwoPunctureABE.o: TwoPunctureABE.C
-	${CXX} $(TP_OPTFLAGS) -qopenmp -c $< -o $@
+	${CXX} $(TP_OPTFLAGS) -fopenmp -c $< -o $@

 # Input files

@@ -86,8 +100,11 @@ 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_rhs and helper kernels
+# 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
 endif

 ## RK4 kernel switch (independent from USE_CXX_KERNELS)
@@ -185,7 +202,7 @@ ABEGPU: $(C++FILES_GPU) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS) $(CUDAFILE
 	$(CLINKER) $(CXXAPPFLAGS) -o $@ $(C++FILES_GPU) $(CFILES) $(F90FILES) $(F77FILES) $(AHFDOBJS) $(CUDAFILES) $(LDLIBS)

 TwoPunctureABE: $(TwoPunctureFILES)
-	$(CLINKER) $(TP_OPTFLAGS) -qopenmp -o $@ $(TwoPunctureFILES) $(LDLIBS)
+	$(CLINKER) $(TP_OPTFLAGS) -fopenmp -o $@ $(TwoPunctureFILES) $(LDLIBS)

 clean:
 	rm *.o ABE ABEGPU TwoPunctureABE make.log -f
--- a/AMSS_NCKU_source/makefile.inc
+++ b/AMSS_NCKU_source/makefile.inc
@@ -1,33 +1,17 @@
-## 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
+## AMD AOCC version with AOCL (Optimized for AMD EPYC Zen 4)

-## Intel oneAPI version with oneMKL (Optimized for performance)
-filein  = -I/usr/include/ -I${MKLROOT}/include
+## AOCL root path for includes and libraries
+AOCL_ROOT ?= /home/gh0s7/AOCC/aocl/5.2.0/aocc

-## 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
+## AOCC-built OpenMPI prefix
+OMPI_PREFIX ?= /home/gh0s7/AOCC/aocc-openmpi

-## 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
+filein  = -I/usr/include/ -I$(AOCL_ROOT)/include

-## PGO build mode switch (ABE only; TwoPunctureABE always uses opt flags)
-##   opt        : (default) maximum performance with PGO profile-guided optimization
-##   instrument : PGO Phase 1 instrumentation to collect fresh profile data
-PGO_MODE ?= opt
+## Using AOCL BLIS + libFLAME for BLAS/LAPACK
+## AOCC Fortran runtime: -lflang (includes FortranRuntime)
+## AOCC OpenMP runtime: -lomp (LLVM OpenMP)
+LDLIBS  = -L$(AOCL_ROOT)/lib -lblis -lflame -lamdlibm -lflang -lpgmath -lpthread -lm -ldl -lomp

 ## Interp_Points load balance profiling mode
 ##   off        : (default) no load balance instrumentation
@@ -48,16 +32,28 @@ endif
 ##   0           : fall back to original Fortran kernels
 USE_CXX_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
+
+## 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

-f90          = ifx
-f77          = ifx
-CXX          = icpx
-CC           = icx
-CLINKER      = mpiicpx
+f90          = flang
+f77          = flang
+CXX          = clang++
+CC           = clang
+CLINKER      = $(OMPI_PREFIX)/bin/mpicxx

 Cu = nvcc
 CUDA_LIB_PATH = -L/usr/lib/cuda/lib64 -I/usr/include -I/usr/lib/cuda/include
--- a/AMSS_NCKU_source/surface_integral.C
+++ b/AMSS_NCKU_source/surface_integral.C
@@ -36,7 +36,14 @@ using namespace std;
 //| Constructor
 //|============================================================================

-surface_integral::surface_integral(int iSymmetry) : Symmetry(iSymmetry)
+surface_integral::surface_integral(int iSymmetry) : Symmetry(iSymmetry),
+                                                    wave_cache_spinw(-1),
+                                                    wave_cache_maxl(-1),
+                                                    wave_cache_modes(0),
+                                                    wave_theta_pos(0),
+                                                    wave_theta_neg(0),
+                                                    wave_phi_cos(0),
+                                                    wave_phi_sin(0)
 {
  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
  MPI_Comm_size(MPI_COMM_WORLD, &cpusize);
@@ -182,6 +189,7 @@ surface_integral::surface_integral(int iSymmetry) : Symmetry(iSymmetry)
 //|============================================================================
 surface_integral::~surface_integral()
 {
+  clear_wave_cache();
  delete[] nx_g;
  delete[] ny_g;
  delete[] nz_g;
@@ -190,6 +198,65 @@ surface_integral::~surface_integral()
  delete[] wtcostheta;
 #endif
 }
+void surface_integral::clear_wave_cache()
+{
+  delete[] wave_theta_pos;
+  delete[] wave_theta_neg;
+  delete[] wave_phi_cos;
+  delete[] wave_phi_sin;
+  wave_theta_pos = 0;
+  wave_theta_neg = 0;
+  wave_phi_cos = 0;
+  wave_phi_sin = 0;
+  wave_cache_spinw = -1;
+  wave_cache_maxl = -1;
+  wave_cache_modes = 0;
+}
+void surface_integral::build_wave_cache(int spinw, int maxl)
+{
+  if (wave_cache_spinw == spinw && wave_cache_maxl == maxl && wave_theta_pos && wave_theta_neg && wave_phi_cos && wave_phi_sin)
+    return;
+
+  clear_wave_cache();
+
+  int modes = 0;
+  for (int pl = spinw; pl < maxl + 1; pl++)
+    for (int pm = -pl; pm < pl + 1; pm++)
+      modes++;
+
+  wave_theta_pos = new double[modes * N_theta];
+  wave_theta_neg = new double[modes * N_theta];
+  wave_phi_cos = new double[modes * N_phi];
+  wave_phi_sin = new double[modes * N_phi];
+
+  int countlm = 0;
+  for (int pl = spinw; pl < maxl + 1; pl++)
+    for (int pm = -pl; pm < pl + 1; pm++)
+    {
+      const double prefactor = sqrt((2 * pl + 1.0) / 4.0 / PI);
+      for (int i = 0; i < N_theta; i++)
+      {
+#ifdef GaussInt
+        const double weight = wtcostheta[i];
+#else
+        const double weight = 1.0;
+#endif
+        wave_theta_pos[countlm * N_theta + i] = prefactor * misc::Wigner_d_function(pl, pm, spinw, arcostheta[i]) * weight;
+        wave_theta_neg[countlm * N_theta + i] = prefactor * misc::Wigner_d_function(pl, pm, spinw, -arcostheta[i]) * weight;
+      }
+      for (int j = 0; j < N_phi; j++)
+      {
+        const double phase = pm * (j + 0.5) * dphi;
+        wave_phi_cos[countlm * N_phi + j] = cos(phase);
+        wave_phi_sin[countlm * N_phi + j] = sin(phase);
+      }
+      countlm++;
+    }
+
+  wave_cache_spinw = spinw;
+  wave_cache_maxl = maxl;
+  wave_cache_modes = modes;
+}
 //|----------------------------------------------------------------
 //  spin weighted spinw component of psi4, general routine
 //  l takes from spinw to maxl; m takes from -l to l
@@ -264,6 +331,39 @@ void surface_integral::surf_Wave(double rex, int lev, cgh *GH, var *Rpsi4, var *
    lpsy = 8;

  double psi4RR, psi4II;
+  if (Symmetry == 0 || Symmetry == 1)
+  {
+    build_wave_cache(spinw, maxl);
+    for (n = Nmin; n <= Nmax; n++)
+    {
+      i = int(n / N_phi);
+      j = n - i * N_phi;
+
+      const double psi4RR0 = shellf[InList * n];
+      const double psi4II0 = shellf[InList * n + 1];
+      const double psi4RR1 = Rpsi4->SoA[2] * psi4RR0;
+      const double psi4II1 = Ipsi4->SoA[2] * psi4II0;
+      for (int countlm = 0; countlm < wave_cache_modes; countlm++)
+      {
+        const int theta_idx = countlm * N_theta + i;
+        const int phi_idx = countlm * N_phi + j;
+        const double theta_pos = wave_theta_pos[theta_idx];
+        const double cosmphi_here = wave_phi_cos[phi_idx];
+        const double sinmphi_here = wave_phi_sin[phi_idx];
+
+        RP_out[countlm] += theta_pos * (psi4RR0 * cosmphi_here + psi4II0 * sinmphi_here);
+        IP_out[countlm] += theta_pos * (psi4II0 * cosmphi_here - psi4RR0 * sinmphi_here);
+        if (Symmetry == 1)
+        {
+          const double theta_neg = wave_theta_neg[theta_idx];
+          RP_out[countlm] += theta_neg * (psi4RR1 * cosmphi_here + psi4II1 * sinmphi_here);
+          IP_out[countlm] += theta_neg * (psi4II1 * cosmphi_here - psi4RR1 * sinmphi_here);
+        }
+      }
+    }
+  }
+  else
+  {
    for (n = Nmin; n <= Nmax; n++)
    {
      //       need round off always
@@ -348,6 +448,7 @@ void surface_integral::surf_Wave(double rex, int lev, cgh *GH, var *Rpsi4, var *
          countlm++; // no sanity check for countlm and NN which should be noted in the input parameters
        }
    }
+  }

  for (int ii = 0; ii < NN; ii++)
  {
@@ -466,6 +567,39 @@ void surface_integral::surf_Wave(double rex, int lev, cgh *GH, var *Rpsi4, var *
    lpsy = 8;

  double psi4RR, psi4II;
+  if (Symmetry == 0 || Symmetry == 1)
+  {
+    build_wave_cache(spinw, maxl);
+    for (n = Nmin; n <= Nmax; n++)
+    {
+      i = int(n / N_phi);
+      j = n - i * N_phi;
+
+      const double psi4RR0 = shellf[InList * n];
+      const double psi4II0 = shellf[InList * n + 1];
+      const double psi4RR1 = Rpsi4->SoA[2] * psi4RR0;
+      const double psi4II1 = Ipsi4->SoA[2] * psi4II0;
+      for (int countlm = 0; countlm < wave_cache_modes; countlm++)
+      {
+        const int theta_idx = countlm * N_theta + i;
+        const int phi_idx = countlm * N_phi + j;
+        const double theta_pos = wave_theta_pos[theta_idx];
+        const double cosmphi_here = wave_phi_cos[phi_idx];
+        const double sinmphi_here = wave_phi_sin[phi_idx];
+
+        RP_out[countlm] += theta_pos * (psi4RR0 * cosmphi_here + psi4II0 * sinmphi_here);
+        IP_out[countlm] += theta_pos * (psi4II0 * cosmphi_here - psi4RR0 * sinmphi_here);
+        if (Symmetry == 1)
+        {
+          const double theta_neg = wave_theta_neg[theta_idx];
+          RP_out[countlm] += theta_neg * (psi4RR1 * cosmphi_here + psi4II1 * sinmphi_here);
+          IP_out[countlm] += theta_neg * (psi4II1 * cosmphi_here - psi4RR1 * sinmphi_here);
+        }
+      }
+    }
+  }
+  else
+  {
    for (n = Nmin; n <= Nmax; n++)
    {
      //       need round off always
@@ -550,6 +684,7 @@ void surface_integral::surf_Wave(double rex, int lev, cgh *GH, var *Rpsi4, var *
          countlm++; // no sanity check for countlm and NN which should be noted in the input parameters
        }
    }
+  }

  for (int ii = 0; ii < NN; ii++)
  {
@@ -2319,7 +2454,7 @@ void surface_integral::surf_MassPAng(double rex, int lev, cgh *GH, var *chi, var
                                     var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
                                     var *Gmx, var *Gmy, var *Gmz,
                                     var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs, // temparay memory for mass^i
-                                     double *Rout, monitor *Monitor)
+                                     double *Rout, monitor *Monitor, bool refresh_mass_fields)
 {
  if (myrank == 0 && GH->grids[lev] != 1)
    if (Monitor && Monitor->outfile)
@@ -2329,6 +2464,8 @@ void surface_integral::surf_MassPAng(double rex, int lev, cgh *GH, var *chi, var

  double mass, px, py, pz, sx, sy, sz;

+  if (refresh_mass_fields)
+  {
    MyList<Patch> *Pp = GH->PatL[lev];
    while (Pp)
    {
@@ -2352,6 +2489,7 @@ void surface_integral::surf_MassPAng(double rex, int lev, cgh *GH, var *chi, var
      }
      Pp = Pp->next;
    }
+  }

  const int InList = 17;

@@ -2581,7 +2719,7 @@ void surface_integral::surf_MassPAng(double rex, int lev, cgh *GH, var *chi, var
                                     var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
                                     var *Gmx, var *Gmy, var *Gmz,
                                     var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs, // temparay memory for mass^i
-                                     double *Rout, monitor *Monitor, MPI_Comm Comm_here)
+                                     double *Rout, monitor *Monitor, MPI_Comm Comm_here, bool refresh_mass_fields)
 {
  int lmyrank;
  MPI_Comm_rank(Comm_here, &lmyrank);
@@ -2593,6 +2731,8 @@ void surface_integral::surf_MassPAng(double rex, int lev, cgh *GH, var *chi, var

  double mass, px, py, pz, sx, sy, sz;

+  if (refresh_mass_fields)
+  {
    MyList<Patch> *Pp = GH->PatL[lev];
    while (Pp)
    {
@@ -2616,6 +2756,7 @@ void surface_integral::surf_MassPAng(double rex, int lev, cgh *GH, var *chi, var
      }
      Pp = Pp->next;
    }
+  }

  const int InList = 17;

@@ -2853,7 +2994,7 @@ void surface_integral::surf_MassPAng(double rex, int lev, ShellPatch *GH, var *c
                                     var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
                                     var *Gmx, var *Gmy, var *Gmz,
                                     var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs, // temparay memory for mass^i
-                                     double *Rout, monitor *Monitor)
+                                     double *Rout, monitor *Monitor, bool refresh_mass_fields)
 {
  if (lev != 0)
  {
@@ -2869,6 +3010,8 @@ void surface_integral::surf_MassPAng(double rex, int lev, ShellPatch *GH, var *c

  double mass, px, py, pz, sx, sy, sz;

+  if (refresh_mass_fields)
+  {
    MyList<ss_patch> *Pp = GH->PatL;
    while (Pp)
    {
@@ -2903,6 +3046,7 @@ void surface_integral::surf_MassPAng(double rex, int lev, ShellPatch *GH, var *c
      }
      Pp = Pp->next;
    }
+  }

  const int InList = 17;

@@ -3128,6 +3272,626 @@ void surface_integral::surf_MassPAng(double rex, int lev, ShellPatch *GH, var *c
  delete[] shellf;
  DG_List->clearList();
 }
+void surface_integral::surf_WaveMassPAng(double rex, int lev, cgh *GH,
+                                         var *Rpsi4, var *Ipsi4, int spinw, int maxl, int NN, double *RP, double *IP,
+                                         var *chi, var *trK,
+                                         var *gxx, var *gxy, var *gxz, var *gyy, var *gyz, var *gzz,
+                                         var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
+                                         var *Gmx, var *Gmy, var *Gmz,
+                                         var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs,
+                                         double *Rout, monitor *Monitor, bool refresh_mass_fields)
+{
+  if (Symmetry != 0 && Symmetry != 1)
+  {
+    surf_Wave(rex, lev, GH, Rpsi4, Ipsi4, spinw, maxl, NN, RP, IP, Monitor);
+    surf_MassPAng(rex, lev, GH, chi, trK,
+                  gxx, gxy, gxz, gyy, gyz, gzz,
+                  Axx, Axy, Axz, Ayy, Ayz, Azz,
+                  Gmx, Gmy, Gmz,
+                  Sfx_rhs, Sfy_rhs, Sfz_rhs,
+                  Rout, Monitor, refresh_mass_fields);
+    return;
+  }
+
+  if (myrank == 0 && GH->grids[lev] != 1)
+    if (Monitor && Monitor->outfile)
+      Monitor->outfile << "WARNING: surface integral on multipatches" << endl;
+    else
+      cout << "WARNING: surface integral on multipatches" << endl;
+
+  if (refresh_mass_fields)
+  {
+    MyList<Patch> *Pp = GH->PatL[lev];
+    while (Pp)
+    {
+      MyList<Block> *BP = Pp->data->blb;
+      while (BP)
+      {
+        Block *cg = BP->data;
+        if (myrank == cg->rank)
+        {
+          f_admmass_bssn(cg->shape, cg->X[0], cg->X[1], cg->X[2],
+                         cg->fgfs[chi->sgfn], cg->fgfs[trK->sgfn],
+                         cg->fgfs[gxx->sgfn], cg->fgfs[gxy->sgfn], cg->fgfs[gxz->sgfn], cg->fgfs[gyy->sgfn], cg->fgfs[gyz->sgfn], cg->fgfs[gzz->sgfn],
+                         cg->fgfs[Axx->sgfn], cg->fgfs[Axy->sgfn], cg->fgfs[Axz->sgfn], cg->fgfs[Ayy->sgfn], cg->fgfs[Ayz->sgfn], cg->fgfs[Azz->sgfn],
+                         cg->fgfs[Gmx->sgfn], cg->fgfs[Gmy->sgfn], cg->fgfs[Gmz->sgfn],
+                         cg->fgfs[Sfx_rhs->sgfn], cg->fgfs[Sfy_rhs->sgfn], cg->fgfs[Sfz_rhs->sgfn],
+                         Symmetry);
+        }
+        if (BP == Pp->data->ble)
+          break;
+        BP = BP->next;
+      }
+      Pp = Pp->next;
+    }
+  }
+
+  const int InList = 19;
+  const int idx_rpsi4 = 0, idx_ipsi4 = 1;
+  const int idx_sfx = 2, idx_sfy = 3, idx_sfz = 4;
+  const int idx_chi = 5, idx_trk = 6;
+  const int idx_gxx = 7, idx_gxy = 8, idx_gxz = 9, idx_gyy = 10, idx_gyz = 11, idx_gzz = 12;
+  const int idx_axx = 13, idx_axy = 14, idx_axz = 15, idx_ayy = 16, idx_ayz = 17, idx_azz = 18;
+
+  MyList<var> *DG_List = new MyList<var>(Rpsi4);
+  DG_List->insert(Ipsi4);
+  DG_List->insert(Sfx_rhs);
+  DG_List->insert(Sfy_rhs);
+  DG_List->insert(Sfz_rhs);
+  DG_List->insert(chi);
+  DG_List->insert(trK);
+  DG_List->insert(gxx);
+  DG_List->insert(gxy);
+  DG_List->insert(gxz);
+  DG_List->insert(gyy);
+  DG_List->insert(gyz);
+  DG_List->insert(gzz);
+  DG_List->insert(Axx);
+  DG_List->insert(Axy);
+  DG_List->insert(Axz);
+  DG_List->insert(Ayy);
+  DG_List->insert(Ayz);
+  DG_List->insert(Azz);
+
+  int n;
+  double *pox[3];
+  for (int ia = 0; ia < 3; ia++)
+    pox[ia] = new double[n_tot];
+  for (n = 0; n < n_tot; n++)
+  {
+    pox[0][n] = rex * nx_g[n];
+    pox[1][n] = rex * ny_g[n];
+    pox[2][n] = rex * nz_g[n];
+  }
+
+  int mp, Lp, Nmin, Nmax;
+  mp = n_tot / cpusize;
+  Lp = n_tot - cpusize * mp;
+  if (Lp > myrank)
+  {
+    Nmin = myrank * mp + myrank;
+    Nmax = Nmin + mp;
+  }
+  else
+  {
+    Nmin = myrank * mp + Lp;
+    Nmax = Nmin + mp - 1;
+  }
+
+  double *shellf = new double[n_tot * InList];
+  GH->PatL[lev]->data->Interp_Points(DG_List, n_tot, pox, shellf, Symmetry, Nmin, Nmax);
+
+  double *RP_out = new double[NN];
+  double *IP_out = new double[NN];
+  for (int ii = 0; ii < NN; ii++)
+  {
+    RP_out[ii] = 0.0;
+    IP_out[ii] = 0.0;
+  }
+
+  double Mass_out = 0.0;
+  double ang_outx = 0.0, ang_outy = 0.0, ang_outz = 0.0;
+  double p_outx = 0.0, p_outy = 0.0, p_outz = 0.0;
+  const double f1o8 = 0.125;
+
+  build_wave_cache(spinw, maxl);
+
+  for (n = Nmin; n <= Nmax; n++)
+  {
+    const int base = InList * n;
+    const int i = int(n / N_phi);
+    const int j = n - i * N_phi;
+
+    const double psi4RR0 = shellf[base + idx_rpsi4];
+    const double psi4II0 = shellf[base + idx_ipsi4];
+    const double psi4RR1 = Rpsi4->SoA[2] * psi4RR0;
+    const double psi4II1 = Ipsi4->SoA[2] * psi4II0;
+    for (int countlm = 0; countlm < wave_cache_modes; countlm++)
+    {
+      const int theta_idx = countlm * N_theta + i;
+      const int phi_idx = countlm * N_phi + j;
+      const double theta_pos = wave_theta_pos[theta_idx];
+      const double cosmphi_here = wave_phi_cos[phi_idx];
+      const double sinmphi_here = wave_phi_sin[phi_idx];
+
+      RP_out[countlm] += theta_pos * (psi4RR0 * cosmphi_here + psi4II0 * sinmphi_here);
+      IP_out[countlm] += theta_pos * (psi4II0 * cosmphi_here - psi4RR0 * sinmphi_here);
+      if (Symmetry == 1)
+      {
+        const double theta_neg = wave_theta_neg[theta_idx];
+        RP_out[countlm] += theta_neg * (psi4RR1 * cosmphi_here + psi4II1 * sinmphi_here);
+        IP_out[countlm] += theta_neg * (psi4II1 * cosmphi_here - psi4RR1 * sinmphi_here);
+      }
+    }
+
+    double Chi = shellf[base + idx_chi];
+    double TRK = shellf[base + idx_trk];
+    double Gxx = shellf[base + idx_gxx] + 1.0;
+    double Gxy = shellf[base + idx_gxy];
+    double Gxz = shellf[base + idx_gxz];
+    double Gyy = shellf[base + idx_gyy] + 1.0;
+    double Gyz = shellf[base + idx_gyz];
+    double Gzz = shellf[base + idx_gzz] + 1.0;
+    double axx = shellf[base + idx_axx];
+    double axy = shellf[base + idx_axy];
+    double axz = shellf[base + idx_axz];
+    double ayy = shellf[base + idx_ayy];
+    double ayz = shellf[base + idx_ayz];
+    double azz = shellf[base + idx_azz];
+
+    Chi = 1.0 / (1.0 + Chi);
+    const double Psi = Chi * sqrt(Chi);
+
+#ifdef GaussInt
+    const double theta_weight = wtcostheta[i];
+    Mass_out += (shellf[base + idx_sfx] * nx_g[n] + shellf[base + idx_sfy] * ny_g[n] + shellf[base + idx_sfz] * nz_g[n]) * theta_weight;
+#else
+    const double theta_weight = 1.0;
+    Mass_out += shellf[base + idx_sfx] * nx_g[n] + shellf[base + idx_sfy] * ny_g[n] + shellf[base + idx_sfz] * nz_g[n];
+#endif
+
+    double detg = Gxx * Gyy * Gzz + Gxy * Gyz * Gxz + Gxz * Gxy * Gyz -
+                  Gxz * Gyy * Gxz - Gxy * Gxy * Gzz - Gxx * Gyz * Gyz;
+    const double gupxx = (Gyy * Gzz - Gyz * Gyz) / detg;
+    const double gupxy = -(Gxy * Gzz - Gyz * Gxz) / detg;
+    const double gupxz = (Gxy * Gyz - Gyy * Gxz) / detg;
+    const double gupyy = (Gxx * Gzz - Gxz * Gxz) / detg;
+    const double gupyz = -(Gxx * Gyz - Gxy * Gxz) / detg;
+    const double gupzz = (Gxx * Gyy - Gxy * Gxy) / detg;
+
+    const double aupxx = gupxx * axx + gupxy * axy + gupxz * axz;
+    const double aupxy = gupxx * axy + gupxy * ayy + gupxz * ayz;
+    const double aupxz = gupxx * axz + gupxy * ayz + gupxz * azz;
+    const double aupyx = gupxy * axx + gupyy * axy + gupyz * axz;
+    const double aupyy = gupxy * axy + gupyy * ayy + gupyz * ayz;
+    const double aupyz = gupxy * axz + gupyy * ayz + gupyz * azz;
+    const double aupzx = gupxz * axx + gupyz * axy + gupzz * axz;
+    const double aupzy = gupxz * axy + gupyz * ayy + gupzz * ayz;
+    const double aupzz = gupxz * axz + gupyz * ayz + gupzz * azz;
+
+    if (Symmetry == 0)
+    {
+      ang_outx += f1o8 * Psi * (nx_g[n] * (pox[1][n] * aupxz - pox[2][n] * aupxy) + ny_g[n] * (pox[1][n] * aupyz - pox[2][n] * aupyy) + nz_g[n] * (pox[1][n] * aupzz - pox[2][n] * aupzy)) * theta_weight;
+      ang_outy += f1o8 * Psi * (nx_g[n] * (pox[2][n] * aupxx - pox[0][n] * aupxz) + ny_g[n] * (pox[2][n] * aupyx - pox[0][n] * aupyz) + nz_g[n] * (pox[2][n] * aupzx - pox[0][n] * aupzz)) * theta_weight;
+      ang_outz += f1o8 * Psi * (nx_g[n] * (pox[0][n] * aupxy - pox[1][n] * aupxx) + ny_g[n] * (pox[0][n] * aupyy - pox[1][n] * aupyx) + nz_g[n] * (pox[0][n] * aupzy - pox[1][n] * aupzx)) * theta_weight;
+    }
+    else
+    {
+      ang_outz += f1o8 * Psi * (nx_g[n] * (pox[0][n] * aupxy - pox[1][n] * aupxx) + ny_g[n] * (pox[0][n] * aupyy - pox[1][n] * aupyx) + nz_g[n] * (pox[0][n] * aupzy - pox[1][n] * aupzx)) * theta_weight;
+    }
+
+    axx = Chi * (axx + Gxx * TRK / 3.0);
+    axy = Chi * (axy + Gxy * TRK / 3.0);
+    axz = Chi * (axz + Gxz * TRK / 3.0);
+    ayy = Chi * (ayy + Gyy * TRK / 3.0);
+    ayz = Chi * (ayz + Gyz * TRK / 3.0);
+    azz = Chi * (azz + Gzz * TRK / 3.0);
+
+    axx -= TRK;
+    ayy -= TRK;
+    azz -= TRK;
+
+    p_outx += f1o8 * Psi * (nx_g[n] * axx + ny_g[n] * axy + nz_g[n] * axz) * theta_weight;
+    p_outy += f1o8 * Psi * (nx_g[n] * axy + ny_g[n] * ayy + nz_g[n] * ayz) * theta_weight;
+    if (Symmetry == 0)
+      p_outz += f1o8 * Psi * (nx_g[n] * axz + ny_g[n] * ayz + nz_g[n] * azz) * theta_weight;
+  }
+
+  for (int ii = 0; ii < NN; ii++)
+  {
+#ifdef GaussInt
+    RP_out[ii] = RP_out[ii] * rex * dphi;
+    IP_out[ii] = IP_out[ii] * rex * dphi;
+#else
+    RP_out[ii] = RP_out[ii] * rex * dphi * dcostheta;
+    IP_out[ii] = IP_out[ii] * rex * dphi * dcostheta;
+#endif
+  }
+
+  double mass, px, py, pz, sx, sy, sz;
+  {
+    double *reduce_out = new double[2 * NN + 7];
+    double *reduce_in = new double[2 * NN + 7];
+    memcpy(reduce_out, RP_out, NN * sizeof(double));
+    memcpy(reduce_out + NN, IP_out, NN * sizeof(double));
+    reduce_out[2 * NN + 0] = Mass_out;
+    reduce_out[2 * NN + 1] = ang_outx;
+    reduce_out[2 * NN + 2] = ang_outy;
+    reduce_out[2 * NN + 3] = ang_outz;
+    reduce_out[2 * NN + 4] = p_outx;
+    reduce_out[2 * NN + 5] = p_outy;
+    reduce_out[2 * NN + 6] = p_outz;
+    MPI_Allreduce(reduce_out, reduce_in, 2 * NN + 7, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
+    memcpy(RP, reduce_in, NN * sizeof(double));
+    memcpy(IP, reduce_in + NN, NN * sizeof(double));
+    mass = reduce_in[2 * NN + 0];
+    sx = reduce_in[2 * NN + 1];
+    sy = reduce_in[2 * NN + 2];
+    sz = reduce_in[2 * NN + 3];
+    px = reduce_in[2 * NN + 4];
+    py = reduce_in[2 * NN + 5];
+    pz = reduce_in[2 * NN + 6];
+    delete[] reduce_out;
+    delete[] reduce_in;
+  }
+
+#ifdef GaussInt
+  mass = mass * rex * rex * dphi * factor;
+
+  sx = sx * rex * rex * dphi * (1.0 / PI) * factor;
+  sy = sy * rex * rex * dphi * (1.0 / PI) * factor;
+  sz = sz * rex * rex * dphi * (1.0 / PI) * factor;
+
+  px = px * rex * rex * dphi * (1.0 / PI) * factor;
+  py = py * rex * rex * dphi * (1.0 / PI) * factor;
+  pz = pz * rex * rex * dphi * (1.0 / PI) * factor;
+#else
+  mass = mass * rex * rex * dphi * dcostheta * factor;
+
+  sx = sx * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+  sy = sy * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+  sz = sz * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+
+  px = px * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+  py = py * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+  pz = pz * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+#endif
+
+  Rout[0] = mass;
+  Rout[1] = px;
+  Rout[2] = py;
+  Rout[3] = pz;
+  Rout[4] = sx;
+  Rout[5] = sy;
+  Rout[6] = sz;
+
+  delete[] pox[0];
+  delete[] pox[1];
+  delete[] pox[2];
+  delete[] shellf;
+  delete[] RP_out;
+  delete[] IP_out;
+  DG_List->clearList();
+}
+void surface_integral::surf_WaveMassPAng(double rex, int lev, ShellPatch *GH,
+                                         var *Rpsi4, var *Ipsi4, int spinw, int maxl, int NN, double *RP, double *IP,
+                                         var *chi, var *trK,
+                                         var *gxx, var *gxy, var *gxz, var *gyy, var *gyz, var *gzz,
+                                         var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
+                                         var *Gmx, var *Gmy, var *Gmz,
+                                         var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs,
+                                         double *Rout, monitor *Monitor, bool refresh_mass_fields)
+{
+  if (Symmetry != 0 && Symmetry != 1)
+  {
+    surf_Wave(rex, lev, GH, Rpsi4, Ipsi4, spinw, maxl, NN, RP, IP, Monitor);
+    surf_MassPAng(rex, lev, GH, chi, trK,
+                  gxx, gxy, gxz, gyy, gyz, gzz,
+                  Axx, Axy, Axz, Ayy, Ayz, Azz,
+                  Gmx, Gmy, Gmz,
+                  Sfx_rhs, Sfy_rhs, Sfz_rhs,
+                  Rout, Monitor, refresh_mass_fields);
+    return;
+  }
+
+  if (lev != 0)
+  {
+    if (myrank == 0)
+    {
+      if (Monitor && Monitor->outfile)
+        Monitor->outfile << "WARNING: shell surface integral not on level 0" << endl;
+      else
+        cout << "WARNING: shell surface integral not on level 0" << endl;
+    }
+    return;
+  }
+
+  if (refresh_mass_fields)
+  {
+    MyList<ss_patch> *Pp = GH->PatL;
+    while (Pp)
+    {
+      MyList<Block> *BL = Pp->data->blb;
+      int fngfs = Pp->data->fngfs;
+      while (BL)
+      {
+        Block *cg = BL->data;
+        if (myrank == cg->rank)
+        {
+          f_admmass_bssn_ss(cg->shape, cg->X[0], cg->X[1], cg->X[2],
+                            cg->fgfs[fngfs + ShellPatch::gx], cg->fgfs[fngfs + ShellPatch::gy], cg->fgfs[fngfs + ShellPatch::gz],
+                            cg->fgfs[fngfs + ShellPatch::drhodx], cg->fgfs[fngfs + ShellPatch::drhody], cg->fgfs[fngfs + ShellPatch::drhodz],
+                            cg->fgfs[fngfs + ShellPatch::dsigmadx], cg->fgfs[fngfs + ShellPatch::dsigmady], cg->fgfs[fngfs + ShellPatch::dsigmadz],
+                            cg->fgfs[fngfs + ShellPatch::dRdx], cg->fgfs[fngfs + ShellPatch::dRdy], cg->fgfs[fngfs + ShellPatch::dRdz],
+                            cg->fgfs[fngfs + ShellPatch::drhodxx], cg->fgfs[fngfs + ShellPatch::drhodxy], cg->fgfs[fngfs + ShellPatch::drhodxz],
+                            cg->fgfs[fngfs + ShellPatch::drhodyy], cg->fgfs[fngfs + ShellPatch::drhodyz], cg->fgfs[fngfs + ShellPatch::drhodzz],
+                            cg->fgfs[fngfs + ShellPatch::dsigmadxx], cg->fgfs[fngfs + ShellPatch::dsigmadxy], cg->fgfs[fngfs + ShellPatch::dsigmadxz],
+                            cg->fgfs[fngfs + ShellPatch::dsigmadyy], cg->fgfs[fngfs + ShellPatch::dsigmadyz], cg->fgfs[fngfs + ShellPatch::dsigmadzz],
+                            cg->fgfs[fngfs + ShellPatch::dRdxx], cg->fgfs[fngfs + ShellPatch::dRdxy], cg->fgfs[fngfs + ShellPatch::dRdxz],
+                            cg->fgfs[fngfs + ShellPatch::dRdyy], cg->fgfs[fngfs + ShellPatch::dRdyz], cg->fgfs[fngfs + ShellPatch::dRdzz],
+                            cg->fgfs[chi->sgfn], cg->fgfs[trK->sgfn],
+                            cg->fgfs[gxx->sgfn], cg->fgfs[gxy->sgfn], cg->fgfs[gxz->sgfn], cg->fgfs[gyy->sgfn], cg->fgfs[gyz->sgfn], cg->fgfs[gzz->sgfn],
+                            cg->fgfs[Axx->sgfn], cg->fgfs[Axy->sgfn], cg->fgfs[Axz->sgfn], cg->fgfs[Ayy->sgfn], cg->fgfs[Ayz->sgfn], cg->fgfs[Azz->sgfn],
+                            cg->fgfs[Gmx->sgfn], cg->fgfs[Gmy->sgfn], cg->fgfs[Gmz->sgfn],
+                            cg->fgfs[Sfx_rhs->sgfn], cg->fgfs[Sfy_rhs->sgfn], cg->fgfs[Sfz_rhs->sgfn],
+                            Symmetry, Pp->data->sst);
+        }
+        if (BL == Pp->data->ble)
+          break;
+        BL = BL->next;
+      }
+      Pp = Pp->next;
+    }
+  }
+
+  const int InList = 19;
+  const int idx_rpsi4 = 0, idx_ipsi4 = 1;
+  const int idx_sfx = 2, idx_sfy = 3, idx_sfz = 4;
+  const int idx_chi = 5, idx_trk = 6;
+  const int idx_gxx = 7, idx_gxy = 8, idx_gxz = 9, idx_gyy = 10, idx_gyz = 11, idx_gzz = 12;
+  const int idx_axx = 13, idx_axy = 14, idx_axz = 15, idx_ayy = 16, idx_ayz = 17, idx_azz = 18;
+
+  MyList<var> *DG_List = new MyList<var>(Rpsi4);
+  DG_List->insert(Ipsi4);
+  DG_List->insert(Sfx_rhs);
+  DG_List->insert(Sfy_rhs);
+  DG_List->insert(Sfz_rhs);
+  DG_List->insert(chi);
+  DG_List->insert(trK);
+  DG_List->insert(gxx);
+  DG_List->insert(gxy);
+  DG_List->insert(gxz);
+  DG_List->insert(gyy);
+  DG_List->insert(gyz);
+  DG_List->insert(gzz);
+  DG_List->insert(Axx);
+  DG_List->insert(Axy);
+  DG_List->insert(Axz);
+  DG_List->insert(Ayy);
+  DG_List->insert(Ayz);
+  DG_List->insert(Azz);
+
+  int n;
+  double *pox[3];
+  for (int ia = 0; ia < 3; ia++)
+    pox[ia] = new double[n_tot];
+  for (n = 0; n < n_tot; n++)
+  {
+    pox[0][n] = rex * nx_g[n];
+    pox[1][n] = rex * ny_g[n];
+    pox[2][n] = rex * nz_g[n];
+  }
+
+  double *shellf = new double[n_tot * InList];
+  GH->Interp_Points(DG_List, n_tot, pox, shellf, Symmetry);
+
+  int mp, Lp, Nmin, Nmax;
+  mp = n_tot / cpusize;
+  Lp = n_tot - cpusize * mp;
+
+  if (Lp > myrank)
+  {
+    Nmin = myrank * mp + myrank;
+    Nmax = Nmin + mp;
+  }
+  else
+  {
+    Nmin = myrank * mp + Lp;
+    Nmax = Nmin + mp - 1;
+  }
+
+  double *RP_out = new double[NN];
+  double *IP_out = new double[NN];
+  for (int ii = 0; ii < NN; ii++)
+  {
+    RP_out[ii] = 0.0;
+    IP_out[ii] = 0.0;
+  }
+
+  double Mass_out = 0.0;
+  double ang_outx = 0.0, ang_outy = 0.0, ang_outz = 0.0;
+  double p_outx = 0.0, p_outy = 0.0, p_outz = 0.0;
+  const double f1o8 = 0.125;
+
+  build_wave_cache(spinw, maxl);
+
+  for (n = Nmin; n <= Nmax; n++)
+  {
+    const int base = InList * n;
+    const int i = int(n / N_phi);
+    const int j = n - i * N_phi;
+
+    const double psi4RR0 = shellf[base + idx_rpsi4];
+    const double psi4II0 = shellf[base + idx_ipsi4];
+    const double psi4RR1 = Rpsi4->SoA[2] * psi4RR0;
+    const double psi4II1 = Ipsi4->SoA[2] * psi4II0;
+    for (int countlm = 0; countlm < wave_cache_modes; countlm++)
+    {
+      const int theta_idx = countlm * N_theta + i;
+      const int phi_idx = countlm * N_phi + j;
+      const double theta_pos = wave_theta_pos[theta_idx];
+      const double cosmphi_here = wave_phi_cos[phi_idx];
+      const double sinmphi_here = wave_phi_sin[phi_idx];
+
+      RP_out[countlm] += theta_pos * (psi4RR0 * cosmphi_here + psi4II0 * sinmphi_here);
+      IP_out[countlm] += theta_pos * (psi4II0 * cosmphi_here - psi4RR0 * sinmphi_here);
+      if (Symmetry == 1)
+      {
+        const double theta_neg = wave_theta_neg[theta_idx];
+        RP_out[countlm] += theta_neg * (psi4RR1 * cosmphi_here + psi4II1 * sinmphi_here);
+        IP_out[countlm] += theta_neg * (psi4II1 * cosmphi_here - psi4RR1 * sinmphi_here);
+      }
+    }
+
+    double Chi = shellf[base + idx_chi];
+    double TRK = shellf[base + idx_trk];
+    double Gxx = shellf[base + idx_gxx] + 1.0;
+    double Gxy = shellf[base + idx_gxy];
+    double Gxz = shellf[base + idx_gxz];
+    double Gyy = shellf[base + idx_gyy] + 1.0;
+    double Gyz = shellf[base + idx_gyz];
+    double Gzz = shellf[base + idx_gzz] + 1.0;
+    double axx = shellf[base + idx_axx];
+    double axy = shellf[base + idx_axy];
+    double axz = shellf[base + idx_axz];
+    double ayy = shellf[base + idx_ayy];
+    double ayz = shellf[base + idx_ayz];
+    double azz = shellf[base + idx_azz];
+
+    Chi = 1.0 / (1.0 + Chi);
+    const double Psi = Chi * sqrt(Chi);
+
+#ifdef GaussInt
+    const double theta_weight = wtcostheta[i];
+    Mass_out += (shellf[base + idx_sfx] * nx_g[n] + shellf[base + idx_sfy] * ny_g[n] + shellf[base + idx_sfz] * nz_g[n]) * theta_weight;
+#else
+    const double theta_weight = 1.0;
+    Mass_out += shellf[base + idx_sfx] * nx_g[n] + shellf[base + idx_sfy] * ny_g[n] + shellf[base + idx_sfz] * nz_g[n];
+#endif
+
+    double detg = Gxx * Gyy * Gzz + Gxy * Gyz * Gxz + Gxz * Gxy * Gyz -
+                  Gxz * Gyy * Gxz - Gxy * Gxy * Gzz - Gxx * Gyz * Gyz;
+    const double gupxx = (Gyy * Gzz - Gyz * Gyz) / detg;
+    const double gupxy = -(Gxy * Gzz - Gyz * Gxz) / detg;
+    const double gupxz = (Gxy * Gyz - Gyy * Gxz) / detg;
+    const double gupyy = (Gxx * Gzz - Gxz * Gxz) / detg;
+    const double gupyz = -(Gxx * Gyz - Gxy * Gxz) / detg;
+    const double gupzz = (Gxx * Gyy - Gxy * Gxy) / detg;
+
+    const double aupxx = gupxx * axx + gupxy * axy + gupxz * axz;
+    const double aupxy = gupxx * axy + gupxy * ayy + gupxz * ayz;
+    const double aupxz = gupxx * axz + gupxy * ayz + gupxz * azz;
+    const double aupyx = gupxy * axx + gupyy * axy + gupyz * axz;
+    const double aupyy = gupxy * axy + gupyy * ayy + gupyz * ayz;
+    const double aupyz = gupxy * axz + gupyy * ayz + gupyz * azz;
+    const double aupzx = gupxz * axx + gupyz * axy + gupzz * axz;
+    const double aupzy = gupxz * axy + gupyz * ayy + gupzz * ayz;
+    const double aupzz = gupxz * axz + gupyz * ayz + gupzz * azz;
+
+    if (Symmetry == 0)
+    {
+      ang_outx += f1o8 * Psi * (nx_g[n] * (pox[1][n] * aupxz - pox[2][n] * aupxy) + ny_g[n] * (pox[1][n] * aupyz - pox[2][n] * aupyy) + nz_g[n] * (pox[1][n] * aupzz - pox[2][n] * aupzy)) * theta_weight;
+      ang_outy += f1o8 * Psi * (nx_g[n] * (pox[2][n] * aupxx - pox[0][n] * aupxz) + ny_g[n] * (pox[2][n] * aupyx - pox[0][n] * aupyz) + nz_g[n] * (pox[2][n] * aupzx - pox[0][n] * aupzz)) * theta_weight;
+      ang_outz += f1o8 * Psi * (nx_g[n] * (pox[0][n] * aupxy - pox[1][n] * aupxx) + ny_g[n] * (pox[0][n] * aupyy - pox[1][n] * aupyx) + nz_g[n] * (pox[0][n] * aupzy - pox[1][n] * aupzx)) * theta_weight;
+    }
+    else
+    {
+      ang_outz += f1o8 * Psi * (nx_g[n] * (pox[0][n] * aupxy - pox[1][n] * aupxx) + ny_g[n] * (pox[0][n] * aupyy - pox[1][n] * aupyx) + nz_g[n] * (pox[0][n] * aupzy - pox[1][n] * aupzx)) * theta_weight;
+    }
+
+    axx = Chi * (axx + Gxx * TRK / 3.0);
+    axy = Chi * (axy + Gxy * TRK / 3.0);
+    axz = Chi * (axz + Gxz * TRK / 3.0);
+    ayy = Chi * (ayy + Gyy * TRK / 3.0);
+    ayz = Chi * (ayz + Gyz * TRK / 3.0);
+    azz = Chi * (azz + Gzz * TRK / 3.0);
+
+    axx -= TRK;
+    ayy -= TRK;
+    azz -= TRK;
+
+    p_outx += f1o8 * Psi * (nx_g[n] * axx + ny_g[n] * axy + nz_g[n] * axz) * theta_weight;
+    p_outy += f1o8 * Psi * (nx_g[n] * axy + ny_g[n] * ayy + nz_g[n] * ayz) * theta_weight;
+    if (Symmetry == 0)
+      p_outz += f1o8 * Psi * (nx_g[n] * axz + ny_g[n] * ayz + nz_g[n] * azz) * theta_weight;
+  }
+
+  for (int ii = 0; ii < NN; ii++)
+  {
+#ifdef GaussInt
+    RP_out[ii] = RP_out[ii] * rex * dphi;
+    IP_out[ii] = IP_out[ii] * rex * dphi;
+#else
+    RP_out[ii] = RP_out[ii] * rex * dphi * dcostheta;
+    IP_out[ii] = IP_out[ii] * rex * dphi * dcostheta;
+#endif
+  }
+
+  double mass, px, py, pz, sx, sy, sz;
+  {
+    double *reduce_out = new double[2 * NN + 7];
+    double *reduce_in = new double[2 * NN + 7];
+    memcpy(reduce_out, RP_out, NN * sizeof(double));
+    memcpy(reduce_out + NN, IP_out, NN * sizeof(double));
+    reduce_out[2 * NN + 0] = Mass_out;
+    reduce_out[2 * NN + 1] = ang_outx;
+    reduce_out[2 * NN + 2] = ang_outy;
+    reduce_out[2 * NN + 3] = ang_outz;
+    reduce_out[2 * NN + 4] = p_outx;
+    reduce_out[2 * NN + 5] = p_outy;
+    reduce_out[2 * NN + 6] = p_outz;
+    MPI_Allreduce(reduce_out, reduce_in, 2 * NN + 7, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
+    memcpy(RP, reduce_in, NN * sizeof(double));
+    memcpy(IP, reduce_in + NN, NN * sizeof(double));
+    mass = reduce_in[2 * NN + 0];
+    sx = reduce_in[2 * NN + 1];
+    sy = reduce_in[2 * NN + 2];
+    sz = reduce_in[2 * NN + 3];
+    px = reduce_in[2 * NN + 4];
+    py = reduce_in[2 * NN + 5];
+    pz = reduce_in[2 * NN + 6];
+    delete[] reduce_out;
+    delete[] reduce_in;
+  }
+
+#ifdef GaussInt
+  mass = mass * rex * rex * dphi * factor;
+
+  sx = sx * rex * rex * dphi * (1.0 / PI) * factor;
+  sy = sy * rex * rex * dphi * (1.0 / PI) * factor;
+  sz = sz * rex * rex * dphi * (1.0 / PI) * factor;
+
+  px = px * rex * rex * dphi * (1.0 / PI) * factor;
+  py = py * rex * rex * dphi * (1.0 / PI) * factor;
+  pz = pz * rex * rex * dphi * (1.0 / PI) * factor;
+#else
+  mass = mass * rex * rex * dphi * dcostheta * factor;
+
+  sx = sx * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+  sy = sy * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+  sz = sz * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+
+  px = px * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+  py = py * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+  pz = pz * rex * rex * dphi * dcostheta * (1.0 / PI) * factor;
+#endif
+
+  Rout[0] = mass;
+  Rout[1] = px;
+  Rout[2] = py;
+  Rout[3] = pz;
+  Rout[4] = sx;
+  Rout[5] = sy;
+  Rout[6] = sz;
+
+  delete[] pox[0];
+  delete[] pox[1];
+  delete[] pox[2];
+  delete[] shellf;
+  delete[] RP_out;
+  delete[] IP_out;
+  DG_List->clearList();
+}
 //|----------------------------------------------------------------
 //  do not discriminate box and shell
 //  for Gravitational wave specially symmetric case
--- a/AMSS_NCKU_source/surface_integral.h
+++ b/AMSS_NCKU_source/surface_integral.h
@@ -36,6 +36,11 @@ private:

 	double *nx_g, *ny_g, *nz_g; // global list of unit normals
 	int myrank, cpusize;
+	int wave_cache_spinw, wave_cache_maxl, wave_cache_modes;
+	double *wave_theta_pos, *wave_theta_neg;
+	double *wave_phi_cos, *wave_phi_sin;
+	void clear_wave_cache();
+	void build_wave_cache(int spinw, int maxl);

 public:
 	surface_integral(int iSymmetry);
@@ -82,13 +87,29 @@ public:
 					   var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
 					   var *Gmx, var *Gmy, var *Gmz,
 					   var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs,
-					   double *Rout, monitor *Monitor);
+					   double *Rout, monitor *Monitor, bool refresh_mass_fields = true);
 	void surf_MassPAng(double rex, int lev, ShellPatch *GH, var *chi, var *trK,
 					   var *gxx, var *gxy, var *gxz, var *gyy, var *gyz, var *gzz,
 					   var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
 					   var *Gmx, var *Gmy, var *Gmz,
 					   var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs,
-					   double *Rout, monitor *Monitor);
+					   double *Rout, monitor *Monitor, bool refresh_mass_fields = true);
+	void surf_WaveMassPAng(double rex, int lev, cgh *GH,
+					   var *Rpsi4, var *Ipsi4, int spinw, int maxl, int NN, double *RP, double *IP,
+					   var *chi, var *trK,
+					   var *gxx, var *gxy, var *gxz, var *gyy, var *gyz, var *gzz,
+					   var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
+					   var *Gmx, var *Gmy, var *Gmz,
+					   var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs,
+					   double *Rout, monitor *Monitor, bool refresh_mass_fields = true);
+	void surf_WaveMassPAng(double rex, int lev, ShellPatch *GH,
+					   var *Rpsi4, var *Ipsi4, int spinw, int maxl, int NN, double *RP, double *IP,
+					   var *chi, var *trK,
+					   var *gxx, var *gxy, var *gxz, var *gyy, var *gyz, var *gzz,
+					   var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
+					   var *Gmx, var *Gmy, var *Gmz,
+					   var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs,
+					   double *Rout, monitor *Monitor, bool refresh_mass_fields = true);
 	void surf_Wave(double rex, cgh *GH, ShellPatch *SH,
 				   var *chi, var *trK,
 				   var *gxx, var *gxy, var *gxz, var *gyy, var *gyz, var *gzz,
@@ -115,7 +136,7 @@ public:
 					   var *Axx, var *Axy, var *Axz, var *Ayy, var *Ayz, var *Azz,
 					   var *Gmx, var *Gmy, var *Gmz,
 					   var *Sfx_rhs, var *Sfy_rhs, var *Sfz_rhs, // temparay memory for mass^i
-					   double *Rout, monitor *Monitor, MPI_Comm Comm_here);
+					   double *Rout, monitor *Monitor, MPI_Comm Comm_here, bool refresh_mass_fields = true);
 	void surf_Wave(double rex, int lev, cgh *GH, var *Rpsi4, var *Ipsi4,
 				   int spinw, int maxl, int NN, double *RP, double *IP,
 				   monitor *Monitor, MPI_Comm Comm_here);
--- a/BSSN_BUILD_CONFIG_MIGRATION.md
+++ b/BSSN_BUILD_CONFIG_MIGRATION.md
@@ -0,0 +1,211 @@
+# BSSN Build Config Migration
+
+This note records the build-configuration fix needed when replacing
+`AMSS_NCKU_Input.py` or `generate_macrodef.py` with a newer upstream version.
+
+## Problem
+
+`AMSS_NCKU_source/macrodef.h` is not the authoritative file used by normal
+runs. `AMSS_NCKU_Program.py` first generates macro files under
+`input_data.File_directory`, copies `AMSS_NCKU_source` to
+`<File_directory>/AMSS_NCKU_source_copy`, then copies the generated macro files
+into that copied source tree and compiles there.
+
+Therefore, makefile logic must not depend only on the stale
+`AMSS_NCKU_source/macrodef.h`. The actual equation path must be passed to the
+copied build tree from the same generation step that creates `macrodef.h`.
+
+The performance regression was caused by compiling/linking the
+`BSSN-EScalar` C wrapper into BSSN vacuum builds. For BSSN vacuum (`ABEtype=0`),
+the build must use:
+
+```make
+BSSN_USE_TRANSFER_CACHE=1
+BSSN_USE_ESCALAR_C_KERNEL=0
+```
+
+and must not link `bssn_escalar_rhs_c.o`.
+
+## Required Migration Steps
+
+### 1. Add an ABE type helper in `generate_macrodef.py`
+
+Add a helper that maps `input_data.Equation_Class` to the numeric `ABEtype`.
+Use the same mapping as `macrodef.h`:
+
+```python
+def get_abe_type():
+    if ( input_data.Equation_Class == "BSSN" ):
+        return 0
+    elif ( input_data.Equation_Class == "BSSN-EScalar" ):
+        return 1
+    elif ( input_data.Equation_Class == "BSSN-EM" ):
+        return 3
+    elif ( input_data.Equation_Class == "Z4C" ):
+        return 2
+    else:
+        raise ValueError("Equation_Class setting error!!!")
+```
+
+Update `generate_macrodef_h()` to print `#define ABEtype {get_abe_type()}`
+instead of duplicating the if/elif mapping.
+
+### 2. Generate a makefile fragment
+
+In `generate_macrodef.py`, add:
+
+```python
+def generate_build_config():
+    file1 = open(os.path.join(input_data.File_directory, "AMSS_NCKU_build.mk"), "w")
+    print("# Generated by generate_macrodef.py; do not edit manually.", file=file1)
+    print(f"ABE_TYPE := {get_abe_type()}", file=file1)
+    file1.close()
+```
+
+This file is the build-time authority for the equation path.
+
+### 3. Call and copy the generated build config
+
+In `AMSS_NCKU_Program.py`, after generating `macrodef.h` and `macrodef.fh`, call:
+
+```python
+generate_macrodef.generate_build_config()
+print(" AMSS-NCKU build config AMSS_NCKU_build.mk has been generated. ")
+```
+
+When copying generated files into `AMSS_NCKU_source_copy`, also copy:
+
+```python
+build_config_path = os.path.join(File_directory, "AMSS_NCKU_build.mk")
+shutil.copy2(build_config_path, AMSS_NCKU_source_copy)
+```
+
+### 4. Make the source makefile consume the generated config
+
+At the top of `AMSS_NCKU_source/makefile`, after `include makefile.inc`, add:
+
+```make
+-include AMSS_NCKU_build.mk
+
+ABE_TYPE ?= $(shell awk '/^[[:space:]]*\#define[[:space:]]+ABEtype/ {print $$3; exit}' macrodef.h 2>/dev/null)
+```
+
+The generated `AMSS_NCKU_build.mk` is used during normal Python-driven builds.
+The fallback keeps manual source-tree builds usable.
+
+### 5. Gate path-specific build options by `ABE_TYPE`
+
+Use effective build switches:
+
+```make
+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
+
+TRANSFER_CACHE_FLAG = -DBSSN_USE_TRANSFER_CACHE=$(EFFECTIVE_USE_TRANSFER_CACHE)
+ESCALAR_KERNEL_FLAG = -DBSSN_USE_ESCALAR_C_KERNEL=$(EFFECTIVE_USE_CXX_ESCALAR_KERNEL)
+```
+
+Only add `bssn_escalar_rhs_c.o` when the effective EScalar C kernel switch is
+enabled:
+
+```make
+ifeq ($(EFFECTIVE_USE_CXX_ESCALAR_KERNEL),1)
+CFILES += bssn_escalar_rhs_c.o
+endif
+```
+
+### 6. Use safe transfer-cache default
+
+In `AMSS_NCKU_source/makefile.inc`, keep:
+
+```make
+USE_TRANSFER_CACHE ?= auto
+```
+
+With the effective switch logic above, this enables cached transfer for BSSN
+vacuum while keeping non-BSSN paths on the uncached path by default.
+
+## Verification Checklist
+
+Run these checks after migrating:
+
+```bash
+python3 -c "import generate_macrodef; generate_macrodef.generate_build_config()"
+cat GW150914/AMSS_NCKU_build.mk
+```
+
+For BSSN, the generated file should contain:
+
+```make
+ABE_TYPE := 0
+```
+
+Dry-run the copied or source makefile:
+
+```bash
+make -n -B INTERP_LB_MODE=off ABE | grep -E 'BSSN_USE_TRANSFER_CACHE|BSSN_USE_ESCALAR_C_KERNEL|bssn_escalar_rhs_c'
+```
+
+Expected BSSN result:
+
+```text
+-DBSSN_USE_TRANSFER_CACHE=1 -DBSSN_USE_ESCALAR_C_KERNEL=0
+```
+
+and no `bssn_escalar_rhs_c.o` in the final link command.
+
+Run the full workflow:
+
+```bash
+python3 AMSS_NCKU_Program.py
+```
+
+For the 10-step BSSN test, compare coordinate output:
+
+```bash
+python3 - <<'PY'
+from pathlib import Path
+old = Path('../GW150914-06457/AMSS_NCKU_output/bssn_BH.dat')
+new = Path('GW150914/AMSS_NCKU_output/bssn_BH.dat')
+
+def rows(path):
+    out = []
+    for line in path.read_text().splitlines():
+        if not line.strip() or line.lstrip().startswith('#'):
+            continue
+        out.append([float(x) for x in line.split()])
+    return out
+
+ro, rn = rows(old), rows(new)
+n = min(len(ro), len(rn))
+max_abs = 0.0
+for i in range(n):
+    for a, b in zip(ro[i], rn[i]):
+        max_abs = max(max_abs, abs(a - b))
+print(f"old_rows={len(ro)} new_rows={len(rn)} compared_rows={n}")
+print(f"max_abs_diff={max_abs:.17g}")
+PY
+```
+
+For the validated migration, the first 10 rows matched exactly:
+
+```text
+max_abs_diff=0
+```
--- a/generate_macrodef.py
+++ b/generate_macrodef.py
@@ -12,6 +12,37 @@ import os
 import AMSS_NCKU_Input as input_data          ## import program input file


+##################################################################
+
+def get_abe_type():
+    if ( input_data.Equation_Class == "BSSN" ):
+        return 0
+    elif ( input_data.Equation_Class == "BSSN-EScalar" ):
+        return 1
+    elif ( input_data.Equation_Class == "BSSN-EM" ):
+        return 3
+    elif ( input_data.Equation_Class == "Z4C" ):
+        return 2
+    else:
+        raise ValueError("Equation_Class setting error!!!")
+
+
+##################################################################
+
+## Generate the makefile fragment used by the copied source tree.
+## The source-tree macrodef.h is not authoritative because macro files
+## are regenerated under File_directory for each run.
+
+def generate_build_config():
+
+    file1 = open( os.path.join(input_data.File_directory, "AMSS_NCKU_build.mk"), "w")
+
+    print( "# Generated by generate_macrodef.py; do not edit manually.", file=file1 )
+    print( f"ABE_TYPE := {get_abe_type()}",                             file=file1 )
+
+    file1.close()
+
+
 ##################################################################

 ## Generate the macro file macrodef.h according to user settings
@@ -58,19 +89,10 @@ def generate_macrodef_h():
    # 2: Z4c vacuum
    # 3: coupled to Maxwell field

-    if ( input_data.Equation_Class == "BSSN" ):
-        print( "#define ABEtype 0", file=file1 )
+    try:
+        print( f"#define ABEtype {get_abe_type()}", file=file1 )
        print(                                      file=file1 )
-    elif ( input_data.Equation_Class == "BSSN-EScalar" ):
-        print( "#define ABEtype 1", file=file1 )
-        print(                      file=file1 )
-    elif ( input_data.Equation_Class == "BSSN-EM" ):
-        print( "#define ABEtype 3", file=file1 )
-        print(                      file=file1 )
-    elif ( input_data.Equation_Class == "Z4C" ):
-        print( "#define ABEtype 2", file=file1 )
-        print(                      file=file1 )
-    else:
+    except ValueError:
        print( "Equation_Class setting error!!!"                )
        print()
        print( "# Equation type #define ABEtype setting error!!!", file=file1 )
@@ -144,6 +166,62 @@ def generate_macrodef_h():
    print( "#define REGLEV 0",      file=file1 )
    print(                          file=file1 )

+    # Define fine-grained timing/debug macros.
+    # All of them default to OFF so production builds do not pay profiling overhead.
+
+    fine_timing = getattr(input_data, "Fine_Timing",
+                  getattr(input_data, "Finegrained_Timing", "no"))
+    kernel_fine_timing = getattr(input_data, "Kernel_Fine_Timing",
+                          getattr(input_data, "BSSN_Kernel_Fine_Timing", "no"))
+    stdin_abort_poll = getattr(input_data, "Enable_Stdin_Abort_Poll",
+                       getattr(input_data, "Stdin_Abort_Poll", "no"))
+    timing_report_every = max(1, int(getattr(
+        input_data, "Timing_Every_Steps",
+        getattr(input_data, "Timing_Report_Every", 1))))
+    timing_top_hotspots = max(1, int(getattr(
+        input_data, "Timing_Top_Hotspots", 8)))
+
+    if ( fine_timing == "yes" ):
+        print( "#define BSSN_FINE_TIMING 1", file=file1 )
+        print(                               file=file1 )
+    elif ( fine_timing == "no" ):
+        print( "#define BSSN_FINE_TIMING 0", file=file1 )
+        print(                               file=file1 )
+    else:
+        print( "Fine_Timing setting error!!!" )
+        print()
+        print( "# Fine_Timing setting error!!!", file=file1 )
+        print(                                   file=file1 )
+
+    print( f"#define BSSN_FINE_TIMING_EVERY {timing_report_every}", file=file1 )
+    print(                                                          file=file1 )
+    print( f"#define BSSN_FINE_TIMING_TOPN {timing_top_hotspots}",  file=file1 )
+    print(                                                          file=file1 )
+
+    if ( kernel_fine_timing == "yes" ):
+        print( "#define BSSN_KERNEL_FINE_TIMING 1", file=file1 )
+        print(                                      file=file1 )
+    elif ( kernel_fine_timing == "no" ):
+        print( "#define BSSN_KERNEL_FINE_TIMING 0", file=file1 )
+        print(                                      file=file1 )
+    else:
+        print( "Kernel_Fine_Timing setting error!!!" )
+        print()
+        print( "# Kernel_Fine_Timing setting error!!!", file=file1 )
+        print(                                          file=file1 )
+
+    if ( stdin_abort_poll == "yes" ):
+        print( "#define BSSN_ENABLE_STDIN_ABORT_POLL 1", file=file1 )
+        print(                                           file=file1 )
+    elif ( stdin_abort_poll == "no" ):
+        print( "#define BSSN_ENABLE_STDIN_ABORT_POLL 0", file=file1 )
+        print(                                           file=file1 )
+    else:
+        print( "Enable_Stdin_Abort_Poll setting error!!!" )
+        print()
+        print( "# Enable_Stdin_Abort_Poll setting error!!!", file=file1 )
+        print(                                               file=file1 )
+
    # Define macro USE_GPU
    # use GPU or not
    
@@ -224,6 +302,21 @@ def generate_macrodef_h():
    print( "//     0: for every level;",                                                 file=file1 ) 
    print( "//     1: for all",                                                          file=file1 )
    print( "//",                                                                         file=file1 )
+    print( "// define BSSN_FINE_TIMING",                                                 file=file1 )
+    print( "//     enable fine-grained per-timestep timing monitor",                     file=file1 )
+    print( "//",                                                                         file=file1 )
+    print( "// define BSSN_FINE_TIMING_EVERY",                                           file=file1 )
+    print( "//     report timing every N coarse timesteps",                              file=file1 )
+    print( "//",                                                                         file=file1 )
+    print( "// define BSSN_FINE_TIMING_TOPN",                                            file=file1 )
+    print( "//     number of hottest timing buckets shown in stdout",                    file=file1 )
+    print( "//",                                                                         file=file1 )
+    print( "// define BSSN_KERNEL_FINE_TIMING",                                          file=file1 )
+    print( "//     enable split timing inside compute_rhs_bssn",                         file=file1 )
+    print( "//",                                                                         file=file1 )
+    print( "// define BSSN_ENABLE_STDIN_ABORT_POLL",                                     file=file1 )
+    print( "//     poll stdin and broadcast abort flag every coarse step",               file=file1 )
+    print( "//",                                                                         file=file1 )
    print( "// define USE_GPU",                                                          file=file1 )
    print( "//     use gpu or not",                                                      file=file1 )
    print( "//",                                                                         file=file1 )
Author	SHA1	Message	Date
CGH0S7	0992e2219a	Migrate build system from Intel oneAPI to AMD AOCC/AOCL/OpenMPI Replace Intel compilers (ifx/icpx/icx) with AOCC (flang/clang++/clang), Intel MPI (mpiicpx) with AOCC-built OpenMPI (mpicxx), and Intel MKL with AOCL BLIS/libFLAME. Replace -xHost with -march=znver4, -ipo with -flto, -fp-model fast=2 with -ffast-math, -qopenmp with -fopenmp. Remove PGO, TBB allocator, and Intel-specific runtime libraries. Fix MKL-specific includes in TwoPunctures.C and gaussj.C to use standard CBLAS/LAPACKE headers from AOCL. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-04-28 02:19:00 +08:00
CGH0S7	0db537479b	Fix BSSN build config selection	2026-04-27 18:42:34 +08:00
CGH0S7	1f3fd264c0	Add missing setup_transfer_caches() to bssnEM_class::Initialize() bssnEScalar_class::Initialize() already calls setup_transfer_caches(), but bssnEM_class::Initialize() did not. When USE_TRANSFER_CACHE=1, the sync_cache pointers remain NULL, causing SIGSEGV in wrapper methods that dereference sync_cache_*[lev]. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-04-27 15:32:27 +08:00
CGH0S7	442674cedc	Fix direct sync_cache accesses bypassing use_transfer_cache() guard Seven Parallel::_cached() calls in RestrictProlong and RestrictProlong_aux were missed during the transfer-cache refactoring (commits 9cd3741..8d28c29). When BSSN_USE_TRANSFER_CACHE=0, all sync_cache pointers are NULL, so dereferencing sync_cache_[lev] triggers SIGSEGV. Replace them with the equivalent wrapper methods (sync_evolution, restrict_evolution, outbdlow2hi_evolution) that check use_transfer_cache() and fall back to uncached direct calls. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-04-27 14:50:59 +08:00
CGH0S7	8d28c29a91	Default to safe BSSN-EScalar C kernel	2026-04-25 02:02:01 +08:00
CGH0S7	0cf58176d9	Add safe BSSN-EScalar kernel and transfer toggles	2026-04-25 01:41:55 +08:00
CGH0S7	0f1d0de1e7	Stabilize and wire BSSN-EScalar C path	2026-04-25 00:08:35 +08:00
CGH0S7	b57d80ca61	Disable cached sync for BSSN-EScalar	2026-04-24 01:58:57 +08:00
CGH0S7	9cd3741a90	Fallback BSSN-EScalar restrict/prolong path	2026-04-24 01:37:54 +08:00
CGH0S7	ac82ebd889	更新精度检查脚本加入图像比对检查	2026-04-15 00:49:46 +08:00
CGH0S7	9c31384b2f	Add optional BSSN kernel profiling switches	2026-04-13 16:51:06 +08:00
CGH0S7	e4e741caa1	Remove dead chi derivative setup in BSSN RHS	2026-04-13 15:55:43 +08:00
CGH0S7	65e0f95f40	Localize chi Ricci intermediates in RHS	2026-04-13 15:14:31 +08:00
CGH0S7	f9fbf97e64	Elide dead stores in BSSN RHS hot path	2026-04-13 15:10:22 +08:00
CGH0S7	968522995b	Add fine-grained step timing and trim BH RHS overhead	2026-04-13 14:50:55 +08:00
CGH0S7	f3988ac8ca	Merge wave and mass extraction interpolation	2026-04-13 13:17:36 +08:00
CGH0S7	e4c25eb21f	Cache wave extraction angular kernels	2026-04-13 12:40:20 +08:00
CGH0S7	4b10519876	Reuse mass integrand across detector radii	2026-04-13 11:55:41 +08:00
CGH0S7	3a58273501	Batch constraint norm reductions	2026-04-13 11:48:02 +08:00
CGH0S7	5c65cea2f0	Optimize constraint refresh after regrid	2026-04-13 11:39:50 +08:00