unit ubancodebaterias01;

interface

uses
  Classes,
  Math,
  xMatDefs, uSimplex,
  ucosa, uCosaConNombre,
  uGlobs, uFechas,
  uGeneradores,
  uNodos,
  SysUtils,
  uEstados,
  uFichasLPD,
  uFuentesAleatorias,
  uconstantesSimSEE,
  uevapUruguay;

resourcestring
  rsBancoDeBaterias01 = 'Banco de Baterías';

type
  TBancoDeBaterias01 = class; // forward declaration



  { TFichaBancoDeBaterias01 }

  TFichaBancoDeBaterias01 = class(TFichaLPD)
  public

    (**************************************************************************)
    (*               A T R I B U T O S   P E R S I S T E N T E S              *)
    (**************************************************************************)

    PMax_Gen: NReal;
    PMax_Dem: NReal;
    ren_Gen: NReal;
    ren_Dem: NReal;
    CapacidadMaxima_MWh: NReal;
    fd: NReal;
    tmr: NReal;

    EnsayoCiclado_pd1: NReal;
    EnsayoCiclado_nc1: integer;
    EnsayoCiclado_pd2: NReal;
    EnsayoCiclado_nc2: integer;

    AniosEnvejecimientoNatural: integer;
    //CapacidadFinal_pu: NReal;

    CostoRecambio_USD_kWh_instalado: NReal;
    AniosRecambio_costeo: integer;
    TasaDescuento_costeo: NReal;


    cv_MWh_ValorizadoManual: NReal;
    pagoPorDisponibilidad_USDxMWhh: NReal;
    (**************************************************************************)


    constructor Create(capa: integer; fecha: TFecha; periodicidad: TPeriodicidad;
      PMax_Gen, PMax_Dem: NReal; ren_Gen, ren_Dem: NReal;
      CapacidadMaxima_MWh: NReal;
      fd, TMR, cv_MWh_ValorizadoManual, pagoPorDisponibilidad_USDxMWhh,
      EnsayoCiclado_pd1: NReal; EnsayoCiclado_nc1: integer; EnsayoCiclado_pd2: NReal;
      EnsayoCiclado_nc2, AniosEnvejecimientoNatural: integer;
      CostoRecambio_USD_kWh_instalado: NReal; AniosRecambio_costeo: integer;
      TasaDescuento_costeo: NReal);

    function Rec: TCosa_RecLnk; override;
    procedure BeforeRead(version, id_hilo: integer); override;
    procedure AfterRead(f: TArchiTexto); override;
    destructor destroy; override;

  end;




  { TBancoDeBaterias01 }

  TBancoDeBaterias01 = class(TGenerador)
  public
    (**************************************************************************)
    (*               A T R I B U T O S   P E R S I S T E N T E S              *)
    (**************************************************************************)

    //Variable de Estado
    NDisc: integer; // discretizacion del estad
    Carga_ini: NReal; // valor inicial
    flg_ValorizadoManual: boolean;
    (**************************************************************************)


    pa: TFichaBancoDeBaterias01;

    X_Carga: NReal;
    Xs_Carga: NReal;

    cv_MWh: NReal; // valor de la energía almacenada

    cvDegDem, cvDegGen: NReal; // costos variables por degradación
      // estimados en un paso de tiempo actuando como Demanda o como Generador.

    // derivada del costo futuro respecto a la carga de la bateria
    dCFdC: NReal;

    NMaquinasDisponibles: integer;


    CapacidadInstalada_MWh: NReal;
    PMax_Gen, PMax_Dem: NReal;
    PGen, PDem: TDAOfNReal;


    flg_UsarCostoDegradacionRecambio: boolean; // al cambiar la ficha dinámica se actualiza
    alfa, beta: NReal;
    expmalfadiv2, expmalfadiv2porbeta: NReal; // auxiliar

    cvRecambio_USD: NReal; // Porción del costo de recambio que se degrada por uso
                           // correspondiente a la CapacidadInstalada

    PorcionFija: NReal;  // Valor en p.u. que determinal la Porción del costo
                         // de recambio que se degrada independientemente del uso
    cfRecambio_USD_MWh_instalado_PorPasoT: NReal; // USD/MW-instalado que se degrada
         // en cada paso de tiempo independientemente del uso
    cvRecambio_USD_MWh_instalado: Nreal; // USD/MW-instalado asociado a la degradación
        // variable.



    constructor Create(capa: integer; nombre: string; nacimiento, muerte: TFecha;
      lpdUnidades, lpd: TFichasLPD; nodo: TNodo;
      flg_CalcularGradienteDeInversion: boolean; Carga_ini: NReal;
      NDisc_: integer; flg_ValorizadoManual: boolean; TonCO2xMWh: NReal;
      LowCostMustRun, CleanDevelopmentMechanism: boolean;
      xFuenteIdxP: TFuenteAleatoria; xBorneIdxP: string);

    function Rec: TCosa_RecLnk; override;
    procedure BeforeRead(version, id_hilo: integer); override;
    procedure AfterRead(f: TArchiTexto); override;

    procedure PrepararMemoria(Catalogo: TCatalogoReferencias; globs: TGlobs); override;
    procedure RegistrarParametrosDinamicos(Catalogo: TCatalogoReferencias); override;


    function PotenciaFirme: NReal; override;

    function InfoAd_: string; override;

    class function DescClase: string; override;


        //  procedure Sim_Inicio; override;
    procedure Sim_Cronica_Inicio; override;

    function get_pa_FD( kTipoUnidad: integer): NReal; override;
    function get_pa_TMR(kTipoUnidad: integer): NReal; override;

    procedure SorteosDelPaso(sortear: boolean); override;

    // Porción de Vida perdida por pasar el estado de Carga1 al estado de Carga2
    // la funcion controla que los estados de carga estén en los rangos adecuados.
    function PorcionDegradada(Carga1_MWh, Carga2_MWh: NReal): NReal;

    procedure PrepararPaso_ps; override;

    procedure opt_nvers(var ivar, ivae, ires: integer); override;

    procedure opt_cargue(s: TSimplex); override;
    procedure opt_fijarRestriccionesDeCaja(s: TSimplex); override;

    procedure opt_leerSolucion(s: TSimplex); override;
    procedure EvolucionarEstado; override;

    procedure CambioFichaPD; override;


    function getNombreVar(ivar: integer; var nombre: string): boolean; override;
    function getNombreRes(ires: integer; var nombre: string): boolean; override;

    procedure PosicionarseEnEstrellita; override;

    procedure ActualizarEstadoGlobal(flg_Xs: boolean); override;

    procedure optx_nvxs(var ixr, ixd, iauxr, iauxd: integer); override;
    procedure optx_RegistrarVariablesDeEstado(adminEstados: TAdminEstados);
      override;

    destructor destroy; override;
    procedure PubliVars; override;

    procedure dump_Variables(var f: TextFile; charIndentacion: char); override;


    procedure InicioSim; override;
    procedure InicioOpt; override;

  end;

