From 685635e6a393e10d8b2332c0d7558e9e79a5512a Mon Sep 17 00:00:00 2001
From: sergio <sergio>
Date: Mon, 21 Jan 2013 12:17:17 +0000
Subject: [PATCH] ENH: Deleting parabolicCylindricalCS, sphericalCS and
toroidalCS 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)
---
src/engine/enginePiston/enginePiston.C | 2 +-
src/engine/engineValve/engineValve.C | 2 +-
.../derived/rotorDiskSource/rotorDiskSource.C | 8 +-
.../trimModel/targetCoeff/targetCoeffTrim.C | 6 +-
src/meshTools/Make/files | 7 +-
src/meshTools/coordinateSystems/cartesianCS.C | 162 +++++++++
.../{sphericalCS.H => cartesianCS.H} | 59 ++--
.../EulerCoordinateRotation.C | 170 ++++++++-
.../EulerCoordinateRotation.H | 97 ++++++
.../STARCDCoordinateRotation.C | 167 ++++++++-
.../STARCDCoordinateRotation.H | 96 ++++++
.../coordinateRotation/axesRotation.C | 324 ++++++++++++++++++
.../coordinateRotation/axesRotation.H | 229 +++++++++++++
.../coordinateRotation/coordinateRotation.C | 204 ++---------
.../coordinateRotation/coordinateRotation.H | 196 ++++++-----
.../coordinateRotationNew.C | 107 ++++++
.../coordinateRotation/localAxesRotation.C | 282 +++++++++++++++
.../coordinateRotation/localAxesRotation.H | 209 +++++++++++
.../coordinateSystems/coordinateSystem.C | 132 ++++---
.../coordinateSystems/coordinateSystem.H | 234 ++++---------
.../coordinateSystems/coordinateSystemNew.C | 78 ++++-
.../coordinateSystems/coordinateSystems.H | 19 +
.../coordinateSystems/cylindricalCS.C | 18 +-
.../coordinateSystems/cylindricalCS.H | 12 +-
.../parabolicCylindricalCS.C | 177 ----------
.../parabolicCylindricalCS.H | 120 -------
src/meshTools/coordinateSystems/sphericalCS.C | 244 -------------
src/meshTools/coordinateSystems/toroidalCS.C | 184 ----------
src/meshTools/coordinateSystems/toroidalCS.H | 133 -------
.../searchableSurfaceCollection.C | 1 -
.../fieldCoordinateSystemTransform.C | 2 +-
.../fieldCoordinateSystemTransformTemplates.C | 2 +-
.../functionObjects/forces/forces/forces.C | 2 +-
src/sampling/sampledSet/array/arraySet.C | 2 +-
.../sampledPlane/sampledPlane.C | 2 +-
35 files changed, 2233 insertions(+), 1456 deletions(-)
create mode 100644 src/meshTools/coordinateSystems/cartesianCS.C
rename src/meshTools/coordinateSystems/{sphericalCS.H => cartesianCS.H} (77%)
create mode 100644 src/meshTools/coordinateSystems/coordinateRotation/axesRotation.C
create mode 100644 src/meshTools/coordinateSystems/coordinateRotation/axesRotation.H
create mode 100644 src/meshTools/coordinateSystems/coordinateRotation/coordinateRotationNew.C
create mode 100644 src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.C
create mode 100644 src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.H
delete mode 100644 src/meshTools/coordinateSystems/parabolicCylindricalCS.C
delete mode 100644 src/meshTools/coordinateSystems/parabolicCylindricalCS.H
delete mode 100644 src/meshTools/coordinateSystems/sphericalCS.C
delete mode 100644 src/meshTools/coordinateSystems/toroidalCS.C
delete mode 100644 src/meshTools/coordinateSystems/toroidalCS.H
diff --git a/src/engine/enginePiston/enginePiston.C b/src/engine/enginePiston/enginePiston.C
index deac506a02f..b186324fd7e 100644
--- a/src/engine/enginePiston/enginePiston.C
+++ b/src/engine/enginePiston/enginePiston.C
@@ -63,7 +63,7 @@ Foam::enginePiston::enginePiston
(
coordinateSystem::New
(
- "coordinateSystem",
+ mesh_,
dict.subDict("coordinateSystem")
)
),
diff --git a/src/engine/engineValve/engineValve.C b/src/engine/engineValve/engineValve.C
index 6b130711a3f..90daa4a2da6 100644
--- a/src/engine/engineValve/engineValve.C
+++ b/src/engine/engineValve/engineValve.C
@@ -125,7 +125,7 @@ Foam::engineValve::engineValve
(
coordinateSystem::New
(
- "coordinateSystem",
+ mesh_,
dict.subDict("coordinateSystem")
)
),
diff --git a/src/fvOptions/sources/derived/rotorDiskSource/rotorDiskSource.C b/src/fvOptions/sources/derived/rotorDiskSource/rotorDiskSource.C
index 070ce02518d..7896ae5dda5 100644
--- a/src/fvOptions/sources/derived/rotorDiskSource/rotorDiskSource.C
+++ b/src/fvOptions/sources/derived/rotorDiskSource/rotorDiskSource.C
@@ -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;
}
diff --git a/src/fvOptions/sources/derived/rotorDiskSource/trimModel/targetCoeff/targetCoeffTrim.C b/src/fvOptions/sources/derived/rotorDiskSource/trimModel/targetCoeff/targetCoeffTrim.C
index 8ee53bad249..4de719b1f60 100644
--- a/src/fvOptions/sources/derived/rotorDiskSource/trimModel/targetCoeff/targetCoeffTrim.C
+++ b/src/fvOptions/sources/derived/rotorDiskSource/trimModel/targetCoeff/targetCoeffTrim.C
@@ -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;
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index 401d14a3836..c8bc7b23a9e 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -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
diff --git a/src/meshTools/coordinateSystems/cartesianCS.C b/src/meshTools/coordinateSystems/cartesianCS.C
new file mode 100644
index 00000000000..4de586c2e9e
--- /dev/null
+++ b/src/meshTools/coordinateSystems/cartesianCS.C
@@ -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);
+}
+
+
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/sphericalCS.H b/src/meshTools/coordinateSystems/cartesianCS.H
similarity index 77%
rename from src/meshTools/coordinateSystems/sphericalCS.H
rename to src/meshTools/coordinateSystems/cartesianCS.H
index f8565bb76f2..3986d8a59ce 100644
--- a/src/meshTools/coordinateSystems/sphericalCS.H
+++ b/src/meshTools/coordinateSystems/cartesianCS.H
@@ -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&);
+
+ //- Construct from dictionary and objectRegistry
+ cartesianCS(const objectRegistry&, const dictionary&);
- // Member Functions
- //- Are angles in degrees?
- bool inDegrees() const;
+ //- Destructor
+ virtual ~cartesianCS();
- //- Non-const access to inDegrees
- bool& inDegrees();
};
+
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.C b/src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.C
index c79697eec90..cf730ec042e 100644
--- a/src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.C
+++ b/src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.C
@@ -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,29 @@ Foam::EulerCoordinateRotation::EulerCoordinateRotation
const dictionary& dict
)
:
- coordinateRotation()
+ 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)
+ );
+}
+
+
+Foam::EulerCoordinateRotation::EulerCoordinateRotation
+(
+ const dictionary& dict,
+ const objectRegistry&
+)
+:
+ R_(sphericalTensor::I),
+ Rtr_(R_)
{
vector rotation(dict.lookup("rotation"));
@@ -141,4 +294,11 @@ Foam::EulerCoordinateRotation::EulerCoordinateRotation
}
+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;
+}
+
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.H b/src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.H
index b8936975ea6..ea7aa8f0234 100644
--- a/src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.H
+++ b/src/meshTools/coordinateSystems/coordinateRotation/EulerCoordinateRotation.H
@@ -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;
};
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.C b/src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.C
index ab2c77ae943..3fe8eab1785 100644
--- a/src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.C
+++ b/src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.C
@@ -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;
+}
+
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.H b/src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.H
index f3286d80ffd..ba5fabad44f 100644
--- a/src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.H
+++ b/src/meshTools/coordinateSystems/coordinateRotation/STARCDCoordinateRotation.H
@@ -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;
};
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/axesRotation.C b/src/meshTools/coordinateSystems/coordinateRotation/axesRotation.C
new file mode 100644
index 00000000000..7d76bc4f313
--- /dev/null
+++ b/src/meshTools/coordinateSystems/coordinateRotation/axesRotation.C
@@ -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;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/axesRotation.H b/src/meshTools/coordinateSystems/coordinateRotation/axesRotation.H
new file mode 100644
index 00000000000..fd61ebc506b
--- /dev/null
+++ b/src/meshTools/coordinateSystems/coordinateRotation/axesRotation.H
@@ -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
+
+// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.C b/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.C
index 4b34a42a8d5..f96e4587bd9 100644
--- a/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.C
+++ b/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.C
@@ -33,197 +33,45 @@ namespace Foam
{
defineTypeNameAndDebug(coordinateRotation, 0);
defineRunTimeSelectionTable(coordinateRotation, dictionary);
+ defineRunTimeSelectionTable(coordinateRotation, objectRegistry);
}
-// * * * * * * * * * * * * * 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 * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
-Foam::autoPtr<Foam::coordinateRotation> Foam::coordinateRotation::New
+Foam::symmTensor Foam::coordinateRotation::transformPrincipal
(
- const dictionary& dict
-)
+ const tensor& tt,
+ const vector& st
+) const
{
- 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));
-}
+ return symmTensor
+ (
+ 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(),
-// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
-
-void Foam::coordinateRotation::clear()
-{
- this->tensor::operator=(sphericalTensor::I);
-}
+ 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(),
-// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
+ tt.yx()*st.x()*tt.zx()
+ + tt.yy()*st.y()*tt.zy()
+ + tt.yz()*st.z()*tt.zz(),
-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 =
- (
- rhs.found(typeName_())
- ? rhs.subDict(typeName_())
- : rhs
+ 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);
}
-
// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.H b/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.H
index 4c58e99c398..3cd8ea5276a 100644
--- a/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.H
+++ b/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotation.H
@@ -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
+ // Declare run-time constructor selection table
+ // for constructors with dictionary and objectRegistry
+ declareRunTimeSelectionTable
+ (
+ autoPtr,
+ coordinateRotation,
+ objectRegistry,
(
- const vector& axis,
- const vector& dir
- );
-
- //- Construct from dictionary
- coordinateRotation(const dictionary&);
+ const dictionary& dict, const objectRegistry& obr
+ ),
+ (dict, obr)
+ );
- //- Return clone
- autoPtr<coordinateRotation> clone() const
- {
- return autoPtr<coordinateRotation>(new coordinateRotation(*this));
- }
// Declare run-time constructor selection table
-
- declareRunTimeSelectionTable
+ // for constructors with dictionary
+ declareRunTimeSelectionTable
+ (
+ autoPtr,
+ coordinateRotation,
+ dictionary,
(
- autoPtr,
- coordinateRotation,
- dictionary,
- (
- const dictionary& dict
- ),
- (dict)
- );
+ 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;
+
+ //- Transform vector using transformation tensor
+ virtual vector transform(const vector& st) const = 0;
+
+ //- 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;
+
- // Member Operators
+ // Write
- //- assign from dictionary
- void operator=(const dictionary&);
+ //- Write
+ virtual void write(Ostream&) const = 0;
};
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotationNew.C b/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotationNew.C
new file mode 100644
index 00000000000..c30c5cb36ea
--- /dev/null
+++ b/src/meshTools/coordinateSystems/coordinateRotation/coordinateRotationNew.C
@@ -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));
+}
+
+// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.C b/src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.C
new file mode 100644
index 00000000000..0c78cc9043d
--- /dev/null
+++ b/src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.C
@@ -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;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.H b/src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.H
new file mode 100644
index 00000000000..7e669bb514e
--- /dev/null
+++ b/src/meshTools/coordinateSystems/coordinateRotation/localAxesRotation.H
@@ -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
+
+// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/coordinateSystem.C b/src/meshTools/coordinateSystems/coordinateSystem.C
index a9153daa85d..8537ec45e01 100644
--- a/src/meshTools/coordinateSystems/coordinateSystem.C
+++ b/src/meshTools/coordinateSystems/coordinateSystem.C
@@ -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()
+ );
}
diff --git a/src/meshTools/coordinateSystems/coordinateSystem.H b/src/meshTools/coordinateSystems/coordinateSystem.H
index 5170b494b48..f0e695b5074 100644
--- a/src/meshTools/coordinateSystems/coordinateSystem.H
+++ b/src/meshTools/coordinateSystems/coordinateSystem.H
@@ -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.
-
- \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
+ Types of coordinateRotation:
+ 1) axesRotation
+ 2) STARCDRotation
+ 3) localAxesRotation
+ 4) EulerCoordinateRotation
- \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
- (
- autoPtr,
- coordinateSystem,
- dictionary,
- (
- const word& name,
- const dictionary& dict
- ),
- (name, dict)
- );
- declareRunTimeSelectionTable
+ // Declare run-time constructor selection table
+ declareRunTimeSelectionTable
+ (
+ autoPtr,
+ coordinateSystem,
+ dictionary,
(
- 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
+ //- Select constructed from dictionary and objectRegistry
static autoPtr<coordinateSystem> New
(
- const word& name,
- const dictionary&
+ const objectRegistry& obr,
+ const dictionary& dict
);
- //- Select constructed from origin and rotation
+ //- Select constructed from dictionary
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 Operators
- friend bool operator!=
- (
- const coordinateSystem&,
- const coordinateSystem&
- );
+ friend bool operator!=
+ (
+ const coordinateSystem&,
+ const coordinateSystem&
+ );
- // IOstream Operators
+ // IOstream Operators
- friend Ostream& operator<<(Ostream&, const coordinateSystem&);
+ friend Ostream& operator<<(Ostream&, const coordinateSystem&);
};
diff --git a/src/meshTools/coordinateSystems/coordinateSystemNew.C b/src/meshTools/coordinateSystems/coordinateSystemNew.C
index 60c4e8482d7..da5bc06958b 100644
--- a/src/meshTools/coordinateSystems/coordinateSystemNew.C
+++ b/src/meshTools/coordinateSystems/coordinateSystemNew.C
@@ -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));
}
diff --git a/src/meshTools/coordinateSystems/coordinateSystems.H b/src/meshTools/coordinateSystems/coordinateSystems.H
index c509eab4ed1..8a0a489eb50 100644
--- a/src/meshTools/coordinateSystems/coordinateSystems.H
+++ b/src/meshTools/coordinateSystems/coordinateSystems.H
@@ -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
diff --git a/src/meshTools/coordinateSystems/cylindricalCS.C b/src/meshTools/coordinateSystems/cylindricalCS.C
index a5055046072..4be9deda7dd 100644
--- a/src/meshTools/coordinateSystems/cylindricalCS.C
+++ b/src/meshTools/coordinateSystems/cylindricalCS.C
@@ -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
diff --git a/src/meshTools/coordinateSystems/cylindricalCS.H b/src/meshTools/coordinateSystems/cylindricalCS.H
index 0cc70efcb56..e03d1feac8a 100644
--- a/src/meshTools/coordinateSystems/cylindricalCS.H
+++ b/src/meshTools/coordinateSystems/cylindricalCS.H
@@ -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
diff --git a/src/meshTools/coordinateSystems/parabolicCylindricalCS.C b/src/meshTools/coordinateSystems/parabolicCylindricalCS.C
deleted file mode 100644
index bf202bd39d1..00000000000
--- a/src/meshTools/coordinateSystems/parabolicCylindricalCS.C
+++ /dev/null
@@ -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());
-}
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/parabolicCylindricalCS.H b/src/meshTools/coordinateSystems/parabolicCylindricalCS.H
deleted file mode 100644
index 9f09e9c2f43..00000000000
--- a/src/meshTools/coordinateSystems/parabolicCylindricalCS.H
+++ /dev/null
@@ -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
-
-// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/sphericalCS.C b/src/meshTools/coordinateSystems/sphericalCS.C
deleted file mode 100644
index f28c87c8c1e..00000000000
--- a/src/meshTools/coordinateSystems/sphericalCS.C
+++ /dev/null
@@ -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;
-}
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/toroidalCS.C b/src/meshTools/coordinateSystems/toroidalCS.C
deleted file mode 100644
index d221b5e93c4..00000000000
--- a/src/meshTools/coordinateSystems/toroidalCS.C
+++ /dev/null
@@ -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;
- }
-}
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/coordinateSystems/toroidalCS.H b/src/meshTools/coordinateSystems/toroidalCS.H
deleted file mode 100644
index fef6ea6303f..00000000000
--- a/src/meshTools/coordinateSystems/toroidalCS.H
+++ /dev/null
@@ -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
-
-// ************************************************************************* //
diff --git a/src/meshTools/searchableSurface/searchableSurfaceCollection.C b/src/meshTools/searchableSurface/searchableSurfaceCollection.C
index 1aa9cbc123f..ba703155a04 100644
--- a/src/meshTools/searchableSurface/searchableSurfaceCollection.C
+++ b/src/meshTools/searchableSurface/searchableSurfaceCollection.C
@@ -203,7 +203,6 @@ Foam::searchableSurfaceCollection::searchableSurfaceCollection
surfI,
coordinateSystem::New
(
- "",
subDict.subDict("transform")
)
);
diff --git a/src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.C b/src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.C
index 250e3c34dca..a4587f26b14 100644
--- a/src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.C
+++ b/src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.C
@@ -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_))
diff --git a/src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransformTemplates.C b/src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransformTemplates.C
index c1ecc72707b..00d21a95f60 100644
--- a/src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransformTemplates.C
+++ b/src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransformTemplates.C
@@ -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))
{
diff --git a/src/postProcessing/functionObjects/forces/forces/forces.C b/src/postProcessing/functionObjects/forces/forces/forces.C
index 27310c7a803..a381a41115c 100644
--- a/src/postProcessing/functionObjects/forces/forces/forces.C
+++ b/src/postProcessing/functionObjects/forces/forces/forces.C
@@ -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;
}
diff --git a/src/sampling/sampledSet/array/arraySet.C b/src/sampling/sampledSet/array/arraySet.C
index fb97a93bfe5..580b718963d 100644
--- a/src/sampling/sampledSet/array/arraySet.C
+++ b/src/sampling/sampledSet/array/arraySet.C
@@ -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)
diff --git a/src/sampling/sampledSurface/sampledPlane/sampledPlane.C b/src/sampling/sampledSurface/sampledPlane/sampledPlane.C
index 3622dcb5853..3f035ee8452 100644
--- a/src/sampling/sampledSurface/sampledPlane/sampledPlane.C
+++ b/src/sampling/sampledSurface/sampledPlane/sampledPlane.C
@@ -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());
--
GitLab