---

Hi,

nach meiner letzten Frage ging es ganz gut voran allerdings habe ich nun wieder ein kleines Problem, dass ich mir nicht erklären kann.
Ich habe in den Solver settlingFoam eine Enthalphie Transportgleichung eingebaut und habe auch alles soweit kompilieren können. Allerdings habe ich ein Problem, weshalb ich nicht weiterkomme.

Starte ich den Solver bekomme ich die folgende Fehlermeldung:

Code:

---

--> FOAM FATAL IO ERROR:
cannot find file

file: /..../0/p at line 0.
From function regIOobject::readStream()
in file db/regIOobjectRead.C at line 73.

---

p ist wie beim original settlingFoam in createFields.H mit IOobject::NO_READ definiert.

Wieso verlangt der Solver trotzdem eine p Datei?
Ich habe auch schon alle hinzugefügten .H und .C files für die enthalpie Gleichung untersucht und konnte da auch nichts finden.
Gibt es eine funktion, die das aufrufen der p Datei verlangen kann außer IOobject?

Viele Grüße,
Bercht1980

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hi,

das ist natürlich jetzt so ohne Code nicht ganz einfach dir zu helfen.

Generell gilt:
1. Bei der Erweiterung von Codes kann es auch bei erfolgreicher Kompilierung immer noch Problemen kommen.
2. Wenn du eine Enthalpiegleichung mit "h.thermo" baust, dann kann es sein das du durch untere (basis) Klassen noch andere Werte benötigst.
3. Eine erfolgreiche Kompilation heißt nicht das du alles richtig hast. Beim Kompilieren wird nicht die Funktionalität des Codes getestet.

Dein Problem sieht ja nach einer fehlenden Datei aus - nicht nach einem Code Problem.
Hast du den ein "p" - Feld definiert? Wenn ja wie?

Wie ich gerade sehe arbeit der settlingFoam mit p_rgh.
Du kannst ja mal eine p Datei einfügen.

Wie gesagt; es ist schwer heir eine Analyse zu machen ohne Code.
Grüße Tobi

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hi,

klar kann ich einfach eine p Datei hinzufügen, dann rechnet er auch den ersten Zeitschritt aber schmiert danach bei der Enthalpie Gleichung ab. Allerdings dürfte er gar keine p Datei verlangen, da settling ja wie gesagt mit p_rgh rechnet und darüber auch p bestimmt. Daher meine Frage:
Wenn p wie oben gezeigt mit NO_READ bereits irgendwo im Code definiert wird, kann es dann noch andere Stellen im Code geben, die eine P Datei lesen wollen? Denn würde ich an anderer Stelle noch einmal ein p Feld definieren würde ich beim Kompilieren schon eine Fehlermeldung bekommen, dass es doppelt definiert wurde.

Es handelt sich im Moment eher um die grundsätzliche Frage, welcher Code noch eine p Datei verlangen könnte. Daher habe ich auch keinen weiteren Code angehängt.

Viele Grüße,
Bercht1980

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hi,

ich verweise dich mal auf den chtMultiFoam.
Dieser verwendet auch den Arbeitsdruck p_rgh, benötigt dennoch den Druck p, auch wenn du hier nichts vorgibst außer "calculated".

Bezüglich doppelter Definition geb ich dir nicht ganz recht.
Du kannst eine Variable p 10x definieren und du wirst niemals einen Fehler bekommen, insofern du die Variable p in anderen
Klassen definierst und somit Klasseneigen sind.

Code:

---

class pressure
{
      pubic: pressure(p(2));
             ~pressure();
             void getP() const {return p; }
      privat:
              int p;

};

class pressureRGH : pressure
{
      public: pressureRGH(p(4));
              ~pressureRGH();
              void getP() const { return p; }
      privat:
              int p;
};

main int()
{

     pressureRGH test;

     cout << text.getP() << endl;           
     cout << text.pressure::getP() << endl;
}

---

Man würde, obwohl man zweimal die gleiche Funktion mit dem selben Objekt aufruft und den gleichen Parameter abruft, nicht den gleichen Wert zurückbekommen.
Vllt. hilfts dir ja.
Grüße Tobi

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Also das p scheint wohl wie du schon gesagt hast in irgendeiner unteren Klasse des thermo modells zu liegen. Die Enthalphiegleichung liefert mir jetzt auch plausible Ergebnisse aber leider habe ich noch Probleme mit dem variablen rho.