procedure TBancoDeBaterias01_cambioFichaPD(Actor: TCosa);

procedure AlInicio;
procedure AlFinal;

implementation


constructor TBancoDeBaterias01.Create(capa: integer; nombre: string;
  nacimiento, muerte: TFecha; lpdUnidades, lpd: TFichasLPD; nodo: TNodo;
  flg_CalcularGradienteDeInversion: boolean; Carga_ini: NReal;
  NDisc_: integer; flg_ValorizadoManual: boolean; TonCO2xMWh: NReal;
  LowCostMustRun, CleanDevelopmentMechanism: boolean; xFuenteIdxP: TFuenteAleatoria;
  xBorneIdxP: string);

begin
  inherited Create(capa, nombre, nacimiento, muerte, lpdUnidades, nodo,
    TonCO2xMWh, LowCostMustRun, CleanDevelopmentMechanism,
    flg_CalcularGradienteDeInversion, xFuenteIdxP, xBorneIdxP);
  Self.lpd := lpd;

  self.Carga_ini := Carga_ini;
  self.NDisc := NDisc_;
  self.flg_ValorizadoManual := flg_ValorizadoManual;
end;

function TBancoDeBaterias01.Rec: TCosa_RecLnk;
begin
  Result := inherited Rec;
  Result.addCampoDef('Carga_ini', Carga_Ini);
  Result.addCampoDef('NDisc', NDisc);
  Result.addCampoDef('flg_ValorizadoManual', flg_ValorizadoManual, 121);
  Result.addCampoDef('lpd', TCosa(lpd));
end;

