Example #1
0
vector Random::position(const vector& start, const vector& end)
{
    vector rndVec(start);

    for (direction cmpt=0; cmpt<vector::nComponents; cmpt++)
    {
        rndVec.component(cmpt) +=
            scalar01()*(end.component(cmpt) - start.component(cmpt));
    }

    return rndVec;
}
void Foam::myVelocityFvPatchVectorField::updateCoeffs()
{
    if (this->updated())
    {
        return;
    }

    // Variablen/ Felder
    const volVectorField& u = db().lookupObject<volVectorField>("u");
    //fvPatchVectorField& u_b = *this;
    tmp<vectorField> tu_b = *this;
    vectorField& u_b = tu_b();

    const tmp<vectorField> tn = this->patch().nf();
    const vectorField& n = tn();

    tmp<volTensorField> tGradU = fvc::grad(u);
    const volTensorField gradU = tGradU();
    tmp<vectorField> tD = patch().delta();
    const vectorField& D = tD();
    const labelList& bcs = patch().faceCells();

    for(int i=0; i<patch().size(); i++) {

        const label bc = bcs[i];
        const vector normal = n[i];
        const tensor Jac_u = gradU[bc];
        const vector u_bc = u[bc];
        const vector Di = D[i];

        vector u_b_extrapolated;

        u_b_extrapolated.component(0) = u_bc.component(0) +
                                        Jac_u.component(tensor::XX) * Di.component(0) +
                                        Jac_u.component(tensor::XY) * Di.component(1) +
                                        Jac_u.component(tensor::XZ) * Di.component(2);

        u_b_extrapolated.component(1) = u_bc.component(1) +
                                        Jac_u.component(tensor::YX) * Di.component(0) +
                                        Jac_u.component(tensor::YY) * Di.component(1) +
                                        Jac_u.component(tensor::YZ) * Di.component(2);

        u_b_extrapolated.component(2) = u_bc.component(2) +
                                        Jac_u.component(tensor::ZX) * Di.component(0) +
                                        Jac_u.component(tensor::ZY) * Di.component(1) +
                                        Jac_u.component(tensor::ZZ) * Di.component(2);

        u_b[i] = u_b_extrapolated - (u_b_extrapolated & normal) * normal;

    }

    //Info << u_b << endl;

    fixedValueFvPatchVectorField::updateCoeffs();     // updated_ = true

}
Example #3
0
Foam::STARCDCoordinateRotation::STARCDCoordinateRotation
(
    const vector& rotZrotXrotY,
    const bool inDegrees
)
:
    coordinateRotation()
{
    calcTransform
    (
        rotZrotXrotY.component(vector::X),
        rotZrotXrotY.component(vector::Y),
        rotZrotXrotY.component(vector::Z),
        inDegrees
    );
}