zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ENH: Deleting parabolicCylindricalCS, sphericalCS and toroidalCS

Browse Source 
coordinate systems
Modifying constructors from dictionary of coordinateSystem class (no
default type)
Adding localAxesRotation type. It constructs a axes-rotation tensor on each
cell centre.
Adding functionality to coordinateRotation blase class (transformTensor,
transformVector, etc)
This commit is contained in:
sergio
2013-01-21 12:17:17 +00:00
parent 740c4fa8fa
commit 685635e6a3
35 changed files with 2244 additions and 1467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/engine/enginePiston/enginePiston.C
View File

@ -63,7 +63,7 @@ Foam::enginePiston::enginePiston
(
coordinateSystem::New
(
"coordinateSystem",
mesh_,
dict.subDict("coordinateSystem")
)
),

2
src/engine/engineValve/engineValve.C
View File

@ -125,7 +125,7 @@ Foam::engineValve::engineValve
(
coordinateSystem::New
(
"coordinateSystem",
mesh_,
dict.subDict("coordinateSystem")
)
),

8
src/fvOptions/sources/derived/rotorDiskSource/rotorDiskSource.C
View File

@ -92,7 +92,7 @@ void Foam::fv::rotorDiskSource::checkData()
(
readScalar(coeffs_.lookup("inletNormalVelocity"))
);
inletVelocity_ = -coordSys_.e3()*UIn;
inletVelocity_ = -coordSys_.R().e3()*UIn;
break;
}
case ifLocal:
@ -345,9 +345,9 @@ void Foam::fv::rotorDiskSource::createCoordinateSystem()
<< " - disk diameter = " << diameter << nl
<< " - disk area = " << sumArea << nl
<< " - origin = " << coordSys_.origin() << nl
<< " - r-axis = " << coordSys_.e1() << nl
<< " - psi-axis = " << coordSys_.e2() << nl
<< " - z-axis = " << coordSys_.e3() << endl;
<< " - r-axis = " << coordSys_.R().e1() << nl
<< " - psi-axis = " << coordSys_.R().e2() << nl
<< " - z-axis = " << coordSys_.R().e3() << endl;
}

6
src/fvOptions/sources/derived/rotorDiskSource/trimModel/targetCoeff/targetCoeffTrim.C
View File

@ -59,9 +59,9 @@ Foam::vector Foam::targetCoeffTrim::calcCoeffs
const List<point>& x = rotor_.x();
const vector& origin = rotor_.coordSys().origin();
const vector& rollAxis = rotor_.coordSys().e1();
const vector& pitchAxis = rotor_.coordSys().e2();
const vector& yawAxis = rotor_.coordSys().e3();
const vector& rollAxis = rotor_.coordSys().R().e1();
const vector& pitchAxis = rotor_.coordSys().R().e2();
const vector& yawAxis = rotor_.coordSys().R().e3();
scalar coeff1 = alpha_*sqr(rotor_.omega())*mathematical::pi;

7
src/meshTools/Make/files
View File

@ -14,12 +14,13 @@ $(csys)/coordinateSystem.C
$(csys)/coordinateSystemNew.C
$(csys)/coordinateSystems.C
$(csys)/cylindricalCS.C
$(csys)/sphericalCS.C
$(csys)/parabolicCylindricalCS.C
$(csys)/toroidalCS.C
$(csys)/cartesianCS.C
$(csys)/coordinateRotation/axesRotation.C
$(csys)/coordinateRotation/coordinateRotation.C
$(csys)/coordinateRotation/coordinateRotationNew.C
$(csys)/coordinateRotation/EulerCoordinateRotation.C
$(csys)/coordinateRotation/STARCDCoordinateRotation.C
$(csys)/coordinateRotation/localAxesRotation.C
edgeFaceCirculator/edgeFaceCirculator.C

162
src/meshTools/coordinateSystems/cartesianCS.C Normal file
View File