procedure TBancoDeBaterias01.BeforeRead(version, id_hilo: integer);
begin
  inherited BeforeRead(version, id_hilo);
  lpd := nil;
end;

procedure TBancoDeBaterias01.AfterRead(f: TArchiTexto);
begin
  inherited AfterRead(f);
  pa := nil;
  nodo := nil;
  if lpd <> nil then
    lpd.Propietario := self;

end;


procedure TBancoDeBaterias01.PrepararMemoria(Catalogo: TCatalogoReferencias;
  globs: TGlobs);
begin
  inherited prepararMemoria(Catalogo, globs);
  setlength(PGen, globs.NPostes);
  setlength(PDem, globs.NPostes);
end;

procedure TBancoDeBaterias01.RegistrarParametrosDinamicos(
  Catalogo: TCatalogoReferencias);
begin
  inherited registrarParametrosDinamicos(Catalogo);
  lpd.expandirFichas(Catalogo, globs);
  lpd.RegistrarFichasAActualizar(Self, globs.ActualizadorLPD, @pa, nil, TBancoDeBaterias01_cambioFichaPD )
end;

function TBancoDeBaterias01.InfoAd_: string;
begin
  Result := '';
end;

function TBancoDeBaterias01.PotenciaFirme: NReal;
begin
  Result := 0;
end;

class function TBancoDeBaterias01.DescClase: string;
begin
  Result := rsBancoDeBaterias01;
end;

function TBancoDeBaterias01.get_pa_FD(kTipoUnidad: integer): NReal;
begin
  Result := pa.fd;
end;

function TBancoDeBaterias01.get_pa_TMR(kTipoUnidad: integer): NReal;
begin
  Result := pa.tmr;
end;



procedure TBancoDeBaterias01.SorteosDelPaso(sortear: boolean);
begin
  CapacidadInstalada_MWh := paUnidades.nUnidades_Instaladas[0] * pa.CapacidadMaxima_MWh;

  if globs.ObligarDisponibilidad_1_ or (not sortear) then
    NMaquinasDisponibles := paUnidades.nUnidades_Operativas[0]
  else
  begin
    ActualizarProbabilidadesReparacionYRotura_(pa.fd, pa.tmr);
    NMaquinasDisponibles := Sorteos_RepRotUnidades;
  end;
  PMax_Gen := pa.PMax_Gen * NMaquinasDisponibles;
  PMax_Dem := pa.PMax_Dem * NMaquinasDisponibles;

end;

function TBancoDeBaterias01.PorcionDegradada(Carga1_MWh, Carga2_MWh: NReal): NReal;
var
  u, us, u_alaBeta, us_alaBeta: NReal;
begin
  if Carga1_MWh < 0 then Carga1_MWh:= 0;
  if Carga2_MWh < 0 then Carga2_MWh:= 0;

  u:= ( CapacidadInstalada_MWh - Carga1_MWh ) / CapacidadInstalada_MWh;
  if u > AsumaCero then
    U_alaBeta:= power( u , beta)
  else
    U_alaBeta:= 0;

  us:= (CapacidadInstalada_MWh - Carga2_MWh) / CapacidadInstalada_MWh;
  if us > AsumaCero then
    Us_alaBeta:=  power( us , beta)
  else
    Us_alaBeta:= 0;
   result:= expmalfadiv2 *abs( U_alaBeta - Us_alaBeta);
end;


procedure TBancoDeBaterias01.dump_Variables(var f: TextFile; charIndentacion: char);
begin
  inherited dump_Variables(f, charIndentacion);
  writeln(f, charIndentacion, 'Carga[MWh]= ', FloatToStrF(X_Carga, ffFixed, 10, 3));
  writeln(f);
end;

procedure TBancoDeBaterias01.InicioSim;
begin
  inherited InicioSim;
end;

procedure TBancoDeBaterias01.InicioOpt;
begin
  inherited InicioOpt;
end;

procedure TBancoDeBaterias01.PrepararPaso_ps;
var
  res: integer;
  xrpos: NREal;
  cv_Dem, cv_Gen: NReal;
  X_Carga_Proyectado, dCarga: NReal;

