---
# System prepended metadata

title: materialNonLinearity.jl
tags: [Entregable 9]

---

# materialNonLinearity.jl

###### tags: `Entregable 9`

**Documento en construccion. Los detalles dependen del Entregable 8.**

## Materiales - (resuelto)

En vez de:

```julia
matName = "linearElastic"
matName2 = "isotropicBiLinear"
matParams = [10.0]
matParams2 = [10.0, 1.0, 7]
mat1 = MaterialModel(matName, matParams)
mat2 = MaterialModel(matName2, matParams2)
```

Buscamos algo asi:

```julia
mat1 = LinearElastic(E=10.0)
mat2 = IsotropicBilinear(E=10.0, σY0=1.0, K=7)
```
Se deberan implementar structs para modelar los distintos materiales como subtypes de `MaterialModel`, que pasaria a ser abstracto.

## Secciones - (resuelto)

En vez de

```julia
secName = "rectangle"
secParams = [0.1, 0.6]
secStr = Section(secName, secParams)
```

```julia
secStr = Rectangle(A=0.1, Iy=0.6)
```
pasaria a ser una implementacion del tipo abstracto `Section`.

## Nota sobre `Array{Float64}`

Observar que `Array{Float64}` es abtracto:

```julia
julia> Matrix{Float64}
Matrix{Float64} (alias for Array{Float64, 2})
```

Para los campos de struct que son matrices, debe utilizar `Array{Float64, 2}` o simplemente `Matrix{Float64}`.

## Nota sobre los algoritmos - (resuelto)

Definir un tipo abstracto de algoritmo y hacer structs para NR y AR.

Sera necesario alinear las firmas de las funciones

```julia
AL(Uₖ, ModelSol, KTₖ, Fintk, time, analysisSettings, dispIter, varFext, currδu, convδu)
```

```
NR(Uk, ModelSol, KTk, Fintk)
```

Luego

```julia
NR = NewtonRaphson() # instancia con parametros por defecto
AL = ArcLength()
# se pasan a
step!(NR, Uk, ModelSol, KTk, Fintk, args...) # o sino
step!(NR, Uk, ModelSol, ModelOpts) # donde ModelOpts es un struct con info adicional
```

El dispatch se hace en el primer argumento.

## Notas (viejas) sobre interfaces

En esta etapa comenzamos una transicion hacia un codigo mas idiomatico. Se deberan definir distintas interfaces (abstract types, structs que las implementan), por ejemplo considerar:

- geometria (grids)
- algoritmos: iteracion de Newton-Rapshon, Arc-Length
- modelos constitutivos
- representacion de la solucion en una etapa intermedia (iteracion)
- representacion de la solucion final (que puede ser la anterior)

Para dar un ejemplo:

Antes:

```julia
if NRBool == 1
    Uk, δUk = NR(Uk, modelSol, KTk, Fintk)
    #λk = strAnalysisSets.loadFactors[time]    
else
    Uk, δUk, λk = AL(Uk, modelSol, KTk, Fintk, time, analysisSettings, dispIter, varFext, currδu, convδu)
    currδu = δUk + currδu
    println(λk)
end
```

Despues podria parecerse a algo asi, donde dispatch en `alg` determina si se utiliza `NR` o `AL`:

```julia
Uk, δUk = step(alg, Uk, KTk, Fintk, cache; options)
```