Ich möchte nämlich, dass lediglich, die Dichte der kontinuierlichen Phase durch die Temperatur verändert wird. Dafür habe ich folgendes zusätzliches rho definiert:

Code:

---

volScalarField rhoT
    (
        IOobject
        (
            "rhoT",
            runTime.timeName(),
            mesh,
            IOobject::NO_READ,
            IOobject::AUTO_WRITE
        ),
        (scalar(1) - alpha)*rhoc
    );

---

Dieses lasse ich nach jeder Druckkorrektur und am Ende der alphaEqn mit diesen zwei Zeilen updaten:

Code:

---

rhoT=thermo.rhoT();

rho=rhoT + alpha*rhod;

---

Ich bekomme auch in den Bereichen höherer Temperatur eine entsprechend niedrigere Dichte angegeben allerdings schießen schon nach 1-2 Zeitschritten die Geschwindigkeiten in die Höhe.
Gibt es etwas was ich noch berücksichtigen muss im Zusammenhang mit settlingFoam?

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hey,

ich weiß nicht ob ich richtig liege aber ist es nicht möglich einfach rhoc zu berechnen?
Also

Code:

---

rhoT=thermo.rhoc();

---

und entsprechend

Code:

---

rho = (scalar(1) - alpha)*rhoT + alpha*rhod;

---

wobei

Code:

---

volScalarField rhoT
    (
        IOobject
        (
            "rhoT",
            runTime.timeName(),
            mesh,
            IOobject::NO_READ,
            IOobject::AUTO_WRITE
        ),
        rhoc
    );

---

Bin leider nicht vertraut mit dem Code von 2PhasenStrömungen :/

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

So wollte ich das eigentlich auch machen, allerdings funktioniert dieser Teil nicht:

Code:

---

volScalarField rhoT
    (
        IOobject
        (
            "rhoT",
            runTime.timeName(),
            mesh,
            IOobject::NO_READ,
            IOobject::AUTO_WRITE
        ),
        rhoc
    );

---

Leider sind meine C++ Kentnisse wenig bis gar nicht vorhanden, deshalb weiß ich nicht so recht, was dem da nicht gefällt. Ich vermute mal, dass er einfach nichts damit anzufangen weiss weil rhoc nur eine Zahl ist und der noch die Information über das Netz damit verknüpfen muss. Wie das funktioniert weiss ich leider nicht. Habe auch kein Beispiel bei den anderen Feldern gefunden.

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Das ist eigentlich nur eine Definition der Variablen.

Kurzerausflug in C++

---------------------------------------------------------------------------------------------------------------------------------------
Hier mal eine Minimalbeispiel:

Code:

---

int i = 1;
int j = 2;
int sum;

sum = i + j;

---

Denke das ist noch sehr nachvollziehbar. Wenn man das genau betrachtet heißt das aber:

Code:

---

int i = 1;  //erstelle die Variable i die von der Klasse int abgeleitet wird und weise dieser den Wert 1 zu.
            //die Klasse int ist eine interne von C++ angelegte Klasse die eben nur ganze Zahlen abbildet.

int j = 2;  //analog
int sum;    //analog

---

Ich stell die Berechnung (auch wenn das sehr sinnlos ist) mal in einer eigenen Klasse dar:

Code:

---

class Bercht
{
public:
      Bercht();      //Konstruktor
    ~Bercht();      //Destruktor

      int calculate(int a, int b) { return a+b;};  // Funktion calculate die zwei Parameter übernimmt und einen Wert als "int" zurückgibt
};

main()
{
    Bercht rhoT;                            // ruft den Konstruktor auf, der aber hier nichts macht außer die Variable rhoT zu erzeugen

    cout << rhoT.calculate(2,4) << endl;    // Ausgabe ist 6

}

---

Das ist aber normal nicht üblich sondern man macht das so:

Code:

---

class Bercht
{
public:
      Bercht();                                    //Standard Konstruktor
      Bercht(int i, int j) : itsA(i), itsB(j) {};  //Überladener Konstruktor; der Doppelpunkt signalisiert -> Werte initialisieren
    ~Bercht();                                    //Destruktor

