---
# System prepended metadata

title: Powerdistancer
tags: [Entregable 9]

---

# Powerdistancer

https://github.com/rpp396/Powerdistancer/

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

- [x] Crear estructura de proyecto para dividir trabajos entre DGM y RPP
- [x] Definir estructura de datos Sistema_trifasico. 
- [ ] Ver estructura de [StructuralDynamicsODESolvers.jl](https://github.com/ONSAS/StructuralDynamicsODESolvers.jl) y usar esa forma para aplicar los diferentes algoritmos.
- [ ] Definir interfase IO para aplicar los distintos aglritmos como Solvers
---
Estructura del proyecto:
* PowerDistancer
    * /scr
        * Powerdistancer.jl (es el Module)
        * estructurasDatos.jl (para contener las structs a usar)
        * /Algoritmos
            * AlgoritmosDistancia.jl
            * AlgoritmosFrecuencia.jl
            * AlgoritmosFasores.jl
            * AlgoritmosTiempoDeFalta.jl
            * AlgoritmosLazoDeFalta.jl

            
            
    

        


## Daniel (DGM)
### Funciones
* #### Desarrollos comunes
    * ##### Documenter
        Estuve seteando el Documenter para empezar a organizar la futura documentación. También busqué y configuré un paquete (DocumenterCitations) para trabajar mejor las referencias a los articulos o papers utilizados.
    * ##### Test
        Revisión de la estructura de test y separación por bloques según desarrollador.
     * ##### Interface
         Diseño de intercafes del módulo .   
* #### obtenerFrecuencia
    * estimate_frequency
    Implementacion de algoritmo Hybrid Estimation Frecuency (FE_HFE) para la estimacion de la frecuencia. 
* #### obtenerTiempoDeFalta
* #### rms_calculation
    * Implementación de un método de cálculo del valor RMS de la señal teniendo en cuenta relación entre frecuencia de la onda y la frecuencia de muestreo.
* #### AlgoritmosLazoDeFalta.jl
* #### distanciaM1
* #### distanciaM2
### Dudas
---
## Rodrigo (RPP)
### Funciones
### generarSeno
La funcion generar seno sirve para evaluar diferentes algorimos usando una entrada conocida.
#### obtenerCanales.jl
Voy a probar Pluto para generar la interacción con el usuario.
Sería la unica función que precisa la interacción del usuario
Pretendo que la función tome los siguientes parametros:
1. el path de los archivos comtrade
2. en que orden están los canales (podria llegar a aplicarse alguna inteligencia para detectarlos automáticamente.)
3. la impedancia por km de linea en valores primarios o secundarios.
#### obtenerFasores
#### distanciaM3
#### distanciaM4
### Dudas
### Notas
Literate.jl #herramienta para generar ejemplos y Test
DocStringExtensions.jl #para automatizar la firma de la función en la documentación
Plots recipes #Para hacer recetas de ploteo
https://github.com/JuliaTesting/Aqua.jl


---

## Reunion con Daniel del 4/11/2022

#### Canales

Dado

```julia
struct Canal
    nombre::String #nombre del canal: vr,vs,vt,ir,is,it
    valores_instantaneos::Any #vector de reales (valores instantáneos)
    unidad::String #Volt, Amper, Hz, etc...
end
```

En `valor_instantaneos` pareceria que `Vector{Float64}` es suficiente, en ese caso es mejor que poner `Any`:

```julia
struct Canal
    nombre::String #nombre del canal: vr,vs,vt,ir,is,it
    valores_instantaneos::Vector{Float64} #vector de reales (valores instantáneos)
    unidad::String #Volt, Amper, Hz, etc...
end
```

En un tercera iteracion, podrian poner

```julia
using Unitful

struct Canal{T}
    nombre::String #nombre del canal: vr,vs,vt,ir,is,it
    valores_instantaneos::Vector{T}
end
```

Por ejemplo:

```julia
julia> [1u"Hz", 2u"Hz"]
2-element Vector{Quantity{Int64, 𝐓^-1, Unitful.FreeUnits{(Hz,), 𝐓^-1, nothing}}}:
 1 Hz
 2 Hz
```
es un vector en Herzios.

Otro ejemplo con distancias:


```julia
julia> x = [1u"m", 2u"m"]
2-element Vector{Quantity{Int64, 𝐋, Unitful.FreeUnits{(m,), 𝐋, nothing}}}:
 1 m
 2 m

julia> y = u"cm".(x)
2-element Vector{Quantity{Int64, 𝐋, Unitful.FreeUnits{(cm,), 𝐋, nothing}}}:
 100 cm
 200 cm
```

```julia
julia> y[1] + x[1]
2//1 m
```

```julia
julia> 1u"cm" + 1u"s"
ERROR: DimensionError: 1 cm and 1 s are not dimensionally compatible.
Stacktrace:
 [1] +(x::Quantity{Int64, 𝐋, Unitful.FreeUnits{(cm,), 𝐋, nothing}}, y::Quantity{Int64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}})
   @ Unitful ~/.julia/packages/Unitful/ApCuY/src/quantities.jl:133
 [2] top-level scope
   @ REPL[17]:1
```

Con unidades electricas (escribir `\Omega[TAB]`)

```julia
julia> 1u"V/A" + 1u"Ω"
2 kg m^2 A^-2 s^-3
```

Usar `@enum` para los valores admisibles

```julia
julia> @enum Trifasico Fase1 Fase2 Fase3

julia> Fase1
Fase1::Trifasico = 0

julia> Fase2
Fase2::Trifasico = 1

julia> Fase3
Fase3::Trifasico = 2
```


- `frecuencia_muestreo::Any` -> `::Float64`

### Algoritmo generico para estimar frecuencia

Idea:

```julia
abstract struct FrequencyEstimator end # << tipo abstracto

Base.@kwdef struct HFE <: FrequencyEstimator
    fn=5
    fs=1000
end

# metodo por defecto
estimate_frequency(datos, n::Integer) = estimate_frequency(HFE(), datos, n)

function estimate_frequency(alg::HFE, datos, n::Integer)
    fn = alg.fn
    fs = alg.fs
    
    # datos un array con las muestras
    # n en que indice del vector tengo que calcular la frecuencia
    # fn frecuencia nominal del sistema
    # fs frecuencia de muestreo

    ciclo=datos[n:Integer(n+ceil(fs/fn))]
    display(plot(ciclo))
    cruces=_NZC(ciclo)
    
    f_est= length(cruces)>=2 ? fs/((cruces[2]-cruces[1])*2) : fn
    f_i=f_est
    grado=1
    error=1 #valor inicial para comenzar bucle
    while  (error > 0.0005) & (grado < 9)
        ciclo=DMF(datos[n:Integer(n+ceil(fs/fn)+grado+1)],grado)
        display(plot!(ciclo))
        cruces=_NZC(ciclo)
        # println(cruces)
        f_i= length(cruces)>=2 ? fs/((cruces[2]-cruces[1])*2) : f_i
        error=abs(f_est-f_i)
        println("grado ",grado,"   F_est ",f_est, "  f_i ",f_i)
        f_est=f_i
        grado+=1
    end
    return f_est
end
```

## Estilo

- Activar JuliaFormatter al guardar el archivo.
- https://www.kutombawewe.net/es/visual-studio-code/como-formatear-el-codigo-en-guardar-en-el-codigo-vs/828268457/

## Algoritmo de lazo de falta

- Metodo elegido, articulo.
- 
## Metodos de debugging

- `Infiltrator.jl`