@ -0,0 +1,162 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
\*---------------------------------------------------------------------------*/
#include "cartesianCS.H"
#include "one.H"
#include "mathematicalConstants.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(cartesianCS, 0);
addToRunTimeSelectionTable(coordinateSystem, cartesianCS, dictionary);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::cartesianCS::cartesianCS()
:
coordinateSystem()
{}
Foam::cartesianCS::cartesianCS
(
const coordinateSystem& cs
)
:
coordinateSystem(cs)
{}
Foam::cartesianCS::cartesianCS
(
const word& name,
const coordinateSystem& cs
)
:
coordinateSystem(name, cs)
{}
Foam::cartesianCS::cartesianCS
(
const word& name,
const point& origin,
const coordinateRotation& cr
)
:
coordinateSystem(name, origin, cr)
{}
Foam::cartesianCS::cartesianCS
(
const word& name,
const point& origin,
const vector& axis,
const vector& dirn
)
:
coordinateSystem(name, origin, axis, dirn)
{}
Foam::cartesianCS::cartesianCS
(
const word& name,
const dictionary& dict
)
:
coordinateSystem(name, dict)
{}
Foam::cartesianCS::cartesianCS
(
const objectRegistry& obr,
const dictionary& dict
)
:
coordinateSystem(obr, dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cartesianCS::~cartesianCS()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::vector Foam::cartesianCS::localToGlobal
(
const vector& local,
bool translate
) const
{
return coordinateSystem::localToGlobal(local, translate);
}
Foam::tmp<Foam::vectorField> Foam::cartesianCS::localToGlobal
(
const vectorField& local,
bool translate
) const
{
return coordinateSystem::localToGlobal(local, translate);
}
Foam::vector Foam::cartesianCS::globalToLocal
(
const vector& global,
bool translate
) const
{
return coordinateSystem::globalToLocal(global, translate);
}
Foam::tmp<Foam::vectorField> Foam::cartesianCS::globalToLocal
(
const vectorField& global,
bool translate
) const
{
return coordinateSystem::globalToLocal(global, translate);
}
// ************************************************************************* //

59
src/meshTools/coordinateSystems/sphericalCS.H → src/meshTools/coordinateSystems/cartesianCS.H
View File

@ -22,20 +22,21 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::sphericalCS
Foam::cartesianCS
Description
Spherical coordinate system
Cylindrical coordinate system
SourceFiles
sphericalCS.C
cartesianCS.C
\*---------------------------------------------------------------------------*/
#ifndef sphericalCS_H
#define sphericalCS_H
#ifndef cartesianCS_H
#define cartesianCS_H
#include "coordinateSystem.H"
#include "typeInfo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -43,23 +44,18 @@ namespace Foam
{
/*---------------------------------------------------------------------------*\
Class sphericalCS Declaration
Class cartesianCS Declaration
\*---------------------------------------------------------------------------*/
class sphericalCS
class cartesianCS
:
public coordinateSystem
{
// Private data members
//- Are angles in degrees? (default = true)
bool inDegrees_;
protected:
// Protected Member Functions
//- Convert from local coordinate system to the global Cartesian system
// with optional translation for the origin
virtual vector localToGlobal(const vector&, bool translate) const;
@ -88,61 +84,58 @@ protected:
public:
//- Runtime type information
TypeName("spherical");
TypeName("cartesian");
// Constructors
//- Construct null
sphericalCS(const bool inDegrees=true);
cartesianCS();
//- Construct copy
sphericalCS
cartesianCS
(
const coordinateSystem&,
const bool inDegrees=true
const coordinateSystem&
);
//- Construct copy with a different name
sphericalCS
cartesianCS
(
const word& name,
const coordinateSystem&,
const bool inDegrees=true
const coordinateSystem&
);
//- Construct from origin and rotation
sphericalCS
cartesianCS
(
const word& name,
const point& origin,
const coordinateRotation&,
const bool inDegrees=true
const coordinateRotation&
);
//- Construct from origin and 2 axes
sphericalCS
cartesianCS
(
const word& name,
const point& origin,
const vector& axis,
const vector& dirn,
const bool inDegrees=true
const vector& dirn
);
//- Construct from dictionary
sphericalCS(const word& name, const dictionary&);
cartesianCS(const word&, const dictionary&);
// Member Functions
//- Construct from dictionary and objectRegistry
cartesianCS(const objectRegistry&, const dictionary&);
//- Are angles in degrees?
bool inDegrees() const;
//- Non-const access to inDegrees
bool& inDegrees();
//- Destructor
virtual ~cartesianCS();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

170
src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.C
View File

@ -39,8 +39,134 @@ namespace Foam
EulerCoordinateRotation,
dictionary
);
addToRunTimeSelectionTable
(
coordinateRotation,
EulerCoordinateRotation,
objectRegistry
);
}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::vector Foam::EulerCoordinateRotation::transform(const vector& st) const
{
return (R_ & st);
}
Foam::vector Foam::EulerCoordinateRotation::invTransform
(
const vector& st
) const
{
return (Rtr_ & st);
}
Foam::tmp<Foam::vectorField> Foam::EulerCoordinateRotation::transform
(
const vectorField& st
) const
{
notImplemented
(
"tmp<vectorField> Foam::EulerCoordinateRotation:: "
"transform(const vectorField& st) const"
);
return tmp<vectorField>(NULL);
}
Foam::tmp<Foam::vectorField> Foam::EulerCoordinateRotation::invTransform
(
const vectorField& st
) const
{
notImplemented
(
"tmp<vectorField> Foam::EulerCoordinateRotation::"
"invTransform(const vectorField& st) const"
);
return tmp<vectorField>(NULL);
}
const Foam::tensorField& Foam::EulerCoordinateRotation::Tr() const
{
notImplemented
(
"const tensorField& EulerCoordinateRotation::Tr() const"
);
return *reinterpret_cast<const tensorField*>(0);
}
Foam::tmp<Foam::tensorField> Foam::EulerCoordinateRotation::transformTensor
(
const tensorField& st
) const
{
notImplemented
(
"const tensorField& EulerCoordinateRotation::transformTensor() const"
);
return tmp<tensorField>(NULL);
}
Foam::tensor Foam::EulerCoordinateRotation::transformTensor
(
const tensor& st
) const
{
return (R_ & st & Rtr_);
}
Foam::tmp<Foam::tensorField> Foam::EulerCoordinateRotation::transformTensor
(
const tensorField& st,
const labelList& cellMap
) const
{
notImplemented
(
"tmp<Foam::tensorField> EulerCoordinateRotation::transformTensor "
" const tensorField& st,"
" const labelList& cellMap "
") const"
);
return tmp<tensorField>(NULL);
}
Foam::tmp<Foam::symmTensorField> Foam::EulerCoordinateRotation::
transformVector
(
const vectorField& st
) const
{
tmp<symmTensorField> tfld(new symmTensorField(st.size()));
symmTensorField& fld = tfld();
forAll(fld, i)
{
fld[i] = transformPrincipal(R_, st[i]);
}
return tfld;
}
Foam::symmTensor Foam::EulerCoordinateRotation::transformVector
(
const vector& st
) const
{
return transformPrincipal(R_, st);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::EulerCoordinateRotation::calcTransform
@ -62,7 +188,7 @@ void Foam::EulerCoordinateRotation::calcTransform
psi *= constant::mathematical::pi/180.0;
}
tensor::operator=
R_ =
(
tensor
(
@ -79,6 +205,8 @@ void Foam::EulerCoordinateRotation::calcTransform
cos(theta)
)
);
Rtr_ = R_.T();
}
@ -86,7 +214,8 @@ void Foam::EulerCoordinateRotation::calcTransform
Foam::EulerCoordinateRotation::EulerCoordinateRotation()
:
coordinateRotation()
R_(sphericalTensor::I),
Rtr_(R_)
{}
@ -96,7 +225,8 @@ Foam::EulerCoordinateRotation::EulerCoordinateRotation
const bool inDegrees
)
:
coordinateRotation()
R_(sphericalTensor::I),
Rtr_(R_)
{
calcTransform
(
@ -116,7 +246,8 @@ Foam::EulerCoordinateRotation::EulerCoordinateRotation
const bool inDegrees
)
:
coordinateRotation()
R_(sphericalTensor::I),
Rtr_(R_)
{
calcTransform(phiAngle, thetaAngle, psiAngle, inDegrees);
}
@ -127,7 +258,8 @@ Foam::EulerCoordinateRotation::EulerCoordinateRotation
const dictionary& dict
)
:
coordinateRotation()
R_(sphericalTensor::I),
Rtr_(R_)
{
vector rotation(dict.lookup("rotation"));
@ -141,4 +273,32 @@ Foam::EulerCoordinateRotation::EulerCoordinateRotation
}
Foam::EulerCoordinateRotation::EulerCoordinateRotation
(
const dictionary& dict,
const objectRegistry&
)
:
R_(sphericalTensor::I),
Rtr_(R_)
{
vector rotation(dict.lookup("rotation"));
calcTransform
(
rotation.component(vector::X),
rotation.component(vector::Y),
rotation.component(vector::Z),
dict.lookupOrDefault("degrees", true)
);
}
void Foam::EulerCoordinateRotation::write(Ostream& os) const
{
os.writeKeyword("e1") << e1() << token::END_STATEMENT << nl;
os.writeKeyword("e2") << e2() << token::END_STATEMENT << nl;
os.writeKeyword("e3") << e3() << token::END_STATEMENT << nl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

97
src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.H
View File

@ -65,6 +65,16 @@ class EulerCoordinateRotation
:
public coordinateRotation
{
// Private Member Data
//- Local-to-global transformation tensor
tensor R_;
//- Global-to-Local transformation tensor
tensor Rtr_;
// Private Member Functions
//- Calculate transformation tensor
@ -107,6 +117,93 @@ public:
//- Construct from dictionary
EulerCoordinateRotation(const dictionary&);
//- Construct from dictionary and mesh
EulerCoordinateRotation(const dictionary&, const objectRegistry&);
// Member Functions
//- Reset rotation to an identity rotation
virtual void clear()
{
R_ = sphericalTensor::I;
Rtr_ = sphericalTensor::I;
}
//- Return local-to-global transformation tensor
virtual const tensor& R() const
{
return R_;
}
//- Return global-to-local transformation tensor
virtual const tensor& Rtr() const
{
return Rtr_;
};
//- Return local Cartesian x-axis
virtual const vector e1() const
{
return R_.x();
}
//- Return local Cartesian y-axis
virtual const vector e2() const
{
return R_.y();
}
//- Return local Cartesian z-axis
virtual const vector e3() const
{
return R_.z();
}
//- Return transformation tensor field
virtual const tensorField& Tr() const;
//- Transform vectorField using transformation tensor field
virtual tmp<vectorField> transform(const vectorField& st) const;
//- Transform vector using transformation tensor
virtual vector transform(const vector& st) const;
//- Inverse transform vectorField using transformation tensor field
virtual tmp<vectorField> invTransform(const vectorField& st) const;
//- Inverse transform vector using transformation tensor
virtual vector invTransform(const vector& st) const;
//- Transform tensor field using transformation tensorField
virtual tmp<tensorField> transformTensor(const tensorField& st) const;
//- Transform tensor using transformation tensorField
virtual tensor transformTensor(const tensor& st) const;
//- Transform tensor sub-field using transformation tensorField
virtual tmp<tensorField> transformTensor
(
const tensorField& st,
const labelList& cellMap
) const;
//- Transform vectorField using transformation tensorField and return
// symmetrical tensorField
virtual tmp<symmTensorField> transformVector
(
const vectorField& st
) const;
//- Transform vector using transformation tensor and return
// symmetrical tensor
virtual symmTensor transformVector(const vector& st) const;
// Write
//- Write
virtual void write(Ostream&) const;
};

167
src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.C
View File

@ -39,9 +39,134 @@ namespace Foam
STARCDCoordinateRotation,
dictionary
);
addToRunTimeSelectionTable
(
coordinateRotation,
STARCDCoordinateRotation,
objectRegistry
);
}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::vector Foam::STARCDCoordinateRotation::transform(const vector& st) const
{
return (R_ & st);
}
Foam::vector Foam::STARCDCoordinateRotation::invTransform
(
const vector& st
) const
{
return (Rtr_ & st);
}
Foam::tmp<Foam::vectorField> Foam::STARCDCoordinateRotation::transform
(
const vectorField& st
) const
{
notImplemented
(
"tmp<vectorField> Foam::STARCDCoordinateRotation:: "
"transform(const vectorField& st) const"
);
return tmp<vectorField>(NULL);
}
Foam::tmp<Foam::vectorField> Foam::STARCDCoordinateRotation::invTransform
(
const vectorField& st
) const
{
notImplemented
(
"tmp<vectorField> Foam::STARCDCoordinateRotation::"
"invTransform(const vectorField& st) const"
);
return tmp<vectorField>(NULL);
}
const Foam::tensorField& Foam::STARCDCoordinateRotation::Tr() const
{
notImplemented
(
"const tensorField& STARCDCoordinateRotatio::Tr() const"
);
return *reinterpret_cast<const tensorField*>(0);
}
Foam::tmp<Foam::tensorField> Foam::STARCDCoordinateRotation::transformTensor
(
const tensorField& st
) const
{
notImplemented
(
"tmp<Foam::tensorField> STARCDCoordinateRotation::transformTensor()"
);
return tmp<tensorField>(NULL);
}
Foam::tensor Foam::STARCDCoordinateRotation::transformTensor
(
const tensor& st
) const
{
return (R_ & st & Rtr_);
}
Foam::tmp<Foam::tensorField> Foam::STARCDCoordinateRotation::transformTensor
(
const tensorField& st,
const labelList& cellMap
) const
{
notImplemented
(
"tmp<Foam::tensorField> STARCDCoordinateRotation::transformTensor "
" const tensorField& st,"
" const labelList& cellMap "
") const"
);
return tmp<tensorField>(NULL);
}
Foam::tmp<Foam::symmTensorField> Foam::STARCDCoordinateRotation::
transformVector
(
const vectorField& st
) const
{
tmp<symmTensorField> tfld(new symmTensorField(st.size()));
symmTensorField& fld = tfld();
forAll(fld, i)
{
fld[i] = transformPrincipal(R_, st[i]);
}
return tfld;
}
Foam::symmTensor Foam::STARCDCoordinateRotation::transformVector
(
const vector& st
) const
{
return transformPrincipal(R_, st);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::STARCDCoordinateRotation::calcTransform
@ -63,7 +188,7 @@ void Foam::STARCDCoordinateRotation::calcTransform
z *= constant::mathematical::pi/180.0;
}
tensor::operator=
R_ =
(
tensor
(
@ -80,6 +205,8 @@ void Foam::STARCDCoordinateRotation::calcTransform
cos(x)*cos(y)
)
);
Rtr_ = R_.T();
}
@ -87,7 +214,8 @@ void Foam::STARCDCoordinateRotation::calcTransform
Foam::STARCDCoordinateRotation::STARCDCoordinateRotation()
:
coordinateRotation()
R_(sphericalTensor::I),
Rtr_(R_)
{}
@ -97,7 +225,8 @@ Foam::STARCDCoordinateRotation::STARCDCoordinateRotation
const bool inDegrees
)
:
coordinateRotation()
R_(sphericalTensor::I),
Rtr_(R_)
{
calcTransform
(
@ -117,7 +246,8 @@ Foam::STARCDCoordinateRotation::STARCDCoordinateRotation
const bool inDegrees
)
:
coordinateRotation()
R_(sphericalTensor::I),
Rtr_(R_)
{
calcTransform(rotZ, rotX, rotY, inDegrees);
}
@ -128,7 +258,8 @@ Foam::STARCDCoordinateRotation::STARCDCoordinateRotation
const dictionary& dict
)
:
coordinateRotation()
R_(sphericalTensor::I),
Rtr_(R_)
{
vector rotation(dict.lookup("rotation"));
@ -141,4 +272,30 @@ Foam::STARCDCoordinateRotation::STARCDCoordinateRotation
);
}
Foam::STARCDCoordinateRotation::STARCDCoordinateRotation
(
const dictionary& dict,
const objectRegistry&
)
{
vector rotation(dict.lookup("rotation"));
calcTransform
(
rotation.component(vector::X),
rotation.component(vector::Y),
rotation.component(vector::Z),
dict.lookupOrDefault("degrees", true)
);
}
void Foam::STARCDCoordinateRotation::write(Ostream& os) const
{
os.writeKeyword("e1") << e1() << token::END_STATEMENT << nl;
os.writeKeyword("e2") << e2() << token::END_STATEMENT << nl;
os.writeKeyword("e3") << e3() << token::END_STATEMENT << nl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

96
src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.H
View File

@ -62,6 +62,16 @@ class STARCDCoordinateRotation
:
public coordinateRotation
{
// Private Member Data
//- Local-to-Global transformation tensor
tensor R_;
//- Global-to-Local transformation tensor
tensor Rtr_;
// Private Member Functions
//- Calculate transformation tensor
@ -104,6 +114,92 @@ public:
//- Construct from dictionary
STARCDCoordinateRotation(const dictionary&);
//- Construct from dictionary and mesh
STARCDCoordinateRotation(const dictionary&, const objectRegistry&);
// Member Functions
//- Reset rotation to an identity rotation
virtual void clear()
{
R_ = sphericalTensor::I;
Rtr_ = sphericalTensor::I;
}
//- Return local-to-global transformation tensor
virtual const tensor& R() const
{
return R_;
}
//- Return global-to-local transformation tensor
virtual const tensor& Rtr() const
{
return Rtr_;
};
//- Return local Cartesian x-axis
virtual const vector e1() const
{
return R_.x();
}
//- Return local Cartesian y-axis
virtual const vector e2() const
{
return R_.y();
}
//- Return local Cartesian z-axis
virtual const vector e3() const
{
return R_.z();
}
//- Return transformation tensor field
virtual const tensorField& Tr() const;
//- Transform vectorField using transformation tensor field
virtual tmp<vectorField> transform(const vectorField& st) const;
//- Transform vector using transformation tensor
virtual vector transform(const vector& st) const;
//- Inverse transform vectorField using transformation tensor field
virtual tmp<vectorField> invTransform(const vectorField& st) const;
//- Inverse transform vector using transformation tensor
virtual vector invTransform(const vector& st) const;
//- Transform tensor field using transformation tensorField
virtual tmp<tensorField> transformTensor(const tensorField& st) const;
//- Transform tensor using transformation tensorField
virtual tensor transformTensor(const tensor& st) const;
//- Transform tensor sub-field using transformation tensorField
virtual tmp<tensorField> transformTensor
(
const tensorField& st,
const labelList& cellMap
) const;
//- Transform vectorField using transformation tensorField and return
// symmetrical tensorField
virtual tmp<symmTensorField> transformVector
(
const vectorField& st
) const;
//- Transform vector using transformation tensor and return
// symmetrical tensor
virtual symmTensor transformVector(const vector& st) const;
// Write
//- Write
virtual void write(Ostream&) const;
};

324
src/meshTools/coordinateSystems/coordinateRotation/axesRotation.C Normal file
View File

@ -0,0 +1,324 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
\*---------------------------------------------------------------------------*/
#include "axesRotation.H"
#include "dictionary.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(axesRotation, 0);
addToRunTimeSelectionTable(coordinateRotation, axesRotation, dictionary);
addToRunTimeSelectionTable
(
coordinateRotation,
axesRotation,
objectRegistry
);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::axesRotation::calcTransform
(
const vector& axis1,
const vector& axis2,
const axisOrder& order
)
{
vector a = axis1 / mag(axis1);
vector b = axis2;
// Absorb minor nonorthogonality into axis2
b = b - (b & a)*a;
if (mag(b) < SMALL)
{
FatalErrorIn("axesRotation::calcTransform()")
<< "axis1, axis2 appear co-linear: "
<< axis1 << ", " << axis2 << endl
<< abort(FatalError);
}
b = b / mag(b);
vector c = a ^ b;
tensor Rtr;
switch (order)
{
case e1e2:
Rtr = tensor(a, b, c);
break;
case e2e3:
Rtr = tensor(c, a, b);
break;
case e3e1:
Rtr = tensor(b, c, a);
break;
default:
FatalErrorIn("axesRotation::calcTransform()")
<< "programmer error" << endl
<< abort(FatalError);
Rtr = tensor::zero;
break;
}
// the global -> local transformation
Rtr_ = Rtr;
// the local -> global transformation
R_ = Rtr.T();
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::axesRotation::axesRotation()
:
R_(sphericalTensor::I),
Rtr_(R_)
{}
Foam::axesRotation::axesRotation
(
const vector& axis,
const vector& dir
)
:
R_(sphericalTensor::I),
Rtr_(R_)
{
calcTransform(axis, dir, e3e1);
}
Foam::axesRotation::axesRotation
(
const dictionary& dict
)
:
R_(sphericalTensor::I),
Rtr_(R_)
{
operator=(dict);
}
Foam::axesRotation::axesRotation
(
const dictionary& dict,
const objectRegistry& obr
)
:
R_(sphericalTensor::I),
Rtr_(R_)
{
operator=(dict);
}
Foam::axesRotation::axesRotation(const tensor& R)
:
R_(R),
Rtr_(R_.T())
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::vector Foam::axesRotation::transform(const vector& st) const
{
return (R_ & st);
}
Foam::vector Foam::axesRotation::invTransform(const vector& st) const
{
return (Rtr_ & st);
}
Foam::tmp<Foam::vectorField> Foam::axesRotation::transform
(
const vectorField& st
) const
{
notImplemented
(
"tmp<vectorField> Foam::axesRotation:: "
"transform(const vectorField& st) const"
);
return tmp<vectorField>(NULL);
}
Foam::tmp<Foam::vectorField> Foam::axesRotation::invTransform
(
const vectorField& st
) const
{
notImplemented
(
"tmp<vectorField> Foam::axesRotation::"
"invTransform(const vectorField& st) const"
);
return tmp<vectorField>(NULL);
}
const Foam::tensorField& Foam::axesRotation::Tr() const
{
notImplemented
(
"const Foam::tensorField& axesRotation::Tr() const"
);
return *reinterpret_cast<const tensorField*>(0);
}
Foam::tmp<Foam::tensorField> Foam::axesRotation::transformTensor
(
const tensorField& st
) const
{
notImplemented
(
"const tensorField& axesRotation::transformTensor() const"
);
return tmp<tensorField>(NULL);
}
Foam::tensor Foam::axesRotation::transformTensor
(
const tensor& st
) const
{
return (R_ & st & Rtr_);
}
Foam::tmp<Foam::tensorField> Foam::axesRotation::transformTensor
(
const tensorField& st,
const labelList& cellMap
) const
{
notImplemented
(
"tmp<Foam::tensorField> axesRotation::transformTensor "
" const tensorField& st,"
" const labelList& cellMap "
") const"
);
return tmp<tensorField>(NULL);
}
Foam::tmp<Foam::symmTensorField> Foam::axesRotation::transformVector
(
const vectorField& st
) const
{
tmp<symmTensorField> tfld(new symmTensorField(st.size()));
symmTensorField& fld = tfld();
forAll(fld, i)
{
fld[i] = transformPrincipal(R_, st[i]);
}
return tfld;
}
Foam::symmTensor Foam::axesRotation::transformVector
(
const vector& st
) const
{
return transformPrincipal(R_, st);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
void Foam::axesRotation::operator=(const dictionary& dict)
{
if (debug)
{
Pout<< "axesRotation::operator=(const dictionary&) : "
<< "assign from " << dict << endl;
}
vector axis1, axis2;
axisOrder order(e3e1);
if (dict.readIfPresent("e1", axis1) && dict.readIfPresent("e2", axis2))
{
order = e1e2;
}
else if (dict.readIfPresent("e2", axis1)&& dict.readIfPresent("e3", axis2))
{
order = e2e3;
}
else if (dict.readIfPresent("e3", axis1)&& dict.readIfPresent("e1", axis2))
{
order = e3e1;
}
else if (dict.found("axis") || dict.found("direction"))
{
// let it bomb if only one of axis/direction is defined
order = e3e1;
dict.lookup("axis") >> axis1;
dict.lookup("direction") >> axis2;
}
else
{
FatalErrorIn
(
"axesRotation::operator=(const dictionary&) "
) << "not entry of the type (e1, e2) or (e2, e3) or (e3, e1) "
<< "found "
<< exit(FatalError);
}
calcTransform(axis1, axis2, order);
}
void Foam::axesRotation::write(Ostream& os) const
{
os.writeKeyword("e1") << e1() << token::END_STATEMENT << nl;
os.writeKeyword("e2") << e2() << token::END_STATEMENT << nl;
os.writeKeyword("e3") << e3() << token::END_STATEMENT << nl;
}
// ************************************************************************* //

229
src/meshTools/coordinateSystems/coordinateRotation/axesRotation.H Normal file
View File

@ -0,0 +1,229 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
Class
Foam::axesRotation
Description
A coordinate rotation specified using global axis
The rotation is defined by a combination of vectors (e1/e2), (e2/e3)
or (e3/e1). Any nonorthogonality will be absorbed into the second vector.
\verbatim
axesRotation
{
type axesRotation;
e1 (1 0 0);
e2 (0 1 0);
}
\endverbatim
\*---------------------------------------------------------------------------*/
#ifndef axesRotation_H
#define axesRotation_H
#include "vector.H"
#include "coordinateRotation.H"
#include "dictionary.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class axesRotation Declaration
\*---------------------------------------------------------------------------*/
class axesRotation
:
public coordinateRotation
{
// Private data
//- Local-to-Global transformation tensor
tensor R_;
//- Global-to-Local transformation tensor
tensor Rtr_;
//- the combination of local axes to be used
enum axisOrder
{
e1e2,
e2e3,
e3e1
};
// Private Member Functions
//- Calculate transformation tensor
void calcTransform
(
const vector& axis1,
const vector& axis2,
const axisOrder& order = e3e1
);
public:
//- Runtime type information
TypeName("axesRotation");
// Constructors
//- Construct null
axesRotation();
//- Construct from 2 axes
axesRotation
(
const vector& axis,
const vector& dir
);
//- Construct from dictionary
axesRotation(const dictionary&);
//- Construct from components
axesRotation(const tensor& R);
//- Construct from dictionary and mesh
axesRotation(const dictionary&, const objectRegistry&);
//- Return clone
autoPtr<axesRotation> clone() const
{
return autoPtr<axesRotation>(new axesRotation(*this));
}
//- Destructor
virtual ~axesRotation()
{}
// Member Functions
//- Reset rotation to an identity rotation
virtual void clear()
{
R_ = sphericalTensor::I;
Rtr_ = sphericalTensor::I;
}
//- Return local-to-global transformation tensor
virtual const tensor& R() const
{
return R_;
}
//- Return global-to-local transformation tensor
virtual const tensor& Rtr() const
{
return Rtr_;
}
//- Return local Cartesian x-axis
virtual const vector e1() const
{
return R_.x();
}
//- Return local Cartesian y-axis
virtual const vector e2() const
{
return R_.y();
}
//- Return local Cartesian z-axis
virtual const vector e3() const
{
return R_.z();
}
//- Return transformation tensor field
virtual const tensorField& Tr() const;
//- Transform vectorField using transformation tensor field
virtual tmp<vectorField> transform(const vectorField& st) const;
//- Transform vector using transformation tensor
virtual vector transform(const vector& st) const;
//- Inverse transform vectorField using transformation tensor field
virtual tmp<vectorField> invTransform(const vectorField& st) const;
//- Inverse transform vector using transformation tensor
virtual vector invTransform(const vector& st) const;
//- Transform tensor field using transformation tensorField
virtual tmp<tensorField> transformTensor(const tensorField& st) const;
//- Transform tensor using transformation tensorField
virtual tensor transformTensor(const tensor& st) const;
//- Transform tensor sub-field using transformation tensorField
virtual tmp<tensorField> transformTensor
(
const tensorField& st,
const labelList& cellMap
) const;
//- Transform vectorField using transformation tensorField and return
// symmetrical tensorField
virtual tmp<symmTensorField> transformVector
(
const vectorField& st
) const;
//- Transform vector using transformation tensor and return
// symmetrical tensor
virtual symmTensor transformVector(const vector& st) const;
// Member Operators
//- assign from dictionary
void operator=(const dictionary&);
// Write
//- Write
virtual void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

212
src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.C
View File

@ -33,197 +33,45 @@ namespace Foam
{
defineTypeNameAndDebug(coordinateRotation, 0);
defineRunTimeSelectionTable(coordinateRotation, dictionary);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::coordinateRotation::calcTransform
(
const vector& axis1,
const vector& axis2,
const axisOrder& order
)
{
vector a = axis1 / mag(axis1);
vector b = axis2;
// Absorb minor nonorthogonality into axis2
b = b - (b & a)*a;
if (mag(b) < SMALL)
{
FatalErrorIn("coordinateRotation::calcTransform()")
<< "axis1, axis2 appear co-linear: "
<< axis1 << ", " << axis2 << endl
<< abort(FatalError);
}
b = b / mag(b);
vector c = a ^ b;
// the global -> local transformation
tensor Rtr;
switch (order)
{
case e1e2:
Rtr = tensor(a, b, c);
break;
case e2e3:
Rtr = tensor(c, a, b);
break;
case e3e1:
Rtr = tensor(b, c, a);
break;
default:
FatalErrorIn("coordinateRotation::calcTransform()")
<< "programmer error" << endl
<< abort(FatalError);
// To satisfy compiler warnings
Rtr = tensor::zero;
break;
}
// the local -> global transformation
tensor::operator=( Rtr.T() );
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::coordinateRotation::coordinateRotation()
:
tensor(sphericalTensor::I)
{}
Foam::coordinateRotation::coordinateRotation
(
const vector& axis,
const vector& dir
)
:
tensor(sphericalTensor::I)
{
calcTransform(axis, dir, e3e1);
}
Foam::coordinateRotation::coordinateRotation
(
const dictionary& dict
)
:
tensor(sphericalTensor::I)
{
operator=(dict);
}
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::coordinateRotation> Foam::coordinateRotation::New
(
const dictionary& dict
)
{
if (debug)
{
Pout<< "coordinateRotation::New(const dictionary&) : "
<< "constructing coordinateRotation"
<< endl;
}
// default type is self (alias: "axes")
word rotType(typeName_());
dict.readIfPresent("type", rotType);
// can (must) construct base class directly
if (rotType == typeName_() || rotType == "axes")
{
return autoPtr<coordinateRotation>(new coordinateRotation(dict));
}
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(rotType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorIn
(
"coordinateRotation::New(const dictionary&)",
dict
) << "Unknown coordinateRotation type "
<< rotType << nl << nl
<< "Valid coordinateRotation types are :" << nl
<< "[default: axes " << typeName_() << "]"
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<coordinateRotation>(cstrIter()(dict));
defineRunTimeSelectionTable(coordinateRotation, objectRegistry);
}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void Foam::coordinateRotation::clear()
Foam::symmTensor Foam::coordinateRotation::transformPrincipal
(
const tensor& tt,
const vector& st
) const
{
this->tensor::operator=(sphericalTensor::I);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
void Foam::coordinateRotation::operator=(const dictionary& rhs)
{
if (debug)
{
Pout<< "coordinateRotation::operator=(const dictionary&) : "
<< "assign from " << rhs << endl;
}
// allow as embedded sub-dictionary "coordinateRotation"
const dictionary& dict =
return symmTensor
(
rhs.found(typeName_())
? rhs.subDict(typeName_())
: rhs
tt.xx()*st.x()*tt.xx()
+ tt.xy()*st.y()*tt.xy()
+ tt.xz()*st.z()*tt.xz(),
tt.xx()*st.x()*tt.yx()
+ tt.xy()*st.y()*tt.yy()
+ tt.xz()*st.z()*tt.yz(),
tt.xx()*st.x()*tt.zx()
+ tt.xy()*st.y()*tt.zy()
+ tt.xz()*st.z()*tt.zz(),
tt.yx()*st.x()*tt.yx()
+ tt.yy()*st.y()*tt.yy()
+ tt.yz()*st.z()*tt.yz(),
tt.yx()*st.x()*tt.zx()
+ tt.yy()*st.y()*tt.zy()
+ tt.yz()*st.z()*tt.zz(),
tt.zx()*st.x()*tt.zx()
+ tt.zy()*st.y()*tt.zy()
+ tt.zz()*st.z()*tt.zz()
);
vector axis1, axis2;
axisOrder order(e3e1);
if (dict.readIfPresent("e1", axis1) && dict.readIfPresent("e2", axis2))
{
order = e1e2;
}
else if (dict.readIfPresent("e2", axis1) && dict.readIfPresent("e3", axis2))
{
order = e2e3;
}
else if (dict.readIfPresent("e3", axis1) && dict.readIfPresent("e1", axis2))
{
order = e3e1;
}
else if (dict.found("axis") || dict.found("direction"))
{
// let it bomb if only one of axis/direction is defined
order = e3e1;
dict.lookup("axis") >> axis1;
dict.lookup("direction") >> axis2;
}
else
{
// unspecified axes revert to the global system
tensor::operator=(sphericalTensor::I);
return;
}
calcTransform(axis1, axis2, order);
}
// ************************************************************************* //

202
src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.H
View File

@ -25,46 +25,24 @@ Class
Foam::coordinateRotation
Description
A coordinate rotation specified per local axes and the base class for
other rotation specifications
The rotation is defined by a combination of local vectors (e1/e2), (e2/e3)
or (e3/e1). Any nonorthogonality will be absorbed into the second vector.
For convenience, the dictionary constructor forms allow a few shortcuts:
- if the \c type is not otherwise specified, the type \c axes
is implicit
- if an axes specification (eg, e3/e1) is used, the coordinateRotation
sub-dictionary can be dropped.
Specifying the rotation by an EulerCoordinateRotation
(type "EulerRotation") or by a STARCDCoordinateRotation
(type "STARCDRotation") requires the coordinateRotation sub-dictionary.
Abstract base class for coordinate rotation
\verbatim
coordinateRotation
{
type STARCDRotation
rotation (0 0 90);
type axesRotation
e1 (1 0 0);
e2 (0 1 0);
}
\endverbatim
- the rotation angles are in degrees, unless otherwise explictly specified:
Types of coordinateRotation:
1) axesRotation
2) STARCDRotation
3) localAxesRotation
4) EulerCoordinateRotation
\verbatim
coordinateRotation
{
type STARCDRotation
degrees false;
rotation (0 0 3.141592654);
}
\endverbatim
Deprecated
Specifying the local vectors as an \c axis (corresponding to e3) and a
\c direction (corresponding to e1), is allowed for backwards
compatibility, but this terminology is generally a bit confusing.
(deprecated Apr 2008)
\*---------------------------------------------------------------------------*/
@ -73,8 +51,10 @@ Deprecated
#include "vector.H"
#include "tensor.H"
#include "tensorField.H"
#include "dictionary.H"
#include "runTimeSelectionTables.H"
#include "objectRegistry.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -86,72 +66,59 @@ namespace Foam
\*---------------------------------------------------------------------------*/
class coordinateRotation
:
public tensor
{
// Private data
protected:
//- the combination of local axes to be used
enum axisOrder
{
e1e2,
e2e3,
e3e1
};
// Protected member functions
// Private Member Functions
//- Transform principal
symmTensor transformPrincipal(const tensor&, const vector&) const;
//- Calculate transformation tensor
void calcTransform
(
const vector& axis1,
const vector& axis2,
const axisOrder& order = e3e1
);
public:
//- Runtime type information
TypeName("coordinateRotation");
// Constructors
//- Construct null
coordinateRotation();
//- Construct from 2 axes
coordinateRotation
(
const vector& axis,
const vector& dir
);
//- Construct from dictionary
coordinateRotation(const dictionary&);
//- Return clone
autoPtr<coordinateRotation> clone() const
{
return autoPtr<coordinateRotation>(new coordinateRotation(*this));
}
// Declare run-time constructor selection table
declareRunTimeSelectionTable
// for constructors with dictionary and objectRegistry
declareRunTimeSelectionTable
(
autoPtr,
coordinateRotation,
objectRegistry,
(
autoPtr,
coordinateRotation,
dictionary,
(
const dictionary& dict
),
(dict)
);
const dictionary& dict, const objectRegistry& obr
),
(dict, obr)
);
// Declare run-time constructor selection table
// for constructors with dictionary
declareRunTimeSelectionTable
(
autoPtr,
coordinateRotation,
dictionary,
(
const dictionary& dict
),
(dict)
);
// Selectors
//- Select constructed from Istream
//- Select constructed from dictionary and objectRegistry
static autoPtr<coordinateRotation> New
(
const dictionary& dict, const objectRegistry& obr
);
//- Select constructed from dictionary
static autoPtr<coordinateRotation> New
(
const dictionary& dict
@ -166,37 +133,76 @@ public:
// Member Functions
//- Reset rotation to an identity rotation
virtual void clear();
virtual void clear() = 0;
//- Return local-to-global transformation tensor
const tensor& R() const
{
return (*this);
}
virtual const tensor& R() const = 0;
//- Return global-to-local transformation tensor
virtual const tensor& Rtr() const = 0;
//- Return local Cartesian x-axis
const vector e1() const
{
return tensor::T().x();
}
virtual const vector e1() const = 0;
//- Return local Cartesian y-axis
const vector e2() const
{
return tensor::T().y();
}
virtual const vector e2() const = 0;
//- Return local Cartesian z-axis
const vector e3() const
virtual const vector e3() const = 0;
//- Return local-to-global transformation tensor
virtual const tensorField& Tr() const = 0;
//- Return true if the rotation tensor is uniform
virtual bool uniform() const
{
return tensor::T().z();
return true;
}
//- Transform vectorField using transformation tensor field
virtual tmp<vectorField> transform(const vectorField& st) const = 0;
// Member Operators
//- Transform vector using transformation tensor
virtual vector transform(const vector& st) const = 0;
//- assign from dictionary
void operator=(const dictionary&);
//- Inverse transform vectorField using transformation tensor field
virtual tmp<vectorField> invTransform(const vectorField& st) const = 0;
//- Inverse transform vector using transformation tensor
virtual vector invTransform(const vector& st) const = 0;
//- Transform tensor field using transformation tensorField
virtual tmp<tensorField> transformTensor
(
const tensorField& st
) const = 0;
//- Transform tensor sub-field using transformation tensorField
virtual tmp<tensorField> transformTensor
(
const tensorField& st,
const labelList& cellMap
) const = 0;
//- Transform tensor using transformation tensorField
virtual tensor transformTensor(const tensor& st) const = 0;
//- Transform vectorField using transformation tensorField and return
// symmetrical tensorField
virtual tmp<symmTensorField> transformVector
(
const vectorField& st
) const = 0;
//- Transform vector using transformation tensor and return
// symmetrical tensor
virtual symmTensor transformVector(const vector& st) const = 0;
// Write
//- Write
virtual void write(Ostream&) const = 0;
};

107
src/meshTools/coordinateSystems/coordinateRotation/coordinateRotationNew.C Normal file
View File

@ -0,0 +1,107 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
\*---------------------------------------------------------------------------*/
#include "coordinateRotation.H"
#include "objectRegistry.H"
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::coordinateRotation> Foam::coordinateRotation::New
(
const dictionary& dict, const objectRegistry& obr
)
{
if (debug)
{
Pout<< "coordinateRotation::New(const dictionary&) : "
<< "constructing coordinateRotation"
<< endl;
}
word rotType = dict.lookup("type");
objectRegistryConstructorTable::iterator cstrIter =
objectRegistryConstructorTablePtr_->find(rotType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorIn
(
"coordinateRotation::New"
"("
" const dictionary&, "
" const objectRegistry& "
")",
dict
) << "Unknown coordinateRotation type "
<< rotType << nl << nl
<< "Valid coordinateRotation types are :" << nl
<< "[default: axes ]"
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<coordinateRotation>(cstrIter()(dict, obr));
}
Foam::autoPtr<Foam::coordinateRotation> Foam::coordinateRotation::New
(
const dictionary& dict
)
{
if (debug)
{
Pout<< "coordinateRotation::New(const dictionary&) : "
<< "constructing coordinateRotation"
<< endl;
}
word rotType = dict.lookup("type");
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(rotType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorIn
(
"coordinateRotation::New"
"("
" const dictionary&, "
")",
dict
) << "Unknown coordinateRotation type "
<< rotType << nl << nl
<< "Valid coordinateRotation types are :" << nl
<< "[default: axes ]"
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<coordinateRotation>(cstrIter()(dict));
}
// ************************************************************************* //

282
src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.C Normal file
View File

@ -0,0 +1,282 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
\*---------------------------------------------------------------------------*/
#include "localAxesRotation.H"
#include "axesRotation.H"
#include "addToRunTimeSelectionTable.H"
#include "polyMesh.H"
#include "tensorIOField.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(localAxesRotation, 0);
addToRunTimeSelectionTable
(
coordinateRotation,
localAxesRotation,
dictionary
);
addToRunTimeSelectionTable
(
coordinateRotation,
localAxesRotation,
objectRegistry
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::localAxesRotation::localAxesRotation
(
const dictionary& dict, const objectRegistry& orb
)
:
Rptr_(),
origin_(point::zero),
e3_(vector::zero)
{
// If origin is specified in the coordinateSystem
if (dict.parent().found("origin"))
{
dict.parent().lookup("origin") >> origin_;
}
// rotation axis
dict.lookup("e3") >> e3_;
const polyMesh& mesh = refCast<const polyMesh>(orb);
Rptr_.reset
(
new tensorField(mesh.nCells())
);
init(dict, orb);
}
Foam::localAxesRotation::localAxesRotation
(
const dictionary& dict
)
:
Rptr_(),
origin_(),
e3_()
{
FatalErrorIn
(
"localAxesRotation(const dictionary&)"
) << " localAxesRotation can not be contructed from dictionary "
<< " use the construtctor : "
"("
" const dictionary& dict, const objectRegistry& orb"
")"
<< exit(FatalIOError);
}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
void Foam::localAxesRotation::clear()
{
if (!Rptr_.empty())
{
Rptr_.clear();
}
}
Foam::vector Foam::localAxesRotation::transform(const vector& st) const
{
notImplemented
(
"vector Foam::localAxesRotation:: "
"transform(const vector& st) const"
);
return vector(vector::zero);
}
Foam::vector Foam::localAxesRotation::invTransform(const vector& st) const
{
notImplemented
(
"vector Foam::localAxesRotation:: "
"transform(const vector& st) const"
);
return vector(vector::zero);
}
Foam::tmp<Foam::vectorField> Foam::localAxesRotation::transform
(
const vectorField& st
) const
{
if (Rptr_->size() != st.size())
{
FatalErrorIn
(
"localAxesRotation::transform(const vectorField& st) "
) << "vectorField st has different size to tensorField "
<< abort(FatalError);
}
return (Rptr_() & st);
}
Foam::tmp<Foam::vectorField> Foam::localAxesRotation::invTransform
(
const vectorField& st
) const
{
return (Rptr_().T() & st);
}
Foam::tmp<Foam::tensorField> Foam::localAxesRotation::transformTensor
(
const tensorField& st
) const
{
if (Rptr_->size() != st.size())
{
FatalErrorIn
(
"localAxesRotation::transformTensor(const tensorField& st) "
) << "tensorField st has different size to tensorField Tr"
<< abort(FatalError);
}
return (Rptr_() & st & Rptr_().T());
}
Foam::tensor Foam::localAxesRotation::transformTensor
(
const tensor& st
) const
{
notImplemented
(
"tensor localAxesRotation::transformTensor() const"
);
return tensor(tensor::zero);
}
Foam::tmp<Foam::tensorField> Foam::localAxesRotation::transformTensor
(
const tensorField& st,
const labelList& cellMap
) const
{
if (cellMap.size() != st.size())
{
FatalErrorIn
(
"localAxesRotation::transformTensor(const tensorField& st) "
) << "tensorField st has different size to tensorField Tr"
<< abort(FatalError);
}
const tensorField Rtr = Rptr_().T();
tmp<tensorField> tt(new tensorField(cellMap.size()));
tensorField& t = tt();
forAll (cellMap, i)
{
const label cellI = cellMap[i];
t[i] = Rptr_()[cellI] & st[i] & Rtr[cellI];
}
return tt;
}
Foam::tmp<Foam::symmTensorField> Foam::localAxesRotation::transformVector
(
const vectorField& st
) const
{
if (Rptr_->size() != st.size())
{
FatalErrorIn
(
"localAxesRotation::transformVector(const vectorField& st) "
) << "tensorField st has different size to tensorField Tr"
<< abort(FatalError);
}
tmp<symmTensorField> tfld(new symmTensorField(Rptr_->size()));
symmTensorField& fld = tfld();
forAll(fld, i)
{
fld[i] = transformPrincipal(Rptr_()[i], st[i]);
}
return tfld;
}
Foam::symmTensor Foam::localAxesRotation::transformVector
(
const vector& st
) const
{
notImplemented
(
"tensor localAxesRotation::transformVector(const vector&) const"
);
return symmTensor(symmTensor::zero);
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
void Foam::localAxesRotation::init
(
const dictionary& dict,
const objectRegistry& obr
)
{
const polyMesh& mesh = refCast<const polyMesh>(obr);
forAll(mesh.cellCentres(), cellI)
{
vector dir = mesh.cellCentres()[cellI] - origin_;
dir /= mag(dir);
Rptr_()[cellI] = axesRotation(e3_, dir).R();
}
}
void Foam::localAxesRotation::write(Ostream& os) const
{
os.writeKeyword("e3") << e3() << token::END_STATEMENT << nl;
}
// ************************************************************************* //

209
src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.H Normal file
View File

@ -0,0 +1,209 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
Class
Foam::localAxesRotation
Description
A local coordinate rotation.
Each rotational tensor is defined with two vectors (dir and e3)
where dir = cellC - origin and e3 is the rotation axis.
Per each cell an axesRotation type of rotation is created
\verbatim
localAxesRotation
{
type localAxes;
e3 (0 0 1);
}
\endverbatim
\*---------------------------------------------------------------------------*/
#ifndef localAxesRotation_H
#define localAxesRotation_H
#include "point.H"
#include "vector.H"
#include "coordinateRotation.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class localAxesRotation Declaration
\*---------------------------------------------------------------------------*/
class localAxesRotation
:
public coordinateRotation
{
// Private data
//- AutoPtr to transformation tensor
autoPtr<tensorField> Rptr_;
//- Origin of the coordinate system
point origin_;
//- Rotation axis
vector e3_;
// Private members
//- Init transformation tensor
void init(const dictionary& dict, const objectRegistry& obr);
public:
//- Runtime type information
TypeName("localAxesRotation");
// Constructors
//- Construct from dictionary and objectRegistry
localAxesRotation(const dictionary&, const objectRegistry&);
//- Construct from dictionary
localAxesRotation(const dictionary&);
//- Return clone
autoPtr<localAxesRotation> clone() const
{
return autoPtr<localAxesRotation>(new localAxesRotation(*this));
}
//- Destructor
virtual ~localAxesRotation()
{}
// Member Functions
//- Reset rotation to an identity rotation
virtual void clear();
//- Return local-to-global transformation tensor
virtual const tensor& R() const
{
notImplemented("const tensor& localAxesRotation::R() const");
return tensor::zero;
}
//- Return global-to-local transformation tensor
virtual const tensor& Rtr() const
{
notImplemented("const tensor& localAxesRotation::Rtr() const");
return tensor::zero;
}
//- Return local Cartesian x-axis
virtual const vector e1() const
{
notImplemented("const tensor& localAxesRotation::e1() const");
return vector::zero;
}
//- Return local Cartesian y-axis
virtual const vector e2() const
{
notImplemented("const tensor& localAxesRotation::e2() const");
return vector::zero;
}
//- Return local Cartesian z-axis
virtual const vector e3() const
{
return e3_;
}
virtual const tensorField& Tr() const
{
return Rptr_();
}
//- Transform vectorField using transformation tensor field
virtual tmp<vectorField> transform(const vectorField& st) const;
//- Transform vector using transformation tensor
virtual vector transform(const vector& st) const;
//- Inverse transform vectorField using transformation tensor field
virtual tmp<vectorField> invTransform(const vectorField& st) const;
//- Inverse transform vector using transformation tensor
virtual vector invTransform(const vector& st) const;
//- Return if the rotation is uniform
virtual bool uniform() const
{
return false;
}
//- Transform tensor field using transformation tensorField
virtual tmp<tensorField> transformTensor(const tensorField& st) const;
//- Transform tensor using transformation tensorField
virtual tensor transformTensor(const tensor& st) const;
//- Transform tensor sub-field using transformation tensorField
virtual tmp<tensorField> transformTensor
(
const tensorField& st,
const labelList& cellMap
) const;
//- Transform vectorField using transformation tensorField and return
// symmetrical tensorField
virtual tmp<symmTensorField> transformVector
(
const vectorField& st
) const;
//- Transform vector using transformation tensor and return
// symmetrical tensor (R & st & R.T())
virtual symmTensor transformVector(const vector& st) const;
// Write
//- Write
virtual void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

132
src/meshTools/coordinateSystems/coordinateSystem.C
View File

@ -24,6 +24,7 @@ License
\*---------------------------------------------------------------------------*/
#include "IOstream.H"
#include "axesRotation.H"
#include "coordinateSystem.H"
#include "coordinateSystems.H"
#include "addToRunTimeSelectionTable.H"
@ -34,18 +35,16 @@ namespace Foam
{
defineTypeNameAndDebug(coordinateSystem, 0);
defineRunTimeSelectionTable(coordinateSystem, dictionary);
defineRunTimeSelectionTable(coordinateSystem, origRotation);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::coordinateSystem::coordinateSystem()
:
name_(type()),
name_(),
note_(),
origin_(point::zero),
R_(),
Rtr_(sphericalTensor::I)
R_(new axesRotation(sphericalTensor::I))
{}
@ -58,8 +57,7 @@ Foam::coordinateSystem::coordinateSystem
name_(name),
note_(),
origin_(cs.origin_),
R_(cs.R_),
Rtr_(R_.T())
R_(const_cast<coordinateRotation*>(&cs.R()))
{}
@ -73,8 +71,7 @@ Foam::coordinateSystem::coordinateSystem
name_(name),
note_(),
origin_(origin),
R_(cr),
Rtr_(R_.T())
R_(const_cast<coordinateRotation*>(&cr))
{}
@ -89,8 +86,7 @@ Foam::coordinateSystem::coordinateSystem
name_(name),
note_(),
origin_(origin),
R_(axis, dirn),
Rtr_(R_.T())
R_(new axesRotation(axis, dirn))
{}
@ -103,37 +99,35 @@ Foam::coordinateSystem::coordinateSystem
name_(name),
note_(),
origin_(point::zero),
R_(),
Rtr_(sphericalTensor::I)
R_()
{
operator=(dict);
init(dict);
}
Foam::coordinateSystem::coordinateSystem(const dictionary& dict)
:
name_(type()),
name_(),
note_(),
origin_(point::zero),
R_(),
Rtr_(sphericalTensor::I)
R_()
{
operator=(dict);
init(dict);
}
Foam::coordinateSystem::coordinateSystem
(
const dictionary& dict,
const objectRegistry& obr
const objectRegistry& obr,
const dictionary& dict
)
:
name_(type()),
name_(),
note_(),
origin_(point::zero),
R_(),
Rtr_(sphericalTensor::I)
R_()
{
const entry* entryPtr = dict.lookupEntryPtr(typeName_(), false, false);
// non-dictionary entry is a lookup into global coordinateSystems
@ -170,7 +164,7 @@ Foam::coordinateSystem::coordinateSystem
}
else
{
operator=(dict);
init(dict, obr);
}
}
@ -180,11 +174,10 @@ Foam::coordinateSystem::coordinateSystem(Istream& is)
name_(is),
note_(),
origin_(point::zero),
R_(),
Rtr_(sphericalTensor::I)
R_()
{
dictionary dict(is);
operator=(dict);
init(dict);
}
@ -215,8 +208,8 @@ Foam::dictionary Foam::coordinateSystem::dict(bool ignoreType) const
}
dict.add("origin", origin_);
dict.add("e1", e1());
dict.add("e3", e3());
dict.add("e1", R_->e1());
dict.add("e3", R_->e3());
return dict;
}
@ -230,11 +223,11 @@ Foam::vector Foam::coordinateSystem::localToGlobal
{
if (translate)
{
return (R_ & local) + origin_;
return (R_->transform(local)) + origin_;
}
else
{
return (R_ & local);
return R_->transform(local);
}
}
@ -247,11 +240,11 @@ Foam::tmp<Foam::vectorField> Foam::coordinateSystem::localToGlobal
{
if (translate)
{
return (R_ & local) + origin_;
return (R_->transform(local)) + origin_;
}
else
{
return (R_ & local);
return R_->transform(local);
}
}
@ -264,11 +257,11 @@ Foam::vector Foam::coordinateSystem::globalToLocal
{
if (translate)
{
return (Rtr_ & (global - origin_));
return R_->invTransform(global - origin_);
}
else
{
return (Rtr_ & global);
return R_->invTransform(global);
}
}
@ -281,11 +274,11 @@ Foam::tmp<Foam::vectorField> Foam::coordinateSystem::globalToLocal
{
if (translate)
{
return (Rtr_ & (global - origin_));
return R_->invTransform(global - origin_);
}
else
{
return (Rtr_ & global);
return R_->invTransform(global);
}
}
@ -294,15 +287,14 @@ void Foam::coordinateSystem::clear()
{
note_.clear();
origin_ = point::zero;
R_.clear();
Rtr_ = sphericalTensor::I;
R_->clear();
}
void Foam::coordinateSystem::write(Ostream& os) const
{
os << type()
<< " origin: " << origin() << " e1: " << e1() << " e3: " << e3();
os << type() << " origin: " << origin() << nl;
R_->write(os);
}
@ -314,11 +306,8 @@ void Foam::coordinateSystem::writeDict(Ostream& os, bool subDict) const
<< indent << token::BEGIN_BLOCK << incrIndent << nl;
}
// only write type for derived types
if (type() != typeName_())
{
os.writeKeyword("type") << type() << token::END_STATEMENT << nl;
}
os.writeKeyword("type") << type() << token::END_STATEMENT << nl;
// The note entry is optional
if (note_.size())
@ -327,8 +316,7 @@ void Foam::coordinateSystem::writeDict(Ostream& os, bool subDict) const
}
os.writeKeyword("origin") << origin_ << token::END_STATEMENT << nl;
os.writeKeyword("e1") << e1() << token::END_STATEMENT << nl;
os.writeKeyword("e3") << e3() << token::END_STATEMENT << nl;
R_->write(os);
if (subDict)
{
@ -339,7 +327,20 @@ void Foam::coordinateSystem::writeDict(Ostream& os, bool subDict) const
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
void Foam::coordinateSystem::operator=(const dictionary& rhs)
void Foam::coordinateSystem::init(const dictionary& rhs)
{
rhs.lookup("origin") >> origin_;
note_.clear();
rhs.readIfPresent("note", note_);
R_.reset(coordinateRotation::New(rhs.subDict("coordinateRotation")).ptr());
}
void Foam::coordinateSystem::init
(
const dictionary& rhs,
const objectRegistry& obr
)
{
if (debug)
{
@ -347,34 +348,16 @@ void Foam::coordinateSystem::operator=(const dictionary& rhs)
<< "assign from " << rhs << endl;
}
// allow as embedded sub-dictionary "coordinateSystem"
const dictionary& dict =
(
rhs.found(typeName_())
? rhs.subDict(typeName_())
: rhs
);
// unspecified origin is (0 0 0)
origin_ = point::zero;
dict.readIfPresent("origin", origin_);
rhs.lookup("origin") >> origin_;
// The note entry is optional
note_.clear();
rhs.readIfPresent("note", note_);
// specify via coordinateRotation sub-dictionary
if (dict.found("coordinateRotation"))
{
R_ = coordinateRotation::New(dict.subDict("coordinateRotation"))();
}
else
{
// let coordinateRotation constructor extract the axes specification
R_ = coordinateRotation(dict);
}
Rtr_ = R_.T();
R_.reset
(
coordinateRotation::New(rhs.subDict("coordinateRotation"), obr).ptr()
);
}
@ -382,7 +365,12 @@ void Foam::coordinateSystem::operator=(const dictionary& rhs)
bool Foam::operator!=(const coordinateSystem& a, const coordinateSystem& b)
{
return (a.origin() != b.origin() || a.R() != b.R() || a.type() != b.type());
return
(
a.origin() != b.origin()
|| a.R().R() != b.R().R()
|| a.type() != b.type()
);
}

242
src/meshTools/coordinateSystems/coordinateSystem.H
View File

@ -25,18 +25,15 @@ Class
Foam::coordinateSystem
Description
A cartesian coordinate system and the base class for other coordinate
Base class for other coordinate
system specifications.
All systems are defined by an origin point and a coordinateRotation.
For convenience, the dictionary constructor forms allow a few shortcuts:
- the default origin corresponds to <em>(0 0 0)</em>
- if the \c type is not otherwise specified, a Cartesian coordinateSystem
is implicit
\verbatim
flipped
coordinateSystem
{
type cartesian;
origin (0 0 0);
coordinateRotation
{
@ -46,79 +43,18 @@ Description
}
\endverbatim
- if an axes specification (eg, e3/e1) is used, the coordinateRotation
sub-dictionary can be dropped.
Types of coordinateRotation:
1) axesRotation
2) STARCDRotation
3) localAxesRotation
4) EulerCoordinateRotation
\verbatim
flipped // the same, specified as axes
{
origin (0 0 0);
coordinateRotation
{
type axes;
e3 (1 0 0);
e1 (0 0 -1);
}
}
flipped // the same, using all the shortcuts
{
e3 (1 0 0);
e1 (0 0 -1);
}
\endverbatim
- if a sub-dictionary coordinateSystem is found within the dictionary, it
will be used. This provides a convenient means of embedding
coordinateSystem information in another dictionary.
This is used, for example, in the porousZones:
\verbatim
1
(
cat1
{
coordinateSystem
{
origin (0 0 0);
coordinateRotation
{
type STARCDRotation;
rotation (0 0 90);
}
}
porosity 0.781;
Darcy
{
d d [0 -2 0 0 0] (-1000 -1000 0.50753e+08);
f f [0 -1 0 0 0] (-1000 -1000 12.83);
}
}
)
\endverbatim
- additionally, if the coordinateSystem points to a plain entry,
it can be used to reference one of the global coordinateSystems
\verbatim
1
(
cat1
{
coordinateSystem system_10;
porosity 0.781;
Darcy
{
d d [0 -2 0 0 0] (-1000 -1000 0.50753e+08);
f f [0 -1 0 0 0] (-1000 -1000 12.83);
}
}
)
\endverbatim
For this to work correctly, the coordinateSystem constructor must be
supplied with both a dictionary and an objectRegistry.
Type of coordinates:
1) cartesian
2) cylindricalCS
See Also
coordinateSystems and coordinateSystems::New
coordinateSystem and coordinateSystem::New
SourceFiles
coordinateSystem.C
@ -136,6 +72,7 @@ SourceFiles
#include "tmp.H"
#include "coordinateRotation.H"
#include "objectRegistry.H"
#include "autoPtr.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -151,19 +88,16 @@ class coordinateSystem
// Private data
//- Name of coordinate system
mutable word name_;
word name_;
//- Optional note
mutable string note_;
string note_;
//- Origin
mutable point origin_;
point origin_;
//- Local-to-Global transformation tensor
coordinateRotation R_;
//- Global-to-Local transformation tensor
tensor Rtr_;
autoPtr<coordinateRotation> R_;
protected:
@ -194,6 +128,12 @@ protected:
bool translate
) const;
//- Init from dict and obr
void init(const dictionary&);
//- Init from dictionary
void init(const dictionary&, const objectRegistry&);
public:
@ -238,63 +178,47 @@ public:
//- Construct from dictionary (default name)
// With the ability to reference global coordinateSystems
coordinateSystem(const dictionary&, const objectRegistry&);
coordinateSystem(const objectRegistry&, const dictionary&);
//- Construct from Istream
// The Istream contains a word followed by a dictionary
coordinateSystem(Istream&);
//- Return clone
autoPtr<coordinateSystem> clone() const
{
return autoPtr<coordinateSystem>(new coordinateSystem(*this));
}
//- Return clone
autoPtr<coordinateSystem> clone() const
{
return autoPtr<coordinateSystem>(new coordinateSystem(*this));
}
// Declare run-time constructor selection table
declareRunTimeSelectionTable
declareRunTimeSelectionTable
(
autoPtr,
coordinateSystem,
dictionary,
(
autoPtr,
coordinateSystem,
dictionary,
(
const word& name,
const dictionary& dict
),
(name, dict)
);
declareRunTimeSelectionTable
(
autoPtr,
coordinateSystem,
origRotation,
(
const word& name,
const point& origin,
const coordinateRotation& cr
),
(name, origin, cr)
);
const objectRegistry& obr,
const dictionary& dict
),
(obr, dict)
);
// Selectors
//- Select constructed from dictionary and objectRegistry
static autoPtr<coordinateSystem> New
(
const objectRegistry& obr,
const dictionary& dict
);
//- Select constructed from dictionary
static autoPtr<coordinateSystem> New
(
const word& name,
const dictionary&
);
//- Select constructed from origin and rotation
static autoPtr<coordinateSystem> New
(
const word& coordType,
const word& name,
const point& origin,
const coordinateRotation&
const dictionary& dict
);
//- Select constructed from Istream
@ -307,6 +231,7 @@ public:
// Member Functions
// Access
//- Return name
@ -333,49 +258,18 @@ public:
return origin_;
}
//- Return coordinate rotation
const coordinateRotation& rotation() const
//- Return const reference to coordinate rotation
const coordinateRotation& R() const
{
return R_;
return R_();
}
//- Return local-to-global transformation tensor
const tensor& R() const
//- Return non const reference to coordinate rotation
coordinateRotation& R()
{
return R_;
return R_();
}
//- Return local Cartesian x-axis
const vector e1() const
{
return Rtr_.x();
}
//- Return local Cartesian y-axis
const vector e2() const
{
return Rtr_.y();
}
//- Return local Cartesian z-axis
const vector e3() const
{
return Rtr_.z();
}
//- Return axis (e3: local Cartesian z-axis)
// \deprecated method e3 is preferred (deprecated Apr 2008)
const vector axis() const
{
return Rtr_.z();
}
//- Return direction (e1: local Cartesian x-axis)
// \deprecated method e1 is preferred (deprecated Apr 2008)
const vector direction() const
{
return Rtr_.x();
}
//- Return as dictionary of entries
// \param [in] ignoreType drop type (cartesian, cylindrical, etc)
@ -386,7 +280,7 @@ public:
// Edit
//- Rename
virtual void rename(const word& newName)
void rename(const word& newName)
{
name_ = newName;
}
@ -408,7 +302,7 @@ public:
virtual void write(Ostream&) const;
//- Write dictionary
virtual void writeDict(Ostream&, bool subDict=true) const;
void writeDict(Ostream&, bool subDict=true) const;
// Transformations
@ -472,22 +366,18 @@ public:
// Member Operators
//- assign from dictionary
void operator=(const dictionary&);
// friend Operators
friend bool operator!=
(
const coordinateSystem&,
const coordinateSystem&
);
// friend Operators
// IOstream Operators
friend bool operator!=
(
const coordinateSystem&,
const coordinateSystem&
);
// IOstream Operators
friend Ostream& operator<<(Ostream&, const coordinateSystem&);
friend Ostream& operator<<(Ostream&, const coordinateSystem&);
};

78
src/meshTools/coordinateSystems/coordinateSystemNew.C
View File

@ -30,7 +30,7 @@ License
Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New
(
const word& name,
const objectRegistry& obr,
const dictionary& dict
)
{
@ -41,17 +41,8 @@ Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New
<< endl;
}
// construct base class directly, also allow 'cartesian' as an alias
word coordType(typeName_());
if
(
!dict.readIfPresent("type", coordType)
|| coordType == typeName_()
|| coordType == "cartesian"
)
{
return autoPtr<coordinateSystem>(new coordinateSystem(name, dict));
}
const dictionary& coordDict = dict.subDict(typeName_());
word coordType = coordDict.lookup("type");
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(coordType);
@ -60,20 +51,54 @@ Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New
{
FatalIOErrorIn
(
"coordinateSystem::New(const word&, const dictionary&)",
"coordinateSystem::New(const objectRegistry&, const dictionary&)",
dict
) << "Unknown coordinateSystem type "
<< coordType << nl << nl
<< "Valid coordinateSystem types are :" << nl
<< "[default: " << typeName_() << "]"
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<coordinateSystem>(cstrIter()(name, dict));
return autoPtr<coordinateSystem>(cstrIter()(obr, coordDict));
}
Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New
(
const dictionary& dict
)
{
if (debug)
{
Pout<< "coordinateSystem::New(cconst dictionary&) : "
<< "constructing coordinateSystem"
<< endl;
}
const dictionary& coordDict = dict.subDict(typeName_());
word coordType = coordDict.lookup("type");
/*
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(coordType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorIn
(
"coordinateSystem::New(const dictionary&)",
dict
) << "Unknown coordinateSystem type "
<< coordType << nl << nl
<< "Valid coordinateSystem types are :" << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
*/
return autoPtr<coordinateSystem>(new coordinateSystem(coordDict));
}
/*
Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New
(
const word& coordType,
@ -109,7 +134,7 @@ Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New
return autoPtr<coordinateSystem>(cstrIter()(name, origin, cr));
}
*/
Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New
(
@ -119,7 +144,26 @@ Foam::autoPtr<Foam::coordinateSystem> Foam::coordinateSystem::New
const word name(is);
const dictionary dict(is);
return New(name, dict);
word coordType = dict.lookup("type");
/*
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(coordType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorIn
(
"coordinateSystem::New(Istream& is)",
dict
) << "Unknown coordinateSystem type "
<< coordType << nl << nl
<< "Valid coordinateSystem types are :" << nl
<< "[default: " << typeName_() << "]"
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
*/
return autoPtr<coordinateSystem>(new coordinateSystem(name, dict));
}

19
src/meshTools/coordinateSystems/coordinateSystems.H
View File

@ -31,6 +31,25 @@ Note
Mixing normal constructors and the coordinateSystems::New constructor
may yield unexpected results.
\verbatim
1
(
cat1
{
coordinateSystem system_10;
porosity 0.781;
Darcy
{
d d [0 -2 0 0 0] (-1000 -1000 0.50753e+08);
f f [0 -1 0 0 0] (-1000 -1000 12.83);
}
}
)
\endverbatim
For this to work correctly, the coordinateSystem constructor must be
supplied with both a dictionary and an objectRegistry.
SourceFiles
coordinateSystems.C

18
src/meshTools/coordinateSystems/cylindricalCS.C
View File

@ -35,7 +35,6 @@ namespace Foam
{
defineTypeNameAndDebug(cylindricalCS, 0);
addToRunTimeSelectionTable(coordinateSystem, cylindricalCS, dictionary);
addToRunTimeSelectionTable(coordinateSystem, cylindricalCS, origRotation);
}
@ -109,6 +108,23 @@ Foam::cylindricalCS::cylindricalCS
{}
Foam::cylindricalCS::cylindricalCS
(
const objectRegistry& obr,
const dictionary& dict
)
:
coordinateSystem(obr, dict),
inDegrees_(dict.lookupOrDefault("degrees", true))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::cylindricalCS::~cylindricalCS()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool Foam::cylindricalCS::inDegrees() const

