"Flecha" de um função

[T!@G0 0]

Boa tarde amigos! Eu estou a escrever um programa em pascal (com o compilador freepascal 0.64a) através de varios procedimentos em que se pretende calcular a "flecha" de um função, que equivale à distancia entre os zeros e o mínimo ou máximo e precisava da ajuda de alguem que percebesse disto.

{«««««««««««««««««««««««««««« INTRODUÇÃO DOS DADOS DA VIGA »»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»}

Procedure IntDados_Viga(Var L:Real;b,K,E,MI,Beta,Alfa,Lambda:Real);

   Begin
       Repeat
           TextColor(White);
           Write('Indique a largura da viga "b"= ');
           TextColor(LightGreen);
           Readln(b);
               If (b<=0) then Erro1
       Until (b>0);

       Repeat
           TextColor(White);
           Write('Indique o modulo do solo "K"= ');
           TextColor(LightGreen);
           Readln(K);
               If (K<=0) then Erro1
       Until (K>0);

       Repeat
           TextColor(White);
           Write('Modulo da elasticidade "E"= ');
           TextColor(LightGreen);
           Readln(E);
               If (E<=0) then Erro1
       Until (E>0);

       Repeat
           TextColor(White);
           Write('Indique o momento de inercia "MI"= ');
           TextColor(LightGreen);
           Readln(MI);
               If (MI<=0) then Erro1
       Until (MI>0);

       Beta:=K*b;
       Alfa:=sqrt(sqrt(Beta/(4*E*MI)));
       Lambda:=2*Pi/Alfa;

       Repeat
           TextColor(White);
           Write('Indique o comprimento da viga "L" maior que',2.5*Lambda:6:1,'= ');
           TextColor(LightGreen);
           Readln(L);
           If (L<=2.5*Lambda) then Erro2 ('O comprimento da viga insuficiente!');
       Until L>2.5*Lambda;

   End;
{«««««««««««««««««««««««««««« INTRODUÇÃO DOS DADOS DA CARGA »»»»»»»»»»»»»»»»»»»»»»»»»»»»»»}

Procedure IntDados_Carga(N:Integer; VAR P,a,x:Real; L:Real);

Var i:Integer;

   Begin
       Repeat
           Writeln;
           Writeln;
           TextColor(White);
           Write('Numero de cargas (N) a aplicar= ');
           TextColor(LightGreen);
           Readln(N);
           If (N<1) then Erro2 ('O número de cargas a aplicar tem que ser maior ou igual a 1');
       Until (N>=1);

       For i:=1 to N do begin
                            TextColor(White);
                            Write('Valor da carga P',i:1,'= ');
                            TextColor(LightGreen);
                            Readln(P);

                          Repeat
                               TextColor(White);
                               Write('Distancia entre a origem e o ponto de aplicacao da Carga a',i:1,'= ');
                               TextColor(LightGreen);
                               Readln(a);
                                    If (a<0) or (a>L) then Erro1
                          Until (a>=0) and (a<=L);

                          Repeat
                               TextColor(White);
                               Write('Seccao onde pretende obter o valor da flecha x',i:1,'= ');
                               TextColor(LightGreen);
                               Readln(x);
                                    If (x<=0) or (x>L) then Erro1
                          Until (x>0) and (x<=L);
                          Writeln;
                        End;

   End;

{««««««««««««««««««««««««« NUMERO DE SECCOES EQUIDISTANTES »»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»}

Procedure Num_SecEqui(var NEQ:Integer);

   Begin
       Repeat
           TextColor(White);
           Write('Indique o numero de seccoes equidistantes (NEQ)= ');
           TextColor(LightGreen);
           Readln(NEQ);
               If(NEQ<0) or (NEQ>Max) then Erro2 ('Atencao: NEQ>0 e NEQ<=100000!');
       Until(NEQ>=0) and (NEQ<=Max);
   End;
{««««««««««««««««« CALCULO DA FLECHA E DA DISTANCIA DA FLECHA À ORIGEM »»»»»»»»»»»»»»»»»»»}

Procedure Calculo_Flecha(NEQ:Integer;L,P,a,x,Beta,Alfa:Real);

Var Q,B1,B2,Fx:Real;
   i:Integer;

   Begin
           Q:=(P*Alfa)/(2*Beta);
           B1:=Alfa*(a-x);
           B2:=Alfa*(x-a);
           dx:=L/(NEQ);

       For i:=0 to NEQ do begin
                              If(x>=0) and (x<=a) then
                                                       Fx:=Q*exp(-B1)*(sin(Alfa*(a-x))+cos(Alfa*(a-x)));
                              If(x>a) and (x<=L) then
                                                       Fx:=Q*exp(-B2)*(sin(Alfa*(x-a))+cos(Alfa*(x-a)));
                              x:=i*dx;
                          end;
   End;

{«««««««««««««««««««««««««««« RESULTADOS DO CALCULO DA FLECHA »»»»»»»»»»»»»»»»»»»»»»»»»»»»}

Procedure Resultados_Flecha();

   Begin
       Write;
       Readln;
   End;

{««««««««««««««««««««««««««««««««« CALCULO DE ZEROS »»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»}

Procedure Calculo_Zeros(Beta,Alfa,a,xA,xB,Erro:Real;MaxIteracoes:Integer);

Var xMedio:Real;
   FxA,FxMedio:Real;
   i:Integer;

Begin
  Write('Em construcao');
  Readln;
end;

{««««««««««««««««««««««««««««««««««« ABRIR GRAFICO »»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»}

Procedure AbrirGrafico();

   Begin
   Write('Em construcao');
   Readln;
   End;

{««««««««««««««««««««««««««««««««« GRAFICO DA FLECHA »»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»}

Procedure Grafico_Flechas();

   Begin
   Write('Em construcao');
   Readln;
   End;

{««««««««««««««««««««««««««««««««« SAIR DO PROGRAMA »»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»}

Procedure SairPrograma(var Sair:Char);

   Begin
       Repeat
           Writeln;
           TextColor(22);
           Write('Pretende Continuar o Programa (S/N)? ');
           Sair:=Readkey;
           Sair:=UpCase(Sair);
       Until Sair IN ['S','N']
   End;

{=======================================================================================}
{################################ BLOCO PRINCIPAL###################################
{=======================================================================================}


Begin
    Moldura(9);
    Password;
    Writeln;
    TextColor(LightBlue);
    Gotoxy(55,22);
    Writeln('Continuar Programa.....');
    REPEAT UNTIL Keypressed;

    Clrscr;
       IntDados_Viga(L,b,K,E,MI,Beta,Alfa,Lambda);
       IntDados_Carga(N,P,a,x,L);
       Num_SecEqui(NEQ);
       Calculo_Flecha(NEQ,L,P,a,x,Beta,Alfa);
End.

Preciso da vossa ajuda no ponto 4 (Nao consigo perceber como fazer este passo)

4) Para cada secção de (0 a NEQ) calcular:

4.1) Distância x[ i ] à origem O;

4.2) Flecha F[ i ] para a distância x[ i ];

SERA QUE ALGUEM ME CONSEGUE AJUDAR? OBRIGADO!

[nunopicado 1,177]

Boas

Posso tentar ajudar, mas não estou a entender qual o problema...

Ainda tentei correr o teu programa, mas faltam lá algumas partes...

Onde ao certo tens dificuldades?

[T!@G0 0]

O meu problema esta em perceber como escrevo a parte seguinte. Vou enviar o enunciado:

1. INTRODUÇÃO

Todos andamos de comboio e por isso sabemos que eles rolam sobre carris que estão assentes

sobre travessas, estando estas por sua vez assentes no balastro. O balastro é constituído por

uma camada espessa de brita colocada sobre o solo.

Estando na moda o TGV, a sua alta velocidade justifica um estudo e cálculo apurados no que

respeita a várias variáveis. Uma das mais importantes é a deslocação vertical do carril quando

solicitado pelo peso do comboio. Esta deslocação diz-se flecha.

No TGV, a linha é constituída por carris soldados uns aos outros, cada um com comprimento

elevado, da ordem da centena de metros. Assim consideramos que se comporta como uma viga

de comprimento infinito.

Consideramos ainda que o conjunto solo-balastro reage para cima apenas naqueles pontos em

que a viga desce, enquanto que não reage nos pontos em que a viga se eleva.

O comportamento elástico do solo-balastro caracteriza-se pelo módulo K que representa a

reacção do solo-balastro numa área de 1cm2 correspondente a uma flecha de 1cm. Tem portanto

como unidades kilogramas por centímetro cúbico. Por exemplo, num solo arenoso, o módulo K

