Test-momentOfInertia.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 =========                   |
 \\      /   F ield          | OpenFOAM: The Open Source CFD Toolbox
  \\    /    O peration      |
   \\  /     A nd            | Copyright (C) 2011-2013 OpenFOAM Foundation
    \\/      M anipulation   |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.
 
    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.
 
    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
Application
    momentOfInertiaTest
 
Description
    Calculates the inertia tensor and principal axes and moments of a
    test face, tetrahedron and cell.
 
\*---------------------------------------------------------------------------*/
 
#include "argList.H"
#include "Time.H"
#include "polyMesh.H"
#include "ListOps.H"
#include "face.H"
#include "tetrahedron.H"
#include "triFaceList.H"
#include "OFstream.H"
#include "meshTools.H"
#include "momentOfInertia.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
using namespace Foam;
 
int main(int argc, char *argv[])
{
    argList::addOption
    (
        "cell",
        "label",
        "cell to use for inertia calculation, defaults to 0"
    );
 
    #include "setRootCase.H"
    #include "createTime.H"
    #include "createPolyMesh.H"
 
    scalar density = 1.0;
 
    {
        label nPts = 6;
 
        pointField pts(nPts);
 
        pts[0] = point(4.495, 3.717, -4.112);
        pts[1] = point(4.421, 3.932, -4.112);
        pts[2] = point(4.379, 4.053, -4.112);
        pts[3] = point(4.301, 4.026, -4.300);
        pts[4] = point(4.294, 4.024, -4.317);
        pts[5] = point(4.409, 3.687, -4.317);
 
        face f(identity(nPts));
 
        point Cf = f.centre(pts);
 
        tensor J = tensor::zero;
 
        J = f.inertia(pts, Cf, density);
 
        vector eVal = eigenValues(J);
 
        tensor eVec = eigenVectors(J);
 
        Info<< nl << "Inertia tensor of test face " << J << nl
            << "eigenValues (principal moments) " << eVal << nl
            << "eigenVectors (principal axes) " << eVec
            << endl;
 
        OFstream str("momentOfInertiaTestFace.obj");
 
        Info<< nl << "Writing test face and scaled principal axes to "
            << str.name() << endl;
 
        forAll(pts, ptI)
        {
            meshTools::writeOBJ(str, pts[ptI]);
        }
 
        str << "l";
 
        forAll(f, fI)
        {
            str << ' ' << fI + 1;
        }
 
        str << " 1" << endl;
 
        scalar scale = mag(Cf - pts[f[0]])/eVal.component(findMin(eVal));
 
        meshTools::writeOBJ(str, Cf);
        meshTools::writeOBJ(str, Cf + scale*eVal.x()*eVec.x());
        meshTools::writeOBJ(str, Cf + scale*eVal.y()*eVec.y());
        meshTools::writeOBJ(str, Cf + scale*eVal.z()*eVec.z());
 
        for (label i = nPts + 1; i < nPts + 4; i++)
        {
            str << "l " << nPts + 1 << ' ' << i + 1 << endl;
        }
    }
 
    {
        label nPts = 4;
 
        pointField pts(nPts);
 
        pts[0] = point(0, 0, 0);
        pts[1] = point(1, 0, 0);
        pts[2] = point(0.5, 1, 0);
        pts[3] = point(0.5, 0.5, 1);
 
        tetPointRef tet(pts[0], pts[1], pts[2], pts[3]);
 
        triFaceList tetFaces(4);
 
        tetFaces[0] = triFace(0, 2, 1);
        tetFaces[1] = triFace(1, 2, 3);
        tetFaces[2] = triFace(0, 3, 2);
        tetFaces[3] = triFace(0, 1, 3);
 
        scalar m = 0.0;
        vector cM = vector::zero;
        tensor J = tensor::zero;
 
        momentOfInertia::massPropertiesSolid(pts, tetFaces, density, m, cM, J);
 
        vector eVal = eigenValues(J);
 
        tensor eVec = eigenVectors(J);
 
        Info<< nl
            << "Mass of tetrahedron " << m << nl
            << "Centre of mass of tetrahedron " << cM << nl
            << "Inertia tensor of tetrahedron " << J << nl
            << "eigenValues (principal moments) " << eVal << nl
            << "eigenVectors (principal axes) " << eVec
            << endl;
 
        OFstream str("momentOfInertiaTestTet.obj");
 
        Info<< nl << "Writing test tetrahedron and scaled principal axes to "
            << str.name() << endl;
 
        forAll(pts, ptI)
        {
            meshTools::writeOBJ(str, pts[ptI]);
        }
 
        forAll(tetFaces, tFI)
        {
            const triFace& f = tetFaces[tFI];
 
            str << "l";
 
            forAll(f, fI)
            {
                str << ' ' << f[fI] + 1;
            }
 
            str << ' ' << f[0] + 1 << endl;
        }
 
        scalar scale = mag(cM - pts[0])/eVal.component(findMin(eVal));
 
        meshTools::writeOBJ(str, cM);
        meshTools::writeOBJ(str, cM + scale*eVal.x()*eVec.x());
        meshTools::writeOBJ(str, cM + scale*eVal.y()*eVec.y());
        meshTools::writeOBJ(str, cM + scale*eVal.z()*eVec.z());
 
        for (label i = nPts + 1; i < nPts + 4; i++)
        {
            str << "l " << nPts + 1 << ' ' << i + 1 << endl;
        }
    }
 
    {
        const label cellI = args.optionLookupOrDefault("cell", 0);
 
        tensorField mI(momentOfInertia::meshInertia(mesh));
 
        tensor& J = mI[cellI];
 
        vector eVal = eigenValues(J);
 
        Info<< nl
            << "Inertia tensor of cell " << cellI << " " << J << nl
            << "eigenValues (principal moments) " << eVal << endl;
 
        J /= cmptMax(eVal);
 
        tensor eVec = eigenVectors(J);
 
        Info<< "eigenVectors (principal axes, from normalised inertia) " << eVec
            << endl;
 
        OFstream str("cell_" + name(cellI) + "_inertia.obj");
 
        Info<< nl << "Writing scaled principal axes of cell " << cellI << " to "
            << str.name() << endl;
 
        const point& cC = mesh.cellCentres()[cellI];
 
        scalar scale = mag
        (
            (cC - mesh.faceCentres()[mesh.cells()[cellI][0]])
           /eVal.component(findMin(eVal))
        );
 
        meshTools::writeOBJ(str, cC);
        meshTools::writeOBJ(str, cC + scale*eVal.x()*eVec.x());
        meshTools::writeOBJ(str, cC + scale*eVal.y()*eVec.y());
        meshTools::writeOBJ(str, cC + scale*eVal.z()*eVec.z());
 
        for (label i = 1; i < 4; i++)
        {
            str << "l " << 1 << ' ' << i + 1 << endl;
        }
    }
 
    Info<< nl << "End" << nl << endl;
 
    return 0;
}
 
 
// ************************************************************************* //