csfpy 0.2.1__tar.gz → 0.2.3__tar.gz

{csfpy-0.2.1/src/csfpy.egg-info → csfpy-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csfpy
-Version: 0.2.1
+Version: 0.2.3
 Summary: An Analytical Engine for Non-Prismatic Structural Members
 Author: Giovanni Boscu
 License: GPL-3.0
@@ -34,6 +34,7 @@ Dynamic: license-file
 
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.20687216.svg)](https://doi.org/10.5281/zenodo.20687216)
 ![Python](https://img.shields.io/badge/python-3.8+-blue.svg)
+![CUF](https://img.shields.io/badge/CUF-Carrera_Unified_Formulation-purple.svg)
 ![Math](https://img.shields.io/badge/Engine-Analytical_Mechanics-red.svg)
 ![License](https://img.shields.io/github/license/giovanniboscu/continuous-section-field)
 ![Repo Size](https://img.shields.io/github/repo-size/giovanniboscu/continuous-section-field)
@@ -56,9 +57,8 @@ It represents variable geometry and material distribution as continuous function
  The resulting data can be exported in **CSV** and **YAML** formats for integration with beam solvers such as OpenSees and SAP2000, or with section-analysis tools such as [csf_sp](https://github.com/giovanniboscu/continuous-section-field/blob/main/docs/csf_sp_user_guide.md) and [sp_csf](https://github.com/giovanniboscu/continuous-section-field/blob/main/docs/sectionproperties/sp_csf_guide.md).
 
 
-
 ---
-
+### Illustrative example
 
 >Three-dimensional representation of the tapered pole with localized degradation. Gray regions indicate the non-degraded portions. Weight in this model is the elastic modulus.
 
@@ -83,6 +83,26 @@ It represents variable geometry and material distribution as continuous function
 
   See [Ekofisk Jacket Platform - Foundation Piles](https://github.com/giovanniboscu/continuous-section-field/blob/main/actions-examples/ekofisk/README.md) for a localized corrosion case. 
 
+---
+
+**CSF–CUF structural analysis**
+
+CSF can be used as the continuous geometry and material provider for a
+Carrera Unified Formulation (CUF) beam model.
+
+The repository includes an open-source CUF implementation in which
+cross-sectional expansion functions are independent from the CSF
+geometry/material description.
+
+```bash
+cd cuf/tutorials/variable_material_t_section/t_section/models/
+csf-actions t_noprismatic_csf.yaml action.yaml   # inspect the non-prismatic T-section
+
+cd ../cases
+csf-cuf bending_halfwave_legendre_N08.yaml       # run a CUF bending analysis
+```
+
+➡️ [CSF–CUF framework and documentation](cuf/readme.md)
 
 
 ---
@@ -182,7 +202,7 @@ then run
 **linux / Mac**
 ```
 python3 -m venv venv
-source source venv/bin/activate
+source venv/bin/activate
 pip install csfpy
 csf-actions geometry.yaml actions.yaml
 ```

{csfpy-0.2.1 → csfpy-0.2.3}/README.md

@@ -6,6 +6,7 @@
 
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.20687216.svg)](https://doi.org/10.5281/zenodo.20687216)
 ![Python](https://img.shields.io/badge/python-3.8+-blue.svg)
+![CUF](https://img.shields.io/badge/CUF-Carrera_Unified_Formulation-purple.svg)
 ![Math](https://img.shields.io/badge/Engine-Analytical_Mechanics-red.svg)
 ![License](https://img.shields.io/github/license/giovanniboscu/continuous-section-field)
 ![Repo Size](https://img.shields.io/github/repo-size/giovanniboscu/continuous-section-field)
@@ -28,9 +29,8 @@ It represents variable geometry and material distribution as continuous function
  The resulting data can be exported in **CSV** and **YAML** formats for integration with beam solvers such as OpenSees and SAP2000, or with section-analysis tools such as [csf_sp](https://github.com/giovanniboscu/continuous-section-field/blob/main/docs/csf_sp_user_guide.md) and [sp_csf](https://github.com/giovanniboscu/continuous-section-field/blob/main/docs/sectionproperties/sp_csf_guide.md).
 
 
-
 ---
-
+### Illustrative example
 
 >Three-dimensional representation of the tapered pole with localized degradation. Gray regions indicate the non-degraded portions. Weight in this model is the elastic modulus.
 
@@ -55,6 +55,26 @@ It represents variable geometry and material distribution as continuous function
 
   See [Ekofisk Jacket Platform - Foundation Piles](https://github.com/giovanniboscu/continuous-section-field/blob/main/actions-examples/ekofisk/README.md) for a localized corrosion case. 
 
+---
+
+**CSF–CUF structural analysis**
+
+CSF can be used as the continuous geometry and material provider for a
+Carrera Unified Formulation (CUF) beam model.
+
+The repository includes an open-source CUF implementation in which
+cross-sectional expansion functions are independent from the CSF
+geometry/material description.
+
+```bash
+cd cuf/tutorials/variable_material_t_section/t_section/models/
+csf-actions t_noprismatic_csf.yaml action.yaml   # inspect the non-prismatic T-section
+
+cd ../cases
+csf-cuf bending_halfwave_legendre_N08.yaml       # run a CUF bending analysis
+```
+
+➡️ [CSF–CUF framework and documentation](cuf/readme.md)
 
 
 ---
@@ -154,7 +174,7 @@ then run
 **linux / Mac**
 ```
 python3 -m venv venv
-source source venv/bin/activate
+source venv/bin/activate
 pip install csfpy
 csf-actions geometry.yaml actions.yaml
 ```

{csfpy-0.2.1 → csfpy-0.2.3}/pyproject.toml

@@ -8,7 +8,7 @@ Repository = "https://github.com/giovanniboscu/continuous-section-field"
 
 [project]
 name = "csfpy"
-version = "v0.2.1"
+version = "v0.2.3"
 description = "An Analytical Engine for Non-Prismatic Structural Members"
 readme = "README.md"
 authors = [{ name = "Giovanni Boscu" }]

{csfpy-0.2.1 → csfpy-0.2.3}/src/csf/cuf/adapters/problem/surface_halfwave.py

@@ -45,11 +45,24 @@ elsewhere only by the prescribed half-wave factor.
 
 Constraints
 -----------
-The constraints are copied mechanically from ``uniform_surface_load.py``:
-all global-y and global-z CUF amplitudes are fixed at both beam ends, and the
-remaining rigid global-x translation is removed with the FEM3D point anchor
+Both beam-end sections are perfectly clamped.
 
-    u_x(x_start, 0, 0) = 0.
+At ``x = x_start`` and ``x = x_end`` the complete displacement field is zero:
+
+    u_x = 0
+    u_y = 0
+    u_z = 0
+
+over the whole cross-section.  No pointwise axial anchor is used.
+
+In CUF this is enforced by setting every generalized transverse amplitude to
+zero for all three displacement components at both longitudinal end nodes.
+Because the physical field is reconstructed as
+
+    u_i(x,y,z) = sum_tau F_tau(y,z) * u_i,tau(x),
+
+zeroing every ``u_i,tau`` at an end node makes the complete physical
+displacement component ``u_i`` vanish everywhere on that end section.
 
 YAML interface
 --------------
@@ -551,25 +564,47 @@ class SurfaceHalfWaveLoadProblem:
         basis: Any,
         longitudinal_integrator: Any,
     ):
-        """Apply the bending supports and the FEM3D pointwise axial anchor.
+        """Perfectly clamp both beam ends: ux = uy = uz = 0.
 
-        Global y and z amplitudes are fixed at both longitudinal ends.  The
-        remaining rigid global-x translation is removed with the same anchor
-        used by the reference FEM3D model: ``u_x(0, 0, 0) = 0``.
+        CUF does not generally associate one generalized degree of freedom with
+        one physical point of the cross-section.  The physical displacement is
+        reconstructed from the transverse expansion
+
+            u_i(x, y, z) = sum_tau F_tau(y, z) * u_i,tau(x).
+
+        Therefore a full sectional clamp is imposed by setting *all* CUF
+        amplitudes ``u_i,tau`` to zero, for all three physical components, at
+        each longitudinal end node.  This avoids the previous pointwise axial
+        anchor and gives a boundary condition that is natural for the CUF
+        representation.
         """
 
         layout = assembled.dof_layout
-        row_count = 4 * int(basis.size) + 1
+        n_tau = int(basis.size)
+
+        # We constrain:
+        #   3 displacement components (x, y, z)
+        # x 2 longitudinal end sections (S0 and S1)
+        # x n_tau transverse CUF amplitudes.
+        #
+        # Hence the total number of scalar constraint equations is 6*n_tau.
+        row_count = 6 * n_tau
         matrix = np.zeros((row_count, layout.total_dofs), dtype=float)
         rhs = np.zeros(row_count, dtype=float)
         row = 0
 
-        # Fix every transverse CUF amplitude (global y and z components) at
-        # both longitudinal ends.  Component numbering follows the solver's
-        # established convention: 0=x, 1=y, 2=z.
+        # Perfect clamp at both longitudinal ends.
+        #
+        # Solver component numbering is:
+        #   0 -> global x displacement
+        #   1 -> global y displacement
+        #   2 -> global z displacement
+        #
+        # Setting every generalized amplitude to zero for a component makes the
+        # complete reconstructed CUF displacement vanish over the whole section.
         for node in (0, mesh.number_of_nodes - 1):
-            for component in (1, 2):
-                for tau in range(1, int(basis.size) + 1):
+            for component in (0, 1, 2):
+                for tau in range(1, n_tau + 1):
                     matrix[
                         row,
                         layout.index(
@@ -580,39 +615,6 @@ class SurfaceHalfWaveLoadProblem:
                     ] = 1.0
                     row += 1
 
-        # The end supports leave one rigid global-x translation.  Match the
-        # FEM3D reference exactly by anchoring the physical displacement at the
-        # start section and at the section point (y, z) = (0, 0):
-        #
-        #     u_x(x=0, y=0, z=0) = 0.
-        #
-        # At the first longitudinal FE node, the physical CUF displacement is
-        # the section-basis expansion sum_tau F_tau(0, 0) * q_x,tau.
-        axial_anchor_factors = np.asarray(
-            [
-                basis.value(
-                    tau,
-                    0.0,
-                    0.0,
-                    x=float(mesh.x_start),
-                )
-                for tau in range(1, int(basis.size) + 1)
-            ],
-            dtype=float,
-        )
-
-        start_node = 0
-        for tau, factor in enumerate(axial_anchor_factors, start=1):
-            matrix[
-                row,
-                layout.index(
-                    node=start_node,
-                    tau=tau,
-                    component=0,
-                ),
-            ] = float(factor)
-
-        row += 1
         if row != row_count:
             raise RuntimeError("internal constraint-row count mismatch")
 

{csfpy-0.2.1 → csfpy-0.2.3}/src/csf/cuf/adapters/problem/torsion_halfwave.py

@@ -1,20 +1,26 @@
-# Version: CSF-CUF torsional line-pair half-wave adapter v1.0 - 2026-09-04
+# Version: CSF-CUF torsional line-pair half-wave adapter v1.2-fixed-fixed - 2026-09-10
 """
 Sinusoidal torsional line-pair problem adapter for CSF-CUF.
 
 This adapter is the m=1 half-wave counterpart of ``torsion_uniform.py``.  It
-preserves exactly the same CSF moving vertices, the same opposite global-z
-force pair, the same longitudinal measure ``dx``, the same CUF projection, and
-the same FEM3D-compatible constraints.  The only mechanical change relative to
-the uniform adapter is the longitudinal half-wave intensity.
+preserves the same opposite global-z force pair, the same longitudinal measure
+``dx``, the same CUF projection, and the same FEM3D-compatible constraints.
+The only mechanical change relative to the uniform adapter is the longitudinal
+half-wave intensity.
 
 Physical loading
 ----------------
-At every physical coordinate x:
+The two load trajectories are defined once from the CSF end sections.
+At ``x = x0`` and ``x = x1``:
 
 * ``point_plus`` is the leftmost CSF vertex on the maximum-z boundary;
 * ``point_minus`` is the rightmost CSF vertex on the minimum-z boundary.
 
+The corresponding S0/S1 points define two straight physical load lines.
+For every interior x, including longitudinal Gauss points, ``point_plus(x)``
+and ``point_minus(x)`` are obtained by affine interpolation along those lines.
+No repeated minimum/maximum search is performed on intermediate CSF sections.
+
 The signed line-load intensities are
 
     + amplitude * sin(pi * (x - x0) / L)
@@ -41,12 +47,17 @@ introduced.  Adding such a factor would define a different physical problem.
 
 Constraints
 -----------
-The constraints are copied mechanically from the current uniform torsion CUF
-adapter and match FEM3D:
+Both beam ends are perfectly clamped.
+
+At ``x = x_start`` and ``x = x_end`` the complete displacement field is zero:
 
-* all global-y and global-z CUF amplitudes are fixed at both beam ends;
-* the remaining rigid global-x translation is removed with
-  ``u_x(x_start, 0, 0) = 0``.
+    u_x = 0
+    u_y = 0
+    u_z = 0
+
+over the whole cross-section.  No pointwise axial anchor is used.  This is a
+fixed-fixed (clamped-clamped) model and therefore suppresses axial warping at
+both end sections.
 
 YAML interface
 --------------
@@ -120,11 +131,14 @@ def _has_vertex(section_provider: Any, x: float, point) -> bool:
 
 
 def moving_load_points(section_provider: Any, x: float):
-    """Return the same two moving CSF vertices as the half-wave torsion case.
+    """Identify the two torsional load vertices on one CSF section.
 
     The positive point is the leftmost vertex on the maximum-z boundary.  The
     negative point is the rightmost vertex on the minimum-z boundary.  Ties are
     resolved deterministically by the physical y coordinate.
+
+    For the half-wave projector this selector is used only at x0 and x1; the
+    interior load points then follow the straight lines joining those endpoints.
     """
 
     x = float(x)
@@ -203,8 +217,36 @@ class HalfWaveTorsionalLinePairProjector:
 
         self.length = self.x1 - self.x0
         self.alpha = math.pi / self.length
+
+        # Identify the two physical load lines once from their CSF endpoints.
+        self.point_plus_0, self.point_minus_0 = moving_load_points(
+            self.section_provider,
+            self.x0,
+        )
+        self.point_plus_1, self.point_minus_1 = moving_load_points(
+            self.section_provider,
+            self.x1,
+        )
+
         self._cache: dict[float, np.ndarray] = {}
 
+    def load_points(self, x: float):
+        """Return the two points on the straight physical load trajectories."""
+
+        x = float(x)
+        t = (x - self.x0) / self.length
+
+        point_plus = (
+            (1.0 - t) * self.point_plus_0[0] + t * self.point_plus_1[0],
+            (1.0 - t) * self.point_plus_0[1] + t * self.point_plus_1[1],
+        )
+        point_minus = (
+            (1.0 - t) * self.point_minus_0[0] + t * self.point_minus_1[0],
+            (1.0 - t) * self.point_minus_0[1] + t * self.point_minus_1[1],
+        )
+
+        return point_plus, point_minus
+
     def generalized_vector(self, x: float) -> np.ndarray:
         """Return the complete half-wave ``q_tau,z(x)`` vector."""
 
@@ -213,10 +255,7 @@ class HalfWaveTorsionalLinePairProjector:
         if cached is not None:
             return cached
 
-        point_plus, point_minus = moving_load_points(
-            self.section_provider,
-            x,
-        )
+        point_plus, point_minus = self.load_points(x)
         y_plus, z_plus = point_plus
         y_minus, z_minus = point_minus
 
@@ -310,19 +349,29 @@ class TorsionHalfWaveProblem:
         basis: Any,
         longitudinal_integrator: Any,
     ):
-        """Apply the torsion supports with the FEM3D pointwise axial anchor."""
+        """Perfectly clamp both beam ends: ux = uy = uz = 0."""
 
         layout = assembled.dof_layout
-        row_count = 4 * int(basis.size) + 1
+        n_tau = int(basis.size)
+
+        # Three displacement components x two beam ends x all transverse
+        # amplitudes.
+        row_count = 6 * n_tau
         matrix = np.zeros((row_count, layout.total_dofs), dtype=float)
         rhs = np.zeros(row_count, dtype=float)
         row = 0
 
-        # Fix all generalized global-y and global-z amplitudes at both beam
-        # ends.  Solver component numbering is 0=x, 1=y, 2=z.
+        # Perfect clamp at both longitudinal ends.
+        #
+        # Fixing every generalized amplitude for components x, y and z makes
+        # the complete CUF displacement field vanish on each end section:
+        #
+        #     u_x = u_y = u_z = 0
+        #
+        # for every physical point (y,z) of the section.
         for node in (0, mesh.number_of_nodes - 1):
-            for component in (1, 2):
-                for tau in range(1, int(basis.size) + 1):
+            for component in (0, 1, 2):
+                for tau in range(1, n_tau + 1):
                     matrix[
                         row,
                         layout.index(
@@ -333,33 +382,6 @@ class TorsionHalfWaveProblem:
                     ] = 1.0
                     row += 1
 
-        # Remove only the rigid global-x translation, using exactly the same
-        # physical anchor as FEM3D: u_x(x_start, y=0, z=0) = 0.
-        axial_anchor_factors = np.asarray(
-            [
-                basis.value(
-                    tau,
-                    0.0,
-                    0.0,
-                    x=float(mesh.x_start),
-                )
-                for tau in range(1, int(basis.size) + 1)
-            ],
-            dtype=float,
-        )
-
-        start_node = 0
-        for tau, factor in enumerate(axial_anchor_factors, start=1):
-            matrix[
-                row,
-                layout.index(
-                    node=start_node,
-                    tau=tau,
-                    component=0,
-                ),
-            ] = float(factor)
-
-        row += 1
         if row != row_count:
             raise RuntimeError("internal constraint-row count mismatch")
 
@@ -413,4 +435,4 @@ __all__ = (
     "HalfWaveTorsionalLinePairProjector",
     "build_problem",
     "moving_load_points",
-)
+)

{csfpy-0.2.1 → csfpy-0.2.3}/src/csf/cuf/core/basis_plugins.py

@@ -20,7 +20,24 @@ LongitudinalTransverseDegree = Callable[[object], int]
 
 @dataclass(frozen=True)
 class CUFBasisPlugin:
-    """Runtime descriptor for one transverse CUF basis implementation."""
+    
+    """Build a basis with access to the complete CSF field context.
+    
+    Simple expansions may ignore ``continuous_section_field``.
+    
+    The longitudinal coordinate ``x`` may be available during runtime basis
+    evaluation as contextual information for diagnostics, logging, tracing,
+    or bookkeeping.
+    
+    In the current CSF-CUF formulation, however, transverse basis functions
+    remain mathematically independent of ``x``:
+    
+        F_tau = F_tau(y, z)
+    
+    Therefore ``x`` must not affect the returned basis value or its
+    transverse derivatives.
+    """
+    
 
     name: str
     builder: BasisBuilder

{csfpy-0.2.1 → csfpy-0.2.3}/src/csf/cuf/expansions/scaled_lagrange.py

@@ -74,14 +74,7 @@ class ScaledLagrangeBasis(CUFBasis):
         self._y_scale = y_scale
         self._z_scale = z_scale
 
-        # Build the physical-coordinate power representation once.  The
-        # solver-side displacement checkpoint consumes this optional generic
-        # representation without knowing which concrete expansion produced
-        # it.  Future polynomial expansions may expose the same
-        # power_coefficients() method to opt into self-contained displacement
-        # checkpoints; the CUFBasis core contract remains unchanged.
-        self._power_coefficients = self._build_power_coefficients()
-        self._power_coefficients.setflags(write=False)
+
 
     @property
     def order(self) -> int:
@@ -106,124 +99,8 @@ class ScaledLagrangeBasis(CUFBasis):
 
         return self._reference_basis.definition(tau)
 
-    def power_coefficients(self) -> np.ndarray:
-        """Return F_tau coefficients in ascending physical powers of y and z.
-
-        The returned array has shape ``(size, order + 1, order + 1)`` and
-        follows
-
-            F_tau(y,z) = sum_{p,q} coefficients[tau-1,p,q] y**p z**q.
-
-        This optional expansion-owned export is used only to create a
-        self-contained displacement checkpoint.  It is deliberately outside
-        the CUFBasis core interface so future non-polynomial expansions can
-        choose a different checkpoint representation without changing core.
-        """
-
-        return self._power_coefficients.copy()
-
-    @staticmethod
-    def _reference_polynomial(order: int, *, reverse: bool = False):
-        """Return p_order(mu) or p_order(-mu) in ascending powers.
-
-        This representation is needed only by the optional physical-power
-        checkpoint export.  The solver itself evaluates the reference
-        polynomial directly from its roots in ``core.basis``.
-
-        Coefficients are accumulated in extended precision before the final
-        float64 cast.  The checkpoint must ultimately contain monomial
-        coefficients, but coefficient construction should not add avoidable
-        float64 roundoff.
-        """
-
-        roots = np.linspace(-1.0, 1.0, int(order), dtype=np.longdouble)
-        coefficients = np.asarray((1.0,), dtype=np.longdouble)
-
-        # Ascending powers: multiply successively by (mu - root).
-        for root in roots:
-            coefficients = np.convolve(
-                coefficients,
-                np.asarray((-root, 1.0), dtype=np.longdouble),
-            )
-
-        if reverse:
-            coefficients = coefficients * np.power(
-                np.longdouble(-1.0),
-                np.arange(coefficients.size),
-            )
-
-        return np.asarray(coefficients, dtype=float)
-
-    def _build_power_coefficients(self) -> np.ndarray:
-        """Compile every hierarchy term into physical y,z power coefficients."""
-
-        count = self.order + 1
-        coefficients = np.zeros((self.size, count, count), dtype=float)
-
-        for tau in range(1, self.size + 1):
-            kind, r, side, n, m = self.definition(tau)
-
-            if kind == "I":
-                corner_signs = (
-                    (-1.0, -1.0),
-                    (+1.0, -1.0),
-                    (+1.0, +1.0),
-                    (-1.0, +1.0),
-                )
-                sign_y, sign_z = corner_signs[side - 1]
-                reference = 0.25 * np.outer(
-                    np.asarray((1.0, sign_y)),
-                    np.asarray((1.0, sign_z)),
-                )
-            elif kind in ("IIA", "IIB"):
-                if side == 1:
-                    reference = 0.5 * np.outer(
-                        self._reference_polynomial(r),
-                        np.asarray((1.0, -1.0)),
-                    )
-                elif side == 2:
-                    reference = 0.5 * np.outer(
-                        np.asarray((1.0, +1.0)),
-                        self._reference_polynomial(r),
-                    )
-                elif side == 3:
-                    reference = 0.5 * np.outer(
-                        self._reference_polynomial(r, reverse=True),
-                        np.asarray((1.0, +1.0)),
-                    )
-                elif side == 4:
-                    reference = 0.5 * np.outer(
-                        np.asarray((1.0, -1.0)),
-                        self._reference_polynomial(r, reverse=True),
-                    )
-                else:
-                    raise RuntimeError("invalid SL edge index")
-            elif kind == "III":
-                reference = np.outer(
-                    self._reference_polynomial(n),
-                    self._reference_polynomial(m),
-                )
-            else:
-                raise RuntimeError(
-                    f"unsupported SL function type {kind!r}"
-                )
-
-            rows, columns = reference.shape
-            y_scaling = np.power(
-                self._y_scale,
-                -np.arange(rows, dtype=float),
-            )
-            z_scaling = np.power(
-                self._z_scale,
-                -np.arange(columns, dtype=float),
-            )
-            coefficients[tau - 1, :rows, :columns] = (
-                reference
-                * y_scaling[:, None]
-                * z_scaling[None, :]
-            )
+    
 
-        return coefficients
 
     def value(
         self,

{csfpy-0.2.1 → csfpy-0.2.3}/src/csf/cuf/solver/compiled_field.py

@@ -71,6 +71,148 @@ class CompiledDisplacementField:
         ):
             value.setflags(write=False)
 
+    ##
+    
+    
+    @staticmethod
+    def _transverse_power_coefficients(basis):
+        """
+        Reconstruct a polynomial transverse basis from the normal CUF basis API.
+
+        No checkpoint-specific method is required from the expansion.
+        The reconstruction uses the existing basis order, transverse scales,
+        and basis evaluations.
+        """
+
+        try:
+            order = int(basis.order)
+            size = int(basis.size)
+            y_scale, z_scale = map(float, basis.scales)
+        except (AttributeError, TypeError, ValueError):
+            return None
+
+        if order < 0 or size < 1:
+            return None
+
+        if (
+            not np.isfinite(y_scale)
+            or not np.isfinite(z_scale)
+            or y_scale <= 0.0
+            or z_scale <= 0.0
+        ):
+            return None
+
+        count = order + 1
+
+        # Chebyshev-Lobatto interpolation points in normalized coordinates.
+        if count == 1:
+            points = np.asarray((0.0,), dtype=float)
+        else:
+            points = np.polynomial.chebyshev.chebpts2(count)
+
+        # V[i,p] = T_p(points[i])
+        vandermonde = np.polynomial.chebyshev.chebvander(
+            points,
+            order,
+        )
+        inverse_vandermonde = np.linalg.inv(vandermonde)
+
+        # values[tau, iy, iz]
+        values = np.empty(
+            (size, count, count),
+            dtype=float,
+        )
+
+        for iy, normalized_y in enumerate(points):
+            y = y_scale * float(normalized_y)
+
+            for iz, normalized_z in enumerate(points):
+                z = z_scale * float(normalized_z)
+
+                if hasattr(basis, "values"):
+                    current = np.asarray(
+                        basis.values(y, z),
+                        dtype=float,
+                    )
+                else:
+                    current = np.asarray(
+                        [
+                            basis.value(tau, y, z)
+                            for tau in range(1, size + 1)
+                        ],
+                        dtype=float,
+                    )
+
+                if current.shape != (size,):
+                    raise ValueError(
+                        "transverse basis evaluation has invalid shape"
+                    )
+
+                values[:, iy, iz] = current
+
+        # Tensor-product interpolation:
+        #
+        # values = V * C_chebyshev * V^T
+        chebyshev_coefficients = np.einsum(
+            "ai,tij,bj->tab",
+            inverse_vandermonde,
+            values,
+            inverse_vandermonde,
+            optimize=True,
+        )
+
+        # Transformation matrix:
+        #
+        # Chebyshev coefficients -> ordinary powers
+        conversion = np.zeros((count, count), dtype=float)
+
+        for degree in range(count):
+            unit = np.zeros(count, dtype=float)
+            unit[degree] = 1.0
+
+            polynomial = np.polynomial.chebyshev.cheb2poly(unit)
+
+            conversion[: polynomial.size, degree] = polynomial
+
+        normalized_power_coefficients = np.einsum(
+            "pa,tab,qb->tpq",
+            conversion,
+            chebyshev_coefficients,
+            conversion,
+            optimize=True,
+        )
+
+        # Convert normalized powers:
+        #
+        # Y = y / y_scale
+        # Z = z / z_scale
+        #
+        # into physical powers y^p z^q.
+        y_scaling = np.power(
+            y_scale,
+            -np.arange(count, dtype=float),
+        )
+        z_scaling = np.power(
+            z_scale,
+            -np.arange(count, dtype=float),
+        )
+
+        coefficients = (
+            normalized_power_coefficients
+            * y_scaling[None, :, None]
+            * z_scaling[None, None, :]
+        )
+
+        if not np.all(np.isfinite(coefficients)):
+            raise ValueError(
+                "compiled transverse polynomial contains non-finite values"
+            )
+
+        return np.asarray(coefficients, dtype=float)    
+    
+    
+
+
     @classmethod
     def from_solution_data(
         cls,
@@ -88,10 +230,7 @@ class CompiledDisplacementField:
         expansions continue to use the existing in-memory recovery path and
         are not altered by this feature.
         """
-
-        export = getattr(basis, "power_coefficients", None)
-        if not callable(export):
-            return None
+  
 
         solved_dofs = np.asarray(solved_dofs, dtype=float)
         if solved_dofs.shape != (dof_layout.total_dofs,):
@@ -135,7 +274,11 @@ class CompiledDisplacementField:
         longitudinal_coefficients = cls._lagrange_power_coefficients(
             reference_nodes
         )
-        transverse_coefficients = np.asarray(export(), dtype=float)
+        
+        
+        transverse_coefficients = cls._transverse_power_coefficients(basis)
+        if transverse_coefficients is None:
+            return None
 
         combined_metadata = dict(metadata or {})
         combined_metadata.update(

{csfpy-0.2.1 → csfpy-0.2.3}/src/csf/cuf/solver/engine.py

@@ -415,14 +415,10 @@ def _longitudinal_gauss_requirement(
                 "must be (y,z) pairs"
             )
 
-        if not close(vm, 0.5 * (v0 + v1)):
-            raise ValueError(
-                "cannot estimate longitudinal Gauss order: CSF geometry is "
-                f"not affine in x for domain {domain_index}"
-            )
 
-        varies_y = varies_y or (not close(v0[:, 0], v1[:, 0]))
-        varies_z = varies_z or (not close(v0[:, 1], v1[:, 1]))
+        varies_y = False
+        varies_z = False
+
 
     configured_material_degree = (
         case.longitudinal.material_polynomial_degree
@@ -477,7 +473,8 @@ def _longitudinal_gauss_requirement(
     # here    
     # contribution of the interaction to the degree of the polynomial 
     #################################################################      
-    varying_axes = int(varies_y) + int(varies_z)
+    #varying_axes = int(varies_y) + int(varies_z)
+    
     r = int(case.longitudinal.order)
     transverse_x_degree = (
         basis_plugin.transverse_x_polynomial_degree(basis)
@@ -565,21 +562,30 @@ def _longitudinal_gauss_requirement(
     ###minimum_gauss_order = (polynomial_degree + 2) // 2
     ######
     
-    axes = []
-    if varies_y:
-        axes.append("y")
-    if varies_z:
-        axes.append("z")      
+    #axes = []
+    #if varies_y:
+    #    axes.append("y")
+    #if varies_z:
+    #    axes.append("z")      
       
 
+    #return {
+    #    "polynomial_degree": int(polynomial_degree),
+    #    "minimum_gauss_order": int(minimum_gauss_order),
+    #    "varying_axes": tuple(axes),
+    #    "material_varies": bool(material_varies),
+    #    "material_polynomial_degree": int(material_degree),
+    #    "material_degree_source": material_degree_source,
+    #}
+    
     return {
         "polynomial_degree": int(polynomial_degree),
         "minimum_gauss_order": int(minimum_gauss_order),
-        "varying_axes": tuple(axes),
         "material_varies": bool(material_varies),
         "material_polynomial_degree": int(material_degree),
         "material_degree_source": material_degree_source,
-    }
+    }    
+    
 
 def solve_case(case, model_bridge, problem, *, progress: bool = True) -> CSFCUFSolution:
     """
@@ -673,17 +679,12 @@ def solve_case(case, model_bridge, problem, *, progress: bool = True) -> CSFCUFS
     )
 
     if progress:
-        axes = longitudinal_requirement["varying_axes"]
-        axes_text = ",".join(axes) if axes else "none"
+
         print(
             f"[quadrature] longitudinal degree estimate = "
             f"{longitudinal_requirement['polynomial_degree']}",
             flush=True,
         )
-        print(
-            f"[quadrature] longitudinal variation axes  = {axes_text}",
-            flush=True,
-        )
         print(
             f"[quadrature] longitudinal material varies = "
             f"{str(longitudinal_requirement['material_varies']).lower()}",

{csfpy-0.2.1 → csfpy-0.2.3/src/csfpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csfpy
-Version: 0.2.1
+Version: 0.2.3
 Summary: An Analytical Engine for Non-Prismatic Structural Members
 Author: Giovanni Boscu
 License: GPL-3.0
@@ -34,6 +34,7 @@ Dynamic: license-file
 
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.20687216.svg)](https://doi.org/10.5281/zenodo.20687216)
 ![Python](https://img.shields.io/badge/python-3.8+-blue.svg)
+![CUF](https://img.shields.io/badge/CUF-Carrera_Unified_Formulation-purple.svg)
 ![Math](https://img.shields.io/badge/Engine-Analytical_Mechanics-red.svg)
 ![License](https://img.shields.io/github/license/giovanniboscu/continuous-section-field)
 ![Repo Size](https://img.shields.io/github/repo-size/giovanniboscu/continuous-section-field)
@@ -56,9 +57,8 @@ It represents variable geometry and material distribution as continuous function
  The resulting data can be exported in **CSV** and **YAML** formats for integration with beam solvers such as OpenSees and SAP2000, or with section-analysis tools such as [csf_sp](https://github.com/giovanniboscu/continuous-section-field/blob/main/docs/csf_sp_user_guide.md) and [sp_csf](https://github.com/giovanniboscu/continuous-section-field/blob/main/docs/sectionproperties/sp_csf_guide.md).
 
 
-
 ---
-
+### Illustrative example
 
 >Three-dimensional representation of the tapered pole with localized degradation. Gray regions indicate the non-degraded portions. Weight in this model is the elastic modulus.
 
@@ -83,6 +83,26 @@ It represents variable geometry and material distribution as continuous function
 
   See [Ekofisk Jacket Platform - Foundation Piles](https://github.com/giovanniboscu/continuous-section-field/blob/main/actions-examples/ekofisk/README.md) for a localized corrosion case. 
 
+---
+
+**CSF–CUF structural analysis**
+
+CSF can be used as the continuous geometry and material provider for a
+Carrera Unified Formulation (CUF) beam model.
+
+The repository includes an open-source CUF implementation in which
+cross-sectional expansion functions are independent from the CSF
+geometry/material description.
+
+```bash
+cd cuf/tutorials/variable_material_t_section/t_section/models/
+csf-actions t_noprismatic_csf.yaml action.yaml   # inspect the non-prismatic T-section
+
+cd ../cases
+csf-cuf bending_halfwave_legendre_N08.yaml       # run a CUF bending analysis
+```
+
+➡️ [CSF–CUF framework and documentation](cuf/readme.md)
 
 
 ---
@@ -182,7 +202,7 @@ then run
 **linux / Mac**
 ```
 python3 -m venv venv
-source source venv/bin/activate
+source venv/bin/activate
 pip install csfpy
 csf-actions geometry.yaml actions.yaml
 ```