Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Refactoring Gridap.TensorValues #210

Closed
fverdugo opened this issue Mar 12, 2020 · 5 comments
Closed

Refactoring Gridap.TensorValues #210

fverdugo opened this issue Mar 12, 2020 · 5 comments
Assignees
@victorsndvg
Labels
enhancement New feature or request

Comments

@fverdugo
Copy link
Member

fverdugo commented Mar 12, 2020 •
edited
Loading 

# types

abstract type MultiValue <: Number

struct VectorValue{D,T} <: MultiValue
  data::NTuple{D,T}
  function VectorValue{D,T}(data::NTuple{D,T}) where {D,T}
    new{D,T}(data)
  end
end

struct TensorValue{D1,D2,T,L} <: MultiValue
  data::NTuple{L,T}
  function TensorValue{D1,D2,T}(data::NTuple{L,T}) where {D1,D2,T,L}
    @assert L == D1*D2
    new{D1,D2,T,L}(data)
  end
end

struct SymTensorValue{D,T,L} <: MultiValue
  data::NTuple{L,T}
  function SymTensorValue{D,T}(data::NTuple{L,T}) where {D,T,L}
    @assert L == D*(D+1)/2
    new{D,T,L}(data)
  end
end

struct SymFourthOrderTensorValue{D,T,L} <: MultiValue
  data::NTuple{L,T}
  function SymFourthOrderTensorValue{D,T}(data::NTuple{L,T}) where {D,T,L}
    @assert L == (D*(D+1)/2)^2
    new{D,T,L}(data)
  end
end

# Construction

v = VectorValue( (1,2) )
v = VectorValue(1,2)

v = VectorValue{2}( (1,2) )
v = VectorValue{2}(1,2)

v = VectorValue{2,Int}( (1,2) )
v = VectorValue{2,Int}(1,2)

v = VectorValue{0,Int}( () )
v = VectorValue{0,Int}()

s = TensorValue(  (11,21,12,22) ) # Assumes square tensor
s = TensorValue(11,21,12,22) # Assumes square tensor

s = TensorValue{3,2}(  (11,21,31,12,22,32) )
s = TensorValue{3,2}(11,21,31,12,22,32)

s = TensorValue{3,2,Int}(  (11,21,31,12,22,32) )
s = TensorValue{3,2,Int}(11,21,31,12,22,32)

s = TensorValue{0,2,Int}(  () )
s = TensorValue{0,2,Int}()

s = SymTensorValue( (11,21,22) )
s = SymTensorValue(11,21,22)

s = SymTensorValue{2}( (11,21,22) )
s = SymTensorValue{2}(11,21,22)

s = SymTensorValue{2,Int}( (11,21,22) )
s = SymTensorValue{2,Int}(11,21,22)

s = SymTensorValue{0,Int}( () )
s = SymTensorValue{0,Int}()

c = SymFourthOrderTensorValue( (1111,2111,2211, 1121,2121,2221, 1122,2122,2222  ) )
c = SymFourthOrderTensorValue( 1111,2111,2211, 1121,2121,2221, 1122,2122,2222  )

c = SymFourthOrderTensorValue{2}( (1111,2111,2211, 1121,2121,2221, 1122,2122,2222  ) )
c = SymFourthOrderTensorValue{2}( 1111,2111,2211, 1121,2121,2221, 1122,2122,2222  )

c = SymFourthOrderTensorValue{2,Int}( (1111,2111,2211, 1121,2121,2221, 1122,2122,2222  ) )
c = SymFourthOrderTensorValue{2,Int}( 1111,2111,2211, 1121,2121,2221, 1122,2122,2222  )

c = SymFourthOrderTensorValue{0,Int}( () )
c = SymFourthOrderTensorValue{0,Int}()
@fverdugo
Copy link
Member Author

fverdugo commented Mar 12, 2020 •
edited
Loading 

# Conversions

convert(::Type{VectorValue{D,T}}, a::NTuple{D}  ) where {D,T}
convert(::Type{NTuple{D,T}}, a::VectorValue{D}  ) where {D,T}
convert(::Type{VectorValue{D,T}}, a::VectorValue{D}  ) where {D,T}

convert(::Type{TensorValue{D1,D2,T,L}}, a::NTuple{L}  ) where {D1,D2,T,L}
convert(::Type{NTuple{T,L}}, a::TensorValue{D1,D2,S,L} where {D1,D2,S}  ) where {T,L}
convert(::Type{TensorValue{D1,D2,T,L}}, a::TensorValue{D1,D2}   ) where {D1,D2,T,L}

convert(::Type{SymTensorValue{D,T,L}}, a::NTuple{L}  ) where {D,T,L}
convert(::Type{NTuple{T,L}}, a::SymTensorValue{D,S,L} where {D,S}  ) where {T,L}
convert(::Type{SymTensorValue{D,T,L}}, a::SymTensorValue{D}  ) where {D,T,L}

convert(::Type{TensorValue{D,D,T,L}}, a::SymTensorValue{D}  ) where {D,T,L}

