Fortran subroutines returning NaN in C# Form TextBox.

Master_Fortran · ‎10-28-2014

Dear all,

I have three modules which returns three variables through a DLL. The variable's names are: reyOleo, fatAtrito and perdaCarga. Running it in a Main file called Principal, the results are OK! But when I call it from a C# TextBox, the variable reyOleo is OK, but fatAtrito and perdaCarga are equal to NaN (Not a number). I'm attatching all the files to help.

It's worthnoting that fatAtrito and perdaCarga modules depends on reyOleo value. I really don't know whats is happening. Can some one save me?

!====================================================================

 module Reynolds
 
    implicit none
    
    ! Declaração global para leitura nos demais módulos.
    double precision :: vazaoOleo, diametroTubo, massaEspecOleo, viscOleo, reyOleo
    
    contains
 
    subroutine Reynol(vazaoOleo, diametroTubo, massaEspecOleo, viscOleo, reyOleo)
        !
        ! Descrição: 
        !   Essa sub-rotina calcula número de Reynolds.
    
        ! Variáveis de entrada:
        !   vazaoOleo      = Vazão do Óleo (m3/d)
        !   diametroTubo   = Diâmetro interno da tubulação (in)  
        !   massaEspecOleo = Massa específica do óleo (kg/m3)
        !   viscOleo       = Viscosidade do óleo (cP)
        !   areaTubo       = Área da secção transversal do tubo (in2)
    
        ! Variável de saída:
        !   ReyOleo = Número de Reynolds do óleo
    
        !Exportando a DLL:
        !DEC$ ATTRIBUTES DLLEXPORT :: Reynol
        
        ! Declarando as variáveis com dupla precisão.
        double precision, intent(in)  :: vazaoOleo, diametroTubo, massaEspecOleo, viscOleo  
        double precision, intent(out) :: reyOleo
    
        !Declarando a variável "Dummy".
        double precision areaTubo
    
        !Declarando o número "pi" como parâmetro.
        parameter pi = 3.1415927d0
    
        !Realizando o cálculo da área em (in2).
        areaTubo = (pi * diametroTubo **2) / 4
    
        ! Calculando o número de Reynolds.
        ! (39370.1/86400) é um fator de conversão, haja vista a diferença no sistemas
        ! de unidades exibidos acima.
        reyOleo  = (39370.1/86400) * (vazaoOleo * diametroTubo * massaEspecOleo / (viscOleo * areaTubo))
        
    end subroutine
    
end module

!====================================================================
  
 module Fatrito
    
    ! Chamando os módulos que calcula Reynolds.
    use Reynolds
    
    implicit none
    
    ! Declaração global para leitura nos demais módulos.
    double precision :: rugoTubo, fatAtrito
    
    contains
    
    subroutine Fatfan(rugoTubo, fatAtrito)
        !
        ! Descrição: 
        !   Essa sub-rotina calcula o fator de atrito de Fanning.
    
        ! Variáveis de entrada:
        !   rugoTubo = Rugosidade da tubulação (m)
        !   diametroTudo   = Diâmetro interno da tubulação (in)
    
        ! Variável de saída:
        !   fatAtrito = Fator de Atrito de Fanning
    
        !Exportando a DLL:
        !DEC$ ATTRIBUTES DLLEXPORT :: Fatfan
                        
        ! Declarando as variáveis com dupla precisão.
        double precision, intent(in)  :: rugoTubo   
        double precision, intent(out) :: fatAtrito
        
        ! Declarando os "Dummy Arguments" ou "argumentos burros".
        double precision :: A1
        double precision :: A2
        
        ! Chamando a subrotina que calcula o número de Reynolds.
        call Reynol(vazaoOleo, diametroTubo, massaEspecOleo, viscOleo, reyOleo)
        
        if (reyOleo < 2100d0) then
        
            ! Cálculo do Fator de atrito caso o regime seja laminar.
            fatAtrito = 16d0 / reyOleo 
             
        else            
        
            if (reyOleo > 4000d0) then
            
                ! Utilizando a equação de & Zigrand e Sylvester (1982) para região turbulenta: 
                A1 = rugoTubo / (3.7 * diametroTubo) + 13 / reyOleo
                A2 = rugoTubo / (3.7 * diametroTubo) - (5.02 / reyOleo) * log10(A1)
                fatAtrito = 1 / (-2 * log10(rugoTubo / (3.7 * diametroTubo) - (5.02 / reyOleo) * log(A2))) **2
            
            else
            
                fatAtrito = (1 / 1.8 * log10(reyOleo / (0.135 * (rugoTubo / diametroTubo) + 6.5))) **2

            end if
            
        end if
        
    end subroutine
    
end module

