Merge pull request #69 from PetrKryslUCSD/develop

Develop

Author: PetrKryslUCSD

Project.toml

@@ -1,7 +1,7 @@
 name = "FinEtools"
 uuid = "91bb5406-6c9a-523d-811d-0644c4229550"
 authors = ["Petr Krysl <pkrysl@ucsd.edu>"]
-version = "8.0.27"
+version = "8.0.28"
 
 [deps]
 DataDrop = "aa547a04-dd37-49ab-8e73-656744f8a8fc"

src/CSysModule.jl

@@ -22,7 +22,7 @@ struct CSys{T<:Number,F<:Function}
     __updatebuffer!::F # function to update the coordinate system matrix.
     # Signature: `update!(csmatout::Matrix{T}, XYZ::VecOrMat{T}, tangents::Matrix{T},
     # feid::IT, qpid::IT) where {T, IT}`
-    _csmat::Array{T,2} # the coordinate system matrix (buffer); see
+    _csmat::Matrix{T} # the coordinate system matrix (buffer); see
 end
 
 """
@@ -33,8 +33,13 @@ rotation matrix is given.
 
 The function signature:
 ```
-update!(csmatout::Matrix{T}, XYZ::VecOrMat{T}, tangents::Matrix{T},
-    feid::IT, qpid::IT) where {T, IT}
+update!(
+        csmatout::AbstractMatrix{<:Real},
+        XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real},
+        feid::Integer,
+        qpid::Integer,
+    ) 
 ```
 where
 - `csmatout`= output matrix buffer, of size `(sdim, mdim)`
@@ -76,8 +81,13 @@ rotation matrix of type `T` is given.
 - `z` = zero value,
 - The `computecsmat` function signature:
     ```
-    update!(csmatout::Matrix{T}, XYZ::VecOrMat{T}, tangents::Matrix{T},
-        feid::IT, qpid::IT) where {T, IT}
+    update!(
+            csmatout::AbstractMatrix{<:Real},
+            XYZ::AbstractVecOrMat{<:Real},
+            tangents::AbstractMatrix{<:Real},
+            feid::Integer,
+            qpid::Integer,
+        ) 
     ```
     where
     - `csmatout`= output matrix buffer, of size `(sdim, mdim)`;
@@ -122,12 +132,12 @@ Construct coordinate system when the rotation matrix is given.
 """
 function CSys(csmat::Matrix{T}) where {T}
     function __updatebuffer!(
-        csmatout::Matrix{T},
-        XYZ::VecOrMat{T},
-        tangents::Matrix{T},
-        feid::IT1,
-        qpid::IT2,
-    ) where {T,IT1,IT2}
+        csmatout::AbstractMatrix{<:Real},
+        XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real},
+        feid::Integer,
+        qpid::Integer,
+    ) 
         return csmatout # nothing to be done here, the matrix is already in the buffer
     end
     return CSys(true, false, __updatebuffer!, deepcopy(csmat))# fill the buffer with the given matrix
@@ -143,12 +153,12 @@ identity.
 """
 function CSys(dim::IT, z::T) where {IT<:Integer,T}
     function __updatebuffer!(
-        csmatout::Matrix{T},
-        XYZ::VecOrMat{T},
-        tangents::Matrix{T},
-        feid::IT1,
-        qpid::IT2,
-    ) where {T,IT1,IT2}
+        csmatout::AbstractMatrix{<:Real},
+        XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real},
+        feid::Integer,
+        qpid::Integer,
+    ) 
         return csmatout # nothing to be done here, the matrix is already in the buffer
     end
     return CSys(
@@ -191,23 +201,25 @@ finite elements.
 """
 function CSys(sdim::IT1, mdim::IT2) where {IT1<:Integer,IT2<:Integer}
     function __updatebuffer!(
-        csmatout::Matrix{T},
-        XYZ::VecOrMat{T},
-        tangents::Matrix{T},
-        feid::IT1,
-        qpid::IT2,
-    ) where {T,IT1,IT2}
+        csmatout::AbstractMatrix{<:Real},
+        XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real},
+        feid::Integer,
+        qpid::Integer,
+    ) 
         return gen_iso_csmat!(csmatout, XYZ, tangents, feid, qpid)
     end
     return CSys(false, false, __updatebuffer!, fill(zero(Float64), sdim, mdim))
 end
 
 """
-    updatecsmat!(self::CSys,
-        XYZ::Matrix{T},
-        tangents::Matrix{T},
-        feid::IT1,
-        qpid::IT2) where {T, IT1, IT2}
+    updatecsmat!(
+        self::CSys,
+        XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real},
+        feid::Integer,
+        qpid::Integer,
+    ) 
 
 Update the coordinate system orientation matrix.
 
@@ -221,11 +233,11 @@ buffer as `self.csmat`.
 """
 function updatecsmat!(
     self::CSys,
-    XYZ::Matrix{T},
-    tangents::Matrix{T},
-    feid::IT1,
-    qpid::IT2,
-) where {T,IT1,IT2}
+    XYZ::AbstractVecOrMat{<:Real},
+    tangents::AbstractMatrix{<:Real},
+    feid::Integer,
+    qpid::Integer,
+) 
     self.__updatebuffer!(self._csmat, XYZ, tangents, feid, qpid)
     return self._csmat
 end

