---

DusemitWarmestrom.png

Hallo zusammen,

ich hätte eine kurze Frage zur Angabe einer thermischen Randbedingung. Gibt es eine Möglichkeit einen linear zunehmenden Wärmestrom an einer Fläche zu definieren?

Wie im Bild schematisch dargestellt, möchte ich einen Wärmestrom an einer Fläche (Düse) vorgeben, welcher von links nach rechts linear zunimmt.

Oder muss ich die Gesamtfläche in einzelne Segmente aufteilen und entsprechend den Gradienten auf jeder Teilfläche angeben?

Vielen Dank schon mal für eure Hilfe.

Mit freundlichen Grüßen
Basti

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

---

Hey,

Möglichkeiten gibt es natürlich. Schau mal ob irgendwas bei der Function1 zutreffend ist. Soweit ich weiß könnte da was drin sein. Damals gab es eine Randbedingung die hies... Muss ich morgen mal nachschauen. Alternativ natürlich eine coded Fixed oder coded Mixed boundary condition. Wenn du den gradient spezifiziert, dann die mixed.

Tobi

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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

---

Hallo Tobi,

danke für den Tipp, ich hab es jetzt mal mit codedFixedValue und codedMixed ausprobiert, allerdings nur für die Temperatur (siehe Beispiel-Code).

Code:

---

