TTubo.h

Go to the documentation of this file.

/* --------------------------------------------------------------------------------*\
==========================|
 \\   /\ /\   // O pen     | OpenWAM: The Open Source 1D Gas-Dynamic Code
 \\ |  X  | //  W ave     |
 \\ \/_\/ //   A ction   | CMT-Motores Termicos / Universidad Politecnica Valencia
 \\/   \//    M odel    |
 ----------------------------------------------------------------------------------
 License

 This file is part of OpenWAM.

 OpenWAM is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 OpenWAM is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with OpenWAM.  If not, see <http://www.gnu.org/licenses/>.


 \*--------------------------------------------------------------------------------*/

//---------------------------------------------------------------------------
#ifndef TTuboH
#define TTuboH
#include <cstdio>
#include <iostream>
#ifdef __BORLANDC__
#include <vcl.h>
#endif
//#include <cmath>
#include "TCondicionContorno.h"
#include "TDeposito.h"
#include "TBloqueMotor.h"
#include "TCCUnionEntreTubos.h"
#include "TCCCilindro.h"
#include "TCCDeposito.h"
#include "TDPF.h"
#include "Constantes.h"
#include "Globales.h"
//#include "roots.h"

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

class TCondicionContorno;
class TBloqueMotor;
class TDeposito;

struct stFunDisCar {
    double A_0;
    double A_1;
    double V_0;
    double V_1;
    double D_t;
    double Sign;

    stFunDisCar(double a0, double a1, double v0, double v1, double dt, double sg) {
        A_0 = a0;
        A_1 = a1;
        V_0 = v0;
        V_1 = v1;
        D_t = dt;
        Sign = sg;
    }
    double operator()(double x) {
        double xx = 1 - x;
        if(Sign > 0) {
            double a = A_0 * xx + A_1 * x;
            double v = V_0 * xx + V_1 * x;
            return x - (a - v) * D_t;
        } else {
            double a = A_0 * x + A_1 * xx;
            double v = V_0 * x + V_1 * xx;
            return xx - (a + v) * D_t;
        }
    }
};

class TTubo {
  private:
//---------------------------------------------------------------------------
//          VARIABLES PRIVADAS
//---------------------------------------------------------------------------

    int FTuboCCNodoIzq; 
    int FTuboCCNodoDer; 

    // Datos Geometricos

    int FNumeroTubo;            
    int FNodoIzq;               
    int FNodoDer;               
    int FNin;                   
    int FJClase;                
    double FXref;                   
    double FLongitudTotal;          
    double FMallado;            
    int FNTramos;               
    nmTipoMallado FTipoMallado;         
    double *FLTramo;         
    double *FDExtTramo; 
    double *FDiametroTubo;         
    double *FDiametroD12; 
    double *FDiametroS12; 
    double *FArea;                  
    double *FArea12;            
    double *FDerLin;
    double *FDerLin12;
    double *FDerLinArea;
    double *FDerLinArea12;
    bool FIntercooler;           
    bool FConcentrico;        
    int FNumeroConductos;       

    // Propiedades termicas y friccion

    double FFriccion;              
    nmTipoTransCal FTipoTransCal;           
    double FCoefAjusFric;          
    double FCoefAjusTC;            
    double FEspesorIntPrin; 
    double FEspesorExtPrin; 
    double FEspesorPrin;        
    double FDensidadPrin; 
    double FCalEspPrin; 
    double FConductPrin; 
    double FTRefrigerante;         
    nmRefrigerante FTipRefrig;              
    int FTctpt;                 
    nmTipoCalcTempParedTubos FTipoCalcTempPared; 
    double FTIniParedTub;          
    double *FVelPro; 
    double *FCoefTurbulencia;      
    double ***FSUMTPTuboPro;       
    double FSUMTime;                
    double **FTPTubo;            
    double **FTParedAnt;        
    double FTExt;                   
    //double FAlpha;
    double FCoefExt;    
    double *Fhi;                   
    double *Fhe;                   
    double *Frho;                  
    double *FRe;                   
    stCapa *FCapa;                 
    int FNumCapas;              
    double FEmisividad;            
    double *FResistRadInt; 
    double *FResistRadExt; 
    double *FResistAxiAnt; 
    double *FResistAxiPos;   
    double *FCapInt;               
    double *FCapMed;               
    double *FCapExt;               