src/DataCacheModule.jl

@@ -22,7 +22,8 @@ follows:
 
 ```
 function fillcache!(cacheout::D,
-    XYZ::VecOrMat{T}, tangents::Matrix{T}, feid::IT, qpid::IT) where {D, T, IT}
+    XYZ::AbstractVecOrMat{<:Real}, tangents::AbstractMatrix{<:Real},
+    feid::IT, qpid::IT) where {D, T, IT}
     ... # modify the value of cacheout
     return cacheout
 end
@@ -41,7 +42,7 @@ called, and the output `cacheout` is filled with the value of the cached data.
 # Example
 ```
 function fillcache!(cacheout::Array{CT, N},
-        XYZ::VecOrMat{T}, tangents::Matrix{T},
+        XYZ::AbstractVecOrMat{<:Real}, tangents::AbstractMatrix{<:Real},
         feid::IT, qpid::IT) where {CT, N, T, IT}
     cacheout .= LinearAlgebra.I(3)
     return cacheout
@@ -61,26 +62,26 @@ end
     The bad news is, the cache is not thread safe. Reading is okay, but writing
     can lead to data races.
 """
-mutable struct DataCache{D,F<:Function}
+mutable struct DataCache{D, F<:Function}
     # Cache where the current value of the data can be retrieved
     _cache::D
     # Function to update and retrieve the array
     _fillcache!::F
 end
 
 """
-    DataCache(data::Array{CT, N}) where {CT<:Number, N}
+    DataCache(data::D) where {D}
 
 Construct data cache. The *constant* data is given.
 """
 function DataCache(data::D) where {D}
     function _fillcache_constant!(
         cacheout::D,
-        XYZ::VecOrMat{T},
-        tangents::Matrix{T},
+        XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real},
         feid::IT,
         qpid::IT,
-    ) where {D,T<:Number,IT<:Integer}
+    ) where {D, IT<:Integer}
         # do nothing:  the data is already in the cache
         return cacheout
     end
@@ -90,16 +91,21 @@ end
 datatype(c::DataCache) = typeof(c._cache)
 
 """
