refactor hbb boundaries to take a blockforest ref, instead of a shared_ptr....

refactor hbb boundaries to take a blockforest ref, instead of a shared_ptr. Extend SweepProperties to accept custom initializers.

include/GenericHbbBoundary.hpp

@@ -69,22 +69,22 @@ public:
   using Stencil      = Stencil_T;
   using IndexVectors = BoundaryIndexVectors< HbbLink >;
 
-  GenericHbbBoundary(const std::shared_ptr< StructuredBlockForest >& blocks)
+  GenericHbbBoundary(StructuredBlockForest& blocks)
   {
     auto createIdxVector = [](IBlock* const, StructuredBlockStorage* const) { return new IndexVectors(); };
-    indexVectorsId_      = blocks->addStructuredBlockData< IndexVectors >(createIdxVector);
+    indexVectorsId_      = blocks.addStructuredBlockData< IndexVectors >(createIdxVector);
   }
 
   template< typename FlagField_T >
-  void fillFromFlagField(const shared_ptr< StructuredBlockForest >& blocks, ConstBlockDataID flagFieldID,
+  void fillFromFlagField(StructuredBlockForest& blocks, ConstBlockDataID flagFieldID,
                          FlagUID boundaryFlagUID, FlagUID domainFlagUID)
   {
-    for (auto blockIt = blocks->begin(); blockIt != blocks->end(); ++blockIt)
-      fillFromFlagField< FlagField_T >(&*blockIt, flagFieldID, boundaryFlagUID, domainFlagUID);
+    for (auto & block: blocks)
+      fillFromFlagField< FlagField_T >(block, flagFieldID, boundaryFlagUID, domainFlagUID);
   }
 
   template< typename FlagField_T >
-  void fillFromFlagField(IBlock* block, ConstBlockDataID flagFieldID, FlagUID boundaryFlagUID, FlagUID domainFlagUID);
+  void fillFromFlagField(IBlock& block, ConstBlockDataID flagFieldID, FlagUID boundaryFlagUID, FlagUID domainFlagUID);
 
 protected:
   BlockDataID indexVectorsId_;
@@ -92,12 +92,12 @@ protected:
 
 template< typename Stencil_T >
 template< typename FlagField_T >
-void GenericHbbBoundary< Stencil_T >::fillFromFlagField(IBlock* block, ConstBlockDataID flagFieldID,
+void GenericHbbBoundary< Stencil_T >::fillFromFlagField(IBlock& block, ConstBlockDataID flagFieldID,
                                                                 FlagUID boundaryFlagUID, FlagUID domainFlagUID)
 {
-  auto* indexVectors   = block->getData< IndexVectors >(indexVectorsId_);
+  auto* indexVectors   = block.getData< IndexVectors >(indexVectorsId_);
   auto& indexVectorAll = indexVectors->vector();
-  auto* flagField      = block->getData< FlagField_T >(flagFieldID);
+  auto* flagField      = block.getData< FlagField_T >(flagFieldID);
 
   if (!(flagField->flagExists(boundaryFlagUID) && flagField->flagExists(domainFlagUID))) return;
 

src/sfg_walberla/api.py

@@ -24,7 +24,7 @@ class Vector2(SrcVector):
     def extract_component(self, coordinate: int) -> AugExpr:
         if coordinate > 1:
             raise ValueError(f"Cannot extract component {coordinate} from Vector2")
-        
+
         return AugExpr(self._value_type).bind("{}[{}]", self, coordinate)
 
 
@@ -66,9 +66,19 @@ class StructuredBlockForest:
     @staticmethod
     def shared_ptr_ref(name, const: bool = False):
         const_str = "const " if const else ""
-        dtype = PsCustomType(f"std::shared_ptr< {const_str}walberla::StructuredBlockForest >", const=True)
+        dtype = PsCustomType(
+            f"std::shared_ptr< {const_str}walberla::StructuredBlockForest >", const=True
+        )
         return AugExpr(Ref(dtype)).var(name)
 
+    @staticmethod
+    def ref_type(const: bool = False):
+        return Ref(PsCustomType("walberla::StructuredBlockForest", const=const))
+
+    @staticmethod
+    def ref(name, const: bool = False):
+        return AugExpr(StructuredBlockForest.ref_type(const)).var(name)
+
 
 class GhostLayerFieldPtr(SrcField):
 

src/sfg_walberla/boundaries/hbb.py

@@ -66,7 +66,7 @@ class BoundaryIndexVectorsPtr(SrcField):
 
 class HbbBoundaryProperties(SweepClassProperties):
     def _constructor(self, sfg: SfgComposer) -> SfgClassComposer.ConstructorBuilder:
-        sbfs = StructuredBlockForest.shared_ptr_ref("blocks")
+        sbfs = StructuredBlockForest.ref("blocks")
         return sfg.constructor(sbfs).init("GenericHbbBoundary")(sbfs)
 
 

src/sfg_walberla/sweep.py

@@ -21,7 +21,7 @@ from pystencils.types import PsType, constify, deconstify, PsCustomType
 
 from pystencilssfg import SfgComposer
 from pystencilssfg.lang import VarLike, asvar, SfgVar, AugExpr, Ref, SrcVector
-from .api import GhostLayerFieldPtr, IBlockPtr, BlockDataID, Vector2, Vector3
+from .api import StructuredBlockForest, GhostLayerFieldPtr, IBlockPtr, BlockDataID, Vector2, Vector3
 
 
 class SweepClassProperties:
@@ -31,6 +31,7 @@ class SweepClassProperties:
         dtype: PsType
         getter: bool
         setter: bool
+        initializer: AugExpr | None = None
 
         def __post_init__(self):
             if self.dtype.const and self.setter:
@@ -103,10 +104,21 @@ class SweepClassProperties:
         ctor = self._constructor(sfg)
 
         for p in self.properties:
-            ctor.add_param(p.var)
+            if p.initializer is None:
+                ctor.add_param(p.var)
+            else:
+                for var in p.initializer.depends:
+                    if var not in ctor.parameters:
+                        if deconstify(var.dtype) == StructuredBlockForest.ref_type():
+                            ctor.add_param(var, 0)
+                        else:
+                            ctor.add_param(var)
 
         for p in self._properties.values():
-            ctor.init(p.member_var)(p.var)
+            if p.initializer is not None:
+                ctor.init(p.member_var)(p.initializer)
+            else:
+                ctor.init(p.member_var)(p.var)
 
         methods = chain.from_iterable(p.make_methods(sfg) for p in self.properties)
         pub = sfg.public(ctor, *(methods))