12
src/meshTools/coordinateSystems/cylindricalCS.H
View File

@ -61,6 +61,7 @@ protected:
// Protected Member Functions
//- Convert from local coordinate system to the global Cartesian system
// with optional translation for the origin
virtual vector localToGlobal(const vector&, bool translate) const;
@ -131,8 +132,15 @@ public:
const bool inDegrees=true
);
//- Construct from dictionary
cylindricalCS(const word& name, const dictionary&);
//- Construct from dictionary and name
cylindricalCS(const word&, const dictionary&);
//- Construct from dictionary and objectRegistry
cylindricalCS(const objectRegistry&, const dictionary&);
//- Destructor
virtual ~cylindricalCS();
// Member Functions

177
src/meshTools/coordinateSystems/parabolicCylindricalCS.C
View File

@ -1,177 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
\*---------------------------------------------------------------------------*/
#include "parabolicCylindricalCS.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(parabolicCylindricalCS, 0);
addToRunTimeSelectionTable
(
coordinateSystem,
parabolicCylindricalCS,
dictionary
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::parabolicCylindricalCS::parabolicCylindricalCS()
:
coordinateSystem()
{}
Foam::parabolicCylindricalCS::parabolicCylindricalCS
(
const word& name,
const point& origin,
const coordinateRotation& cr
)
:
coordinateSystem(name, origin, cr)
{}
Foam::parabolicCylindricalCS::parabolicCylindricalCS
(
const word& name,
const dictionary& dict
)
:
coordinateSystem(name, dict)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::vector Foam::parabolicCylindricalCS::localToGlobal
(
const vector& local,
bool translate
) const
{
// Notation: u = local.x() v = local.y() z = local.z();
if (local.y() < 0.0)
{
FatalErrorIn
(
"parabolicCylindricalCS::localToGlobal(const vector&, bool) const"
)
<< "parabolic cylindrical coordinates v < 0"
<< abort(FatalError);
}
return coordinateSystem::localToGlobal
(
vector
(
0.5*(sqr(local.x()) - sqr(local.y())),
local.x()*local.y(),
local.z()
),
translate
);
}
Foam::tmp<Foam::vectorField> Foam::parabolicCylindricalCS::localToGlobal
(
const vectorField& local,
bool translate
) const
{
if (min(local.component(vector::Y)) < 0.0)
{
FatalErrorIn
(
"parabolicCylindricalCS::localToGlobal"
"(const vectorField&, bool) const"
) << "parabolic cylindrical coordinates v < 0"
<< abort(FatalError);
}
vectorField lc(local.size());
lc.replace
(
vector::X,
0.5*
(
sqr(local.component(vector::X))
- sqr(local.component(vector::Y))
)
);
lc.replace
(
vector::Y,
local.component(vector::X) * local.component(vector::Y)
);
lc.replace
(
vector::Z,
local.component(vector::Z)
);
return coordinateSystem::localToGlobal(lc, translate);
}
Foam::vector Foam::parabolicCylindricalCS::globalToLocal
(
const vector& global,
bool translate
) const
{
notImplemented
(
"parabolicCylindricalCS::globalToLocal(const vector&, bool) const"
);
return vector::zero;
}
Foam::tmp<Foam::vectorField> Foam::parabolicCylindricalCS::globalToLocal
(
const vectorField& global,
bool translate
) const
{
notImplemented
(
"parabolicCylindricalCS::globalToLocal(const vectorField&, bool) const"
);
return tmp<vectorField>(vectorField::null());
}
// ************************************************************************* //

120
src/meshTools/coordinateSystems/parabolicCylindricalCS.H
View File

@ -1,120 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
Class
Foam::parabolicCylindricalCS
Description
Parabolic cylindrical coordinate system.
Notation: u = a.x() v = a.y() z = a.z();
Note
The maintenance of this class may lag that of the main types.
SourceFiles
parabolicCylindricalCS.C
\*---------------------------------------------------------------------------*/
#ifndef parabolicCylindricalCS_H
#define parabolicCylindricalCS_H
#include "coordinateSystem.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class parabolicCylindricalCS Declaration
\*---------------------------------------------------------------------------*/
class parabolicCylindricalCS
:
public coordinateSystem
{
protected:
// Protected Member Functions
//- Convert from local coordinate system to the global Cartesian system
// with optional translation for the origin
virtual vector localToGlobal(const vector&, bool translate) const;
//- Convert from local coordinate system to the global Cartesian system
// with optional translation for the origin
virtual tmp<vectorField> localToGlobal
(
const vectorField&,
bool translate
) const;
//- Convert from global Cartesian system to the local coordinate system
// with optional translation for the origin
virtual vector globalToLocal(const vector&, bool translate) const;
//- Convert from global Cartesian system to the local coordinate system
// with optional translation for the origin
virtual tmp<vectorField> globalToLocal
(
const vectorField&,
bool translate
) const;
public:
//- Runtime type information
TypeName("parabolicCylindrical");
// Constructors
//- Construct null
parabolicCylindricalCS();
//- Construct from origin and rotation
parabolicCylindricalCS
(
const word& name,
const point& origin,
const coordinateRotation&
);
//- Construct from dictionary
parabolicCylindricalCS(const word&, const dictionary&);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

244
src/meshTools/coordinateSystems/sphericalCS.C
View File

@ -1,244 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
\*---------------------------------------------------------------------------*/
#include "sphericalCS.H"
#include "one.H"
#include "mathematicalConstants.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(sphericalCS, 0);
addToRunTimeSelectionTable(coordinateSystem, sphericalCS, dictionary);
addToRunTimeSelectionTable(coordinateSystem, sphericalCS, origRotation);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::sphericalCS::sphericalCS(const bool inDegrees)
:
coordinateSystem(),
inDegrees_(inDegrees)
{}
Foam::sphericalCS::sphericalCS
(
const coordinateSystem& cs,
const bool inDegrees
)
:
coordinateSystem(cs),
inDegrees_(inDegrees)
{}
Foam::sphericalCS::sphericalCS
(
const word& name,
const coordinateSystem& cs,
const bool inDegrees
)
:
coordinateSystem(name, cs),
inDegrees_(inDegrees)
{}
Foam::sphericalCS::sphericalCS
(
const word& name,
const point& origin,
const coordinateRotation& cr,
const bool inDegrees
)
:
coordinateSystem(name, origin, cr),
inDegrees_(inDegrees)
{}
Foam::sphericalCS::sphericalCS
(
const word& name,
const point& origin,
const vector& axis,
const vector& dirn,
const bool inDegrees
)
:
coordinateSystem(name, origin, axis, dirn),
inDegrees_(inDegrees)
{}
Foam::sphericalCS::sphericalCS
(
const word& name,
const dictionary& dict
)
:
coordinateSystem(name, dict),
inDegrees_(dict.lookupOrDefault("degrees", true))
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool Foam::sphericalCS::inDegrees() const
{
return inDegrees_;
}
bool& Foam::sphericalCS::inDegrees()
{
return inDegrees_;
}
Foam::vector Foam::sphericalCS::localToGlobal
(
const vector& local,
bool translate
) const
{
scalar r = local.x();
const scalar theta
(
local.y()
*(inDegrees_ ? constant::mathematical::pi/180.0 : 1.0)
);
const scalar phi
(
local.z()
*(inDegrees_ ? constant::mathematical::pi/180.0 : 1.0)
);
return coordinateSystem::localToGlobal
(
vector(r*cos(theta)*sin(phi), r*sin(theta)*sin(phi), r*cos(phi)),
translate
);
}
Foam::tmp<Foam::vectorField> Foam::sphericalCS::localToGlobal
(
const vectorField& local,
bool translate
) const
{
const scalarField r(local.component(vector::X));
const scalarField theta
(
local.component(vector::Y)
*(inDegrees_ ? constant::mathematical::pi/180.0 : 1.0)
);
const scalarField phi
(
local.component(vector::Z)
*(inDegrees_ ? constant::mathematical::pi/180.0 : 1.0)
);
vectorField lc(local.size());
lc.replace(vector::X, r*cos(theta)*sin(phi));
lc.replace(vector::Y, r*sin(theta)*sin(phi));
lc.replace(vector::Z, r*cos(phi));
return coordinateSystem::localToGlobal(lc, translate);
}
Foam::vector Foam::sphericalCS::globalToLocal
(
const vector& global,
bool translate
) const
{
const vector lc = coordinateSystem::globalToLocal(global, translate);
const scalar r = mag(lc);
return vector
(
r,
atan2
(
lc.y(), lc.x()
)*(inDegrees_ ? 180.0/constant::mathematical::pi : 1.0),
acos
(
lc.z()/(r + SMALL)
)*(inDegrees_ ? 180.0/constant::mathematical::pi : 1.0)
);
}
Foam::tmp<Foam::vectorField> Foam::sphericalCS::globalToLocal
(
const vectorField& global,
bool translate
) const
{
const vectorField lc(coordinateSystem::globalToLocal(global, translate));
const scalarField r(mag(lc));
tmp<vectorField> tresult(new vectorField(lc.size()));
vectorField& result = tresult();
result.replace
(
vector::X, r
);
result.replace
(
vector::Y,
atan2
(
lc.component(vector::Y),
lc.component(vector::X)
)*(inDegrees_ ? 180.0/constant::mathematical::pi : 1.0)
);
result.replace
(
vector::Z,
acos
(
lc.component(vector::Z)/(r + SMALL)
)*(inDegrees_ ? 180.0/constant::mathematical::pi : 1.0)
);
return tresult;
}
// ************************************************************************* //

184
src/meshTools/coordinateSystems/toroidalCS.C
View File

@ -1,184 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
\*---------------------------------------------------------------------------*/
#include "toroidalCS.H"
#include "addToRunTimeSelectionTable.H"
#include "unitConversion.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(toroidalCS, 0);
addToRunTimeSelectionTable(coordinateSystem, toroidalCS, dictionary);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::toroidalCS::toroidalCS
(
const word& name,
const point& origin,
const coordinateRotation& cr,
const scalar radius
)
:
coordinateSystem(name, origin, cr),
radius_(radius)
{}
Foam::toroidalCS::toroidalCS
(
const word& name,
const dictionary& dict
)
:
coordinateSystem(name, dict),
radius_(readScalar(dict.lookup("radius")))
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::vector Foam::toroidalCS::localToGlobal
(
const vector& local,
bool translate
) const
{
// Notation: r = local.x()
scalar theta = degToRad(local.y());
scalar phi = degToRad(local.z());
scalar rprime = radius_ + local.x()*sin(phi);
if ((local.x()*sin(phi)) > (radius_))
{
FatalErrorIn("toroidalCS::toGlobal(vector) const")
<< "Badly defined toroidal coordinates"
<< abort(FatalError);
}
return coordinateSystem::localToGlobal
(
vector(rprime*cos(theta), rprime*sin(theta), local.x()*cos(phi)),
translate
);
}
Foam::tmp<Foam::vectorField> Foam::toroidalCS::localToGlobal
(
const vectorField& local,
bool translate
) const
{
const scalarField r
(
local.component(vector::X)
);
const scalarField theta
(
local.component(vector::Y)*constant::mathematical::pi/180.0
);
const scalarField phi
(
local.component(vector::Z)*constant::mathematical::pi/180.0
);
const scalarField rprime
(
radius_ + r*sin(phi)
);
vectorField lc(local.size());
lc.replace(vector::X, rprime*cos(theta));
lc.replace(vector::Y, rprime*sin(theta));
lc.replace(vector::Z, r*cos(phi));
return coordinateSystem::localToGlobal(lc, translate);
}
Foam::vector Foam::toroidalCS::globalToLocal
(
const vector& global,
bool translate
) const
{
notImplemented
(
"toroidalCS::globalToLocal(const vector&, bool) const"
);
return vector::zero;
}
Foam::tmp<Foam::vectorField> Foam::toroidalCS::globalToLocal
(
const vectorField& global,
bool translate
) const
{
notImplemented
(
"toroidalCS::globalToLocal(const vectorField&, bool) const"
);
return tmp<vectorField>(vectorField::null());
}
void Foam::toroidalCS::write(Ostream& os) const
{
coordinateSystem::write(os);
os << "radius: " << radius() << endl;
}
void Foam::toroidalCS::writeDict(Ostream& os, bool subDict) const
{
if (subDict)
{
os << indent << name() << nl
<< indent << token::BEGIN_BLOCK << incrIndent << nl;
}
coordinateSystem::writeDict(os, false);
os.writeKeyword("radius") << radius() << token::END_STATEMENT << nl;
if (subDict)
{
os << decrIndent << indent << token::END_BLOCK << endl;
}
}
// ************************************************************************* //

133
src/meshTools/coordinateSystems/toroidalCS.H
View File

@ -1,133 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
Class
Foam::toroidalCS
Description
Toroidal coordinate system, always in degrees
Note
The maintenance of this class may lag that of the main types.
SourceFiles
toroidalCS.C
\*---------------------------------------------------------------------------*/
#ifndef toroidalCS_H
#define toroidalCS_H
#include "coordinateSystem.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class toroidalCS Declaration
\*---------------------------------------------------------------------------*/
class toroidalCS
:
public coordinateSystem
{
// Private data
//- Radius of the torus
scalar radius_;
// Private Member Functions
//- Convert from local coordinate system to the global Cartesian system
// with optional translation for the origin
virtual vector localToGlobal(const vector&, bool translate) const;
//- Convert from local coordinate system to the global Cartesian system
// with optional translation for the origin
virtual tmp<vectorField> localToGlobal
(
const vectorField&,
bool translate
) const;
//- Convert from global Cartesian system to the local coordinate system
// with optional translation for the origin
virtual vector globalToLocal(const vector&, bool translate) const;
//- Convert from global Cartesian system to the local coordinate system
// with optional translation for the origin
virtual tmp<vectorField> globalToLocal
(
const vectorField&,
bool translate
) const;
public:
//- Runtime type information
TypeName("toroidal");
// Constructors
//- Construct from origin, rotation and radius
toroidalCS
(
const word& name,
const point& origin,
const coordinateRotation&,
const scalar radius
);
//- Construct from dictionary
toroidalCS(const word& name, const dictionary&);
// Member Functions
//- Return radius
scalar radius() const
{
return radius_;
}
//- Write
virtual void write(Ostream&) const;
//- Write dictionary
virtual void writeDict(Ostream&, bool subDict=true) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

1
src/meshTools/searchableSurface/searchableSurfaceCollection.C
View File

@ -203,7 +203,6 @@ Foam::searchableSurfaceCollection::searchableSurfaceCollection
surfI,
coordinateSystem::New
(
"",
subDict.subDict("transform")
)
);

2
src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.C
View File

@ -48,7 +48,7 @@ Foam::fieldCoordinateSystemTransform::fieldCoordinateSystemTransform
obr_(obr),
active_(true),
fieldSet_(),
coordSys_(dict, obr)
coordSys_(obr, dict)
{
// Check if the available mesh is an fvMesh otherise deactivate
if (!isA<fvMesh>(obr_))

2
src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransformTemplates.C
View File

@ -39,7 +39,7 @@ void Foam::fieldCoordinateSystemTransform::transformField
{
const word& fieldName = field.name() + "Transformed";
dimensionedTensor R("R", field.dimensions(), coordSys_.R());
dimensionedTensor R("R", field.dimensions(), coordSys_.R().R());
if (obr_.foundObject<Type>(fieldName))
{

2
src/postProcessing/functionObjects/forces/forces/forces.C
View File

@ -444,7 +444,7 @@ void Foam::forces::read(const dictionary& dict)
// specified directly, from coordinate system, or implicitly (0 0 0)
if (!dict.readIfPresent<point>("CofR", coordSys_.origin()))
{
coordSys_ = coordinateSystem(dict, obr_);
coordSys_ = coordinateSystem(obr_, dict);
localSystem_ = true;
}

2
src/sampling/sampledSet/array/arraySet.C
View File

@ -83,7 +83,7 @@ void Foam::arraySet::calcSamples
forAll(sampleCoords, i)
{
sampleCoords[i] = transform(coordSys_.R(), sampleCoords[i]);
sampleCoords[i] = transform(coordSys_.R().R(), sampleCoords[i]);
}
forAll(sampleCoords, sampleI)

2
src/sampling/sampledSurface/sampledPlane/sampledPlane.C
View File

@ -77,7 +77,7 @@ Foam::sampledPlane::sampledPlane
// allow lookup from global coordinate systems
if (dict.found("coordinateSystem"))
{
coordinateSystem cs(dict, mesh);
coordinateSystem cs(mesh, dict);
point base = cs.globalPosition(planeDesc().refPoint());
vector norm = cs.globalVector(planeDesc().normal());