zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lagrangian: Removed unnecessary patch argument from hit methods

Browse Source 
The patch can be determined from the particle when it is needed. Most of
the time it is not.
This commit is contained in:
Will Bainbridge
2017-08-23 16:27:36 +01:00
parent dc10cfd686
commit b3e675ea43
23 changed files with 166 additions and 544 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
src/functionObjects/field/nearWallFields/findCellParticle.C
View File

@ -126,12 +126,7 @@ bool Foam::findCellParticle::move
} }
bool Foam::findCellParticle::hitPatch bool Foam::findCellParticle::hitPatch(Cloud<findCellParticle>&, trackingData&)
(
const polyPatch&,
Cloud<findCellParticle>& cloud,
trackingData& td
)
{ {
return false; return false;
} }
@ -139,8 +134,7 @@ bool Foam::findCellParticle::hitPatch
void Foam::findCellParticle::hitWedgePatch void Foam::findCellParticle::hitWedgePatch
( (
const wedgePolyPatch&, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -151,8 +145,7 @@ void Foam::findCellParticle::hitWedgePatch
void Foam::findCellParticle::hitSymmetryPlanePatch void Foam::findCellParticle::hitSymmetryPlanePatch
( (
const symmetryPlanePolyPatch&, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -163,8 +156,7 @@ void Foam::findCellParticle::hitSymmetryPlanePatch
void Foam::findCellParticle::hitSymmetryPatch void Foam::findCellParticle::hitSymmetryPatch
( (
const symmetryPolyPatch&, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -175,8 +167,7 @@ void Foam::findCellParticle::hitSymmetryPatch
void Foam::findCellParticle::hitCyclicPatch void Foam::findCellParticle::hitCyclicPatch
( (
const cyclicPolyPatch&, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -187,8 +178,7 @@ void Foam::findCellParticle::hitCyclicPatch
void Foam::findCellParticle::hitCyclicAMIPatch void Foam::findCellParticle::hitCyclicAMIPatch
( (
const cyclicAMIPolyPatch&, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud,
trackingData& td, trackingData& td,
const vector& const vector&
) )
@ -200,8 +190,7 @@ void Foam::findCellParticle::hitCyclicAMIPatch
void Foam::findCellParticle::hitCyclicACMIPatch void Foam::findCellParticle::hitCyclicACMIPatch
( (
const cyclicACMIPolyPatch&, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud,
trackingData& td, trackingData& td,
const vector& const vector&
) )
@ -213,8 +202,7 @@ void Foam::findCellParticle::hitCyclicACMIPatch
void Foam::findCellParticle::hitProcessorPatch void Foam::findCellParticle::hitProcessorPatch
( (
const processorPolyPatch&, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -225,8 +213,7 @@ void Foam::findCellParticle::hitProcessorPatch
void Foam::findCellParticle::hitWallPatch void Foam::findCellParticle::hitWallPatch
( (
const wallPolyPatch& wpp, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud,
trackingData& td trackingData& td
) )
{ {

60
src/functionObjects/field/nearWallFields/findCellParticle.H
View File

@ -222,84 +222,46 @@ public:
//- Track all particles to their end point //- Track all particles to their end point
bool move(Cloud<findCellParticle>&, trackingData&, const scalar); bool move(Cloud<findCellParticle>&, trackingData&, const scalar);
//- Overridable function to handle the particle hitting a patch //- Overridable function to handle the particle hitting a patch
// Executed before other patch-hitting functions // Executed before other patch-hitting functions
bool hitPatch bool hitPatch(Cloud<findCellParticle>&, trackingData&);
(
const polyPatch&,
Cloud<findCellParticle>&,
trackingData& td
);
//- Overridable function to handle the particle hitting a wedge //- Overridable function to handle the particle hitting a wedge
void hitWedgePatch void hitWedgePatch(Cloud<findCellParticle>&, trackingData&);
(
const wedgePolyPatch&,
Cloud<findCellParticle>&,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// symmetry plane // symmetry plane
void hitSymmetryPlanePatch void hitSymmetryPlanePatch(Cloud<findCellParticle>&, trackingData&);
(
const symmetryPlanePolyPatch&,
Cloud<findCellParticle>&,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// symmetry patch // symmetry patch
void hitSymmetryPatch void hitSymmetryPatch(Cloud<findCellParticle>&, trackingData&);
(
const symmetryPolyPatch&,
Cloud<findCellParticle>&,
trackingData& td
);
//- Overridable function to handle the particle hitting a cyclic //- Overridable function to handle the particle hitting a cyclic
void hitCyclicPatch void hitCyclicPatch(Cloud<findCellParticle>&, trackingData&);
(
const cyclicPolyPatch&,
Cloud<findCellParticle>&,
trackingData& td
);
//- Overridable function to handle the particle hitting a cyclicAMI //- Overridable function to handle the particle hitting a cyclicAMI
void hitCyclicAMIPatch void hitCyclicAMIPatch
( (
const cyclicAMIPolyPatch&, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud, trackingData&,
trackingData& td,
const vector& const vector&
); );
//- Overridable function to handle the particle hitting a cyclicACMI //- Overridable function to handle the particle hitting a cyclicACMI
void hitCyclicACMIPatch void hitCyclicACMIPatch
( (
const cyclicACMIPolyPatch&, Cloud<findCellParticle>&,
Cloud<findCellParticle>& cloud, trackingData&,
trackingData& td,
const vector& const vector&
); );
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
//- processorPatch //- processorPatch
void hitProcessorPatch void hitProcessorPatch(Cloud<findCellParticle>&, trackingData&);
(
const processorPolyPatch&,
Cloud<findCellParticle>&,
trackingData& td
);
//- Overridable function to handle the particle hitting a wallPatch //- Overridable function to handle the particle hitting a wallPatch
void hitWallPatch void hitWallPatch(Cloud<findCellParticle>&, trackingData&);
(
const wallPolyPatch&,
Cloud<findCellParticle>&,
trackingData& td
);
// Ostream Operator // Ostream Operator

31
src/functionObjects/field/streamLine/streamLineParticle.C
View File

@ -270,12 +270,7 @@ bool Foam::streamLineParticle::move
} }
bool Foam::streamLineParticle::hitPatch bool Foam::streamLineParticle::hitPatch(streamLineParticleCloud&, trackingData&)
(
const polyPatch&,
streamLineParticleCloud& cloud,
trackingData& td
)
{ {
// Disable generic patch interaction // Disable generic patch interaction
return false; return false;
@ -284,8 +279,7 @@ bool Foam::streamLineParticle::hitPatch
void Foam::streamLineParticle::hitWedgePatch void Foam::streamLineParticle::hitWedgePatch
( (
const wedgePolyPatch& pp, streamLineParticleCloud&,
streamLineParticleCloud& cloud,
trackingData& td trackingData& td
) )
{ {
@ -296,8 +290,7 @@ void Foam::streamLineParticle::hitWedgePatch
void Foam::streamLineParticle::hitSymmetryPlanePatch void Foam::streamLineParticle::hitSymmetryPlanePatch
( (
const symmetryPlanePolyPatch& pp, streamLineParticleCloud&,
streamLineParticleCloud& cloud,
trackingData& td trackingData& td
) )
{ {
@ -308,8 +301,7 @@ void Foam::streamLineParticle::hitSymmetryPlanePatch
void Foam::streamLineParticle::hitSymmetryPatch void Foam::streamLineParticle::hitSymmetryPatch
( (
const symmetryPolyPatch& pp, streamLineParticleCloud&,
streamLineParticleCloud& cloud,
trackingData& td trackingData& td
) )
{ {
@ -320,8 +312,7 @@ void Foam::streamLineParticle::hitSymmetryPatch
void Foam::streamLineParticle::hitCyclicPatch void Foam::streamLineParticle::hitCyclicPatch
( (
const cyclicPolyPatch& pp, streamLineParticleCloud&,
streamLineParticleCloud& cloud,
trackingData& td trackingData& td
) )
{ {
@ -332,8 +323,7 @@ void Foam::streamLineParticle::hitCyclicPatch
void Foam::streamLineParticle::hitCyclicAMIPatch void Foam::streamLineParticle::hitCyclicAMIPatch
( (
const cyclicAMIPolyPatch&, streamLineParticleCloud&,
streamLineParticleCloud& cloud,
trackingData& td, trackingData& td,
const vector& const vector&
) )
@ -345,8 +335,7 @@ void Foam::streamLineParticle::hitCyclicAMIPatch
void Foam::streamLineParticle::hitCyclicACMIPatch void Foam::streamLineParticle::hitCyclicACMIPatch
( (
const cyclicACMIPolyPatch&, streamLineParticleCloud&,
streamLineParticleCloud& cloud,
trackingData& td, trackingData& td,
const vector& const vector&
) )
@ -358,8 +347,7 @@ void Foam::streamLineParticle::hitCyclicACMIPatch
void Foam::streamLineParticle::hitProcessorPatch void Foam::streamLineParticle::hitProcessorPatch
( (
const processorPolyPatch&, streamLineParticleCloud&,
streamLineParticleCloud& cloud,
trackingData& td trackingData& td
) )
{ {
@ -370,8 +358,7 @@ void Foam::streamLineParticle::hitProcessorPatch
void Foam::streamLineParticle::hitWallPatch void Foam::streamLineParticle::hitWallPatch
( (
const wallPolyPatch& wpp, streamLineParticleCloud&,
streamLineParticleCloud& cloud,
trackingData& td trackingData& td
) )
{ {

66
src/functionObjects/field/streamLine/streamLineParticle.H
View File

@ -207,63 +207,32 @@ public:
// Tracking // Tracking
//- Track all particles to their end point //- Track all particles to their end point
bool move bool move(streamLineParticleCloud&, trackingData&, const scalar);
(
streamLineParticleCloud& cloud,
trackingData&,
const scalar
);
//- Overridable function to handle the particle hitting a patch //- Overridable function to handle the particle hitting a patch
// Executed before other patch-hitting functions // Executed before other patch-hitting functions
bool hitPatch bool hitPatch(streamLineParticleCloud&, trackingData&);
(
const polyPatch&,
streamLineParticleCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wedge //- Overridable function to handle the particle hitting a wedge
void hitWedgePatch void hitWedgePatch(streamLineParticleCloud&, trackingData&);
(
const wedgePolyPatch&,
streamLineParticleCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// symmetry plane // symmetry plane
void hitSymmetryPlanePatch void hitSymmetryPlanePatch(streamLineParticleCloud&, trackingData&);
(
const symmetryPlanePolyPatch&,
streamLineParticleCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// symmetry patch // symmetry patch
void hitSymmetryPatch void hitSymmetryPatch(streamLineParticleCloud&, trackingData&);
(
const symmetryPolyPatch&,
streamLineParticleCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a cyclic //- Overridable function to handle the particle hitting a cyclic
void hitCyclicPatch void hitCyclicPatch(streamLineParticleCloud&, trackingData&);
(
const cyclicPolyPatch&,
streamLineParticleCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// cyclicAMIPatch // cyclicAMIPatch
void hitCyclicAMIPatch void hitCyclicAMIPatch
( (
const cyclicAMIPolyPatch&, streamLineParticleCloud&,
streamLineParticleCloud& cloud, trackingData&,
trackingData& td,
const vector& direction const vector& direction
); );
@ -271,28 +240,17 @@ public:
// cyclicACMIPatch // cyclicACMIPatch
void hitCyclicACMIPatch void hitCyclicACMIPatch
( (
const cyclicACMIPolyPatch&, streamLineParticleCloud&,
streamLineParticleCloud& cloud, trackingData&,
trackingData& td,
const vector& direction const vector& direction
); );
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
//- processorPatch //- processorPatch
void hitProcessorPatch void hitProcessorPatch(streamLineParticleCloud&, trackingData&);
(
const processorPolyPatch&,
streamLineParticleCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wallPatch //- Overridable function to handle the particle hitting a wallPatch
void hitWallPatch void hitWallPatch(streamLineParticleCloud&, trackingData&);
(
const wallPolyPatch&,
streamLineParticleCloud& cloud,
trackingData& td
);
// I-O // I-O

30
src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.C
View File

@ -81,12 +81,7 @@ bool Foam::DSMCParcel<ParcelType>::move
template<class ParcelType> template<class ParcelType>
template<class TrackCloudType> template<class TrackCloudType>
bool Foam::DSMCParcel<ParcelType>::hitPatch bool Foam::DSMCParcel<ParcelType>::hitPatch(TrackCloudType&, trackingData&)
(
const polyPatch&,
TrackCloudType& cloud,
trackingData& td
)
{ {
return false; return false;
} }
@ -96,8 +91,7 @@ template<class ParcelType>
template<class TrackCloudType> template<class TrackCloudType>
void Foam::DSMCParcel<ParcelType>::hitProcessorPatch void Foam::DSMCParcel<ParcelType>::hitProcessorPatch
( (
const processorPolyPatch&, TrackCloudType&,
TrackCloudType& cloud,
trackingData& td trackingData& td
) )
{ {
@ -109,14 +103,19 @@ template<class ParcelType>
template<class TrackCloudType> template<class TrackCloudType>
void Foam::DSMCParcel<ParcelType>::hitWallPatch void Foam::DSMCParcel<ParcelType>::hitWallPatch
( (
const wallPolyPatch& wpp,
TrackCloudType& cloud, TrackCloudType& cloud,
trackingData& td trackingData&
) )
{ {
label wppIndex = wpp.index(); const label wppIndex = this->patch();
label wppLocalFace = wpp.whichFace(this->face()); const wallPolyPatch& wpp =
static_cast<const wallPolyPatch&>
(
this->mesh().boundaryMesh()[wppIndex]
);
const label wppLocalFace = wpp.whichFace(this->face());
const scalar fA = mag(wpp.faceAreas()[wppLocalFace]); const scalar fA = mag(wpp.faceAreas()[wppLocalFace]);
@ -155,11 +154,7 @@ void Foam::DSMCParcel<ParcelType>::hitWallPatch
// pre-interaction momentum // pre-interaction momentum
vector preIMom = m*U_; vector preIMom = m*U_;
cloud.wallInteraction().correct cloud.wallInteraction().correct(*this);
(
static_cast<DSMCParcel<ParcelType> &>(*this),
wpp
);
U_dot_nw = U_ & nw; U_dot_nw = U_ & nw;
@ -194,7 +189,6 @@ void Foam::DSMCParcel<ParcelType>::hitWallPatch
cloud.qBF()[wppIndex][wppLocalFace] += deltaQ; cloud.qBF()[wppIndex][wppLocalFace] += deltaQ;
cloud.fDBF()[wppIndex][wppLocalFace] += deltaFD; cloud.fDBF()[wppIndex][wppLocalFace] += deltaFD;
} }

21
src/lagrangian/DSMC/parcels/Templates/DSMCParcel/DSMCParcel.H
View File

@ -262,31 +262,16 @@ public:
//- Overridable function to handle the particle hitting a patch //- Overridable function to handle the particle hitting a patch
// Executed before other patch-hitting functions // Executed before other patch-hitting functions
template<class TrackCloudType> template<class TrackCloudType>
bool hitPatch bool hitPatch(TrackCloudType&, trackingData&);
(
const polyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// processorPatch // processorPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitProcessorPatch void hitProcessorPatch(TrackCloudType&, trackingData&);
(
const processorPolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wallPatch //- Overridable function to handle the particle hitting a wallPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitWallPatch void hitWallPatch(TrackCloudType&, trackingData&);
(
const wallPolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Transform the physical properties of the particle //- Transform the physical properties of the particle
// according to the given transformation tensor // according to the given transformation tensor

9
src/lagrangian/DSMC/submodels/WallInteractionModel/MaxwellianThermal/MaxwellianThermal.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -53,8 +53,7 @@ Foam::MaxwellianThermal<CloudType>::~MaxwellianThermal()
template<class CloudType> template<class CloudType>
void Foam::MaxwellianThermal<CloudType>::correct void Foam::MaxwellianThermal<CloudType>::correct
( (
typename CloudType::parcelType& p, typename CloudType::parcelType& p
const wallPolyPatch& wpp
) )
{ {
vector& U = p.U(); vector& U = p.U();
@ -63,7 +62,9 @@ void Foam::MaxwellianThermal<CloudType>::correct
label typeId = p.typeId(); label typeId = p.typeId();
label wppIndex = wpp.index(); const label wppIndex = p.patch();
const polyPatch& wpp = p.mesh().boundaryMesh()[wppIndex];
label wppLocalFace = wpp.whichFace(p.face()); label wppLocalFace = wpp.whichFace(p.face());

8
src/lagrangian/DSMC/submodels/WallInteractionModel/MaxwellianThermal/MaxwellianThermal.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -72,11 +72,7 @@ public:
// Member Functions // Member Functions
//- Apply wall correction //- Apply wall correction
virtual void correct virtual void correct(typename CloudType::parcelType& p);
(
typename CloudType::parcelType& p,
const wallPolyPatch& wpp
);
}; };

9
src/lagrangian/DSMC/submodels/WallInteractionModel/MixedDiffuseSpecular/MixedDiffuseSpecular.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -51,8 +51,7 @@ Foam::MixedDiffuseSpecular<CloudType>::~MixedDiffuseSpecular()
template<class CloudType> template<class CloudType>
void Foam::MixedDiffuseSpecular<CloudType>::correct void Foam::MixedDiffuseSpecular<CloudType>::correct
( (
typename CloudType::parcelType& p, typename CloudType::parcelType& p
const wallPolyPatch& wpp
) )
{ {
vector& U = p.U(); vector& U = p.U();
@ -61,7 +60,9 @@ void Foam::MixedDiffuseSpecular<CloudType>::correct
label typeId = p.typeId(); label typeId = p.typeId();
label wppIndex = wpp.index(); const label wppIndex = p.patch();
const polyPatch& wpp = p.mesh().boundaryMesh()[wppIndex];
label wppLocalFace = wpp.whichFace(p.face()); label wppLocalFace = wpp.whichFace(p.face());

8
src/lagrangian/DSMC/submodels/WallInteractionModel/MixedDiffuseSpecular/MixedDiffuseSpecular.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -80,11 +80,7 @@ public:
// Member Functions // Member Functions
//- Apply wall correction //- Apply wall correction
virtual void correct virtual void correct(typename CloudType::parcelType& p);
(
typename CloudType::parcelType& p,
const wallPolyPatch& wpp
);
}; };

5
src/lagrangian/DSMC/submodels/WallInteractionModel/SpecularReflection/SpecularReflection.C
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -52,8 +52,7 @@ Foam::SpecularReflection<CloudType>::~SpecularReflection()
template<class CloudType> template<class CloudType>
void Foam::SpecularReflection<CloudType>::correct void Foam::SpecularReflection<CloudType>::correct
( (
typename CloudType::parcelType& p, typename CloudType::parcelType& p
const wallPolyPatch& wpp
) )
{ {
vector& U = p.U(); vector& U = p.U();

8
src/lagrangian/DSMC/submodels/WallInteractionModel/SpecularReflection/SpecularReflection.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -70,11 +70,7 @@ public:
// Member Functions // Member Functions
//- Apply wall correction //- Apply wall correction
virtual void correct virtual void correct(typename CloudType::parcelType& p);
(
typename CloudType::parcelType& p,
const wallPolyPatch& wpp
);
}; };

8
src/lagrangian/DSMC/submodels/WallInteractionModel/WallInteractionModel/WallInteractionModel.H
View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -127,11 +127,7 @@ public:
// Member Functions // Member Functions
//- Apply wall correction //- Apply wall correction
virtual void correct virtual void correct(typename CloudType::parcelType& p) = 0;
(
typename CloudType::parcelType& p,
const wallPolyPatch& wpp
) = 0;
}; };

75
src/lagrangian/basic/particle/particle.H
View File

@ -284,93 +284,44 @@ protected:
// Patch interactions // Patch interactions
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a patch.
// patch. Executed before other patch-hitting functions. // Executed before other patch-hitting functions.
template<class TrackCloudType> template<class TrackCloudType>
bool hitPatch bool hitPatch(TrackCloudType&, trackingData&);
(
const polyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wedgePatch //- Overridable function to handle the particle hitting a wedgePatch
template<class TrackCloudType> template<class TrackCloudType>
void hitWedgePatch void hitWedgePatch(TrackCloudType&, trackingData&);
(
const wedgePolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// symmetryPlanePatch // symmetryPlanePatch
template<class TrackCloudType> template<class TrackCloudType>
void hitSymmetryPlanePatch void hitSymmetryPlanePatch(TrackCloudType&, trackingData&);
(
const symmetryPlanePolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a symmetryPatch
// symmetryPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitSymmetryPatch void hitSymmetryPatch(TrackCloudType&, trackingData&);
(
const symmetryPolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a cyclicPatch //- Overridable function to handle the particle hitting a cyclicPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitCyclicPatch void hitCyclicPatch(TrackCloudType&, trackingData&);
(
const cyclicPolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a cyclicAMIPatch //- Overridable function to handle the particle hitting a cyclicAMIPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitCyclicAMIPatch void hitCyclicAMIPatch(TrackCloudType&, trackingData&, const vector&);
(
const cyclicAMIPolyPatch&,
TrackCloudType& cloud,
trackingData& td,
const vector& direction
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// cyclicACMIPatch // cyclicACMIPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitCyclicACMIPatch void hitCyclicACMIPatch(TrackCloudType&, trackingData&, const vector&);
(
const cyclicACMIPolyPatch&,
TrackCloudType& cloud,
trackingData& td,
const vector& direction
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a processorPatch
// processorPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitProcessorPatch void hitProcessorPatch(TrackCloudType&, trackingData&);
(
const processorPolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wallPatch //- Overridable function to handle the particle hitting a wallPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitWallPatch void hitWallPatch(TrackCloudType&, trackingData&);
(
const wallPolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
public: public:

130
src/lagrangian/basic/particle/particleTemplates.C
View File

@ -122,73 +122,41 @@ void Foam::particle::hitFace
} }
else if (onBoundaryFace()) else if (onBoundaryFace())
{ {
if(!p.hitPatch(mesh_.boundaryMesh()[p.patch()], cloud, ttd)) if(!p.hitPatch(cloud, ttd))
{ {
const polyPatch& patch = mesh_.boundaryMesh()[p.patch()]; const polyPatch& patch = mesh_.boundaryMesh()[p.patch()];
if (isA<wedgePolyPatch>(patch)) if (isA<wedgePolyPatch>(patch))
{ {
p.hitWedgePatch p.hitWedgePatch(cloud, ttd);
(
static_cast<const wedgePolyPatch&>(patch), cloud, ttd
);
} }
else if (isA<symmetryPlanePolyPatch>(patch)) else if (isA<symmetryPlanePolyPatch>(patch))
{ {
p.hitSymmetryPlanePatch p.hitSymmetryPlanePatch(cloud, ttd);
(
static_cast<const symmetryPlanePolyPatch&>(patch),
cloud,
ttd
);
} }
else if (isA<symmetryPolyPatch>(patch)) else if (isA<symmetryPolyPatch>(patch))
{ {
p.hitSymmetryPatch p.hitSymmetryPatch(cloud, ttd);
(
static_cast<const symmetryPolyPatch&>(patch), cloud, ttd
);
} }
else if (isA<cyclicPolyPatch>(patch)) else if (isA<cyclicPolyPatch>(patch))
{ {
p.hitCyclicPatch p.hitCyclicPatch(cloud, ttd);
(
static_cast<const cyclicPolyPatch&>(patch), cloud, ttd
);
} }
else if (isA<cyclicACMIPolyPatch>(patch)) else if (isA<cyclicACMIPolyPatch>(patch))
{ {
p.hitCyclicACMIPatch p.hitCyclicACMIPatch(cloud, ttd, direction);
(
static_cast<const cyclicACMIPolyPatch&>(patch),
cloud,
ttd,
direction
);
} }
else if (isA<cyclicAMIPolyPatch>(patch)) else if (isA<cyclicAMIPolyPatch>(patch))
{ {
p.hitCyclicAMIPatch p.hitCyclicAMIPatch(cloud, ttd, direction);
(
static_cast<const cyclicAMIPolyPatch&>(patch),
cloud,
ttd,
direction
);
} }
else if (isA<processorPolyPatch>(patch)) else if (isA<processorPolyPatch>(patch))
{ {
p.hitProcessorPatch p.hitProcessorPatch(cloud, ttd);
(
static_cast<const processorPolyPatch&>(patch), cloud, ttd
);
} }
else if (isA<wallPolyPatch>(patch)) else if (isA<wallPolyPatch>(patch))
{ {
p.hitWallPatch p.hitWallPatch(cloud, ttd);
(
static_cast<const wallPolyPatch&>(patch), cloud, ttd
);
} }
else else
{ {
@ -220,43 +188,36 @@ void Foam::particle::trackToAndHitFace
template<class TrackCloudType> template<class TrackCloudType>
bool Foam::particle::hitPatch bool Foam::particle::hitPatch(TrackCloudType&, trackingData&)
(
const polyPatch&,
TrackCloudType&,
trackingData&
)
{ {
return false; return false;
} }
template<class TrackCloudType> template<class TrackCloudType>
void Foam::particle::hitWedgePatch void Foam::particle::hitWedgePatch(TrackCloudType& cloud, trackingData& td)
(
const wedgePolyPatch& wpp,
TrackCloudType&,
trackingData&
)
{ {
FatalErrorInFunction FatalErrorInFunction
<< "Hitting a wedge patch should not be possible." << "Hitting a wedge patch should not be possible."
<< abort(FatalError); << abort(FatalError);
vector nf = normal(); hitSymmetryPatch(cloud, td);
nf /= mag(nf);
transformProperties(I - 2.0*nf*nf);
} }
template<class TrackCloudType> template<class TrackCloudType>
void Foam::particle::hitSymmetryPlanePatch void Foam::particle::hitSymmetryPlanePatch
( (
const symmetryPlanePolyPatch& spp, TrackCloudType& cloud,
TrackCloudType&, trackingData& td
trackingData&
) )
{
hitSymmetryPatch(cloud, td);
}
template<class TrackCloudType>
void Foam::particle::hitSymmetryPatch(TrackCloudType&, trackingData&)
{ {
vector nf = normal(); vector nf = normal();
nf /= mag(nf); nf /= mag(nf);
@ -266,28 +227,10 @@ void Foam::particle::hitSymmetryPlanePatch
template<class TrackCloudType> template<class TrackCloudType>
void Foam::particle::hitSymmetryPatch void Foam::particle::hitCyclicPatch(TrackCloudType&, trackingData&)
(
const symmetryPolyPatch& spp,
TrackCloudType&,
trackingData&
)
{
vector nf = normal();
nf /= mag(nf);
transformProperties(I - 2.0*nf*nf);
}
template<class TrackCloudType>
void Foam::particle::hitCyclicPatch
(
const cyclicPolyPatch& cpp,
TrackCloudType&,
trackingData&
)
{ {
const cyclicPolyPatch& cpp =
static_cast<const cyclicPolyPatch&>(mesh_.boundaryMesh()[patch()]);
const cyclicPolyPatch& receiveCpp = cpp.neighbPatch(); const cyclicPolyPatch& receiveCpp = cpp.neighbPatch();
const label receiveFacei = receiveCpp.whichFace(facei_); const label receiveFacei = receiveCpp.whichFace(facei_);
@ -327,14 +270,15 @@ void Foam::particle::hitCyclicPatch
template<class TrackCloudType> template<class TrackCloudType>
void Foam::particle::hitCyclicAMIPatch void Foam::particle::hitCyclicAMIPatch
( (
const cyclicAMIPolyPatch& cpp, TrackCloudType&,
TrackCloudType& cloud,
trackingData& td, trackingData& td,
const vector& direction const vector& direction
) )
{ {
vector pos = position(); vector pos = position();
const cyclicAMIPolyPatch& cpp =
static_cast<const cyclicAMIPolyPatch&>(mesh_.boundaryMesh()[patch()]);
const cyclicAMIPolyPatch& receiveCpp = cpp.neighbPatch(); const cyclicAMIPolyPatch& receiveCpp = cpp.neighbPatch();
const label sendFacei = cpp.whichFace(facei_); const label sendFacei = cpp.whichFace(facei_);
const label receiveFacei = cpp.pointFace(sendFacei, direction, pos); const label receiveFacei = cpp.pointFace(sendFacei, direction, pos);
@ -398,12 +342,14 @@ void Foam::particle::hitCyclicAMIPatch
template<class TrackCloudType> template<class TrackCloudType>
void Foam::particle::hitCyclicACMIPatch void Foam::particle::hitCyclicACMIPatch
( (
const cyclicACMIPolyPatch& cpp,
TrackCloudType& cloud, TrackCloudType& cloud,
trackingData& td, trackingData& td,
const vector& direction const vector& direction
) )
{ {
const cyclicACMIPolyPatch& cpp =
static_cast<const cyclicACMIPolyPatch&>(mesh_.boundaryMesh()[patch()]);
const label localFacei = cpp.whichFace(facei_); const label localFacei = cpp.whichFace(facei_);
// If the mask is within the patch tolerance at either end, then we can // If the mask is within the patch tolerance at either end, then we can
@ -424,7 +370,7 @@ void Foam::particle::hitCyclicACMIPatch
if (couple) if (couple)
{ {
hitCyclicAMIPatch(cpp, cloud, td, direction); hitCyclicAMIPatch(cloud, td, direction);
} }
else else
{ {
@ -437,22 +383,12 @@ void Foam::particle::hitCyclicACMIPatch
template<class TrackCloudType> template<class TrackCloudType>
void Foam::particle::hitProcessorPatch void Foam::particle::hitProcessorPatch(TrackCloudType&, trackingData&)
(
const processorPolyPatch&,
TrackCloudType&,
trackingData&
)
{} {}
template<class TrackCloudType> template<class TrackCloudType>
void Foam::particle::hitWallPatch void Foam::particle::hitWallPatch(TrackCloudType&, trackingData&)
(
const wallPolyPatch&,
TrackCloudType&,
trackingData&
)
{} {}

13
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcel.C
View File

@ -352,7 +352,6 @@ template<class ParcelType>
template<class TrackCloudType> template<class TrackCloudType>
bool Foam::KinematicParcel<ParcelType>::hitPatch bool Foam::KinematicParcel<ParcelType>::hitPatch
( (
const polyPatch& pp,
TrackCloudType& cloud, TrackCloudType& cloud,
trackingData& td trackingData& td
) )
@ -360,6 +359,8 @@ bool Foam::KinematicParcel<ParcelType>::hitPatch
typename TrackCloudType::parcelType& p = typename TrackCloudType::parcelType& p =
static_cast<typename TrackCloudType::parcelType&>(*this); static_cast<typename TrackCloudType::parcelType&>(*this);
const polyPatch& pp = p.mesh().boundaryMesh()[p.patch()];
// Invoke post-processing model // Invoke post-processing model
cloud.functions().postPatch(p, pp, td.keepParticle); cloud.functions().postPatch(p, pp, td.keepParticle);
@ -386,8 +387,7 @@ template<class ParcelType>
template<class TrackCloudType> template<class TrackCloudType>
void Foam::KinematicParcel<ParcelType>::hitProcessorPatch void Foam::KinematicParcel<ParcelType>::hitProcessorPatch
( (
const processorPolyPatch&, TrackCloudType&,
TrackCloudType& cloud,
trackingData& td trackingData& td
) )
{ {
@ -399,12 +399,11 @@ template<class ParcelType>
template<class TrackCloudType> template<class TrackCloudType>
void Foam::KinematicParcel<ParcelType>::hitWallPatch void Foam::KinematicParcel<ParcelType>::hitWallPatch
( (
const wallPolyPatch& wpp, TrackCloudType&,
TrackCloudType& cloud, trackingData&
trackingData& td
) )
{ {
// Wall interactions handled by generic hitPatch function // wall interactions are handled by the generic hitPatch method
} }

21
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcel.H
View File

@ -585,31 +585,16 @@ public:
//- Overridable function to handle the particle hitting a patch //- Overridable function to handle the particle hitting a patch
// Executed before other patch-hitting functions // Executed before other patch-hitting functions
template<class TrackCloudType> template<class TrackCloudType>
bool hitPatch bool hitPatch(TrackCloudType& cloud, trackingData& td);
(
const polyPatch& p,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// processorPatch // processorPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitProcessorPatch void hitProcessorPatch(TrackCloudType& cloud, trackingData& td);
(
const processorPolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wallPatch //- Overridable function to handle the particle hitting a wallPatch
template<class TrackCloudType> template<class TrackCloudType>
void hitWallPatch void hitWallPatch(TrackCloudType& cloud, trackingData& td);
(
const wallPolyPatch&,
TrackCloudType& cloud,
trackingData& td
);
//- Transform the physical properties of the particle //- Transform the physical properties of the particle
// according to the given transformation tensor // according to the given transformation tensor

21
src/lagrangian/molecularDynamics/molecule/molecule/molecule.C
View File

@ -235,34 +235,19 @@ void Foam::molecule::setSiteSizes(label size)
} }
bool Foam::molecule::hitPatch bool Foam::molecule::hitPatch(moleculeCloud&, trackingData&)
(
const polyPatch&,
moleculeCloud&,
trackingData&
)
{ {
return false; return false;
} }
void Foam::molecule::hitProcessorPatch void Foam::molecule::hitProcessorPatch(moleculeCloud&, trackingData& td)
(
const processorPolyPatch&,
moleculeCloud&,
trackingData& td
)
{ {
td.switchProcessor = true; td.switchProcessor = true;
} }
void Foam::molecule::hitWallPatch void Foam::molecule::hitWallPatch(moleculeCloud&, trackingData&)
(
const wallPolyPatch& wpp,
moleculeCloud& cloud,
trackingData& td
)
{ {
vector nw = normal(); vector nw = normal();
nw /= mag(nw); nw /= mag(nw);

21
src/lagrangian/molecularDynamics/molecule/molecule/molecule.H
View File

@ -364,28 +364,13 @@ public:
//- Overridable function to handle the particle hitting a patch //- Overridable function to handle the particle hitting a patch
// Executed before other patch-hitting functions // Executed before other patch-hitting functions
bool hitPatch bool hitPatch(moleculeCloud& cloud, trackingData& td);
(
const polyPatch&,
moleculeCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a processorPatch //- Overridable function to handle the particle hitting a processorPatch
void hitProcessorPatch void hitProcessorPatch(moleculeCloud& cloud, trackingData& td);
(
const processorPolyPatch&,
moleculeCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wallPatch //- Overridable function to handle the particle hitting a wallPatch
void hitWallPatch void hitWallPatch(moleculeCloud& cloud, trackingData& td);
(
const wallPolyPatch&,
moleculeCloud& cloud,
trackingData& td
);
// I-O // I-O

19
src/lagrangian/solidParticle/solidParticle.C
View File

@ -96,12 +96,7 @@ bool Foam::solidParticle::move
} }
bool Foam::solidParticle::hitPatch bool Foam::solidParticle::hitPatch(solidParticleCloud&, trackingData&)
(
const polyPatch&,
solidParticleCloud& cloud,
trackingData&
)
{ {
return false; return false;
} }
@ -109,8 +104,7 @@ bool Foam::solidParticle::hitPatch
void Foam::solidParticle::hitProcessorPatch void Foam::solidParticle::hitProcessorPatch
( (
const processorPolyPatch&, solidParticleCloud&,
solidParticleCloud& cloud,
trackingData& td trackingData& td
) )
{ {
@ -118,12 +112,7 @@ void Foam::solidParticle::hitProcessorPatch
} }
void Foam::solidParticle::hitWallPatch void Foam::solidParticle::hitWallPatch(solidParticleCloud& cloud, trackingData&)
(
const wallPolyPatch& wpp,
solidParticleCloud& cloud,
trackingData& td
)
{ {
vector nw = normal(); vector nw = normal();
nw /= mag(nw); nw /= mag(nw);
@ -140,7 +129,7 @@ void Foam::solidParticle::hitWallPatch
} }
void Foam::solidParticle::transformProperties (const tensor& T) void Foam::solidParticle::transformProperties(const tensor& T)
{ {
particle::transformProperties(T); particle::transformProperties(T);
U_ = transform(T, U_); U_ = transform(T, U_);

21
src/lagrangian/solidParticle/solidParticle.H
View File

@ -196,29 +196,14 @@ public:
//- Overridable function to handle the particle hitting a patch //- Overridable function to handle the particle hitting a patch
// Executed before other patch-hitting functions // Executed before other patch-hitting functions
bool hitPatch bool hitPatch(solidParticleCloud& cloud, trackingData& td);
(
const polyPatch&,
solidParticleCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// processorPatch // processorPatch
void hitProcessorPatch void hitProcessorPatch(solidParticleCloud& cloud, trackingData& td);
(
const processorPolyPatch&,
solidParticleCloud& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wallPatch //- Overridable function to handle the particle hitting a wallPatch
void hitWallPatch void hitWallPatch(solidParticleCloud& cloud, trackingData& td);
(
const wallPolyPatch&,
solidParticleCloud& cloud,
trackingData& td
);
//- Transform the physical properties of the particle //- Transform the physical properties of the particle
// according to the given transformation tensor // according to the given transformation tensor

33
src/mesh/snappyHexMesh/trackedParticle/trackedParticle.C
View File

@ -154,12 +154,7 @@ bool Foam::trackedParticle::move
} }
bool Foam::trackedParticle::hitPatch bool Foam::trackedParticle::hitPatch(Cloud<trackedParticle>&, trackingData&)
(
const polyPatch&,
Cloud<trackedParticle>& cloud,
trackingData& td
)
{ {
return false; return false;
} }
@ -167,8 +162,7 @@ bool Foam::trackedParticle::hitPatch
void Foam::trackedParticle::hitWedgePatch void Foam::trackedParticle::hitWedgePatch
( (
const wedgePolyPatch&, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -179,8 +173,7 @@ void Foam::trackedParticle::hitWedgePatch
void Foam::trackedParticle::hitSymmetryPlanePatch void Foam::trackedParticle::hitSymmetryPlanePatch
( (
const symmetryPlanePolyPatch&, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -191,8 +184,7 @@ void Foam::trackedParticle::hitSymmetryPlanePatch
void Foam::trackedParticle::hitSymmetryPatch void Foam::trackedParticle::hitSymmetryPatch
( (
const symmetryPolyPatch&, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -203,8 +195,7 @@ void Foam::trackedParticle::hitSymmetryPatch
void Foam::trackedParticle::hitCyclicPatch void Foam::trackedParticle::hitCyclicPatch
( (
const cyclicPolyPatch&, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -215,10 +206,9 @@ void Foam::trackedParticle::hitCyclicPatch
void Foam::trackedParticle::hitCyclicAMIPatch void Foam::trackedParticle::hitCyclicAMIPatch
( (
const cyclicAMIPolyPatch&, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud,
trackingData& td, trackingData& td,
const vector& const vector& direction
) )
{ {
// Remove particle // Remove particle
@ -228,8 +218,7 @@ void Foam::trackedParticle::hitCyclicAMIPatch
void Foam::trackedParticle::hitCyclicACMIPatch void Foam::trackedParticle::hitCyclicACMIPatch
( (
const cyclicACMIPolyPatch&, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud,
trackingData& td, trackingData& td,
const vector& const vector&
) )
@ -241,8 +230,7 @@ void Foam::trackedParticle::hitCyclicACMIPatch
void Foam::trackedParticle::hitProcessorPatch void Foam::trackedParticle::hitProcessorPatch
( (
const processorPolyPatch&, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud,
trackingData& td trackingData& td
) )
{ {
@ -253,8 +241,7 @@ void Foam::trackedParticle::hitProcessorPatch
void Foam::trackedParticle::hitWallPatch void Foam::trackedParticle::hitWallPatch
( (
const wallPolyPatch& wpp, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud,
trackingData& td trackingData& td
) )
{ {

62
src/mesh/snappyHexMesh/trackedParticle/trackedParticle.H
View File

@ -242,88 +242,50 @@ public:
//- Track all particles to their end point //- Track all particles to their end point
bool move(Cloud<trackedParticle>&, trackingData&, const scalar); bool move(Cloud<trackedParticle>&, trackingData&, const scalar);
//- Overridable function to handle the particle hitting a patch //- Overridable function to handle the particle hitting a patch
// Executed before other patch-hitting functions // Executed before other patch-hitting functions
bool hitPatch bool hitPatch(Cloud<trackedParticle>&, trackingData&);
(
const polyPatch&,
Cloud<trackedParticle>& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wedge //- Overridable function to handle the particle hitting a wedge
void hitWedgePatch void hitWedgePatch(Cloud<trackedParticle>&, trackingData&);
(
const wedgePolyPatch&,
Cloud<trackedParticle>& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// symmetry plane // symmetry plane
void hitSymmetryPlanePatch void hitSymmetryPlanePatch(Cloud<trackedParticle>&, trackingData&);
(
const symmetryPlanePolyPatch&,
Cloud<trackedParticle>& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
// symmetry patch // symmetry patch
void hitSymmetryPatch void hitSymmetryPatch(Cloud<trackedParticle>&, trackingData&);
(
const symmetryPolyPatch&,
Cloud<trackedParticle>& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a cyclic //- Overridable function to handle the particle hitting a cyclic
void hitCyclicPatch void hitCyclicPatch(Cloud<trackedParticle>&, trackingData&);
(
const cyclicPolyPatch&,
Cloud<trackedParticle>& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a cyclicAMI //- Overridable function to handle the particle hitting a cyclicAMI
void hitCyclicAMIPatch void hitCyclicAMIPatch
( (
const cyclicAMIPolyPatch&, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud, trackingData&,
trackingData& td,
const vector& const vector&
); );
//- Overridable function to handle the particle hitting a cyclicACMI //- Overridable function to handle the particle hitting a cyclicACMI
void hitCyclicACMIPatch void hitCyclicACMIPatch
( (
const cyclicACMIPolyPatch&, Cloud<trackedParticle>&,
Cloud<trackedParticle>& cloud, trackingData&,
trackingData& td,
const vector& const vector&
); );
//- Overridable function to handle the particle hitting a //- Overridable function to handle the particle hitting a
//- processorPatch //- processorPatch
void hitProcessorPatch void hitProcessorPatch(Cloud<trackedParticle>&, trackingData&);
(
const processorPolyPatch&,
Cloud<trackedParticle>& cloud,
trackingData& td
);
//- Overridable function to handle the particle hitting a wallPatch //- Overridable function to handle the particle hitting a wallPatch
void hitWallPatch void hitWallPatch(Cloud<trackedParticle>&, trackingData&);
(
const wallPolyPatch&,
Cloud<trackedParticle>& cloud,
trackingData& td
);
//- Convert processor patch addressing to the global equivalents //- Convert processor patch addressing to the global equivalents
// and set the celli to the face-neighbour // and set the celli to the face-neighbour
void correctAfterParallelTransfer(const label, trackingData& td); void correctAfterParallelTransfer(const label, trackingData&);
// Ostream Operator // Ostream Operator