mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
6697bb4735
Previously the coordinate system functionality was split between
coordinateSystem and coordinateRotation. The coordinateRotation stored
the rotation tensor and handled all tensor transformations.
The functionality has now been revised and consolidated into the
coordinateSystem classes. The sole purpose of coordinateRotation
is now just to provide a selectable mechanism of how to define the
rotation tensor (eg, axis-angle, euler angles, local axes) for user
input, but after providing the appropriate rotation tensor it has
no further influence on the transformations.
--
The coordinateSystem class now contains an origin and a base rotation
tensor directly and various transformation methods.
- The origin represents the "shift" for a local coordinate system.
- The base rotation tensor represents the "tilt" or orientation
of the local coordinate system in general (eg, for mapping
positions), but may require position-dependent tensors when
transforming vectors and tensors.
For some coordinate systems (currently the cylindrical coordinate system),
the rotation tensor required for rotating a vector or tensor is
position-dependent.
The new coordinateSystem and its derivates (cartesian, cylindrical,
indirect) now provide a uniform() method to define if the rotation
tensor is position dependent/independent.
The coordinateSystem transform and invTransform methods are now
available in two-parameter forms for obtaining position-dependent
rotation tensors. Eg,
... = cs.transform(globalPt, someVector);
In some cases it can be useful to use query uniform() to avoid
storage of redundant values.
if (cs.uniform())
{
vector xx = cs.transform(someVector);
}
else
{
List<vector> xx = cs.transform(manyPoints, someVector);
}
Support transform/invTransform for common data types:
(scalar, vector, sphericalTensor, symmTensor, tensor).
====================
Breaking Changes
====================
- These changes to coordinate systems and rotations may represent
a breaking change for existing user coding.
- Relocating the rotation tensor into coordinateSystem itself means
that the coordinate system 'R()' method now returns the rotation
directly instead of the coordinateRotation. The method name 'R()'
was chosen for consistency with other low-level entities (eg,
quaternion).
The following changes will be needed in coding:
Old: tensor rot = cs.R().R();
New: tensor rot = cs.R();
Old: cs.R().transform(...);
New: cs.transform(...);
Accessing the runTime selectable coordinateRotation
has moved to the rotation() method:
Old: Info<< "Rotation input: " << cs.R() << nl;
New: Info<< "Rotation input: " << cs.rotation() << nl;
- Naming consistency changes may also cause code to break.
Old: transformVector()
New: transformPrincipal()
The old method name transformTensor() now simply becomes transform().
====================
New methods
====================
For operations requiring caching of the coordinate rotations, the
'R()' method can be used with multiple input points:
tensorField rots(cs.R(somePoints));
and later
Foam::transformList(rots, someVectors);
The rotation() method can also be used to change the rotation tensor
via a new coordinateRotation definition (issue #879).
The new methods transformPoint/invTransformPoint provide
transformations with an origin offset using Cartesian for both local
and global points. These can be used to determine the local position
based on the origin/rotation without interpreting it as a r-theta-z
value, for example.
================
Input format
================
- Streamline dictionary input requirements
* The default type is cartesian.
* The default rotation type is the commonly used axes rotation
specification (with e1/e2/3), which is assumed if the 'rotation'
sub-dictionary does not exist.
Example,
Compact specification:
coordinateSystem
{
origin (0 0 0);
e2 (0 1 0);
e3 (0.5 0 0.866025);
}
Full specification (also accepts the longer 'coordinateRotation'
sub-dictionary name):
coordinateSystem
{
type cartesian;
origin (0 0 0);
rotation
{
type axes;
e2 (0 1 0);
e3 (0.5 0 0.866025);
}
}
This simplifies the input for many cases.
- Additional rotation specification 'none' (an identity rotation):
coordinateSystem
{
origin (0 0 0);
rotation { type none; }
}
- Additional rotation specification 'axisAngle', which is similar
to the -rotate-angle option for transforming points (issue #660).
For some cases this can be more intuitive.
For example,
rotation
{
type axisAngle;
axis (0 1 0);
angle 30;
}
vs.
rotation
{
type axes;
e2 (0 1 0);
e3 (0.5 0 0.866025);
}
- shorter names (or older longer names) for the coordinate rotation
specification.
euler EulerRotation
starcd STARCDRotation
axes axesRotation
================
Coding Style
================
- use Foam::coordSystem namespace for categories of coordinate systems
(cartesian, cylindrical, indirect). This reduces potential name
clashes and makes a clearer declaration. Eg,
coordSystem::cartesian csys_;
The older names (eg, cartesianCS, etc) remain available via typedefs.
- added coordinateRotations namespace for better organization and
reduce potential name clashes.
319 lines
7.7 KiB
C++
319 lines
7.7 KiB
C++
/*---------------------------------------------------------------------------*\
|
|
========= |
|
|
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
|
\\ / O peration |
|
|
\\ / A nd | Copyright (C) 2012-2017 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::ParticleCollector
|
|
|
|
Group
|
|
grpLagrangianIntermediateFunctionObjects
|
|
|
|
Description
|
|
Function object to collect the parcel mass- and mass flow rate over a
|
|
set of polygons. The polygons can either be specified by sets of user-
|
|
supplied points, or in a concentric circles arrangement. If a
|
|
parcel is 'collected', it can be flagged to be removed from the
|
|
domain using the removeCollected entry.
|
|
|
|
Example usage:
|
|
\verbatim
|
|
particleCollector1
|
|
{
|
|
type particleCollector;
|
|
|
|
mode concentricCircle;
|
|
origin (0.05 0.025 0.005);
|
|
radius (0.01 0.025 0.05);
|
|
nSector 10;
|
|
refDir (1 0 0);
|
|
normal (0 0 1);
|
|
|
|
negateParcelsOppositeNormal no;
|
|
removeCollected no;
|
|
surfaceFormat vtk;
|
|
resetOnWrite no;
|
|
log yes;
|
|
}
|
|
|
|
particleCollector2
|
|
{
|
|
type particleCollector;
|
|
|
|
mode polygon;
|
|
polygons
|
|
(
|
|
(
|
|
(0 0 0)
|
|
(1 0 0)
|
|
(1 1 0)
|
|
(0 1 0)
|
|
)
|
|
(
|
|
(0 0 1)
|
|
(1 0 1)
|
|
(1 1 1)
|
|
(0 1 1)
|
|
)
|
|
);
|
|
normal (0 0 1);
|
|
|
|
negateParcelsOppositeNormal no;
|
|
removeCollected no;
|
|
surfaceFormat vtk;
|
|
resetOnWrite no;
|
|
log yes;
|
|
}
|
|
\endverbatim
|
|
|
|
SourceFiles
|
|
ParticleCollector.C
|
|
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
#ifndef ParticleCollector_H
|
|
#define ParticleCollector_H
|
|
|
|
#include "CloudFunctionObject.H"
|
|
#include "cylindricalCS.H"
|
|
#include "face.H"
|
|
#include "Switch.H"
|
|
#include "OFstream.H"
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
namespace Foam
|
|
{
|
|
|
|
/*---------------------------------------------------------------------------*\
|
|
Class ParticleCollector Declaration
|
|
\*---------------------------------------------------------------------------*/
|
|
|
|
template<class CloudType>
|
|
class ParticleCollector
|
|
:
|
|
public CloudFunctionObject<CloudType>
|
|
{
|
|
public:
|
|
|
|
enum modeType
|
|
{
|
|
mtPolygon,
|
|
mtConcentricCircle,
|
|
mtUnknown
|
|
};
|
|
|
|
|
|
private:
|
|
|
|
// Private Data
|
|
|
|
// Typedefs
|
|
|
|
//- Convenience typedef for parcel type
|
|
typedef typename CloudType::parcelType parcelType;
|
|
|
|
//- Collector mode type
|
|
modeType mode_;
|
|
|
|
//- Index of parcel types to collect (-1 by default = all particles)
|
|
const label parcelType_;
|
|
|
|
//- Flag to remove collected particles
|
|
Switch removeCollected_;
|
|
|
|
//- List of points
|
|
Field<point> points_;
|
|
|
|
//- List of faces
|
|
List<face> faces_;
|
|
|
|
|
|
// Polygon collector
|
|
|
|
//- Triangulation of faces
|
|
List<List<face>> faceTris_;
|
|
|
|
// Concentric circles collector
|
|
|
|
//- Number of sectors per circle
|
|
label nSector_;
|
|
|
|
//- List of radii
|
|
List<scalar> radius_;
|
|
|
|
//- Cylindrical coordinate system
|
|
coordSystem::cylindrical coordSys_;
|
|
|
|
|
|
//- Face areas
|
|
Field<scalar> area_;
|
|
|
|
//- Polygon normal vector per face
|
|
Field<vector> normal_;
|
|
|
|
//- Remove mass of parcel travelling in opposite direction to normal_
|
|
bool negateParcelsOppositeNormal_;
|
|
|
|
//- Surface output format
|
|
const word surfaceFormat_;
|
|
|
|
//- Flag to indicate whether data should be reset/cleared on writing
|
|
Switch resetOnWrite_;
|
|
|
|
//- Total time
|
|
scalar totalTime_;
|
|
|
|
//- Mass storage
|
|
List<scalar> mass_;
|
|
|
|
//- Mass total storage
|
|
List<scalar> massTotal_;
|
|
|
|
//- Mass flow rate storage
|
|
List<scalar> massFlowRate_;
|
|
|
|
//- Flag to indicate whether data should be written to file
|
|
Switch log_;
|
|
|
|
//- Output file pointer
|
|
autoPtr<OFstream> outputFilePtr_;
|
|
|
|
//- Last calculation time
|
|
scalar timeOld_;
|
|
|
|
//- Work list to store which faces are hit
|
|
mutable DynamicList<label> hitFaceIDs_;
|
|
|
|
|
|
// Private Member Functions
|
|
|
|
//- Helper function to create log files
|
|
void makeLogFile
|
|
(
|
|
const faceList& faces,
|
|
const Field<point>& points,
|
|
const Field<scalar>& area
|
|
);
|
|
|
|
//- Initialise polygon collectors
|
|
void initPolygons(const List<Field<point>>& polygons);
|
|
|
|
//- Initialise concentric circle collectors
|
|
void initConcentricCircles();
|
|
|
|
//- Collect parcels in polygon collectors
|
|
void collectParcelPolygon
|
|
(
|
|
const point& p1,
|
|
const point& p2
|
|
) const;
|
|
|
|
//- Collect parcels in concentric circle collectors
|
|
void collectParcelConcentricCircles
|
|
(
|
|
const point& p1,
|
|
const point& p2
|
|
) const;
|
|
|
|
|
|
protected:
|
|
|
|
// Protected Member Functions
|
|
|
|
//- Write post-processing info
|
|
void write();
|
|
|
|
|
|
public:
|
|
|
|
//- Runtime type information
|
|
TypeName("particleCollector");
|
|
|
|
|
|
// Constructors
|
|
|
|
//- Construct from dictionary
|
|
ParticleCollector
|
|
(
|
|
const dictionary& dict,
|
|
CloudType& owner,
|
|
const word& modelName
|
|
);
|
|
|
|
//- Construct copy
|
|
ParticleCollector(const ParticleCollector<CloudType>& pc);
|
|
|
|
//- Construct and return a clone
|
|
virtual autoPtr<CloudFunctionObject<CloudType>> clone() const
|
|
{
|
|
return autoPtr<CloudFunctionObject<CloudType>>
|
|
(
|
|
new ParticleCollector<CloudType>(*this)
|
|
);
|
|
}
|
|
|
|
|
|
//- Destructor
|
|
virtual ~ParticleCollector();
|
|
|
|
|
|
// Member Functions
|
|
|
|
// Access
|
|
|
|
//- Return const access to the reset on write flag
|
|
inline const Switch& resetOnWrite() const;
|
|
|
|
|
|
// Evaluation
|
|
|
|
//- Post-move hook
|
|
virtual void postMove
|
|
(
|
|
parcelType& p,
|
|
const scalar dt,
|
|
const point& position0,
|
|
bool& keepParticle
|
|
);
|
|
};
|
|
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
} // End namespace Foam
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
#include "ParticleCollectorI.H"
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
#ifdef NoRepository
|
|
#include "ParticleCollector.C"
|
|
#endif
|
|
|
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
|
|
|
#endif
|
|
|
|
// ************************************************************************* //
|