convert(::Type{SymFourthOrderTensorValue{D,T,L}}, a::NTuple{L}  ) where {D,T,L}
convert(::Type{NTuple{T,L}}, a::SymFourthOrderTensorValue{D,S,L} where {D,S}  ) where {T,L}
convert(::Type{SymFourthOrderTensorValue{D,T,L}}, a::SymFourthOrderTensorValue{D}  ) where {D,T,L}

# + two-way conversion to SArray for VectorValue + TensorValue


# other constructors

zero(::Type{VectorValue{D,T}}) where {D,T}
zero(::Type{TensorValue{D1,D2,T}}) where {D1,D2,T}
zero(::Type{SymTensorValue{D,T}}) where {D,T}
zero(::Type{SymFourthOrderTensorValue{D,T}}) where {D,T}

# + idem on instances

one(::Type{TensorValue{D1,D2,T}}) where {D1,D2,T}
one(::Type{SymTensorValue{D,T}}) where {D,T}
one(::Type{SymFourthOrderTensorValue{D,T}}) where {D,T}

# + idem on instances

mutable(::Type{VectorValue{D,T}}) where {D,T}
mutable(::Type{TensorValue{D1,D2,T}}) where {D1,D2,T}

convert(::Type{VectorValue{D,T}}, a::MVector{D}  ) where {D,T}
convert(::Type{MVector{D,T}}, a::VectorValue{D}  ) where {D,T}

convert(::Type{TensorValue{D1,D2,T}}, a::MMatrix{D1,D2}  ) where {D1,D2,T}
convert(::Type{MMatrix{D1,D2,T}}, a::TensorValue{D1,D2}  ) where {D1,D2,T}

# + idem on instances

change_eltype(::Type{<:VectorValue{D}},::Type{T}) where {D,T}
change_eltype(::Type{<:TensorValue{D1,D2}},::Type{T}) where {D1,D2,T}
change_eltype(::Type{<:SymTensorValue{D}},::Type{T}) where {D,T}
change_eltype(::Type{<:SymFourthOrderTensorValue{D}},::Type{T}) where {D,T}
change_eltype(::Type{<:Real},::Type{T}) where T

# + idem on instances

Tuple(a::VectorValue)
Tuple(a::TensorValue)
Tuple(a::SymTensorValue)
Tuple(a::SymFourthOrderTensorValue)

SArray(a::VectorValue)
SArray(a::TensorValue)
SVector(a::VectorValue)
SMatrix(a::TensorValue)

@fverdugo
Copy link
Member Author

fverdugo commented Mar 12, 2020 •
edited
Loading 

# Getters

eltype(::Type{VectorValue{D,T}}) where {D,T}
eltype(::Type{TensorValue{D1,D2,T}}) where {D1,D2,T}
eltype(::Type{SymTensorValue{D,T}}) where {D,T}
eltype(::Type{SymFourthOrderTensorValue{D,T}}) where {D,T}

# + idem on instances

size(::Type{VectorValue{D,T}}) where {D,T}
size(::Type{TensorValue{D1,D2,T}}) where {D1,D2,T}
size(::Type{SymTensorValue{D,T}}) where {D,T}
size(::Type{SymFourthOrderTensorValue{D,T}}) where {D,T}

# + idem on instances

length(::Type{VectorValue{D,T}}) where {D,T}
length(::Type{TensorValue{D1,D2,T}}) where {D1,D2,T}
length(::Type{SymTensorValue{D,T}}) where {D,T}
length(::Type{SymFourthOrderTensorValue{D,T}}) where {D,T}

# + idem on instances

num_components(::Type{VectorValue{D,T}}) where {D,T}
num_components(::Type{TensorValue{D1,D2,T}}) where {D1,D2,T}
num_components(::Type{SymTensorValue{D,T}}) where {D,T}
num_components(::Type{SymFourthOrderTensorValue{D,T}}) where {D,T}

# + idem on instances

getindex(a::VectorValue,i::Integer)
getindex(a::TensorValue,i::Integer,j::Integer)
getindex(a::SymTensorValue,i::Integer,j::Integer)
getindex(a::SymFourthOrderTensorValue,i::Integer,j::Integer,k::Integer,l::Integer)

getindex(a::VectorValue,i::CartesianIndex{1})
getindex(a::TensorValue,i::CartesianIndex{2})
getindex(a::SymTensorValue,i::CartesianIndex{2})
getindex(a::SymFourthOrderTensorValue,i::CartesianIndex{4})

getindex(a::TensorValue,i::Integer)
getindex(a::SymTensorValue,i::Integer)
getindex(a::SymFourthOrderTensorValue,i::Integer)

CartesianIndices(a::VectorValue)
CartesianIndices(a::TensorValue)
CartesianIndices(a::SymTensorValue)
CartesianIndices(a::SymFourthOrderTensorValue)

LinearIndices(a::VectorValue)
LinearIndices(a::TensorValue)
LinearIndices(a::SymTensorValue)
LinearIndices(a::SymFourthOrderTensorValue)