      int calculate() { return itsA+itsB;};        // Funktion die die internen Variablen heranzieht um die Berechnung durchzuführen

privat:
      int itsA;
      int itsB;
};

main()
{
    Bercht rhoT;                            // ruft den Standard Konstruktor auf
    Bercht rhoTsec (4,8);                  // ruft den überladenen Konstruktor auf

    cout << rhoT.calculate(2,4) << endl;    // Fehler, Funktion existiert nicht

    cout << rhoT.calculate() << endl;      // Ergebnis 0, oder irgendwas unsinniges, da itsA und itsB nicht definiert worden sind.
                                            // Normal werden die Werte dann auf 0 gesetzt

    cout << rhoTsec.calculate() << endl;    // Ergebnis 12
}

---

Wichtig ist dieses Zeile: Bercht rhoTsec (4,8);
Man kann dann auch sowas machen:

Code:

---

class Bercht
{
public:
      Bercht();                                    //Standard Konstruktor

      Bercht (Input(), int a);                  //überladener Konstruktor mit Funktion

    ~Bercht();                                    //Destruktor

     
.
.
.
};

---

So jetzt kommt der springende Punkt. Egal wie du dein Objekt erstellst:

Code:

---

  Bercht  variable1;
  Bercht  variable2(4,2);
  Bercht  variable3(Input(),6); 

---

weiß das Programm genau welchen Konstruktor er braucht und ausführen muss. Das nennt man überladen von Funktionen/Konstruktoren oder allgemein auch unter Polymorphismus bekannt.

Der Sinn ist simple.
Wenn man ein Programm erstellt, dass nur ganzzahlige Berechnungen durchführen kann. Bspw. durch Aufruf einer Funktion:

Code:

---

  var.calculate(4,2);

---

dann ist es nicht möglich eine Dezimalzahl anzugeben wie:

Code:

---

  var.calculate(2.1,4.2);    // Fehler

---

Entsprechend könnte man jetzt eine neue Funktion "calculateDezi()" definieren und diese verwenden. Das ist aber umständlich.
Deswegen definiert man einfach die gleiche Funktion "calculate" mit anderen Übergabeparameter. Das Programm weiß dann selber
in welche Funktion es gehen muss. Dadurch muss man nicht mehr nachdenken, wie die Funktion heißt und nimmt immer calculate().

---------------------------------------------------------------------------------------------------------------------------------------

Zurück zu deinem Problem:

Code:

---

volScalarField rhoT
    (
        IOobject
        (
            "rhoT",
            runTime.timeName(),
            mesh,
            IOobject::NO_READ,
            IOobject::AUTO_WRITE
        ),
        (scalar(1) - alpha)*rhoc
    );

---

Ist das gleiche wie:

Code:

---

volScalarField rhoT (IOobject(), scalar);

---

wobei IOobject eine Funktion darstellt, die wieder Parameter benötigt.

Es ist also eine Definition von rhoT die von der Klasse volScalarField abgeleitet wird. Dabei wird der Konstruktor aufgerufen (siehe oben) und je nach dem was du vorgibst, kann OF das zuordnen. bspw:

Code:

---

volScalarField rhoT (IOobject(), scalar);
volScalarField rhoT (IOobject(), mesh);
volScalarField rhoT (klassey, klassex, klassez, klassek);

---

Was es für Möglichkeiten gibt müsste man nachschauen :)
Aber vllt hilft dir das ja schon etwas (oder auch überhaupt nicht) :(

Versuch mal:

Code:

---

volScalarField rhoT
    (
        IOobject
        (
            "rhoT",
            runTime.timeName(),
            mesh,
            IOobject::NO_READ,
            IOobject::AUTO_WRITE
        ),
        mesh
    );

---

Grüße und viel Erfolg
Tobi

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

und wie wäre es wenn du nur

Code:

---

rhoc = thermo.rhoc();

---

verwendest?
Bin leider nur in dem  thermophysikalischen Modell von Herrn Alberto Cuoci drin und kann somit beim settlingFoam nur "raten" 
Grüße
Tobi

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP