Separate GPU symmetry filters and align callbacks with loop order

include/RI/physics/Exx.hpp

@@ -9,7 +9,7 @@
 #include "../ri/Cell_Nearest.h"
 #include "../ri/Label.h"
 #include "../global/Map_Operator.h"
-#include "./symmetry/Filter_Atom_Symmetry.h"
+#include "./symmetry/Filter_Atom_Symmetry_Wrapper.h"
 
 #include <cassert>
 
@@ -42,10 +42,10 @@ void Exx<TA,Tcell,Ndim,Tdata>::set_symmetry(
 	const std::map<std::pair<TA,TA>, std::set<TC>> &irreducible_sector)
 {
 	if(flag_symmetry)
-		this->lri.filter_atom = std::make_shared<Filter_Atom_Symmetry<TA,TC,Tdata>>(
+		this->lri.filter_atom = Filter_Atom_Symmetry_Wrapper<TA,TC,Tdata>(
 			this->period, irreducible_sector);
 	else
-		this->lri.filter_atom = std::make_shared<Filter_Atom<TA,TAC>>();
+		this->lri.filter_atom = {};
 }
 
 template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>

include/RI/physics/GW.hpp

@@ -6,7 +6,7 @@
 
 #include "GW.h"
 #include "../ri/Label.h"
-#include "./symmetry/Filter_Atom_Symmetry.h"
+#include "./symmetry/Filter_Atom_Symmetry_Wrapper.h"
 
 namespace RI
 {
@@ -37,10 +37,10 @@ void GW<TA,Tcell,Ndim,Tdata>::set_symmetry(
 	const std::map<std::pair<TA,TA>, std::set<TC>> &irreducible_sector)
 {
 	if(flag_symmetry)
-		this->lri.filter_atom = std::make_shared<Filter_Atom_Symmetry<TA,TC,Tdata>>(
+		this->lri.filter_atom = Filter_Atom_Symmetry_Wrapper<TA,TC,Tdata>(
 			this->period, irreducible_sector);
 	else
-		this->lri.filter_atom = std::make_shared<Filter_Atom<TA,TAC>>();
+		this->lri.filter_atom = {};
 }
 
 template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>

include/RI/physics/RPA.hpp

@@ -7,7 +7,7 @@
 
 #include "RPA.h"
 #include "../ri/Label.h"
-#include "./symmetry/Filter_Atom_Symmetry.h"
+#include "./symmetry/Filter_Atom_Symmetry_Wrapper.h"
 
 #include <cassert>
 
@@ -38,10 +38,10 @@ void RPA<TA,Tcell,Ndim,Tdata>::set_symmetry(
 	const std::map<std::pair<TA,TA>, std::set<TC>> &irreducible_sector)
 {
 	if(flag_symmetry)
-		this->lri.filter_atom = std::make_shared<Filter_Atom_Symmetry<TA,TC,Tdata>>(
+		this->lri.filter_atom = Filter_Atom_Symmetry_Wrapper<TA,TC,Tdata>(
 			this->period, irreducible_sector);
 	else
-		this->lri.filter_atom = std::make_shared<Filter_Atom<TA,TAC>>();
+		this->lri.filter_atom = {};
 }
 
 template<typename TA, typename Tcell, std::size_t Ndim, typename Tdata>

include/RI/physics/symmetry/Filter_Atom_Symmetry.h

@@ -45,14 +45,6 @@ class Filter_Atom_Symmetry: public Filter_Atom<TA, std::pair<TA, TC>>
 				case Label::ab_ab::a1b2_a2b0:
 				case Label::ab_ab::a1b2_a2b1:
 					return !this->symmetry.is_Aa_in_irreducible_sector(A1);
-			// GPU visits Aa01 before the output Aa2 is known in these cases.
-				case Label::ab_ab::a0b0_a1b1:
-				case Label::ab_ab::a0b1_a1b0:
-				case Label::ab_ab::a0b0_a1b2:
-				case Label::ab_ab::a0b1_a1b2:
-				case Label::ab_ab::a0b2_a1b0:
-				case Label::ab_ab::a0b2_a1b1:
-					return false;
 			default:
 				throw std::invalid_argument("label "+Label_Tools::get_name(label)+" error in "+std::string(__FILE__)+" line "+std::to_string(__LINE__));
 		}
@@ -70,11 +62,6 @@ class Filter_Atom_Symmetry: public Filter_Atom<TA, std::pair<TA, TC>>
 				case Label::ab_ab::a0b1_a1b2:
 				case Label::ab_ab::a0b2_a1b0:
 				case Label::ab_ab::a0b2_a1b1:
-			// a01b2_a2b01: Ab01 is the output right atom on GPU.
-				case Label::ab_ab::a0b2_a2b0:
-				case Label::ab_ab::a0b2_a2b1:
-				case Label::ab_ab::a1b2_a2b0:
-				case Label::ab_ab::a1b2_a2b1:
 					return !this->symmetry.is_Ab_in_irreducible_sector(A1.first);
 			default:
 				throw std::invalid_argument("label "+Label_Tools::get_name(label)+" error in "+std::string(__FILE__)+" line "+std::to_string(__LINE__));
@@ -113,14 +100,6 @@ class Filter_Atom_Symmetry: public Filter_Atom<TA, std::pair<TA, TC>>
 				case Label::ab_ab::a1b0_a2b2:
 				case Label::ab_ab::a1b1_a2b2:
 					return !this->symmetry.in_irreducible_sector(A1, A3);
-			// GPU output is (Aa2, Ab2) or (Aa2, Ab01); Aa01 is intermediate.
-				case Label::ab_ab::a0b0_a1b1:
-				case Label::ab_ab::a0b1_a1b0:
-				case Label::ab_ab::a0b0_a1b2:
-				case Label::ab_ab::a0b1_a1b2:
-				case Label::ab_ab::a0b2_a1b0:
-				case Label::ab_ab::a0b2_a1b1:
-					return !this->symmetry.in_irreducible_sector(A2, A3);
 			// a01b2_a2b01:                                        Aa01,          Ab01,          Aa2
 			default:
 					return false;

include/RI/physics/symmetry/Filter_Atom_Symmetry_GPU.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "../../ri/Filter_Atom.h"
+#include "../../ri/Label_Tools.h"
+#include "Symmetry_Filter.h"
+
+namespace RI
+{
+
+// Arguments follow the GPU loop nesting, from outermost to innermost.
+// Only output atoms may be screened; intermediate atoms are summed over.
+template<typename TA, typename TC, typename Tdata>
+class Filter_Atom_Symmetry_GPU: public Filter_Atom<TA, std::pair<TA, TC>>
+{
+  public:
+    using TAC = std::pair<TA, TC>;
+    using Group = Label::Aab_Aab;
+
+    Filter_Atom_Symmetry_GPU(
+        const TC &period,
+        const std::map<std::pair<TA,TA>, std::set<TC>> &irsec)
+        : symmetry(period, irsec) {}
+
+    bool filter_for1(const Label::ab_ab &label, const TA &A1) const override
+    {
+        switch (Label_Tools::to_Aab_Aab(label))
+        {
+            case Group::a01b01_a01b01: // Aa01 is intermediate.
+            case Group::a01b01_a01b2:
+                return false;
+            default: // Aa01 is the left output atom.
+                return !symmetry.is_Aa_in_irreducible_sector(A1);
+        }
+    }
+
+    bool filter_for1(const Label::ab_ab &, const TAC &A1) const override
+    {
+        // The first loop with a cell-bearing atom visits output Ab01.
+        return !symmetry.is_Ab_in_irreducible_sector(A1.first);
+    }
+
+    bool filter_for2(const Label::ab_ab &label, const TA &A1, const TAC &A2) const override
+    {
+        // Only the final stage of a01b2_a2b01 has both outputs at level 2.
+        if (Label_Tools::to_Aab_Aab(label) == Group::a01b2_a2b01)
+            return !symmetry.in_irreducible_sector(A1, A2);
+        return false;
+    }
+
+    bool filter_for32(const Label::ab_ab &label,
+                      const TA &A1, const TAC &A2, const TAC &A3) const override
+    {
+        switch (Label_Tools::to_Aab_Aab(label))
+        {
+            case Group::a01b01_a01b01: // Aa01, Aa2, Ab2
+                return !symmetry.in_irreducible_sector(A2, A3);
+            case Group::a01b01_a01b2: // Aa01, Ab01, Aa2
+                return !symmetry.in_irreducible_sector(A3, A2);
+            case Group::a01b01_a2b01: // Aa01, Ab01, Ab2
+            case Group::a01b2_a2b01: // Aa01, Aa2, Ab01
+                return !symmetry.in_irreducible_sector(A1, A3);
+            case Group::a01b01_a2b2: // Aa01, Ab01, Ab2
+                return !symmetry.in_irreducible_sector(A1, A2);
+            default:
+                throw std::invalid_argument("Unknown GPU symmetry label");
+        }
+    }
+
+    // filter_for31 builds intermediates and deliberately never screens pairs.
+    // All other callbacks retain the base class's no-op behavior.
+    Symmetry_Filter<TA,TC,Tdata> symmetry;
+};
+
+}

include/RI/physics/symmetry/Filter_Atom_Symmetry_Wrapper.h

@@ -0,0 +1,64 @@
+// ===================
+//  Author: Peize Lin
+//  date: 2026.11.10
+// ===================
+
+#pragma once
+
+#include "Filter_Atom_Symmetry.h"
+#include "../../ri/LRI.h"
+#ifdef __GPU_RI
+#include "Filter_Atom_Symmetry_GPU.h"
+#endif
+#include <memory>
+
+namespace RI
+{
+
+// Own both policies and select once before entering the contraction loops.
+// This callable is not an atom filter and does not forward filter callbacks.
+template<typename TA, typename TC, typename Tdata>
+class Filter_Atom_Symmetry_Wrapper
+{
+    using TAC = std::pair<TA, TC>;
+    struct Configuration
+    {
+        TC period;
+        std::map<std::pair<TA,TA>, std::set<TC>> sector;
+    };
+    // Shared immutable configuration keeps filter references valid after copies.
+    std::shared_ptr<const Configuration> configuration;
+    Filter_Atom_Symmetry<TA,TC,Tdata> filter_CPU;
+#ifdef __GPU_RI
+    Filter_Atom_Symmetry_GPU<TA,TC,Tdata> filter_GPU;
+#endif
+
+  public:
+    Filter_Atom_Symmetry_Wrapper(
+        const TC &period,
+        const std::map<std::pair<TA,TA>, std::set<TC>> &irsec)
+        : configuration(std::make_shared<Configuration>(Configuration{period, irsec})),
+          filter_CPU(configuration->period, configuration->sector)
+#ifdef __GPU_RI
+        , filter_GPU(configuration->period, configuration->sector)
+#endif
+    {}
+
+    const Filter_Atom<TA,TAC>* operator()(LRI_Cal_Mode mode) const
+    {
+        switch (mode)
+        {
+            case LRI_Cal_Mode::CPU:
+            case LRI_Cal_Mode::CPU_fine_grained_lock:
+                return &filter_CPU;
+#ifdef __GPU_RI
+            case LRI_Cal_Mode::GPU:
+                return &filter_GPU;
+#endif
+            default:
+                throw std::invalid_argument("Unknown contraction mode for symmetry filter");
+        }
+    }
+};
+
+}