-    (c::DataCache)(XYZ::VecOrMat{T}, tangents::Matrix{T}, feid::IT, qpid::IT) where {T<:Number, IT<:Integer}
+    (c::DataCache)(
+        XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real},
+        feid::IT,
+        qpid::IT,
+    ) where {IT<:Integer}
 
 Update the cache and retrieve the array.
 """
 function (c::DataCache)(
-    XYZ::VecOrMat{T},
-    tangents::Matrix{T},
+    XYZ::AbstractVecOrMat{<:Real},
+    tangents::AbstractMatrix{<:Real},
     feid::IT,
     qpid::IT,
-) where {T<:Number,IT<:Integer}
+) where {IT<:Integer}
     c._cache = c._fillcache!(c._cache, XYZ, tangents, feid, qpid)
     return c._cache
 end

src/IntegDomainModule.jl

@@ -75,12 +75,30 @@ function IntegDomain(
     integration_rule::IR,
     otherdimension::T,
 ) where {S<:AbstractFESet,IR<:AbstractIntegRule,T<:Number}
-    function otherdimensionfu(loc::Matrix{T}, conn::CC, N::Matrix{T}) where {CC,T<:Number}
+    function otherdimensionfu(loc::AbstractVecOrMat{<:Real}, conn::CC, N::AbstractMatrix{<:Real}) where {CC}
         return otherdimension
     end
     return IntegDomain(fes, integration_rule, otherdimensionfu, false)
 end
 
+"""
+    IntegDomain(
+        fes::S,
+        integration_rule::IR,
+        otherdimension::F,
+    ) where {S<:AbstractFESet, IR<:AbstractIntegRule, F<:Function}
+
+Construct with the default orientation matrix (identity), and  other
+dimension provided by a function.
+"""
+function IntegDomain(
+    fes::S,
+    integration_rule::IR,
+    otherdimension::F,
+) where {S<:AbstractFESet, IR<:AbstractIntegRule, F<:Function}
+    return IntegDomain(fes, integration_rule, otherdimension, false)
+end
+
 """
     IntegDomain(
         fes::S,

src/SurfaceNormalModule.jl

@@ -25,11 +25,11 @@ point `XYZ`, using the columns of the Jacobian matrix of the element,
 quadrature point, `qpid`:
 
 ```
-function computenormal!(normalout::Vector{CT}, XYZ::Matrix{T},
-        tangents::Matrix{T}, feid::IT, qpid::IT) where {CT, T, IT}
-        # Calculate the normal  and copy it into the buffer....
-        return normalout
-    end
+function computenormal!(normalout::Vector{CT}, XYZ::AbstractVecOrMat{<:Real},
+    tangents::AbstractMatrix{<:Real}, feid::IT, qpid::IT) where {CT, IT}
+    # Calculate the normal  and copy it into the buffer....
+    return normalout
+end
 ```
 
 The buffer `normalout` needs to be filled with the value  of the normal vector.
@@ -65,8 +65,8 @@ vector is given.
   have a signature of
 
     ```
-    function computenormal!(normalout::Vector{CT}, XYZ::Matrix{T},
-        tangents::Matrix{T}, feid::IT, qpid::IT) where {CT, T, IT}
+    function computenormal!(normalout::Vector{CT}, XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real}, feid::IT, qpid::IT) where {CT, IT}
         # Calculate the normal  and copy it into the buffer....
         return normalout
     end
@@ -95,12 +95,12 @@ In that case a zero vector is returned, and a warning is printed.
 """
 function SurfaceNormal(ndimensions)
     function defaultcomputenormal!(
-        normalout::Vector{T},
-        XYZ::Matrix{T},
-        tangents::Matrix{T},
+        normalout::AbstractVector{T},
+        XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real},
         feid::IT,
         qpid::IT,
-    ) where {T<:Number,IT<:Integer}
+    ) where {T<:Real, IT<:Integer}
         fill!(normalout, zero(T))
         # Produce a default normal
         if (size(tangents, 1) == 3) && (size(tangents, 2) == 2)# surface in three dimensions
@@ -132,19 +132,25 @@ function SurfaceNormal(vector::Vector{T}) where {T<:Number}
 end
 
 """
-    updatenormal!(self::SurfaceNormal, XYZ::Matrix{T}, tangents::Matrix{T}, feid::IT, qpid::IT) where {T, IT}
+    updatenormal!(
+        self::SurfaceNormal,
+        XYZ::AbstractVecOrMat{<:Real},
+        tangents::AbstractMatrix{<:Real},
+        feid::IT,
+        qpid::IT,
+    ) where {IT}
 
 Update the surface normal vector.
 
 Returns the normal vector (stored in the cache).
 """
 function updatenormal!(
     self::SurfaceNormal,
-    XYZ::Matrix{T},
-    tangents::Matrix{T},
+    XYZ::AbstractVecOrMat{<:Real},
+    tangents::AbstractMatrix{<:Real},
     feid::IT,
     qpid::IT,
-) where {T,IT}
+) where {IT}
     return self._cache(XYZ, tangents, feid, qpid)
 end