!====================================================================

 module QuedaPressao
    
    ! Chamando os módulos que calcula Reynolds e o fator de atrito.
    use Reynolds
    use Fatrito
    
    implicit none
    
    ! Declaração global para leitura nos demais módulos
    double precision :: compTubo, perdaCarga
    
    contains
 
    subroutine Quedap(compTubo, perdaCarga)
    
        ! Descrição: 
        ! Essa sub-rotina calcula a perda de carga para um escoamento de um fluido newtoniano 
        ! em uma tubulação.
    
        ! Variáveis de entrada:
        !   vazaoOleo      = Vazão do Óleo (m3/d)
        !   diametroTubo   = Diâmetro interno da tubulação (in) 
        !   compTubo       = Comprimento da tubulação (m)
        !   massaEspecOleo = Massa específica do óleo (kg/m3)
        !   fatAtrito      = Fator de Atrito de Fanning
        !   g              = Aceleração da gravidade (m/s2)
    
        ! Variável de saída:
        ! deltaP = Perda de Carga (kgf/cm2)
    
        !Exportando a DLL:
        !DEC$ ATTRIBUTES DLLEXPORT :: Quedap

        ! Declarando as variáveis com dupla precisão.
        double precision, intent(in)  :: compTubo   
        double precision, intent(out) :: perdaCarga
        
        ! Declarando os "Dummy Arguments" ou "argumentos burros".
        double precision g
    
        ! Chamando a sub-rotina que calcula o fator de atrito de Fanning.
        call Reynol(vazaoOleo, diametroTubo, massaEspecOleo, viscOleo, reyOleo)
        call Fatfan(rugoTubo, fatAtrito)   
    
        ! A aceleração da gravidade por ser declarada aqui.
        g = 9.81

        ! Calculando a Perda de Carga para uma tubulação vertical ou horizontal.
        ! 0.1143 é um fator para recber as unidades mostradas acima.
        ! 98066,5 é um fator de conversão de mcl para kgf/cm2.
        perdaCarga = ((0.1143 * massaEspecOleo * g) * fatAtrito * (compTubo / diametroTubo **5) * (1 / g) * (8 * vazaoOleo **2)) / 98066.5  
     
    end subroutine
    
end module

!====================================================================

public partial class ReynoldsForm : Form
    {

        // Comando para importar a DLL do FORTRAN.
        [DllImport("Escoa_H2S_DLL", CharSet = CharSet.Auto, SetLastError = true, CallingConvention = CallingConvention.Cdecl, EntryPoint = "REYNOLDS_mp_REYNOL")]

        public static extern void REYNOL([In] ref double _vazaoOleo, [In] ref double _diametroTubo, [In] ref double _massaEspecOleo, [In] ref double _viscOleo, [In, Out] ref double _reyOleo);

        // Comando para importar a DLL do FORTRAN.
        [DllImport("Escoa_H2S_DLL", CharSet = CharSet.Auto, SetLastError = true, CallingConvention = CallingConvention.Cdecl, EntryPoint = "FATRITO_mp_FATFAN")]

        public static extern void FATFAN([In] ref double _rugoTubo, [In, Out] ref double _fatAtrito);

        // Comando para importar a DLL do FORTRAN.
        [DllImport("Escoa_H2S_DLL", CharSet = CharSet.Auto, SetLastError = true, CallingConvention = CallingConvention.Cdecl, EntryPoint = "QUEDAPRESSAO_mp_QUEDAP")]

        public static extern void QUEDAP([In] ref double _compTubo, [In, Out] ref double _perdaCarga);

        public ReynoldsForm()
        {
            InitializeComponent();
        }

        // Declando as variáveis:
        double _vazaoOleo,
               _diametroTubo,
               _massaEspecOleo,
               _viscOleo,
               _reyOleo,
               _compTubo,
               _perdaCarga,
               _rugoTubo,
               _fatAtrito;
        string reyOleoString,
               fatAtritoString, 
               perdaCargaString;

        private void calculaReynoldsbutton_Click(object sender, EventArgs e)
        {
             // Entrando com os dados brutalmente. Depois vou chamar pelo array de entrada. 
             // Isso é apenas para fins de teste.
            _vazaoOleo      = 54.28672;//4000;     // m3/d
            _diametroTubo   = 0.15740; //6;     // inch
            _massaEspecOleo = 1.23; //880; // kg/m3
            _viscOleo       = 0.0179;  //1.85;      // cP
            _compTubo       = 0.1; //m
            _rugoTubo       = 4.5e-5;

            // Chamando a DLL do Fortran:
             REYNOL(ref _vazaoOleo, ref _diametroTubo, ref _massaEspecOleo, ref _viscOleo, ref _reyOleo);

             // Chamando a DLL do Fortran:
             FATFAN(ref _rugoTubo, ref _fatAtrito);

             // Chamando a DLL do Fortran:
             QUEDAP(ref _compTubo, ref _perdaCarga);

            // Passando para string o valor de Reynolds que vem da DLL e armazenando em reyOleoString.
            reyOleoString = Convert.ToString(_reyOleo);

            // Passando para string o valor do fator de atrito que vem da DLL e armazenando em fatAtritoString.
            fatAtritoString = Convert.ToString(_fatAtrito);

            // Passando para string o valor da perda de carga que vem da DLL e armazenando em perdaCargaString.
            perdaCargaString = Convert.ToString(_perdaCarga);

            // Exibindo o resultado na TextBox.
            reynoldsTextBox.Text = reyOleoString;

            // Exibindo o resultado na TextBox.
            fatordeAtritotextBox.Text = fatAtritoString;

            // Exibindo o resultado na TextBox.
            quedaPressaotextBox.Text = perdaCargaString;

        } // Fim do método de clique calculaReynoldsbutton_Click

Steven_L_Intel1 · ‎10-29-2014

See https://software.intel.com/en-us/forums/topic/534579