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

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 ?

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

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.

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.

#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.

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

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)

namespace Foam
{

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

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

class boundaryMesh
{
....
}