    // Propiedades termofluidodinamicas

    double FVelMedia;             
    double FTini;                  
    double FPini;                  
    double *FPresion0;             
    double *FAsonido0; 
    double *FVelocidad0; 
    double *FPresion1;             
    double *FAsonido1; 
    double *FVelocidad1; 
    double *FVelocidadDim;          
    double *FAsonidoDim;            
    double *FTemperature;           
    double *FFlowMass;              

    // Vectores metodo de calculo

    stModeloCalculoTubos FMod;              
    double **FU0;                   
    double **FU0Sum;                
    double **FU0Medio;              
    double *FVelocidadMedia;        
    double *FAsonidoMedia;          
    double *FPresionMedia;          
    double **FU1;                   
    double **FUt;                   
    double **FU12;              
    double **FW;                    
    double **FV1;   
    double **FV2;   
    double FCcese;                  

    // Vectores del flux corrected transport

    double **FUfct0;            
    double **FUfct1;            
    double **FUfctd;                
    double **FUfctad;               
    double **Ffl;                   
    double **FdU;                   
    double **FDeltaFCTd;            
    double **FflU;                  
    double **FaU;                   

    // Vectores de TVD Davis

    //double **FTVD;
    //double **FTVDdU;
    //double *FTVDpp;
    //double *FTVDpn;
    //double *FTVDphp;
    //double *FTVDphn;
    //double *FTVDrp;
    //double *FTVDrn;
    //double *FTVDGn;
    //double *FTVDGp;

    // Variables del TVD

    stTVD FTVD;     
    double *sqrtRhoA;

    // Calculo Especies

    int FNumeroEspecies;        
    nmTipoCalculoEspecies FCalculoEspecies;     
    nmCalculoGamma FCalculoGamma;   
    double *FComposicionInicial;    
    double **FFraccionMasicaEspecie; 
    double **FFraccionMasicaCC; 
    bool FHayEGR;               
    int FIntEGR;    

    int FNumEcuaciones; 

    double *FVelocidadCC;           
    double *FDensidadCC;            
    double *FAreaCC;                
    double *FGamma;         
    double *FRMezcla;       
    double *FCpMezcla;      
    double *FCvMezcla; 
    double FGammaN;

    double *FGamma1;                
    double *FGamma3;                
    double *FGamma4;                
    double *FGamma5;                
    double *FGamma6;                

    // Tiempos

//        double                        FTime0;                 //!< Time at current time step
//        double                        FTime1;                 //!< Time at following time step
//        double                        FDeltaTime;             //!< Time step
    double *FCourantLocal;  
    double FCourant;                

    // Resultados medios e instantaneos

    stResMediosTubo *ResultadosMedios;      
    int FNumResMedios;          
    stResInstantTubo *ResultInstantaneos;           
    int FNumResInstant;         
    double FTiempoMedSUM;   
    double FControlResMed;  
    stSensoresTubo *Sensor;             
    int FNumDistSensores;       

    double FAnguloTotalCiclo;       
    double FRegimenFicticio;    

    int FCicloTubo;             
    int FCicloActual; // !< Number of the current cycle when there is not engine in the configuration
    double FDuracionCiclo; // !< Cycle duration (in time) to calculate wall temperature convergence when there is not engine in the configuration
    int FNumCiclosSinInerciaTermica; // !< Number of cycles without thermal inertia consideration when there is not engine in the configuration

    TDPF *FDPFSalidaTubo;       //  DPF connected to the outlet of the duct
    TDPF *FDPFEntradaTubo;       //  DPF connected to the inlet of the duct
    bool FHayDPFNodoIzq; //  bool to identify DPF connected at the inlet of the duct
    bool FHayDPFNodoDer; //  bool to identify DPF connected at the outlet of the duct
    int FNodoDPFEntrada;  //  Node of the DPF connected to the inlet of the duct
    int FNodoDPFSalida;  //  Node of the DPF connected to the outlet of the duct
    int *FTipoCanal; //  bool to identify DPF connected at the outlet of the duct

//---------------------------------------------------------------------------
//          FUNCIONES PRIVADAS
//---------------------------------------------------------------------------

    void CalculoPuntosMalla(double ene                      
                           );

    //double InterpolaTubo(double  vizq,double  vder,double  axid,double  xif);