/*--------------------------------*- C++ -*----------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Version:  8
     \\/     M anipulation  |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       volScalarField;
    object      T;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

dimensions      [0 0 0 1 0 0 0];

internalField   uniform 273;

boundaryField
{
    codedPatch
    {
        type           codedFixedValue;
        value uniform 0;
       
        name codedPatchBC;
       
        code
        #{
        const fvPatch& patch = this->patch();
        const vectorField& cf = patch.Cf();
        const scalar l = 0.2;
        scalarField& field = *this;
       
                forAll(cf,i)
        {
        field[i] = 293 + (100/l)*cf[i].x();
        }
        #};
      
    }
...

---

Ist das Ganze auch in der Art und Weise auf den Wärmestrom [W/m²] übertragbar?

Vielen Dank schon mal für deine Hilfe.

Gruß
Basti

[Diese Nachricht wurde von RevolutionZero am 27. Okt. 2021 editiert.]

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

---

Genau so hab ich das gemeint. Korrekt. Und ja, du kannst das natürlich auch auf den Wärmestrom anwenden. Dazu empfehle ich Dir die Randbedingung externalWallHeatFluxTemperature anzuschauen. Dort kann man auch ein HeatFlux angeben oder eine Leistung. Du kannst daraus entnehmen, wie Du das entsprechend umrechnen musst. Sehr schön. Find ich gut, dass Du gleich mit einem Beispiel kommst. Übrigens meinte ich die timevaryingmappedfixedvalue Randbedingung. Jedoch ist diese RB tatsächlich nur bezüglich Temperatur. Hier kannst also keinen Gradienten oder Wärmestrom angeben. Beim Heat-Flux wirst Du wahrscheinlich eine codedMixed RB benötigen weil Du da nen Gradientenanteil dabei hast.

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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

---

Ok alles klar, dann werde ich das mal mit dieser Randbedingung versuchen und mich dann wieder melden.

Vielen Dank für deine Hilfe.

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

---

HeatFlux.JPG

Ich hab mir heute mal die zugrundeliegenden Formeln von externalWallHeatFluxTemperature (Ansatz 1) und das Fourier'sche Gesetz
(Ansatz 2) angeschaut. Ist es so richtig, dass ich Ansatz 1 nach der Temperatur an der Oberfläche, also refValue, und Ansatz 2
nach dem Temperaturgradienten, also refGrad, umstellen kann? (Siehe dazu angehängtes Bild)

Beim Ansatz 1 weiß ich nicht genau, was ich für den Abstand d einsetzen muss und wie ich diesen Ansatz implementieren soll.
Des Weiteren würde ich gerne wissen, ob hier auch eine codedFixedValue-BC anwendbar wäre?

Ich hab dann mal versucht den Ansatz 2 in der codedmixed-BC zu implementieren, habe allerdings auch hier meine Schwierigkeiten
(siehe Code), bin leider nicht so firm mit C++. Was müsste ich am Code anpassen bzw. ist es überhaupt so umsetzbar?

Code:

---

/*--------------------------------*- C++ -*----------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Version:  8
     \\/     M anipulation  |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       volScalarField;
    object      T;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

dimensions      [0 0 0 1 0 0 0];

internalField   uniform 473;

boundaryField
{
    codedPatch
    {
        type           codedMixed;
       
        refValue    uniform 0;
        refGradient    uniform 0;
        valueFraction    uniform 0;
       
        name codedPatchBC;
       
         code
        #{
        const fvPatch& patch = this->patch();
        const vectorField& cf = patch.Cf();
        const scalar l = 0.1; # Länge der Düse
        const scalar q = 500; # Wärmestrom [w/m²]
        const scalar d = 500; # Delta Wärmestrom [w/m²]
        const scalar lambda = 50; # Wärmeleitfähigkeit [W/mK]
        scalarField& field = 0;
       
        forAll(cf,i)
        {
        field[i] = q + (d/l)*cf[i].x();
    
        this->valueFraction(i) = 0;
        this->refValue(i)      = 0;
        this->refGrad(i)       = -field[i]/lambda;
        }
        #};
      
    }

---

Bin dankbar für jede Hilfe.

Mit freundlichen Grüßen
Basti

[Diese Nachricht wurde von RevolutionZero am 27. Okt. 2021 editiert.]

[Diese Nachricht wurde von RevolutionZero am 27. Okt. 2021 editiert.]

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

---

https://pure.unileoben.ac.at/portal/files/2572654/AC15097410n01.pdf

-> 2.7.2
Gleichung (2.28) ist die Gleichung für die Mixed-BC. Eine genaue Herleitung ist in Anhang A2 gegeben.

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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

---

Erstmal danke für das Dokument und für die Herleitung der zugrundeliegenden Gleichung.

Nach dieser Gleichung habe ich auch versucht meinen Code aufzubauen. Ich hab das Fourier'sche Gesetz nach den Temperaturgradienten umgestellt und die entsprechende Gleichung dann als Temperaturgradient bei refGradient eingesetzt.

Da die Temperatur und der Wärmeübergangskoeffizient unbekannt ist, habe ich den valueFraction auf 0 gesetzt, um somit eine reine Neumann-Randbedingung zu generieren. 

Dann möchte ich den Wärmestrom [W/m²] in Abhängigkeit von der x-Koordinate berechnen und anschließend über das Fourier'sche Gesetz in den Temperaturgradienten umrechnen, um somit den Temperaturgradienten an der Oberfläche vorzugeben.

Ist das überhaupt vom Grundgedanken so möglich oder habe ich einen Denkfehler bei der Herangehensweise? Und wie kann ich dem Temperaturgradienten im Code den entsprechenden Wert in Abhängigkeit von x zuweisen?

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

---

Hey, das ist nicht ganz richtig. Du musst eigentlich Gleichung (A.24) heranziehen. Du musst eineBilanz erstellen und zwar exakt wie (A. 24).zwar sagst du, das Tfarfield und HTC nicht bekannt ist, aber du hast ja deinen warmestrom qK. In deinem Fall eben eine Funktion von x (in W/m2). Heißt, du musst die Gleichung A. 24 auf Tf umstellen. Bei dir is es nochmals einfacher, weil du eben qK nicht von Tf abhängig ist, weil Du ja den warmestrom vorgibst.

Gleichung A. 25 hat auf der rechten Seite dann eben ein qK(x). Da du kein Tp hast, müsste rauskommen, dass es eine reine Gradienten Bedingung ist.

qK(x) ist ein Feld, dass Du halt zuvor erzeugen musst. Am besten machst Du Dir ein neues scalarField mit der Anzahl an faces und bestimmst deinen Wärmfluss in Abhängigkeit von x. Das fließt dann in Deine Bedingung rein.

Das wäre jetzt mal so mein Gedanke, ohne daß ich das genauer Überprüft hätte.

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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

---

Also wenn ichs kurz mal herleite erhalten ich

Tf = Tc + qw(x) delta / lambda

Mit Gleichung 2.25 sieht man dann direkt den Zusammenhang. Das qw(x) muss man eben zuvor bestimmen. Einheit ist Watt. Das hast Du ja bei der Temperatur schon richtig gemacht und sollte kein Problem mehr darstellen.

Wahrscheinlich ist das Ergebnis identisch zu dem, dass Du erst hattest.

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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

---

Hey Tobi,

ok alles klar, vielen Dank. Dann stimmt deine Herleitung mit meiner aus dem Ansatz 1 im vorherigen Bild überein. Müsste die Einheit von qw(x) nicht trotzdem W/m² sein oder?

Aber wenn ich nach der Temperatur umstelle müsste ich eine reine Neumann-Randbedingung erhalten oder? Dann könnte ich mit der codedFixedValue-Randbedingung arbeiten oder?

Hätte jetzt meinen Code wie folgt angepasst. Passt das so?

Code:

---

dimensions      [0 0 0 1 0 0 0];

internalField  uniform 373;

boundaryField
{
    codedPatch
    {
        type          codedFixedValue;
        value uniform 0;
       
        name codedPatchBC;
       
        code
        #{
        const fvPatch& patch = this->patch();
        const vectorField& cf = patch.Cf();
        const scalar l  = 0.1;
        const scalar k  = 50.0;
        const scalar d  = 0.001;
        const scalar Tp = 373.0;
        const scalar q  = 5000000;
        const scalar dq = 5000000;
        scalarField& field = *this;
       
        forAll(cf,i)
        {
        field[i] = Tp + (q + (dq/l)*cf[i].x())*(d/k);
        }
        #};
    }

---

Vom Ergebnis und Verlauf der Temperatur ist es, wie du bereits gesagt hast, annähernd identisch.

Vielen Dank für deine Hilfe!

Schönes Wochenende

Gruß Basti

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

---

Hi Basti,

Neumann Randbedingung ist Gradient und kann man nur mit einer codedMixedValue erreichen

Dirichlet Randbedingung ist eine direkte Wertevorgabe der Größe am Face und kann mit der codedMixedValue umgesetzt werden.

qa(x), ja sollte W/m2 sein.

Einige Fehler und Anmerkungen.

Delta ist der Abstand von Cell Center zu Face Center. Ist also möglicherweise nicht konstant. Musst dir das delta Feld einfach holen (Hinweis, delta in OpenFOAM ist 1/delta,... Sollte in meiner PhD auch drin stehen, auch wie man die deltas bekommt. Such mal nach laserConvectionBC).

Tp ist der Wert am Zellmittelpunkt, also auch falsch wenn Du den Wert vorgibst.

k oder lambda, sofern Du einen Solver hast, der ein Temperaturabhangiges Feld zu k oder lambda hat, das verwenden. Ist das Feld konstant, kannst den Wert auch belassen aber Achtung : änderst du lambda in den thermophysicalProperties musst du das manuell auch in der BC machen. Ist dein Feld Temperaturabhangig, dann natürlich keine andere Wahl als das richtige Feld zu nehmen.

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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

---

Hey Tobi,

vielen Dank für die Rückmeldung und Anmerkungen. Oh ja ich meinte eigentlich die Dirichlet-Randbedingung.

Zitat:

---

Neumann Randbedingung ist Gradient und kann man nur mit einer codedMixedValue erreichen

Dirichlet Randbedingung ist eine direkte Wertevorgabe der Größe am Face und kann mit der codedMixedValue umgesetzt werden.

---

In meinem Fall habe ich ja dann eine direkte Wertvorgabe, wieso ist diese dann nicht mit codedFixedValue umsetzbar?
Bei der codedMixed müsste ich dann Tf einfach refValue zuordnen und refGrad und valueFraction Null setzen, oder?

Zitat:

---

Delta ist der Abstand von Cell Center zu Face Center. Ist also möglicherweise nicht konstant. Musst dir das delta Feld einfach holen (Hinweis, delta in OpenFOAM ist 1/delta,... Sollte in meiner PhD auch drin stehen, auch wie man die deltas bekommt. Such mal nach laserConvectionBC).

Tp ist der Wert am Zellmittelpunkt, also auch falsch wenn Du den Wert vorgibst.

---

Ok für den Abstand verwende ich jetzt const scalarFiels& d = patch.deltaCoeffs() und invertiere dann den Wert entsprechend. Danke für den Tipp mit der laserConvectionBC.

Wie kann ich die Temperatur der Zellmittelpunkte holen? Habe bisher nur folgenden Ansatz gefunden:

Code:

---

const volScalarField& T = mesh().lookupObject<volScalarField>("T");
const volScalarField Tcc = T.mesh().C() & vector(1,1,1); 

---

Dieser Ansatz funktioniert allerdings nicht. Gibt es eine Möglichkeit die Temperatur zu holen, wie auch bei den Koordinaten des Cell Centre und dem Abstand zwischen Cell Centre und Cell Face?

Zitat:

---

k oder lambda, sofern Du einen Solver hast, der ein Temperaturabhangiges Feld zu k oder lambda hat, das verwenden. Ist das Feld konstant, kannst den Wert auch belassen aber Achtung : änderst du lambda in den thermophysicalProperties musst du das manuell auch in der BC machen. Ist dein Feld Temperaturabhangig, dann natürlich keine andere Wahl als das richtige Feld zu nehmen.

---

Alles klar. In meinem Fall würde ich k bzw. lambda konstant halten, da ich hierfür nur einen Richtwert habe.

Danke für deine Hilfe und noch ein schönes Wochenende

Gruß
Basti

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

---

Du hast keine Dirichlet Randbedingung weil Du das nicht weißt:

Code:

---

Tf = Tc + qw(x) delta / lambda

---

• Tc - Zum zugehörigen Face der Zellmittelpunkts Temperaturwert (wird überall anders sein) - kannst Du nicht wissen
  
• qw(x) weißt Du
  
• delta weißt Du nicht (ist Netz abhängig)
  
• lambda weißt Du allgemein auch nicht (außer es ist konstant)
  

Daher ist es ja auch eine Gradientenbedingung und kein Festwertvorgabe (Festwert = Dirichlet = Feste-Temperatur --> dann kannst auch gleich mit fixedValue arbeiten).

Zitat:

---

In meinem Fall habe ich ja dann eine direkte Wertvorgabe, wieso ist diese dann nicht mit codedFixedValue umsetzbar?

---

Du hast eine Gradientenbedingung und keine direkte Vorgabe der Temperatur. Merke: codedFixedValue ist wie fixedValue. Du gibst direkt die Temperatur des Patches vor - willst Du doch nicht, oder?

Zitat:

---

Bei der codedMixed müsste ich dann Tf einfach refValue zuordnen und refGrad und valueFraction Null setzen, oder?

---

Nein. valueFraction ist der Faktor zwischen 0-1 der zwischen Dirichlet und Neumann wechselt bzw. linear interpoliert.

• refValue = Festwert des Faces
  
• refGrad = Gradientenbedingung
  

Bei refValue = 320 und valueFraction = 1 wird die codedMixed ganz einfach zu einer Dirichlet-Bedingung weil Du auf die Faces 320 K ansetzt. In Deinem Fall ist es:

• refValue = Egal --> 0
  
• refGrad = deine Gradientenbedingung
  
• valueFraction = 0 -> reiner Gradient
  

Zitat:

---

Ok für den Abstand verwende ich jetzt const scalarFiels& d = patch.deltaCoeffs() und invertiere dann den Wert entsprechend.

---

Wieso invertieren? Zusätzlicher Rechenaufwand (wenn auch nicht merkbar). Du machst ja auch nicht:

Code:

---

C* = 1/C

A = B*x + 1/C*

--> A = B*x + C

---

Zitat:

---

Wie kann ich die Temperatur der Zellmittelpunkte holen? Habe bisher nur folgenden Ansatz gefunden:

---

Na das brauchst Du nicht. Schau nochmals die Gleichungen an und was Du in der codedMixed als Parameter setzt. Bzw. schau meine Diss nochmals an.

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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

---

Danke für die Rückmeldung und danke, dass du dir Zeit für mein Problem nimmst.

Ja ich möchte eine Gradientenbedingung umsetzen. Dann haben meine Parameter im codedMixed-Code eigentlich soweit gepasst oder?

Aber ich habe denk ich noch ein Verständnisproblem. Der Gradient ist doch (Tp-Tf)/dx bzw. dT/dx und meine Gradientenbedingung ist doch dann -q(x)/lambda, oder? Müsste doch auf die Einheit [K/m] kommen und dx müsste doch mein delta sein, wieso muss ich mir dieses dann holen?

Dann würde ich wie ich bereits in codedMixed-Code beschrieben habe, erst mein q(x) berechnen und anschließend mit der Gradientenbedingung meinen refGrad bestimmen. Aber wie weise ich dem refGrad meine Gradientenbedingung zu?

Zitat:

---

dimensions      [0 0 0 1 0 0 0];

internalField  uniform 373;

boundaryField
{
    codedPatch
    {
        type          codedMixed;
     
        refValue        uniform 0;
        refGradient      uniform 0;
        valueFraction    uniform 0;
     
        name codedPatchBC;
     
        code
        #{
        const fvPatch& patch = this->patch();
        const vectorField& cf = patch.Cf();
        const scalar l = 0.1;                        # Länge der Düse
        const scalar q = 500000;                    # Wärmestrom [w/m²]
        const scalar dq = 500000;                    # Delta Wärmestrom [w/m²]
        const scalar lambda = 50;                  # Wärmeleitfähigkeit [W/mK]
        scalarField& field = 0;
     
        forAll(cf,i)
        {
        field[i] = q + (dq/l)*cf[i].x();
   
        this->valueFraction(i) = 0;
        this->refValue(i)      = 0;
        this->refGrad(i)      = -field[i]/lambda;
        }
        #};
     
    }

---

Nochmal vielen Dank, dass du dir hierfür Zeit nimmst und sorry für die Verständnisprobleme.

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

---

Gleichung.png

Status Quo:

Die codedMixed hat folgende Form:

• Zeta ist deine valueFraction = 0, damit fällt der erste Summand (Diriclet) heraus und es bleibt nur der zweite Term (Gradient) übrig.
• Man sieht es ja direkt. Der Wert des Faces (der Boundary) ist identisch zu Zellwert + Gradient. Den Gradient musst Du in der gradRef vorgeben.
  
• Wie bereits erwähnt und hergeleitet erhältst Du unter Berücksichtigung des Energiegleichgewichts (haben wir auch schon besprochen) folgendes:
  

Code:

---

Tf = Tc + qw(x) delta / lambda

---

oder

Code:

---

Tf = valueFraction * T_festwert + (1 - valueFraction) * [ Tc + qw(x) delta / lambda]

---

Solltest Du was anderes rausbekommen, dann gib Bescheid. Natürlich ist die valueFraciton 0, und somit sind beide Gleichungen identisch. Letztere ist nur in Anlehnung an Gleichung (2.28) ggf. logischer. In der Herleitung siehst du ja, dass

Code:

---

qw(x) delta / lambda

---

der Analogterm ist wie in Gleichung (2.28) der letzte Term. Und der letzte Term ist ja der Gradient. Soweit sollte es klar sein, oder?

Dieser Code hier:

Code:

---

code
        #{
        const fvPatch& patch = this->patch();
        const vectorField& cf = patch.Cf();
        const scalar l = 0.1;                        # Länge der Düse
        const scalar q = 500000;                    # Wärmestrom [w/m²]
        const scalar dq = 500000;                    # Delta Wärmestrom [w/m²]
        const scalar lambda = 50;                  # Wärmeleitfähigkeit [W/mK]
        scalarField& field = 0;
   
        forAll(cf,i)
        {
        field[ i] = q + (dq/l)*cf[ i].x();
 
        this->valueFraction(i) = 0;
        this->refValue(i)      = 0;
        this->refGrad(i)      = -field[ i]/lambda;
        }
        #};

---

ist nicht gut lesbar. Benenne doch das Feld field zu qwx (machts zumindest einfacher für andere). Das field ist zunächst mal falsch deklariert. Du machst nen scalarField mit Array-Größe Null. Dann schreibst Du irgendwo in den Arbeitsspeicher irgendwas (das wird nicht gut gehen außer Du hast Glück) --> anpassen. Auch eine "Referenz" kann nicht funktionieren. Auf was referenzierst Du Dich denn ;)

Code:

---

scalarField& field = 0; // Kompiler-Fehler - macht 0 Sinn

// wenn dann schon so
scalarField qwx (cf.size(), 0.);

---

Ich entnehme dann aus Deiner RB, dass du von 500.000 W/m² auf 1.000.000 W/m² linear ansteigst (sind die Werte korrekt?). Anschließend ist soweit alles korrekt, außer das Dein delta Feld fehlt.

Einheiten
Ich hab mal die laserConvectionBC nochmals angeschaut.
Die refGrad hat die Einheit K/m, wobei ich da nicht mehr ganz weiß wieso das im Code so ist, da ich in der Gleichung und Herleitung eigentlich das Delta drin hab. Aber wahrscheinlich, weil in Gleichung (2.28) das Delta auch drin ist, und eben in dem Term den wir betrachten auch:

Code:

---

Tf = Tc + qw(x) delta / lambda

// Mit Foam delta folgt:
Tf = Tc + gw(x) / (lambda * delta) --> Analogie zu Gl. (2.28) folgt, der Gradient ist gw(x)/lambda

---

Entsprechend hast dann (wie bei Dir im Code schon richtig) nur gw(x)/lambda.

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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

---

Test.png

Hallo Tobi,

vielen Dank für die ausführliche Erklärung. Die zugrundeliegenden Gleichungen habe ich denk ich nun verstanden.

Ich habe jetzt meinen Code entsprechend nochmal angepasst. Bei den Wärmeströmen hatte ich eine 0 zu viel.

Code:

---

/*--------------------------------*- C++ -*----------------------------------*\
  =========                |
  \\      /  F ield        | OpenFOAM: The Open Source CFD Toolbox
  \\    /  O peration    | Website:  https://openfoam.org
    \\  /    A nd          | Version:  8
    \\/    M anipulation  |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version    2.0;
    format      ascii;
    class      volScalarField;
    object      T;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

dimensions      [0 0 0 1 0 0 0];

internalField  uniform 373;

boundaryField
{
    codedPatch // Fläche oben
    {
        type          codedMixed;
       
        refValue uniform 0;
        refGradient uniform 0;
        valueFraction uniform 0;
       
        name codedPatchBC;

        const fvPatch& patch  = this->patch();
        const vectorField& cf = patch.Cf();
        const scalar l  = 0.1;             // Länge [m]
        const scalar lambda  = 50.0;       // Wärmeleitfähigkeit [W/mK]
        const scalar q  = 50000;             // Ausgangs-Wärmestrom [W/m²]
        const scalar dq = 50000;             // Delta Wärmestrom [W/m²]
        scalarField  qwx (cf.size(),0.);       // Skalares Feld für Wärmestrom
       
        forAll(cf,i)
        {
        qwx[i] = q + (dq/l)*cf[i].x();
       
        this->valueFraction(i) = 0;
        this->refValue(i) = 0;
        this->refGrad(i) = qwx[i]/lambda;
        }
    } 

    lrbPatch // Fläche links, rechts und unten
    {
        type            zeroGradient;
    }
   
    frontAndBack // Fläche vorn und hinten
    {
        type            empty;
    }   

}

// ************************************************************************* //

---

Ich habe die Randbedingung nun auch mal an einem einfachen Beispiel mit laplacianFoam ausgetestet.
Allerdings steigt die Temperatur nicht an, sondern bleibt bei den 373 K vom internalField.
Zudem ist auch kein Anstieg von links nach rechts feststellbar. Ein Bild habe ich mal angehängt.

Liegt hier noch ein Fehler im Code vor? Eigentlich müsste doch die Temperatur mit der Zeit ansteigen.

Danke für deine Hilfe!

Gruß
Basti

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

---

Also ich hab das noch nie so gesehen wie Du es machst. Zumal die Klammern hinter refGrad falsch sind (oder war das zwecks Formatierung?).

Mach mal folgendes.

Code:

---

forAll(cf, I)
{
    Qwx[I] = (q +...) /lambda
}

this->refGrad() = Qwx;
this->valueFraction() = 0;
this->refValue() = 0;

---

Wenn das nichts zeigt, setz mal die fraction auf 1 und den Qwx auf refValue. Zumindest müsste im ersten Zeitschritt dann eine (unphysikalische aber zu Testzwecken) Temperaturverteilung rauskommen.

Tobi

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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

---

Hallo Tobi,

oh ja stimmt, die Klammern sind falsch. Ich habe mal deine beiden Ansätze ausgetestet, allerdings ohne Erfolg.

Hab dann nochmal meinen Code mit meiner codedFixedValue-BC verglichen und den Fehler gefunden.
Habe die Code-Klammern bei der codedMixed-BC vergessen. Jetzt funktioniert der Code auch so wie gewünscht.

Code:

---

/*--------------------------------*- C++ -*----------------------------------*\
  =========                |
  \\      /  F ield        | OpenFOAM: The Open Source CFD Toolbox
  \\    /  O peration    | Website:  https://openfoam.org
    \\  /    A nd          | Version:  8
    \\/    M anipulation  |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version    2.0;
    format      ascii;
    class      volScalarField;
    object      T;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

dimensions      [0 0 0 1 0 0 0];

internalField  uniform 373;

boundaryField
{
    codedPatch
    {
      type          codedMixed;
       
      refValue uniform 0;
      refGradient uniform 0;
      valueFraction uniform 0;
       
      name codedPatchBC;
   
    code
    #{
    const fvPatch& patch  = this->patch();
    const vectorField& cf = patch.Cf();
    const scalar l  = 0.1; // Länge [m]
    const scalar lambda  = 50.0; // Wärmeleitfähigkeit [W/mK]
    const scalar q  = 50000; // Ausgangs-Wärmestrom [W/m²]
    const scalar dq = 50000; // Delta Wärmestrom [W/m²]
    scalarField  Qwx (cf.size(),0.); // Skalares Feld für Wärmestrom
       
    forAll(cf,I)
    {
          Qwx[I] = (q + (dq/l)*cf[I].x())/lambda;
    }

    this->valueFraction()  = 0;
    this->refValue() = 0;
    this->refGrad() = Qwx;
    #};
    } 

    lrbPatch
    {
        type            zeroGradient;
    }
   
    frontAndBack
    {
        type            empty;
    }   

}

// ************************************************************************* //

---

Vielen Dank für deine Hilfe und Unterstützung, Tobi!

Gruß
Basti

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

---

Da hab ich auf m Smartphone gar nicht gesehen   aber schön wenn es jetzt klappt. Freut mich und gerne.
Eine freiwillige Spende kannst du natürlich jederzeit auf meiner Seite tätigen 

------------------
Glück Auf,
Tobi

OpenFOAM® Community - Knowledge Base

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