pode variar entre 1 e 4 Kg/cm3. Para obter valores seguros é necessário fazer ensaios

laboratoriais.

Pode parecer estranho que o terreno reaja proporcionalmente às deformações que sofre, isto é,

que se comporte elasticamente. Mas é o que demonstra a experiência, confirmando-se também

que as travessas se afundam no balastro de cada vez que passa um rodado, recuperando

imediatamente depois!

Com as hipóteses anteriores, o modelo que V. irá automatizar é o de uma viga infinita sobre

apoio elástico contínuo.

2. OBJECTIVO

Elaborar um Programa em Pascal que, tendo por base uma viga sobre apoio elástico contínuo, de

comprimento L, onde são igualmente conhecidos:

· b - Largura da viga

· K - Módulo do solo

· E - Módulo de elasticidade

· MI - Momento de inércia da secção

e sujeita a uma carga P, aplicada à distância a, permita:

a) Automatizar o cálculo da Flecha

Optimizar o programa por forma a que L > 2.5

c) Calcular a flecha em N secções equidistantes

d) Calcular os pontos onde a flecha é nula

e) Guardar em ficheiro de texto os valores obtidos em c) e d)

f) Traçar gráfico de Fx

g) Generalizar a utilização do programa para i cargas Pi

No decurso das aulas será fornecido o Modelo Matemático necessário à resolução das questões

enunciadas.

3. METODOLOGIA

Cada grupo deverá analisar a metodologia adequada à resolução do problema. Sugere-se no

entanto especial atenção para os seguintes aspectos:

a) Análise do problema, identificando:

Objectivo

Elementos de Input

Algoritmo

Elaboração do inerente Pseudocódigo;

c) Utilização de variáveis de fácil identificação, sendo obrigatória a utilização das

identificadas em seguida1:

P – Valor da Carga

L – Comprimento da Viga

a – Distância entre a origem e o ponto de aplicação da Carga

x – Secção correspondente ao ponto de aplicação da Carga

b – Largura da viga

K – Módulo do solo

E – Módulo de elasticidade

MI – Momento de inércia da secção

NEQ – Número de Secções Equidistantes

NCP – Número de Cargas Pontuais

d) Escrita legível do programa de modo a que facilmente se identifiquem as tarefas bem

como as estruturas utilizadas e respectiva abrangência;

e) Utilização de comentários ao longo do programa, nomeadamente no que respeita à

identificação das variáveis e tarefas;

f) Utilização de procedimentos que individualizem tarefas, sendo de utilização obrigatória

os assinalados com (*):

Écran de Apresentação (*) (Moldura)

“Password” de acesso ao Programa (*) (Password)

Registo e validação de inputs através do teclado – Viga (*); (IntDados_Viga)

Registo e validação de inputs através do teclado – Carga (*) (IntDados_Carga)

Cálculo da Flecha (*) (Calculo_Flecha)

Pontos onde a flecha é nula (*) (Calculo_Zeros)

Escrita de resultados em Ficheiro

Iniciar gráfico (*) (AbrirGrafico)

Gráfico com o diagrama de flechas (*) (Grafico_Flechas)

…

Nos procedimentos, deverá ser preocupação (sempre que possível) o recurso a parâmetros.

4. PROCEDIMENTO DE UTILIZAÇÃO OBRIGATÓRIA

Apresenta-se em seguida um procedimento, que terá obrigatoriamente que ser incorporado no

trabalho2 e que tem como finalidade o cálculo de pontos onde a flecha é nula.

Procedure Calculo_Zeros(Beta,Alfa,a,xA,xB,Erro:Real;MaxIteracoes:Integer);

Var XMedio:Real;
FxA,FxMedio:Real;
i:Integer;

   Begin
   i := 1;
         Repeat
                Xmedio := (xA + xB) / 2;
                Calculo_Flecha(Beta,Alfa,a,xA,FxA);
                Calculo_Flecha(Beta,Alfa,a,xMedio,FxMedio);
                IF FxA * FxMedio < 0 THEN xB := XMedio
                                                 ELSE xA := XMedio;
                i:=i+1
         Until (abs(FxMedio) < Erro) or (i > MaxIteracoes);
         Writeln(i:4,' Zero = ',xMedio:8:4,' Fx = ',FxMedio:12:10)
   End;

Nao postei os prededimentos da moldura e da password porque esses ja se encontram resolvidos e a funcinar correctamente. Aguardo resposta.