    void Transforma1(const double& v,                       
                     const double& a,                               
                     const double& p,                               
                     double** U,                                
                     const double& Gamma,                       
                     const double& Gamma1,                  
                     double* Yespecie,      
                     const int& i                               
                    );

    void Transforma1Area(const double& v,                   
                         const double& a,                               
                         const double& p,                               
                         double** U,                                
                         const double& area,                            
                         const double& Gamma,                       
                         const double& Gamma1,                  
                         double* Yespecie,      
                         const int& i                               
                        );

    void Transforma2(double& v,                             
                     double& a,                             
                     double& p,                             
                     double** U,                                
                     const double& Gamma,                       
                     const double& Gamma1,                  
                     double* Yespecie,          
                     const int& i                               
                    );

    void Transforma2Area(double& v,                         
                         double& a,                             
                         double& p,                             
                         double** U,                                
                         const double& area,                            
                         const double& Gamma,                           
                         const double& Gamma1,                          
                         double* Yespecie,                      
                         const int& i                               
                        );

    void Transforma3Area(double** Ufct,                             
                         double** U,                                    
                         double Area,                               
                         double Gamma,                              
                         double Gamma1,                             
                         double Gamma6,                             
                         int i                                  
                        );

    void Transforma4Area(double** U1,       
                         double** Ufctd,    
                         double Area,   
                         double Gamma,  
                         double Gamma1, 
                         double Gamma3, 
                         double Gamma4, 
                         double Gamma6, 
                         int i      
                        );

    double Maximo(double x, 
                  double y  
                 );

    double Minimo(double x, 
                  double y  
                 );

    void LaxWendroff();

    void LaxWendroffArea();

    void FluxCorrectedTransport();

    void CalculaFlujo(double** U,       
                      double** W,       
                      double* Gamma,    
                      double* Gamma1,   
                      int Nodos 
                     );

    void CalculaFuente1(double** U,     
                        double** V1,        
                        double* Gamma,  
                        double* Gamma1, 
                        int Nodos   
                       );

    void CalculaFuente1Area(double** U,     
                            double** V1,        
                            double* Area,   
                            double* Gamma1, 
                            int Nodos   
                           );

    void CalculaFuente2(double** U,                 
                        double** V2,                    
                        double* Area,               
                        double* hi,                 
                        double* rho,                
                        double* Re,                 
                        double* TempParedTubo,      
                        double* Gamma,              
                        double* Rmezcla,            
                        double* Gamma1,             
                        int Nodos               
                       );

    void CalculaFuente2Area(double** U,                 
                            double** V2,                    
                            double* Area,               
                            double* hi,                 
                            double* rho,                
                            double* Re,                 
                            double* TempParedTubo,      
                            double* Gamma,              
                            double* Rmezcla,            
                            double* Gamma1,             
                            int Nodos               
                           );

    double DerLinF(double d1,   
                   double d2,   
                   double xref  
                  );

    double DerLinFArea(double area1,    
                       double area2,    
                       double xref      
                      );

    void Colebrook(double rug,  
                   double dia,  
                   double& f,       
                   double Re        
                  );

    void TransmisionCalor(double tgas,              
                          double diametro,          
                          double& q,                    
                          double hi,                    
                          double rho,               
                          double Tw                 
                         );

    void TransformaContorno(double& L,      
                            double& B,      
                            double& E,      
                            double& a,      
                            double& v,      
                            double& p,      
                            const int& modo,    
                            const double& Gamma1,   
                            const double& Gamma3,   
                            const double& Gamma4,   
                            const double& Gamma5    
                           );

    double CalculaNIT(double a,     
                      double v,     
                      double p,     
                      double d,     
                      double Gamma, double Rmezcla);

    //void FuncionTVD();

    void Calculo_Entropia(double& entropia,     
                          double& velocidadp,       
                          int ind,          
                          double dist,          
                          int signo,            
                          double DeltaTiempo,   
                          int indiceCC      
                         );

    void Calculo_Caracteristica(double& caracteristica, 
                                double& velocidadp,     
                                double& asonidop,       
                                int ind,            
                                double dist,            
                                int signo,          
                                double entropia,        
                                double DeltaTiempo      
                               );

    void CalculaB();

    void CalculaBmen();

    void CalculaBmas();

    void CalculaMatrizJacobiana();

    void TVD_Estabilidad();

    void TVD_Limitador();

    void RoeConstants();

    void DimensionaTVD();

    double Limita(double r  
                 );

  public:
//---------------------------------------------------------------------------
//          VARIABLES PUBLICAS
//---------------------------------------------------------------------------

    int getNumeroTubo() const;

    int getNodoIzq() const;

    int getNodoDer() const;

    int getNin() {
        return FNin;
    }
    ;
    int getNumeroConductos() {
        return FNumeroConductos;
    }
    ;
    double getXRef() {
        return FXref;
    }
    ;

    double getLongitudTotal() const;

    nmTipoTransCal getTipoTransCal() {
        return FTipoTransCal;
    }
    ;
    double getCoefAjustTC() {
        return FCoefAjusTC;
    }
    ;
    double getCoefAjustFric() {
        return FCoefAjusFric;
    }
    ;
    double getFriccion() {
        return FFriccion;
    }
    ;
    double getEmisividad() {
        return FEmisividad;
    }
    ;
    bool getConcentrico() {
        return FConcentrico;
    }
    ;
    double getDuracionCiclo() {
        return FDuracionCiclo;
    }
    ;
    double getNumCiclosSinInerciaTermica() {
        return FNumCiclosSinInerciaTermica;
    }
    ;
    nmTipoCalcTempParedTubos getTipoCalcTempPared() {
        return FTipoCalcTempPared;
    }
    ;
    double getAnguloTotalCiclo() {
        return FAnguloTotalCiclo;
    }
    ;
    double getTExt() {
        return FTExt;
    }
    ;
    double getEspesorIntPrin() {
        return FEspesorIntPrin;
    }
    ;
    double getConductPrin() {
        return FConductPrin;
    }
    ;
    double getEspesorPrin() {
        return FEspesorPrin;
    }
    ;
    double getDensidadPrin() {
        return FDensidadPrin;
    }
    ;
    double getCalEspPrin() {
        return FCalEspPrin;
    }
    ;
    bool getHayDPFNodoDer() {
        return FHayDPFNodoDer;
    }
    ;
    bool getHayDPFNodoIzq() {
        return FHayDPFNodoIzq;
    }
    ;
    int getNumCapas() {
        return FNumCapas;
    }
    ; 
    TDPF* getDPFEntrada() {
        return FDPFEntradaTubo;
    }
    ;
    TDPF* getDPFSalida() {
        return FDPFSalidaTubo;
    }
    ;
    int getNodoDPFEntrada() {
        return FNodoDPFEntrada;
    }
    ;
    int getNodoDPFSalida() {
        return FNodoDPFSalida;
    }
    ;

    double FTime0; 

    double getTime0() const;

    void PutTime0(double valor);

    double FTime1; 

    double getTime1() const;

    void PutTime1(double valor);

    double FDeltaTime; 

    double getDeltaTime() const;

    void PutDeltaTime(double valor);

    double getMallado() const;

    double GetDensidad(int i) const;

    double GetArea(int i) const;

    double GetDiametro(int i) const;

    double GetVelocidad(int i) const;

    double GetAsonido(int i) const;

    double GetPresion(int i) const;

    double GetTPTubo(int j, int i) const;

    void PutTPTubo(int k, int i, double valor);

    double GetTPTuboAnt(int j, int) const;

    double GetVelPro(int i) const;

    void PutVelPro(int i, double valor);

    double GetCoefTurbulencia(int i) const;

    double getTemperaturaInicial() const;

    double getTempWallIni() const;

    double getPresionInicial() const;

    double getVelocidadMedia() const;

    double GetFraccionMasicaInicial(int i) const;

    double GetFraccionMasicaCC(int j,                       
                               int i                                            
                              ) {
        return FFraccionMasicaCC[j][i];
    }
    ;

    double GetVelocidadCC(int i                             
                         ) {
        return FVelocidadCC[i];
    }
    ;

    double GetDensidadCC(int i                              
                        ) {
        return FDensidadCC[i];
    }
    ;

    double GetAreaCC(int i                                  
                    ) {
        return FAreaCC[i];
    }
    ;

    double GetGamma(int i) const;

    double GetRMezcla(int i) const;

    double GetCpMezcla(int i) const;

    double GetCvMezcla(int i) const;

    nmFormulacionLeyes getFormulacionLeyes() {
        return FMod.FormulacionLeyes;
    }
    ;
    double GetU0(int i,                                     
                 int j                                          
                ) {
        return FU0[i][j];
    }
    ;

    double Gethi(int i                                          
                ) {
        return Fhi[i];
    }
    ;

    double Gethe(int i                                          
                ) {
        return Fhe[i];
    }
    ;

    stCapa GetCapa(int i) {
        return FCapa[i];
    }
    ;

    int GetTipoCanal(int i) {
        return FTipoCanal[i];
    }
    ;

    void PutConcentric(double valor) {
        valor == 0 ? FConcentrico = false : FConcentrico = true;
    }
    ;

//---------------------------------------------------------------------------
//          FUNCIONES PUBLICAS
//---------------------------------------------------------------------------

    TTubo(int SpeciesNumber, 
          int j,                                        
          double SimulationDuration,                                
          TBloqueMotor **Engine,            
          nmTipoCalculoEspecies SpeciesModel,   
          nmCalculoGamma GammaCalculation,  
          bool ThereIsEGR                       
         );

    ~TTubo();

    void LeeDatosGeneralesTubo(const char*FileWAM,                  
                               fpos_t&filepos                       
                              );

    void LeeDatosGeometricosTubo(const char* FileWAM,          
                                 fpos_t& filepos,          
                                 double ene,              
                                 int tipomallado,      
                                 TBloqueMotor ** Engine            
                                );

    void IniciaVariablesFundamentalesTubo();

    void IniciaVariablesTransmisionCalor(TCondicionContorno ** BC,  
                                         TBloqueMotor ** Engine,     
                                         double AmbientTemperature        
                                        );

    void EstabilidadMetodoCalculo();

    void CalculaVariablesFundamentales();

    void ActualizaValoresNuevos(TCondicionContorno ** BC         
                               );

    void ReduccionFlujoSubsonico();

    void ReduccionFlujoSubsonicoFCT();

    void ReadAverageResultsTubo(const char* FileWAM,                
                                fpos_t& filepos,                
                                bool HayMotor                
                               );

    void HeaderAverageResults(std::stringstream& medoutput,        
                              stEspecies* DatosEspecies     
                             ) const;

    void ImprimeResultadosMedios(std::stringstream& medoutput       
                                ) const;

    void ReadInstantaneousResultsTubo(const char* FileWAM,          
                                      fpos_t& filepos,                
                                      bool HayMotor                
                                     );

    void HeaderInstantaneousResults(std::stringstream& insoutput,   
                                    stEspecies* DatosEspecies     
                                   ) const;

    void ImprimeResultadosInstantaneos(std::stringstream& insoutput 
                                      ) const;

    void CalculaResultadosMedios(double Theta            
                                );

    void CalculaResultadosInstantaneos();

    void SalidaGeneralTubos(stEspecies* DatosEspecies      
                           ) const;

    void CalculaTemperaturaPared(TBloqueMotor ** Engine,     
                                 double Theta,      
                                 double CrankAngle,     
                                 TCondicionContorno ** BC         
                                );

    void CalculaTemperaturaParedSinMotor(TCondicionContorno **BC);

    void AjustaPaso(double Intervalo                
                   );

    void CalculaCaracteristicasExtremos(TCondicionContorno ** BC,   
                                        double DeltaTiempo 
                                       );

    double Interpola_Entropia(nmPipeEnd TipoExtremoTubo,    
                              double DeltaTiempo         
                             );

    double Interpola_Caracteristica(double entropia,                
                                    int signo,                    
                                    int extremo,                  
                                    double DeltaTiempo               
                                   );

    void ComunicacionTubo_CC(TCondicionContorno ** BC         
                            );

    void ComunicacionDPF(TCondicionContorno **CC,  
                         TDeposito **Deposito                        
                        );

    void InicializaCaracteristicas(TCondicionContorno ** BC         
                                  );

    void CalculaCoeficientePeliculaExterior(TBloqueMotor ** Engine, 
                                            double AmbientPressure,             
                                            double AmbientTemperature              
                                           );

    void CalculaResistenciasdePared(TCondicionContorno ** BC        
                                   );

    void CalculaCoeficientePeliculaInterior(TCondicionContorno ** BC 
                                           );

    void ActualizaPropiedadesGas();

    double GetFraccionMasica(int j,                             
                             int i                                          
                            ) {
        return FFraccionMasicaEspecie[j][i];
    }
    ;
};

//---------------------------------------------------------------------------
#endif