Verständnisfragen

Hallo,

habe leider nur Basiskenntnisse in C++.

In einem Quellcode gibt es folgende Zeile:

patch_.boundaryMesh().mesh()();

Was heißt dieses patch_ , und was bewirkt dieser Befehl ?

Genauso gibt es noch:

const liste& gesPunkte = patch().meshPoints()

Wie kann ich herausfinden, was außer patch().meshPoints(), also z.B. patch().meshFaces() (oder halt was anderes, das will ich ja herausfinden ) möglich ist ?

Danke euch

drakon

Das ist irgend ein Objekt, mit Membern. Zuerst musst du wissen, von was für einem Typ patch_ ist und dann schaust du in der entsprechenden Doku nach, was das Objekt für öffentliche Member anbietet.

Hi drakon, erstmal danke für die schnelle Antwort. Es geht hier anscheinend um templates, habe damit aber bis jetzt noch nie gearbeitet. Das Template sieht folgendermaßen aus:

template
<
    template<class> class PatchField,
    class Mesh,
    class PointPatch,
    template<class> class MatrixType,
    class Type
>
const objectRegistry&
PointPatchField<PatchField, Mesh, PointPatch, MatrixType, Type>::db() const
{
    return patch_.boundaryMesh().mesh()();
}

Ich kann damit irgendwie nicht viel anfangen. Kann man hier sehen von welchem Typ patch_ ist ?

drakon

Das ist ja lediglich eine Funktionstemplate des Klassentemplates PointPatchField . Schau dort nach. Oder schau dir die Rückgabewerte der Funktionen an, die du aufrufst.

Allerdings sollte solche Sachen in der Dokumentation zur Library stehen..

Sebastian Pizer

Enno schrieb:

Kann man hier sehen von welchem Typ patch_ ist ?

Nein, kann man nicht sehen. patch_ scheint ein Element der Klasse PointPatchField<PatchField, Mesh, PointPatch, MatrixType, Type> zu sein.

Wenn das aus einer Bibliothek kommt, die Du nur nutzen willst, musst Du diese Internas nicht verstehen. Dazu sollte es eine Dokumentation geben.

Ok,

darf man in templates einfach auf externe Klassen zugreifen oder wird der Compiler damit ein Problem haben ?

Will nämlich eine ermittelte Zahl aus einer Klasse einbinden.

drakon

Wie meinst du das? - Du darfst natürlich einen Klasse includen und dann Objekte erzeugen und die öffentliche Schnittstelle benutzen.. Aber ich vermute, dass du etwas anderes meinst. Mach mal ein Beispielprogramm.

Ok, hier mal der Originalcode des Templateabschnittes um das es geht. Wenn weitere Infos gewünscht sind, bitte sagen

#include "polyMesh.H"
#include "polyBoundaryMesh.H"

//Diese Dateien wurden neu included und werden auch gefunden

// Return field created from appropriate internal field values
// given the internal field
template
<
    template<class> class PatchField,
    class Mesh,
    class PointPatch,
    template<class> class MatrixType,
    class Type
>
template<class Type1>
tmp<Field<Type1> >
PointPatchField<PatchField, Mesh, PointPatch, MatrixType, Type>::
patchInternalField
(
    const Field<Type1>& iF
) const
{
    // Check size
    if (iF.size() != internalField().size())
    {
        FatalErrorIn
        (
            "tmp<Field<Type1> > PointPatchField<PatchField, PointPatch, "
            "Type>::"
            "patchInternalField(const Field<Type1>& iF) const"
        )   << "given internal field does not correspond to the mesh. "
            << "Field size: " << iF.size()
            << " mesh size: " << internalField().size()
            << abort(FatalError);
    }

    // get addressing

    //const polyBoundaryMesh& meshPoints = patch_.boundaryMesh();

    const labelList& meshPoints = patch().meshPoints();

//    tmp<Field<Type1> > tvalues(new Field<Type1>(meshPoints[2].nPoints()));
    tmp<Field<Type1> > tvalues(new Field<Type1>(meshPoints.size()));
    Field<Type1>& values = tvalues();
//  for (label pointI = 0; pointI < meshPoints[2].nPoints(); pointI++)
    for (label pointI = 0; pointI < meshPoints.size(); pointI++)
    {
	Info << "pointI = "<< pointI << endl;
	Info << "meshPoints.size() =" << meshPoints.size() << endl;
	Info << "iF.size() =" << iF.size() << endl;

	values[pointI] = iF[meshPoints[pointI]];
        //values[pointI] = iF[meshPoints[2][pointI]];
	Info << "Sucessfully values SET" << endl;
    }
    return tvalues;
}

Ich will das am liebsten so haben wie in den auskommentierten Zeilen (denke ersichtlich wo)

Die Sache ist, dass meshPoint.size() den alten Wert einliest, also von einer nicht aktuellen Liste. Ich weiß aber (schon geprüft), dass in der Klasse "boundaryMesh" er den aktuellen Wert hat

meshPoints = patch_.boundaryMesh();

Mit dem patch_ bin ich mir halt nicht sicher.

In der eigentlich Klasse von polyMesh kann ich das einfach folgendermaßen eingeben und es funktioniert:

const polyBoundaryMesh& patches = boundaryMesh();

Habe jetzt halt nicht so den Plan wie man aus dem Template nun drauf zugreift. Ich drücke mich vielleicht dumm aus, weiß aber nicht wie ich es erklären soll.

Die Fehlermledung meldet der Compiler dann:

Fehler: ungültige Initialisierung einer Referenz des Typs »const Foam::polyBoundaryMesh&« von Ausdruck des Typs »const Foam::pointBoundaryMesh

Und wenn ich es direk so reinschreibe:

const polyBoundaryMesh& patches = boundaryMesh();

Ich will einfach, dass diese Zuweisung klappt.

Meckert er:

Fehler: es gibt keine Argumente für »boundaryMesh«, die von einem Templateparameter abhängen, weshalb eine Deklaration von »boundaryMesh« verfügbar sein muss
lnInclude/PointPatchField.C:190: Fehler: (mit »-fpermissive« wird G++ den Code akzeptieren, aber die Verwendung eines nicht deklarierten Namens ist veraltet)

BoundaryMesh.H

namespace Foam
{

// Forward declaration of classes
class Time;
class polyMesh;
class primitiveMesh;

/---------------------------------------------------------------------------\
Class boundaryMesh Declaration
\---------------------------------------------------------------------------/

class boundaryMesh
{
....
}