ich glaube, ich habe ein Verständnisproblem. Ich will Ergebnisse aus FE-Rechnungen weiterverarbeiten. Dabei fallen enorme Mengen an Zahlen an, die ich strukturiert einlesen und verwalten muss. Ich beginne mit den Knoten, die eine Nummer und 2 oder 3 Raumkoordinaten besitzen. Also habe ich folgendes definiert:
Code: Alles auswählen
Type
PNodeCoordinates = ^TNodeCoordinates;
TNodeCoordinates = Record
inod : integer; { user node number }
xcord : Array[1..3] of double; { coordinates of node }
End;
PAllNodalCoordinates = ^TAllNodalCoordinates;
TAllNodalCoordinates = Record
numnp : integer; { number of nodes }
ncrd : integer; { number of coordinates per node }
icoord : Array of TNodeCoordinates; { array of node coordinates (numnp entries) }
End;
Es gibt also eine Struktur, die die Nummer (als Integer) und ein Array für die 3 Koordinaten (Double) eines Knotens aufnehmen; diese Infos gehören zusammen. Dazu gibt es eine Struktur, die den gesamten Satz an Knoten beherbergen soll. Die hat die Info zu Gesamtzahl der Knoten (Integer), die Anzahl der Koordinaten pro Knoten (2 bzw. 3 für 2-D oder 3-D) und natürlich ein Array (dynamisch) mit der oben definierten Struktur für die Knoten selbst.
Das Einlesen passiert in einer Funktion, die wie folgt definiert ist:
Code: Alles auswählen
function ReadNodalCoordinates(postcode : TPostCodes; strlist : TStringList; idx : integer; numnodes : integer; coordpernode : integer) : PAllNodalCoordinates;
Die Struktur kann ich auch mit Daten füllen; zumindest liegen die Daten im Speicher und lassen sich auch auslesen (das habe ich mit dem Debugger geprüft - Code kann ich zeigen wenn gewünscht). Aber wenn ich versuche, den Speicherverbrauch festzustellen, bekomme ich absurd niedrige Werte:
Code: Alles auswählen
var
PtrNodalCoordinates : PAllNodalCoordinates;
//...
New(PtrNodalCoordinates);
PtrNodalCoordinates := ReadNodalCoordinates(PCFileNo1,slT19File,idx,numNodes,.numCoordPerNode);
Memo1.Append(' +---- Nodal Coordinates');
Memo1.Append(' | =================');
Memo1.Append(' | # Nodes: '+IntToStr(PtrNodalCoordinates^.numnp));
Memo1.Append(' | # Coordinates per Node: '+IntToStr(PtrNodalCoordinates^.ncrd));
Memo1.Append(' | Length of coord[]: '+IntToStr(Length(PtrNodalCoordinates^.icoord)));
Memo1.Append(' | coord['+IntToStr(PtrNodalCoordinates^.icoord[1000]. inod)+']: ('+ // read node info of node number 1000 for test
FloatToStr(PtrNodalCoordinates^.icoord[1000].xcord[1])+'/'+
FloatToStr(PtrNodalCoordinates^.icoord[1000].xcord[2])+'/'+
FloatToStr(PtrNodalCoordinates^.icoord[1000].xcord[3])+')');
Memo1.Append(' + ----------------------------- Memory: '+
IntToStr(SizeOf(PtrNodalCoordinates^))+' Bytes');
ergibt folgendes im Memo1:
Code: Alles auswählen
+---- Nodal Coordinates
| =================
| # Nodes: 7695
| # Coordinates per Node: 3
| Length of coord[]: 7695
| coord[1001]: (22.7388/10/0)
+ ----------------------------- Memory: 16 Bytes
Fragen:
- die 16 Bytes sind sicher nicht die Gesamtlänge/größe der Struktur im Speicher sondern "misst" nur den Pointer auf das dynamische Array mit. Wie bekomme ich die Größe der ganzen Struktur? Die Anzahl der Knoten (= Länge des Arrays) stimmt genauso, wie die Nummer und die Koordinaten des Knotens. (Fußnote: wahrscheinlich ist die Antwort wieder so einfach, dass man sich anschließend wieder drei Tage nicht vor die Tür traut )
- da das gleiche noch mit weiteren Strukturen geschehen soll (Elementdefinitionen, Ergebnisgrößen für einige Ergebnis-Files gleichzeitig), will ich sicher sein, dass ich den ganzen Mechanismus verstanden habe. Und ich möchte natürlich den Speicherverbrauch im Auge behalten bzw. im Voraus abschätzen können, wieviel ich brauche.
- ist die Wahl eines dynamischen Arrays überhaupt die richtige Wahl? Oder wäre eine TList (bzw. TObjectList) besser geeignet? Geschwindigkeit ist neben dem Speicherverbrauch auch ein wichtiger Aspekt bei der Zahl an Daten.
Vielen Dank für Eure Hilfe,
Photor