home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1987 / 01 / berech.inc < prev    next >
Encoding:
Text File  |  1986-11-25  |  7.8 KB  |  170 lines
  1. (*--------------------------------------------------------------------------*)
  2. (*                        Modul:  berech.inc                                *)
  3. (*--------------------------------------------------------------------------*)
  4. (*   Berechnet aus einer Streckenlast die Groesse und den Angriffspunkt der
  5.      Resultierenden. Wobei Trapezlasten in Rechteck- und Dreieckslasten
  6.      aufgeteilt werden.                                                     *)
  7.  
  8. PROCEDURE Trapezlast (Ort,Lastlaenge,Lastlinks,Lastrechts : REAL;
  9.                       VAR Resultierende,Resultort : REAL);
  10.  
  11.   VAR c,      (* fuer den Ort der Resultierenden einer Dreieckslast (c/3xL) *)
  12.       GewichtDR,                             (* Groesse der  Deiecksflaeche *)
  13.       GewichtRE,                             (* Groesse der Rechteckflaeche *)
  14.       OrtDR,OrtRE       (* Orte der Resultierenden aus Dreieck und Rechteck *)
  15.                   : REAL;
  16.  
  17.   (*------------------------------------------------------------------------*)
  18.  
  19.   FUNCTION MIN (a,b : REAL) : REAL;
  20.  
  21.     BEGIN
  22.       IF a > b THEN
  23.         MIN := b
  24.       ELSE
  25.         MIN := a;
  26.     END; (* min *)
  27.  
  28.  
  29.   BEGIN (* Trapezlast *)
  30.     GewichtDR := ABS (Lastlinks - Lastrechts) * Lastlaenge / 2;
  31.     GewichtRE := MIN (Lastlinks,Lastrechts) * Lastlaenge;
  32.     IF Lastlinks > Lastrechts THEN
  33.       c := 1
  34.     ELSE
  35.       c := 2;
  36.     OrtDR := c/3 * Lastlaenge;
  37.     OrtRE := Lastlaenge / 2;
  38.     Resultierende := GewichtRE + GewichtDR;
  39.     Resultort := Ort + (GewichtRE * OrtRE + GewichtDR * OrtDR) / Resultierende;
  40.   END; (* trapezlast *)
  41.  
  42. (*---------------------------------------------------------------------------*)
  43. (*   Berechnet beide Auflagerkraefte ('links' und 'rechts').                 *)
  44.  
  45. PROCEDURE Auflagerkraefte (VAR links,rechts : REAL);
  46.  
  47.   VAR Resultierende,Resultort : REAL;
  48.       i                       : INTEGER;          (* Zaehler fuer die Lasten *)
  49.  
  50.   BEGIN
  51.     FOR i:=1 to Anzahl DO BEGIN
  52.       IF Last[i].Laenge <> 0 THEN    (* Streckenlast: berechne Resultierende
  53.                                                                und deren Ort *)
  54.         Trapezlast (Last[i].Ort,Last[i].Laenge,Last[i].Links,Last[i].Rechts,
  55.                       Resultierende,Resultort)
  56.       ELSE BEGIN                (* Einzellast: Resultierende und Ort bekannt *)
  57.         Resultierende := Last[i].Links;
  58.         Resultort := Last[i].Ort;
  59.       END; (* else *)
  60.       links := links + Resultierende * (Feldlaenge - Resultort) / Feldlaenge;
  61.       rechts := rechts + Resultierende * Resultort / Feldlaenge;
  62.     END; (* for *)
  63.   END; (* auflagerkraefte *)
  64.  
  65. (*--------------------------------------------------------------------------*)
  66. (*   Berechnet die Schittreaktionen (Moment und Querkraft) an beliebiger
  67.      Stelle des Balkens.                                                    *)
  68.  
  69. PROCEDURE Schnittkraft (Ort : REAL; VAR Moment,Querkraft : REAL);
  70.  
  71.   VAR Resultierende,Resultort,
  72.       Hebelarm,            (* Abstand der Resultierenden vom Berechnungsort *)
  73.       SummeM,SummeQ,       (* Zwischensummen des Momentes und der Querkraft *)
  74.       Laenge,          (* Laenge der Last, evtl. nur bis zum Berechnungsort *)
  75.       Rechts  (* rechte Ordinate der Last, evtl. Ordinate am Berechnungsort *)
  76.              : REAL;
  77.       i      : INTEGER;                          (* Zaehler fuer die Lasten *)
  78.  
  79.   (*------------------------------------------------------------------------*)
  80.   (*   Interpoliert die rechte Ordinate einer Streckenlast, falls der
  81.        Berechnungsort innerhalb der Last liegt.                             *)
  82.  
  83.   FUNCTION Interpolation (ILinks,IRechts,Ort,WertLinks,WertRechts:REAL):REAL;
  84.  
  85.     BEGIN
  86.       Interpolation := (WertRechts - WertLinks) / (IRechts - ILinks)
  87.                          * (Ort - ILinks) + WertLinks
  88.     END; (* interpolation *)
  89.  
  90.  
  91.   BEGIN (* Schnittkraft *)
  92.     SummeM := Auflagerlinks * Ort;           (* Moment des linken Auflagers *)
  93.     SummeQ := Auflagerlinks;                (* Querkraft am linken Auflager *)
  94.     FOR i:=1 to Anzahl DO BEGIN
  95.       Hebelarm := 0; Resultierende := 0;
  96.       IF (Last[i].Laenge = 0) AND (Last[i].Ort < Ort) THEN BEGIN
  97.         Resultierende := Last[i].Links;                       (* Einzellast *)
  98.         Hebelarm := Ort - Last[i].Ort;
  99.       END; (* if *)
  100.       IF (Last[i].Laenge <> 0) AND (Last[i].Ort < Ort) THEN BEGIN
  101.         Laenge := Last[i].Laenge;            (* Streckenlast, die links vom *)
  102.         Rechts := Last[i].Rechts;            (* Berechnungsort liegt.       *)
  103.         IF Last[i].Ort + Last[i].Laenge > Ort THEN BEGIN
  104.               (* Streckenlast, deren Anfangspunkt links, und deren Endpunkt *)
  105.               (* rechts vom Berechnungsort liegt, d.h. die rechte Ordinate  *)
  106.               (* und die Laenge muss berechnet werden.                      *)
  107.           Laenge := Ort - Last[i].Ort;
  108.           Rechts := Interpolation (Last[i].Ort,Last[i].Ort+Last[i].Laenge,
  109.                                    Ort,Last[i].Links,Last[i].Rechts);
  110.         END; (* if *)
  111.         Trapezlast (Last[i].Ort,Laenge,Last[i].Links,Rechts,
  112.                     Resultierende,Resultort);
  113.         Hebelarm := Ort - Resultort;
  114.       END; (* if *)
  115.       SummeM := SummeM - Resultierende * Hebelarm;    (* summiere Moment    *)
  116.       SummeQ := SummeQ - Resultierende;               (* summiere Querkraft *)
  117.     END; (* for *)
  118.     Moment := SummeM;
  119.     Querkraft := SummeQ;
  120.   END; (* moment *)
  121.  
  122. (*--------------------------------------------------------------------------*)
  123. (*   Findet iterativ den Ort des maximalen Momentes auf einen cm genau.     *)
  124.  
  125. FUNCTION OrtMaximumMoment : REAL;
  126.  
  127.   VAR ILinks,IRechts,                                   (* Intervallgrenzen *)
  128.       Step,                                (* Schrittweite der Untersuchung *)
  129.       dummy          : REAL;
  130.       i              : INTEGER;             (* Zaehler fuer die Genauigkeit *)
  131.  
  132.   (*------------------------------------------------------------------------*)
  133.   (*   Berechnet bei Vorgabe eines Intervalls und einer Schrittweite das
  134.        Maximum. Wird mehrmals mit jeweils groesserer Genauigkeit aufgerufen *)
  135.  
  136.   FUNCTION Maximum (links,rechts,step : REAL) : REAL;
  137.  
  138.     VAR Letzt,Jetzt,               (* zum Vergleich der berechneten Momente *)
  139.         dummy       : REAL;        (*   Querkraft wird hier nicht benoetigt *)
  140.         i,                                              (*          Zaehler *)
  141.         a,b         : INTEGER;                          (* Intervallgrenzen *)
  142.  
  143.     BEGIN
  144.       a := TRUNC (links  / step);     (* Umrechnung der Intervallgrenzen in *)
  145.       b := TRUNC (rechts / step);     (* Integer, zur Verwendung von FOR.   *)
  146.       Schnittkraft (links,Letzt,dummy);   (* Moment am linken Intervallrand *)
  147.       FOR i:=a+1 TO b DO BEGIN
  148.         Schnittkraft (i*step,Jetzt,dummy);              (* Berechne Moment. *)
  149.         IF Jetzt > Letzt THEN BEGIN      (* Vergleiche Momente, und behalte *)
  150.           Letzt := Jetzt;                (* Groesse und Ort des Groesseren. *)
  151.           Maximum := i * step;           (* Rechne Integer in Real zurueck. *)
  152.         END; (* if *)
  153.       END; (* for *)
  154.     END; (* maximum *)
  155.  
  156.  
  157.   BEGIN (* OrtMaximumMoment *)
  158.     ILinks := 0;                         (* Festlegung der Intervallgrenzen *)
  159.     IRechts := Feldlaenge + 1;
  160.     Step := 10;                                        (* erste Genauigkeit *)
  161.     FOR i:=1 TO 3 DO BEGIN                 (* Berechne und vergleiche maxi- *)
  162.       Step := Step / 10;                   (* male Momente zunaechst im     *)
  163.       dummy := Maximum (ILinks,IRechts,Step); (* m-Abstand, dann im dm- und *)
  164.       ILinks  := dummy - Step;             (* zuletzt im cm-Abstand.        *)
  165.       IRechts := dummy + Step;
  166.     END; (* for *)
  167.     OrtMaximumMoment := dummy;                  (* uebergebe gefundenen Ort *)
  168.   END; (* momentmaximum *)
  169.  
  170.