eachindex(a::VectorValue)
eachindex(a::TensorValue)
eachindex(a::SymTensorValue)
eachindex(a::SymFourthOrderTensorValue)

iterate(a::VectorValue)
iterate(a::VectorValue,state)
# iterate(a::TensorValue)
# iterate(a::TensorValue,state)
# iterate(a::SymTensorValue)
# iterate(a::SymTensorValue,state)
# iterate(a::SymFourthOrderTensorValue)
# iterate(a::SymFourthOrderTensorValue,state)

@fverdugo
Copy link
Member Author

fverdugo commented Mar 12, 2020 •
edited
Loading 

# Algebraic operations (for all cases they make sense)

import LinearAlgebra:   det, inv, tr, dot, norm
import Base: adjoint, transpose, conj,+, -, *,  /,  \, ==, ≈  # for us * is equivalent to dot
inner, outer, meas

:+(a::VectorValue,b::VectorValue) -> VectorValue
:+(a::VectorValue,b::Real) -> VectorValue
:+(a::Real,b::VectorValue) -> VectorValue

:-(a::VectorValue,b::VectorValue) -> VectorValue
:-(a::VectorValue,b::Real) -> VectorValue
:-(a::Real,b::VectorValue) -> VectorValue

:*(a::VectorValue,b::Real) -> VectorValue
:*(a::Real,b::VectorValue) -> VectorValue

# Simple contraction *, or dot
:*(a::VectorValue,b::VectorValue) -> Real
:*(a::TensorValue,b::VectorValue) -> VectorValue
:*(a::SymTensorValue,b::VectorValue) -> VectorValue

# Double contraction
dotdot(a::(Sym)TensorValue,b::(Sym)TensorValue) -> Real
dotdot(a::SymFourthOrderTensorValue,b::SymTensorValue) -> SymTensorValue

# Full contraction
inner(a::VectorValue,b::VectorValue) -> Real
inner(a::(Sym)TensorValue,b::(Sym)TensorValue) -> Real

# dyadic product
outer(a::VectorValue,b::VectorValue) -> SymTensorValue
outer(a::SymTensorValue,b::SymTensorValue) -> SymFourthOrderTensorValue

# Operators returning symmetric objects

symmetic_part(a::TensorValue) 
symmetic_part(a::SymTensorValue)
symmetic_part(a::SymFourthOrderTensorValue)
diagonal_tensor(v::VectorValue)




# Reductions
import Base: sum, maximum, minimum

# IO 
import Base: show

@fverdugo fverdugo added the enhancement New feature or request label Mar 12, 2020
victorsndvg added a commit that referenced this issue Mar 25, 2020
@victorsndvg
First stage of TensorValues refactoring #210
03f6193 
Needs to clean and reorder the code
@fverdugo
Copy link
Member Author

Enhanced type signatures

abstract type MultiValue{S,T,N,L} <: Number

struct VectorValue{D,T} <: MultiValue{Tuple{D},T,1,D}
  data::NTuple{D,T}
  function VectorValue{D,T}(data::NTuple{D,T}) where {D,T}
    new{D,T}(data)
  end
end

struct TensorValue{D1,D2,T,L} <: MultiValue{Tuple{D1,D2},T,2,L}
  data::NTuple{L,T}
  function TensorValue{D1,D2,T}(data::NTuple{L,T}) where {D1,D2,T,L}
    @assert L == D1*D2
    new{D1,D2,T,L}(data)
  end
end

struct SymTensorValue{D,T,L} <: MultiValue{Tuple{D,D},T,2,L}
  data::NTuple{L,T}
  function SymTensorValue{D,T}(data::NTuple{L,T}) where {D,T,L}
    @assert L == D*(D+1)/2
    new{D,T,L}(data)
  end
end

struct SymFourthOrderTensorValue{D,T,L} <: MultiValue{Tuple{D,D,D,D},T,4,L}
  data::NTuple{L,T}
  function SymFourthOrderTensorValue{D,T}(data::NTuple{L,T}) where {D,T,L}
    @assert L == (D*(D+1)/2)^2
    new{D,T,L}(data)
  end
end

victorsndvg added a commit that referenced this issue Mar 30, 2020
@victorsndvg
Enhanced TensorValues types signatures #210
8f64acd 
#210 (comment)
victorsndvg added a commit that referenced this issue Apr 7, 2020
@victorsndvg
SymTensorValue implementation almost complete. #210
b68e7ed 
Some operations pending and its corresponding tests
victorsndvg added a commit that referenced this issue Apr 7, 2020
@victorsndvg
SymTensorValue operations implemented #210
be0775c
victorsndvg added a commit that referenced this issue Apr 15, 2020
@victorsndvg
Complete constructors and add indexing features for SymFourthOrderTen…
2fbfa0a 
…sorValue. #210

Pending: Some operations and tests (ongoing)
@victorsndvg victorsndvg mentioned this issue Apr 23, 2020
Merged
@fverdugo
Copy link
Member Author

Done in PR #239

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees

@victorsndvg victorsndvg

Labels
enhancement New feature or request
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
2 participants
@victorsndvg @fverdugo