begin

  if flg_ValorizadoManual then
    cv_MWh := pa.cv_MWh_ValorizadoManual
  else
  begin
    globs.CF.devxr_continuo(
      ixr, globs.kPaso_Opt + 1, cv_Dem , cv_Gen , res, xrpos);

    case res of
      -1: cv_MWh := cv_Dem ;
      0: cv_MWh := (cv_Dem + cv_Gen) / 2.0;
      1: cv_MWh := cv_Gen;
    end;

    if CapacidadInstalada_MWh > 0.00001 then
      cv_MWh := -cv_MWh / CapacidadInstalada_MWh;
  end;

  if flg_UsarCostoDegradacionRecambio then
  begin
    cvRecambio_USD:= CapacidadInstalada_MWh * cvRecambio_USD_MWh_instalado;

    // Calculo de los costos variables por degradación como
    // aproximación lineal en el paso suponiendo que se carga o descarga
    // a PMaxDem o PMaxGen.
    // Carga
    if PMax_Dem > AsumaCero then
    begin
      X_Carga_Proyectado:= min(  X_Carga + PMax_Dem * globs.HorasDelPaso  * pa.ren_Dem, CapacidadInstalada_MWh );
      dCarga:= X_Carga_Proyectado - X_Carga;
      if dCarga > AsumaCero then
        cvDegDem:= PorcionDegradada( X_Carga, X_Carga_Proyectado ) * cvRecambio_USD / dCarga
      else
        cvDegDem:= 0;
    end
    else
      cvDegDem:= 0;

    if PMax_Gen > AsumaCero then
    begin
      X_Carga_Proyectado:= max( X_Carga - PMax_Gen * globs.HorasDelPaso / pa.ren_Gen, 0 );
      dCarga:= X_Carga - X_Carga_Proyectado;
      if dCarga > AsumaCero then
        cvDegGen:= PorcionDegradada( X_Carga, X_Carga_Proyectado ) * cvRecambio_USD / dCarga
      else
        cvDegGen:= 0;
    end;
  end;

end;

procedure TBancoDeBaterias01.opt_nvers(var ivar, ivae, ires: integer);
begin
  self.ivar := ivar;
  self.ires := ires;
  if NMaquinasDisponibles > 0 then
  begin
    ivar := ivar + 2 * globs.NPostes + 1; // PGen_i ;  PDem_i ; Xs_Carga
    ires := ires + 1; // Restricción dinámica
    // X_Carga - PGen_i*dupos_i * renGen + PDem_i * dupos_i / renDem  - Xs_Carga = 0
  end;
end;

procedure TBancoDeBaterias01.opt_cargue(s: TSimplex);
var
  ibaseres: integer;
  iposte: integer;
begin


  if NMaquinasDisponibles <= 0 then
    exit;

  ibaseres := nodo.ires;

  // Tenemos que aportar a las restricciones de demanda del nodo al que está
  // conectado el generador
  for iposte := 0 to globs.NPostes - 1 do
  begin
    s.pon_e(ibaseres + iposte, ivar + iposte, 1);
    s.pon_e(ibaseres + iposte, ivar + globs.NPostes + iposte, -1);
  end;


  // Xs_Carga = X_Carga -  PGen_i * durpos_i / renGen +  PDem_i * durpos_i * renDem
  for iposte := 0 to globs.NPostes - 1 do
  begin
    s.pon_e(ires, ivar + iposte, -globs.durpos[iposte] / pa.ren_Gen);
    s.pon_e(ires, ivar + globs.NPostes + iposte, globs.durpos[iposte] * pa.ren_Dem);
  end;

  s.pon_e(ires, ivar + 2 * globs.NPostes, -1); // -Xs_Carga
  s.pon_e(ires, s.nc, X_Carga);

  // Aportes a la función de -costo.
  for iposte := 0 to globs.NPostes - 1 do
  begin

    s.pon_e(s.nf, ivar + iposte,
      s.e(ires, ivar + iposte) * (cv_MWh + cvDegGen ));

    s.pon_e(s.nf, ivar + globs.NPostes + iposte, s.e(
      ires, ivar + globs.NPostes + iposte) * (cv_MWh - cvDegDem));
  end;

end;

procedure TBancoDeBaterias01.opt_fijarRestriccionesDeCaja(s: TSimplex);
var
  iposte: integer;
begin
  // Le fijamos como cota máxima PMax a la potencia en todos los postes
  if NMaquinasDisponibles > 0 then
  begin
    for iposte := 0 to globs.NPostes - 1 do
      s.cota_sup_set(ivar + iposte, PMax_Gen);

    for iposte := 0 to globs.NPostes - 1 do
      s.cota_sup_set(ivar + globs.NPostes + iposte, PMax_Dem);

    s.cota_sup_set(ivar + 2 * globs.NPostes, CapacidadInstalada_MWh);
    // DV@201811131450  s.cota_sup_set(ivar + 2 * globs.NPostes, pa.CapacidadMaxima_MWh);
    s.FijarRestriccionIgualdad(ires);
  end;
end;

procedure TBancoDeBaterias01.Sim_Cronica_Inicio;
begin
  inherited Sim_Cronica_Inicio;

  X_Carga := Carga_ini;

end;

procedure TBancoDeBaterias01.opt_leerSolucion(s: TSimplex);
var
  iposte: integer;
  CostoDegradacionVariable: NReal;

begin

  CostoDirectoDelPaso := cfRecambio_USD_MWh_instalado_PorPasoT  * CapacidadInstalada_MWh;

  if NMaquinasDisponibles <= 0 then
  begin
    vclear(PGen);
    vclear(PDem);
    vclear(P);
    //vclear( cv_Spot );
    for iposte := 0 to globs.NPostes - 1 do
    begin
      Lambda_P[iPoste] := 0;
      cv_Spot[iPoste] := get_cv_falla;
      // para que en el ordenamiento quede último, con costo variable igual a la falla;
    end;
    Ingreso_PorDisponibilidad_ := 0;
    Xs_Carga := X_Carga; // ??? ojo falta la descarga vegetativa
    exit;
  end;

  for iposte := 0 to globs.NPostes - 1 do
  begin
    PGen[iposte] := s.xval(ivar + iposte);
    PDem[iposte] := s.xval(ivar + globs.npostes + iposte);
    P[iposte] := PGen[iposte] - PDem[iposte];
    Lambda_P[iPoste] := s.xmult(ivar + iposte) / globs.DurPos[iPoste];
    cv_Spot[iPoste] := Nodo.cmarg[iposte] - Lambda_P[iPoste];
  end;

  Ingreso_PorDisponibilidad_ :=
    pa.CapacidadMaxima_MWh * NMaquinasDisponibles * pa.pagoPorDisponibilidad_USDxMWhh *
    globs.HorasDelPaso;
  Xs_Carga := s.xval(ivar + 2 * globs.NPostes);

  CostoDegradacionVariable:=  PorcionDegradada( X_Carga, Xs_Carga ) *  cvRecambio_USD;
  CostoDirectoDelPaso := CostoDirectoDelPaso + CostoDegradacionVariable;

end;


procedure TBancoDeBaterias01.EvolucionarEstado;
begin
  X_Carga := Xs_Carga;
end;

procedure TBancoDeBaterias01.CambioFichaPD;
var
  q: NReal;
  sq: NReal;
  AnualidadCosteo_USD_MWh_anio: NReal;
begin
  flg_UsarCostoDegradacionRecambio:= true;
  if ( pa.EnsayoCiclado_nc2 <= 0 )
     or ( pa.EnsayoCiclado_nc1 <= 0)
     or ( pa.EnsayoCiclado_pd2  < AsumaCero )
     or ( pa.EnsayoCiclado_pd1  < AsumaCero )
     or ( pa.CostoRecambio_USD_kWh_instalado < AsumaCero ) then
  begin
    flg_UsarCostoDegradacionRecambio:= false;
    cvRecambio_USD:= 0;
    cvDegDem:= 0;
    cvDegGen:= 0;
    exit;
  end;

  beta := -(ln(pa.EnsayoCiclado_nc2) - ln(pa.EnsayoCiclado_nc1)) /
    (ln(pa.EnsayoCiclado_pd2) - ln(pa.EnsayoCiclado_pd1));

  alfa := ln(pa.EnsayoCiclado_nc2) + beta * ln(pa.EnsayoCiclado_pd2);

  expmalfadiv2 := exp(-alfa) / 2.0;
  expmalfadiv2porbeta := expmalfadiv2 * beta;

  q := 1.0 / (1.0 + pa.TasaDescuento_costeo);

  //  serie geométrica usada para el costeo
  sq := (1.0 - power(q, pa.AniosRecambio_costeo)) / (1.0 - q);


  // Anulidad en USD/(año y MWh_instalado)
  AnualidadCosteo_USD_MWh_anio := ( pa.CostoRecambio_USD_kWh_instalado * 1.0e3  ) / sq;

  PorcionFija := 0.1; // Parte que suponemos se consume por el paso del tiempo
    // use o no la batería.

  cfRecambio_USD_MWh_instalado_PorPasoT := ( PorcionFija * AnualidadCosteo_USD_MWh_anio / 8760.0 * globs.HorasDelPaso );
  cvRecambio_USD_MWh_instalado := (1.0 - PorcionFija)*AnualidadCosteo_USD_MWh_anio*pa.AniosRecambio_costeo;

  end;


function TBancoDeBaterias01.getNombreVar(ivar: integer; var nombre: string): boolean;
begin
  if (ivar >= self.ivar) and (ivar < self.ivar + 2 * globs.NPostes) then
  begin
    Result := True;
    if (ivar < self.ivar + globs.NPostes) then
      nombre := self.Nombre + '_PGen[MW]' + IntToStr(ivar - self.ivar + 1)
    else
      nombre := self.Nombre + '_PDem[MW]' + IntToStr(ivar - self.ivar -
        globs.NPostes + 1);
  end
  else
    Result := False;
end;

function TBancoDeBaterias01.getNombreRes(ires: integer; var nombre: string): boolean;
begin
  if (ires = self.ires) then
  begin
    nombre := self.nombre + 'f(x,u,r)-Xs=0';
    Result := True;
  end
  else
    Result := False;
end;

procedure TBancoDeBaterias01.PubliVars;
begin
  inherited PubliVars;
  PublicarVariableVR('PGen', '[MW]', 6, 2, PGen, True, True);
  PublicarVariableVR('PDem', '[MW]', 6, 2, PDem, True, True);
  PublicarVariableNR('cv_MWh', '[USD/MWh]', 6, 1, cv_MWh, True);
  PublicarVariableNR('X_Carga', '[MWh]', 6, 1, X_Carga, True);
  PublicarVariableNI('NMaquinasDisponibles', '-', NMaquinasDisponibles, False);

  PublicarVariableNR('cfRecambio_USD_MWh_instalado_PorPasoT', '[USD]', 6, 1, cfRecambio_USD_MWh_instalado_PorPasoT, True);
  PublicarVariableNR('cvDegDem', '[USD/MWh]', 6, 1, cvDegDem, True);
  PublicarVariableNR('cvDegGen', '[USD/MWh]', 6, 1, cvDegGen, True);
end;

procedure TBancoDeBaterias01.optx_nvxs(var ixr, ixd, iauxr, iauxd: integer);
begin
  if not flg_ValorizadoManual then
  begin
    self.ixr := ixr;
    ixr := ixr + 1;
  end;
end;

procedure TBancoDeBaterias01.PosicionarseEnEstrellita;
begin
  if not flg_ValorizadoManual then
    X_Carga := globs.CF.xr[ixr] * CapacidadInstalada_MWh;
end;

procedure TBancoDeBaterias01.ActualizarEstadoGlobal(flg_Xs: boolean);
begin
  if not flg_ValorizadoManual then
    if CapacidadInstalada_MWh > AsumaCero then
      globs.CF.xr[ixr] := X_Carga / CapacidadInstalada_MWh
    else
      globs.CF.xr[ixr] := 0;
end;

procedure TBancoDeBaterias01.optx_RegistrarVariablesDeEstado(
  adminEstados: TAdminEstados);
begin
  if not flg_ValorizadoManual then
    adminEstados.Registrar_Continua(
      ixr,
      0.0,
      1.0,
      ndisc,
      nombre + '_Carga', // nombre de la variable
      'p.u.' // unidades de la capacidad instalada en cada momento
      );
end;

destructor TBancoDeBaterias01.destroy;
begin
  if lpd <> nil then
    lpd.Free;
  setlength(PGen, 0);
  setlength(PDem, 0);
  inherited destroy;
end;



{*********************************
*Métodos de TFichaBancoBaterias *
*********************************}

constructor TFichaBancoDeBaterias01.Create(capa: integer; fecha: TFecha;
  periodicidad: TPeriodicidad; PMax_Gen, PMax_Dem: NReal; ren_Gen, ren_Dem: NReal;
  CapacidadMaxima_MWh: NReal; fd, TMR, cv_MWh_ValorizadoManual,
  pagoPorDisponibilidad_USDxMWhh, EnsayoCiclado_pd1: NReal;
  EnsayoCiclado_nc1: integer; EnsayoCiclado_pd2: NReal;
  EnsayoCiclado_nc2, AniosEnvejecimientoNatural: integer;
  CostoRecambio_USD_kWh_instalado: NReal; AniosRecambio_costeo: integer;
  TasaDescuento_costeo: NReal);
begin
  inherited Create(capa, fecha, periodicidad);

  Self.PMax_Gen := PMax_Gen;
  self.PMax_Dem := PMax_Dem;
  self.ren_Gen := ren_Gen;
  self.ren_Dem := ren_Dem;
  self.CapacidadMaxima_MWh := CapacidadMaxima_MWh;
  self.fd := fd;
  self.TMR := TMR;
  self.cv_MWh_ValorizadoManual := cv_MWh_ValorizadoManual;
  self.pagoPorDisponibilidad_USDxMWhh := pagoPorDisponibilidad_USDxMWhh;

  self.EnsayoCiclado_pd1 := EnsayoCiclado_pd1;
  self.EnsayoCiclado_nc1 := EnsayoCiclado_nc1;
  self.EnsayoCiclado_pd2 := EnsayoCiclado_pd2;
  self.EnsayoCiclado_nc2 := EnsayoCiclado_nc2;
  self.AniosEnvejecimientoNatural := AniosEnvejecimientoNatural;
  self.CostoRecambio_USD_kWh_instalado := CostoRecambio_USD_kWh_instalado;
  self.AniosRecambio_costeo := AniosRecambio_costeo;
  self.TasaDescuento_costeo := TasaDescuento_costeo;

end;

function TFichaBancoDeBaterias01.Rec: TCosa_RecLnk;
begin
  Result := inherited Rec;
  Result.addCampoDef('PMax_Gen', PMax_Gen);
  Result.addCampoDef('PMax_Dem', PMax_Dem);
  Result.addCampoDef('ren_Gen', ren_Gen);
  Result.addCampoDef('ren_Dem', ren_Dem);
  Result.addCampoDef('CapacidadMaxima_MWh', CapacidadMaxima_MWh);
  Result.addCampoDef('fd', fd);
  Result.addCampoDef('TMR', TMR);
  Result.addCampoDef('cv_MWh_ValorizadoManual', cv_MWh_ValorizadoManual, 121);
  Result.addCampoDef('pagoPorDisponibilidad_USDxMWhh',
    pagoPorDisponibilidad_USDxMWhh, 149);

  Result.addCampoDef('EnsayoCiclado_pd1', EnsayoCiclado_pd1, 191);
  Result.addCampoDef('EnsayoCiclado_nc1', EnsayoCiclado_nc1, 191);
  Result.addCampoDef('EnsayoCiclado_pd2', EnsayoCiclado_pd2, 191);
  Result.addCampoDef('EnsayoCiclado_nc2', EnsayoCiclado_nc2, 191);
  Result.addCampoDef('AniosEnvejecimientoNatural', AniosEnvejecimientoNatural, 191);
  //Result.addCampoDef('CapacidadFinal_pu', CapacidadFinal_pu, 191);
  Result.addCampoDef('CostoRecambio_USD_kWh_instalado',
    CostoRecambio_USD_kWh_instalado, 191);

  Result.addCampoDef('AniosRecambio_costeo', AniosRecambio_costeo, 191);
  Result.addCampoDef('TasaDescuento_costeo', TasaDescuento_costeo, 191);

end;

procedure TFichaBancoDeBaterias01.BeforeRead(version, id_hilo: integer);
begin
  inherited BeforeRead(version, id_hilo);
end;

procedure TFichaBancoDeBaterias01.AfterRead(f: TArchiTexto);
begin
  inherited AfterRead(f);
end;

procedure TBancoDeBaterias01_cambioFichaPD(Actor: TCosa);
begin
  (Actor as TBancoDeBaterias01).cambioFichaPD;
end;



destructor TFichaBancoDeBaterias01.destroy;
begin
  inherited destroy;
end;


procedure AlInicio;
begin
  registrarClaseDeCosa(TBancoDeBaterias01.ClassName, TBancoDeBaterias01);
  registrarClaseDeCosa(TFichaBancoDeBaterias01.ClassName, TFichaBancoDeBaterias01);
end;

procedure AlFinal;
begin
end;

end.
