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

Resolved unexpected merge problem.

Browse Source
This commit is contained in:
henry
2010-05-25 18:49:10 +01:00
parent 361b153343 619d3e24fc
commit 068b6b1d14
96 changed files with 2936 additions and 452 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
doc/changes/splitCyclic.txt
View File

@ -104,6 +104,14 @@ type 'processorCyclic'.
- processor patches use overlapping communication using a different message
tag. This maps straight through into the MPI message tag.
See processorCyclicPolyPatch::tag(). This needs to be calculated the
same on both sides so is calculated as
Pstream::nProcs()*max(myProcNo, neighbProcNo)
+ min(myProcNo, neighbProcNo)
which is
- unique
- commutative
- does not interfere with the default tag (= 1)
- when constructing a GeometricField from a dictionary it will explicitly

2
src/OpenFOAM/Make/files
View File

@ -341,6 +341,7 @@ $(constraintPolyPatches)/empty/emptyPolyPatch.C
$(constraintPolyPatches)/symmetry/symmetryPolyPatch.C
$(constraintPolyPatches)/wedge/wedgePolyPatch.C
$(constraintPolyPatches)/cyclic/cyclicPolyPatch.C
$(constraintPolyPatches)/cyclicSlip/cyclicSlipPolyPatch.C
$(constraintPolyPatches)/processorCyclic/processorCyclicPolyPatch.C
$(constraintPolyPatches)/processor/processorPolyPatch.C
@ -452,6 +453,7 @@ $(constraintPointPatches)/empty/emptyPointPatch.C
$(constraintPointPatches)/symmetry/symmetryPointPatch.C
$(constraintPointPatches)/wedge/wedgePointPatch.C
$(constraintPointPatches)/cyclic/cyclicPointPatch.C
$(constraintPointPatches)/cyclicSlip/cyclicSlipPointPatch.C
$(constraintPointPatches)/processor/processorPointPatch.C
$(constraintPointPatches)/processorCyclic/processorCyclicPointPatch.C

24
src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C
View File

@ -219,30 +219,6 @@ Foam::List<int> Foam::UPstream::procIDs_(1, 0);
// Standard transfer message type
int Foam::UPstream::msgType_(1);
// New message type
int Foam::UPstream::freeTag_(msgType()+1);
// Free'd message types
Foam::LIFOStack<int> Foam::UPstream::freedTags_;
int Foam::UPstream::allocateTag()
{
if (freedTags_.empty())
{
return freeTag_++;
}
else
{
return freedTags_.pop();
}
}
void Foam::UPstream::freeTag(const int tag)
{
freedTags_.push(tag);
}
// Linear communication schedule
Foam::List<Foam::UPstream::commsStruct> Foam::UPstream::linearCommunication_(0);

12
src/OpenFOAM/db/IOstreams/Pstreams/UPstream.H
View File

@ -45,7 +45,6 @@ SourceFiles
#include "HashTable.H"
#include "string.H"
#include "NamedEnum.H"
#include "LIFOStack.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -191,12 +190,6 @@ private:
static List<commsStruct> treeCommunication_;
//- Current free tag
static int freeTag_;
//- Freed tags
static LIFOStack<int> freedTags_;
// Private Member Functions
//- Set data for parallel running
@ -346,11 +339,6 @@ public:
{
return msgType_;
}
//- Allocate new tag
static int allocateTag();
//- Release allocated tag
static void freeTag(const int tag);
//- Get the communications type of the stream

23
src/OpenFOAM/fields/pointPatchFields/constraint/cyclicSlip/cyclicSlipPointPatchField.C
View File

@ -8,10 +8,10 @@
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 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 2 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
@ -19,12 +19,12 @@ 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/>.
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "cyclicSlipPointPatchField.H"
#include "pointConstraint.H"
#include "transformField.H"
#include "symmTransformField.H"
@ -104,17 +104,6 @@ void cyclicSlipPointPatchField<Type>::evaluate(const Pstream::commsTypes)
}
template<class Type>
void cyclicSlipPointPatchField<Type>::applyConstraint
(
const label pointi,
pointConstraint& pc
) const
{
pc.applyConstraint(this->patch().pointNormals()[pointi]);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam

27
src/OpenFOAM/fields/pointPatchFields/constraint/cyclicSlip/cyclicSlipPointPatchField.H
View File

@ -8,10 +8,10 @@
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 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 2 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
@ -19,13 +19,14 @@ 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/>.
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::cyclicSlipPointPatchField
Description
Specialisation of cyclic that constrains to the patch
Cyclic + slip constraints
SourceFiles
cyclicSlipPointPatchField.C
@ -36,6 +37,7 @@ SourceFiles
#define cyclicSlipPointPatchField_H
#include "cyclicPointPatchField.H"
#include "cyclicSlipPointPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -55,7 +57,7 @@ class cyclicSlipPointPatchField
public:
//- Runtime type information
TypeName("cyclicSlip");
TypeName(cyclicSlipPointPatch::typeName_());
// Constructors
@ -121,19 +123,14 @@ public:
// Member functions
//- Update the patch field
// Evaluation functions
//- Evaluate the patch field
virtual void evaluate
(
const Pstream::commsTypes commsType=Pstream::blocking
);
//- Accumulate the effect of constraint direction of this patch
virtual void applyConstraint
(
const label pointi,
pointConstraint&
) const;
};

11
src/OpenFOAM/fields/pointPatchFields/constraint/cyclicSlip/cyclicSlipPointPatchFields.C
View File

@ -8,10 +8,10 @@
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 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 2 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
@ -19,7 +19,8 @@ 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/>.
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/

11
src/OpenFOAM/fields/pointPatchFields/constraint/cyclicSlip/cyclicSlipPointPatchFields.H
View File

@ -8,10 +8,10 @@
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 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 2 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
@ -19,7 +19,8 @@ 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/>.
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/

75
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclicSlip/cyclicSlipPointPatch.C Normal file
View File

@ -0,0 +1,75 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "cyclicSlipPointPatch.H"
#include "pointConstraint.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
defineTypeNameAndDebug(cyclicSlipPointPatch, 0);
// Add the patch constructor functions to the hash tables
addToRunTimeSelectionTable
(
facePointPatch,
cyclicSlipPointPatch,
polyPatch
);
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const vectorField& cyclicSlipPointPatch::pointNormals() const
{
// Use underlying patch normals
return refCast<const facePointPatch>
(
*this
).facePointPatch::pointNormals();
}
void cyclicSlipPointPatch::applyConstraint
(
const label pointi,
pointConstraint& pc
) const
{
pc.applyConstraint(pointNormals()[pointi]);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

103
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclicSlip/cyclicSlipPointPatch.H Normal file
View File

@ -0,0 +1,103 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::cyclicSlipPointPatch
Description
Cyclic patch with slip constraint
SourceFiles
cyclicSlipPointPatch.C
\*---------------------------------------------------------------------------*/
#ifndef cyclicSlipPointPatch_H
#define cyclicSlipPointPatch_H
#include "cyclicPointPatch.H"
#include "cyclicSlipPolyPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cyclicSlipPointPatch Declaration
\*---------------------------------------------------------------------------*/
class cyclicSlipPointPatch
:
public cyclicPointPatch
{
public:
//- Runtime type information
TypeName(cyclicSlipPolyPatch::typeName_());
// Constructors
//- Construct from components
cyclicSlipPointPatch
(
const polyPatch& patch,
const pointBoundaryMesh& bm
)
:
cyclicPointPatch(patch, bm)
{}
// Destructor
virtual ~cyclicSlipPointPatch()
{}
// Member Functions
//- Return point unit normals.
virtual const vectorField& pointNormals() const;
//- Accumulate the effect of constraint direction of this patch
virtual void applyConstraint
(
const label pointi,
pointConstraint&
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

41
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.C Normal file
View File

@ -0,0 +1,41 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "cyclicSlipPolyPatch.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(cyclicSlipPolyPatch, 0);
addToRunTimeSelectionTable(polyPatch, cyclicSlipPolyPatch, word);
addToRunTimeSelectionTable(polyPatch, cyclicSlipPolyPatch, dictionary);
}
// ************************************************************************* //

200
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclicSlip/cyclicSlipPolyPatch.H Normal file
View File

@ -0,0 +1,200 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::cyclicSlipPolyPatch
Description
Copy of cyclicSlip - used to be able to instantiate cyclicSlip pointPatch
which is cyclicSlip with slip constraints
SourceFiles
cyclicSlipPolyPatch.C
\*---------------------------------------------------------------------------*/
#ifndef cyclicSlipPolyPatch_H
#define cyclicSlipPolyPatch_H
#include "cyclicPolyPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cyclicSlipPolyPatch Declaration
\*---------------------------------------------------------------------------*/
class cyclicSlipPolyPatch
:
public cyclicPolyPatch
{
public:
//- Runtime type information
TypeName("cyclicSlip");
// Constructors
//- Construct from components
cyclicSlipPolyPatch
(
const word& name,
const label size,
const label start,
const label index,
const polyBoundaryMesh& bm
)
:
cyclicPolyPatch(name, size, start, index, bm)
{}
//- Construct from dictionary
cyclicSlipPolyPatch
(
const word& name,
const dictionary& dict,
const label index,
const polyBoundaryMesh& bm
)
:
cyclicPolyPatch(name, dict, index, bm)
{}
//- Construct as copy, resetting the boundary mesh
cyclicSlipPolyPatch
(
const cyclicSlipPolyPatch& pp,
const polyBoundaryMesh& bm
)
:
cyclicPolyPatch(pp, bm)
{}
//- Construct given the original patch and resetting the
// face list and boundary mesh information
cyclicSlipPolyPatch
(
const cyclicSlipPolyPatch& pp,
const polyBoundaryMesh& bm,
const label index,
const label newSize,
const label newStart,
const word& neighbPatchName
)
:
cyclicPolyPatch(pp, bm, index, newSize, newStart, neighbPatchName)
{}
//- Construct given the original patch and a map
cyclicSlipPolyPatch
(
const cyclicPolyPatch& pp,
const polyBoundaryMesh& bm,
const label index,
const unallocLabelList& mapAddressing,
const label newStart
)
:
cyclicPolyPatch(pp, bm, index, mapAddressing, newStart)
{}
//- Construct and return a clone, resetting the boundary mesh
virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
{
return autoPtr<polyPatch>(new cyclicSlipPolyPatch(*this, bm));
}
//- Construct and return a clone, resetting the face list
// and boundary mesh
virtual autoPtr<polyPatch> clone
(
const polyBoundaryMesh& bm,
const label index,
const label newSize,
const label newStart
) const
{
return autoPtr<polyPatch>
(
new cyclicSlipPolyPatch
(
*this,
bm,
index,
newSize,
newStart,
neighbPatchName()
)
);
}
//- Construct and return a clone, resetting the face list
// and boundary mesh
virtual autoPtr<polyPatch> clone
(
const polyBoundaryMesh& bm,
const label index,
const unallocLabelList& mapAddressing,
const label newStart
) const
{
return autoPtr<polyPatch>
(
new cyclicSlipPolyPatch
(
*this,
bm,
index,
mapAddressing,
newStart
)
);
}
// Destructor
virtual ~cyclicSlipPolyPatch()
{}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

32
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processorCyclic/processorCyclicPolyPatch.C
View File

@ -55,10 +55,20 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
)
:
processorPolyPatch(name, size, start, index, bm, myProcNo, neighbProcNo),
tag_(UPstream::allocateTag()),
tag_
(
Pstream::nProcs()*max(myProcNo, neighbProcNo)
+ min(myProcNo, neighbProcNo)
),
referPatchName_(referPatchName),
referPatchID_(-1)
{}
{
if (debug)
{
Pout<< "processorCyclicPolyPatch " << name << " uses tag " << tag_
<< endl;
}
}
Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
@ -70,10 +80,20 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
)
:
processorPolyPatch(name, dict, index, bm),
tag_(UPstream::allocateTag()),
tag_
(
Pstream::nProcs()*max(myProcNo(), neighbProcNo())
+ min(myProcNo(), neighbProcNo())
),
referPatchName_(dict.lookup("referPatch")),
referPatchID_(-1)
{}
{
if (debug)
{
Pout<< "processorCyclicPolyPatch " << name << " uses tag " << tag_
<< endl;
}
}
Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
@ -125,9 +145,7 @@ Foam::processorCyclicPolyPatch::processorCyclicPolyPatch
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::processorCyclicPolyPatch::~processorCyclicPolyPatch()
{
UPstream::freeTag(tag_);
}
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //

3
src/finiteVolume/Make/files
View File

@ -20,6 +20,7 @@ $(constraintFvPatches)/empty/emptyFvPatch.C
$(constraintFvPatches)/symmetry/symmetryFvPatch.C
$(constraintFvPatches)/wedge/wedgeFvPatch.C
$(constraintFvPatches)/cyclic/cyclicFvPatch.C
$(constraintFvPatches)/cyclicSlip/cyclicSlipFvPatch.C
$(constraintFvPatches)/processor/processorFvPatch.C
$(constraintFvPatches)/processorCyclic/processorCyclicFvPatch.C
@ -96,6 +97,7 @@ $(basicFvPatchFields)/zeroGradient/zeroGradientFvPatchFields.C
constraintFvPatchFields = $(fvPatchFields)/constraint
$(constraintFvPatchFields)/cyclic/cyclicFvPatchFields.C
$(constraintFvPatchFields)/cyclicSlip/cyclicSlipFvPatchFields.C
$(constraintFvPatchFields)/empty/emptyFvPatchFields.C
$(constraintFvPatchFields)/jumpCyclic/jumpCyclicFvPatchFields.C
$(constraintFvPatchFields)/processor/processorFvPatchFields.C
@ -167,6 +169,7 @@ $(basicFvsPatchFields)/sliced/slicedFvsPatchFields.C
constraintFvsPatchFields = $(fvsPatchFields)/constraint
$(constraintFvsPatchFields)/cyclic/cyclicFvsPatchFields.C
$(constraintFvsPatchFields)/cyclicSlip/cyclicSlipFvsPatchFields.C
$(constraintFvsPatchFields)/empty/emptyFvsPatchFields.C
$(constraintFvsPatchFields)/processor/processorFvsPatchFields.C
$(constraintFvsPatchFields)/processorCyclic/processorCyclicFvsPatchFields.C

97
src/finiteVolume/fields/fvPatchFields/constraint/cyclicSlip/cyclicSlipFvPatchField.C Normal file
View File

@ -0,0 +1,97 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "cyclicSlipFvPatchField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
cyclicSlipFvPatchField<Type>::cyclicSlipFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
)
:
cyclicFvPatchField<Type>(p, iF)
{}
template<class Type>
cyclicSlipFvPatchField<Type>::cyclicSlipFvPatchField
(
const cyclicSlipFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
cyclicFvPatchField<Type>(ptf, p, iF, mapper)
{}
template<class Type>
cyclicSlipFvPatchField<Type>::cyclicSlipFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
cyclicFvPatchField<Type>(p, iF, dict)
{}
template<class Type>
cyclicSlipFvPatchField<Type>::cyclicSlipFvPatchField
(
const cyclicSlipFvPatchField<Type>& ptf
)
:
cyclicFvPatchField<Type>(ptf)
{}
template<class Type>
cyclicSlipFvPatchField<Type>::cyclicSlipFvPatchField
(
const cyclicSlipFvPatchField<Type>& ptf,
const DimensionedField<Type, volMesh>& iF
)
:
cyclicFvPatchField<Type>(ptf, iF)
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

141
src/finiteVolume/fields/fvPatchFields/constraint/cyclicSlip/cyclicSlipFvPatchField.H Normal file
View File

@ -0,0 +1,141 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::cyclicSlipFvPatchField
Description
Foam::cyclicSlipFvPatchField
SourceFiles
cyclicSlipFvPatchField.C
\*---------------------------------------------------------------------------*/
#ifndef cyclicSlipFvPatchField_H
#define cyclicSlipFvPatchField_H
#include "cyclicFvPatchField.H"
#include "cyclicSlipFvPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cyclicSlipFvPatch Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class cyclicSlipFvPatchField
:
public cyclicFvPatchField<Type>
{
// Private data
public:
//- Runtime type information
TypeName(cyclicSlipFvPatch::typeName_());
// Constructors
//- Construct from patch and internal field
cyclicSlipFvPatchField
(
const fvPatch&,
const DimensionedField<Type, volMesh>&
);
//- Construct from patch, internal field and dictionary
cyclicSlipFvPatchField
(
const fvPatch&,
const DimensionedField<Type, volMesh>&,
const dictionary&
);
//- Construct by mapping given cyclicSlipFvPatchField onto a new patch
cyclicSlipFvPatchField
(
const cyclicSlipFvPatchField<Type>&,
const fvPatch&,
const DimensionedField<Type, volMesh>&,
const fvPatchFieldMapper&
);
//- Construct as copy
cyclicSlipFvPatchField
(
const cyclicSlipFvPatchField<Type>&
);
//- Construct and return a clone
virtual tmp<fvPatchField<Type> > clone() const
{
return tmp<fvPatchField<Type> >
(
new cyclicSlipFvPatchField<Type>(*this)
);
}
//- Construct as copy setting internal field reference
cyclicSlipFvPatchField
(
const cyclicSlipFvPatchField<Type>&,
const DimensionedField<Type, volMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<fvPatchField<Type> > clone
(
const DimensionedField<Type, volMesh>& iF
) const
{
return tmp<fvPatchField<Type> >
(
new cyclicSlipFvPatchField<Type>(*this, iF)
);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "cyclicSlipFvPatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/finiteVolume/fields/fvPatchFields/constraint/cyclicSlip/cyclicSlipFvPatchFields.C Normal file
View File

@ -0,0 +1,44 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "cyclicSlipFvPatchFields.H"
#include "addToRunTimeSelectionTable.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makePatchFields(cyclicSlip);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

50
src/finiteVolume/fields/fvPatchFields/constraint/cyclicSlip/cyclicSlipFvPatchFields.H Normal file
View File

@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#ifndef cyclicSlipFvPatchFields_H
#define cyclicSlipFvPatchFields_H
#include "cyclicSlipFvPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makePatchTypeFieldTypedefs(cyclicSlip)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

51
src/finiteVolume/fields/fvPatchFields/constraint/cyclicSlip/cyclicSlipFvPatchFieldsFwd.H Normal file
View File

@ -0,0 +1,51 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#ifndef cyclicSlipFvPatchFieldsFwd_H
#define cyclicSlipFvPatchFieldsFwd_H
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type> class cyclicSlipFvPatchField;
makePatchTypeFieldTypedefs(cyclicSlip)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

97
src/finiteVolume/fields/fvsPatchFields/constraint/cyclicSlip/cyclicSlipFvsPatchField.C Normal file
View File

@ -0,0 +1,97 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "cyclicSlipFvsPatchField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
cyclicSlipFvsPatchField<Type>::cyclicSlipFvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF
)
:
cyclicFvsPatchField<Type>(p, iF)
{}
template<class Type>
cyclicSlipFvsPatchField<Type>::cyclicSlipFvsPatchField
(
const cyclicSlipFvsPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
cyclicFvsPatchField<Type>(ptf, p, iF, mapper)
{}
template<class Type>
cyclicSlipFvsPatchField<Type>::cyclicSlipFvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
:
cyclicFvsPatchField<Type>(p, iF, dict)
{}
template<class Type>
cyclicSlipFvsPatchField<Type>::cyclicSlipFvsPatchField
(
const cyclicSlipFvsPatchField<Type>& ptf
)
:
cyclicFvsPatchField<Type>(ptf)
{}
template<class Type>
cyclicSlipFvsPatchField<Type>::cyclicSlipFvsPatchField
(
const cyclicSlipFvsPatchField<Type>& ptf,
const DimensionedField<Type, surfaceMesh>& iF
)
:
cyclicFvsPatchField<Type>(ptf, iF)
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

139
src/finiteVolume/fields/fvsPatchFields/constraint/cyclicSlip/cyclicSlipFvsPatchField.H Normal file
View File

@ -0,0 +1,139 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::cyclicSlipFvsPatchField
Description
Foam::cyclicSlipFvsPatchField
SourceFiles
cyclicSlipFvsPatchField.C
\*---------------------------------------------------------------------------*/
#ifndef cyclicSlipFvsPatchField_H
#define cyclicSlipFvsPatchField_H
#include "cyclicFvsPatchField.H"
#include "cyclicSlipFvPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cyclicSlipFvsPatch Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class cyclicSlipFvsPatchField
:
public cyclicFvsPatchField<Type>
{
public:
//- Runtime type information
TypeName(cyclicSlipFvPatch::typeName_());
// Constructors
//- Construct from patch and internal field
cyclicSlipFvsPatchField
(
const fvPatch&,
const DimensionedField<Type, surfaceMesh>&
);
//- Construct from patch, internal field and dictionary
cyclicSlipFvsPatchField
(
const fvPatch&,
const DimensionedField<Type, surfaceMesh>&,
const dictionary&
);
//- Construct by mapping given cyclicSlipFvsPatchField onto a new patch
cyclicSlipFvsPatchField
(
const cyclicSlipFvsPatchField<Type>&,
const fvPatch&,
const DimensionedField<Type, surfaceMesh>&,
const fvPatchFieldMapper&
);
//- Construct as copy
cyclicSlipFvsPatchField
(
const cyclicSlipFvsPatchField<Type>&
);
//- Construct and return a clone
virtual tmp<fvsPatchField<Type> > clone() const
{
return tmp<fvsPatchField<Type> >
(
new cyclicSlipFvsPatchField<Type>(*this)
);
}
//- Construct as copy setting internal field reference
cyclicSlipFvsPatchField
(
const cyclicSlipFvsPatchField<Type>&,
const DimensionedField<Type, surfaceMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<fvsPatchField<Type> > clone
(
const DimensionedField<Type, surfaceMesh>& iF
) const
{
return tmp<fvsPatchField<Type> >
(
new cyclicSlipFvsPatchField<Type>(*this, iF)
);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "cyclicSlipFvsPatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/finiteVolume/fields/fvsPatchFields/constraint/cyclicSlip/cyclicSlipFvsPatchFields.C Normal file
View File

@ -0,0 +1,44 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "cyclicSlipFvsPatchFields.H"
#include "fvsPatchFields.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeFvsPatchFields(cyclicSlip);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

50
src/finiteVolume/fields/fvsPatchFields/constraint/cyclicSlip/cyclicSlipFvsPatchFields.H Normal file
View File

@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#ifndef cyclicSlipFvsPatchFields_H
#define cyclicSlipFvsPatchFields_H
#include "cyclicSlipFvsPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeFvsPatchTypeFieldTypedefs(cyclicSlip)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

51
src/finiteVolume/fields/fvsPatchFields/constraint/cyclicSlip/cyclicSlipFvsPatchFieldsFwd.H Normal file
View File

@ -0,0 +1,51 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#ifndef cyclicSlipFvsPatchFieldsFwd_H
#define cyclicSlipFvsPatchFieldsFwd_H
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type> class cyclicSlipFvsPatchField;
makeFvsPatchTypeFieldTypedefs(cyclicSlip)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

45
src/finiteVolume/fvMesh/fvPatches/constraint/cyclicSlip/cyclicSlipFvPatch.C Normal file
View File

@ -0,0 +1,45 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "cyclicSlipFvPatch.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
defineTypeNameAndDebug(cyclicSlipFvPatch, 0);
addToRunTimeSelectionTable(fvPatch, cyclicSlipFvPatch, polyPatch);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

80
src/finiteVolume/fvMesh/fvPatches/constraint/cyclicSlip/cyclicSlipFvPatch.H Normal file
View File

@ -0,0 +1,80 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::cyclicSlipFvPatch
Description
Cyclic-plane patch.
SourceFiles
cyclicSlipFvPatch.C
\*---------------------------------------------------------------------------*/
#ifndef cyclicSlipFvPatch_H
#define cyclicSlipFvPatch_H
#include "cyclicFvPatch.H"
#include "cyclicSlipPolyPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cyclicSlipFvPatch Declaration
\*---------------------------------------------------------------------------*/
class cyclicSlipFvPatch
:
public cyclicFvPatch
{
public:
//- Runtime type information
TypeName(cyclicSlipPolyPatch::typeName_());
// Constructors
//- Construct from polyPatch
cyclicSlipFvPatch(const polyPatch& patch, const fvBoundaryMesh& bm)
:
cyclicFvPatch(patch, bm)
{}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

8
src/lagrangian/dsmc/clouds/Templates/DsmcCloud/DsmcCloud.C
View File

@ -291,7 +291,10 @@ void Foam::DsmcCloud<ParcelType>::initialise
template<class ParcelType>
void Foam::DsmcCloud<ParcelType>::collisions()
{
buildCellOccupancy();
if (!binaryCollision().active())
{
return;
}
// Temporary storage for subCells
List<DynamicList<label> > subCells(8);
@ -1057,6 +1060,9 @@ void Foam::DsmcCloud<ParcelType>::evolve()
// Move the particles ballistically with their current velocities
Cloud<ParcelType>::move(td);
// Update cell occupancy
buildCellOccupancy();
// Calculate new velocities via stochastic collisions
collisions();

7
src/lagrangian/dsmc/parcels/derived/dsmcParcel/makeDsmcParcelBinaryCollisionModels.C
View File

@ -25,6 +25,7 @@ License
#include "dsmcParcel.H"
#include "DsmcCloud.H"
#include "NoBinaryCollision.H"
#include "VariableHardSphere.H"
#include "LarsenBorgnakkeVariableHardSphere.H"
@ -34,6 +35,12 @@ namespace Foam
// Add instances of collision model to the table
makeBinaryCollisionModelType
(
NoBinaryCollision,
DsmcCloud,
dsmcParcel
);
makeBinaryCollisionModelType
(
VariableHardSphere,
DsmcCloud,

10
src/lagrangian/dsmc/submodels/BinaryCollisionModel/BinaryCollisionModel/BinaryCollisionModel.C
View File

@ -27,6 +27,15 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::BinaryCollisionModel<CloudType>::BinaryCollisionModel(CloudType& owner)
:
dict_(dictionary::null),
owner_(owner),
coeffDict_(dictionary::null)
{}
template<class CloudType>
Foam::BinaryCollisionModel<CloudType>::BinaryCollisionModel
(
@ -87,4 +96,3 @@ Foam::BinaryCollisionModel<CloudType>::coeffDict() const
#include "BinaryCollisionModelNew.C"
// ************************************************************************* //

6
src/lagrangian/dsmc/submodels/BinaryCollisionModel/BinaryCollisionModel/BinaryCollisionModel.H
View File

@ -85,6 +85,9 @@ public:
// Constructors
//- Construct null from owner
BinaryCollisionModel(CloudType& owner);
//- Construct from components
BinaryCollisionModel
(
@ -123,6 +126,9 @@ public:
// Member Functions
//- Flag to indicate whether model activates collision model
virtual bool active() const = 0;
//- Return the collision cross section * relative velocity product
virtual scalar sigmaTcR
(

6
src/lagrangian/dsmc/submodels/BinaryCollisionModel/LarsenBorgnakkeVariableHardSphere/LarsenBorgnakkeVariableHardSphere.C
View File

@ -117,6 +117,12 @@ Foam::LarsenBorgnakkeVariableHardSphere<CloudType>::
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
bool Foam::LarsenBorgnakkeVariableHardSphere<CloudType>::active() const
{
return true;
}
template <class CloudType>
Foam::scalar Foam::LarsenBorgnakkeVariableHardSphere<CloudType>::sigmaTcR

3
src/lagrangian/dsmc/submodels/BinaryCollisionModel/LarsenBorgnakkeVariableHardSphere/LarsenBorgnakkeVariableHardSphere.H
View File

@ -89,6 +89,9 @@ public:
// Member Functions
//- Flag to indicate whether model activates collision model
virtual bool active() const;
//- Return the collision cross section * relative velocity product
virtual scalar sigmaTcR
(

102
src/lagrangian/dsmc/submodels/BinaryCollisionModel/NoBinaryCollision/NoBinaryCollision.C Normal file
View File

@ -0,0 +1,102 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2010 OpenCFD Ltd.
\\/ 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 "NoBinaryCollision.H"
#include "constants.H"
using namespace Foam::constant::mathematical;
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template <class CloudType>
Foam::NoBinaryCollision<CloudType>::NoBinaryCollision
(
const dictionary& dict,
CloudType& cloud
)
:
BinaryCollisionModel<CloudType>(cloud)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template <class CloudType>
Foam::NoBinaryCollision<CloudType>::~NoBinaryCollision()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
bool Foam::NoBinaryCollision<CloudType>::active() const
{
return false;
}
template <class CloudType>
Foam::scalar Foam::NoBinaryCollision<CloudType>::sigmaTcR
(
label typeIdP,
label typeIdQ,
const vector& UP,
const vector& UQ
) const
{
FatalErrorIn
(
"Foam::scalar Foam::NoBinaryCollision<CloudType>::sigmaTcR"
"("
"label typeIdP,"
"label typeIdQ,"
"const vector& UP,"
"const vector& UQ"
") const"
)
<< "sigmaTcR called on NoBinaryCollision model, this should "
<< "not happen, this is not an actual model." << nl
<< "Enclose calls to sigmaTcR within a if(binaryCollision().active()) "
<< " check."
<< abort(FatalError);
return 0.0;
}
template <class CloudType>
void Foam::NoBinaryCollision<CloudType>::collide
(
label typeIdP,
label typeIdQ,
vector& UP,
vector& UQ,
scalar& EiP,
scalar& EiQ
)
{}
// ************************************************************************* //

110
src/lagrangian/dsmc/submodels/BinaryCollisionModel/NoBinaryCollision/NoBinaryCollision.H Normal file
View File

@ -0,0 +1,110 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2010 OpenCFD Ltd.
\\/ 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::NoBinaryCollision
Description
No collison BinaryCollision Model
\*---------------------------------------------------------------------------*/
#ifndef NoBinaryCollision_H
#define NoBinaryCollision_H
#include "BinaryCollisionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class NoBinaryCollision Declaration
\*---------------------------------------------------------------------------*/
template<class CloudType>
class NoBinaryCollision
:
public BinaryCollisionModel<CloudType>
{
public:
//- Runtime type information
TypeName("none");
// Constructors
//- Construct from dictionary
NoBinaryCollision
(
const dictionary& dict,
CloudType& cloud
);
//- Destructor
virtual ~NoBinaryCollision();
// Member Functions
//- Flag to indicate whether model activates collision model
virtual bool active() const;
//- Return the collision cross section * relative velocity product
virtual scalar sigmaTcR
(
label typeIdP,
label typeIdQ,
const vector& UP,
const vector& UQ
) const;
//- Apply collision
virtual void collide
(
label typeIdP,
label typeIdQ,
vector& UP,
vector& UQ,
scalar& EiP,
scalar& EiQ
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "NoBinaryCollision.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

6
src/lagrangian/dsmc/submodels/BinaryCollisionModel/VariableHardSphere/VariableHardSphere.C
View File

@ -51,6 +51,12 @@ Foam::VariableHardSphere<CloudType>::~VariableHardSphere()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CloudType>
bool Foam::VariableHardSphere<CloudType>::active() const
{
return true;
}
template <class CloudType>
Foam::scalar Foam::VariableHardSphere<CloudType>::sigmaTcR

3
src/lagrangian/dsmc/submodels/BinaryCollisionModel/VariableHardSphere/VariableHardSphere.H
View File

@ -74,6 +74,9 @@ public:
// Member Functions
//- Flag to indicate whether model activates collision model
virtual bool active() const;
//- Return the collision cross section * relative velocity product
virtual scalar sigmaTcR
(

9
src/lagrangian/dsmc/submodels/InflowBoundaryModel/InflowBoundaryModel/InflowBoundaryModel.C
View File

@ -27,6 +27,15 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::InflowBoundaryModel<CloudType>::InflowBoundaryModel(CloudType& owner)
:
dict_(dictionary::null),
owner_(owner),
coeffDict_(dictionary::null)
{}
template<class CloudType>
Foam::InflowBoundaryModel<CloudType>::InflowBoundaryModel
(

3
src/lagrangian/dsmc/submodels/InflowBoundaryModel/InflowBoundaryModel/InflowBoundaryModel.H
View File

@ -86,6 +86,9 @@ public:
// Constructors
//- Construct null from owner
InflowBoundaryModel(CloudType& owner);
//- Construct from dictionary
InflowBoundaryModel
(

2
src/lagrangian/dsmc/submodels/InflowBoundaryModel/NoInflow/NoInflow.C
View File

@ -34,7 +34,7 @@ Foam::NoInflow<CloudType>::NoInflow
CloudType& cloud
)
:
InflowBoundaryModel<CloudType>(dict, cloud, typeName)
InflowBoundaryModel<CloudType>(cloud)
{}

2
src/lagrangian/dsmc/submodels/InflowBoundaryModel/NoInflow/NoInflow.H
View File

@ -50,7 +50,7 @@ class NoInflow
public:
//- Runtime type information
TypeName("NoInflow");
TypeName("none");
// Constructors

2
src/lagrangian/dsmc/submodels/WallInteractionModel/MaxwellianThermal/MaxwellianThermal.C
View File

@ -37,7 +37,7 @@ Foam::MaxwellianThermal<CloudType>::MaxwellianThermal
CloudType& cloud
)
:
WallInteractionModel<CloudType>(dict, cloud, typeName)
WallInteractionModel<CloudType>(cloud)
{}

2
src/lagrangian/dsmc/submodels/WallInteractionModel/SpecularReflection/SpecularReflection.C
View File

@ -36,7 +36,7 @@ Foam::SpecularReflection<CloudType>::SpecularReflection
CloudType& cloud
)
:
WallInteractionModel<CloudType>(dict, cloud, typeName)
WallInteractionModel<CloudType>(cloud)
{}

9
src/lagrangian/dsmc/submodels/WallInteractionModel/WallInteractionModel/WallInteractionModel.C
View File

@ -27,6 +27,15 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CloudType>
Foam::WallInteractionModel<CloudType>::WallInteractionModel(CloudType& owner)
:
dict_(dictionary::null),
owner_(owner),
coeffDict_(dictionary::null)
{}
template<class CloudType>
Foam::WallInteractionModel<CloudType>::WallInteractionModel
(

3
src/lagrangian/dsmc/submodels/WallInteractionModel/WallInteractionModel/WallInteractionModel.H
View File

@ -85,6 +85,9 @@ public:
// Constructors
//- Construct null from owner
WallInteractionModel(CloudType& owner);
//- Construct from components
WallInteractionModel
(

207
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/CollisionRecordList.C
View File

@ -28,37 +28,41 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::CollisionRecordList<Type>::CollisionRecordList()
template<class PairType, class WallType>
Foam::CollisionRecordList<PairType, WallType>::CollisionRecordList()
:
DynamicList<CollisionRecord<Type> >()
pairRecords_(),
wallRecords_()
{}
template<class Type>
Foam::CollisionRecordList<Type>::CollisionRecordList(Istream& is)
template<class PairType, class WallType>
Foam::CollisionRecordList<PairType, WallType>::CollisionRecordList(Istream& is)
:
DynamicList<CollisionRecord<Type> >(is)
pairRecords_(is),
wallRecords_(is)
{
// Check state of Istream
is.check
(
"Foam::CollisionRecordList<Type>::CollisionRecordList(Foam::Istream&)"
"Foam::CollisionRecordList<PairType, WallType>::"
"CollisionRecordList(Foam::Istream&)"
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * /
template<class Type>
Foam::CollisionRecordList<Type>::~CollisionRecordList()
template<class PairType, class WallType>
Foam::CollisionRecordList<PairType, WallType>::~CollisionRecordList()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class Type>
Foam::CollisionRecord<Type>& Foam::CollisionRecordList<Type>::matchRecord
template<class PairType, class WallType>
Foam::PairCollisionRecord<PairType>&
Foam::CollisionRecordList<PairType, WallType>::matchPairRecord
(
label origProcOfOther,
label origIdOfOther
@ -68,15 +72,15 @@ Foam::CollisionRecord<Type>& Foam::CollisionRecordList<Type>::matchRecord
// identifiers. Two records with the same identification is not
// supported.
forAll(*this, i)
forAll(pairRecords_, i)
{
CollisionRecord<Type>& cR = (*this)[i];
PairCollisionRecord<PairType>& pCR = pairRecords_[i];
if (cR.match(origProcOfOther, origIdOfOther))
if (pCR.match(origProcOfOther, origIdOfOther))
{
cR.setAccessed();
pCR.setAccessed();
return cR;
return pCR;
}
}
@ -84,28 +88,179 @@ Foam::CollisionRecord<Type>& Foam::CollisionRecordList<Type>::matchRecord
// member of the list. The status of the record will be accessed
// by construction.
append(CollisionRecord<Type>(origProcOfOther, origIdOfOther));
pairRecords_.append
(
PairCollisionRecord<PairType>(origProcOfOther, origIdOfOther)
);
return (*this)[this->size() - 1];
return pairRecords_.last();
}
template<class Type>
void Foam::CollisionRecordList<Type>::update()
template<class PairType, class WallType>
Foam::WallCollisionRecord<WallType>&
Foam::CollisionRecordList<PairType, WallType>::matchWallRecord
(
const vector& pRel,
scalar radius
)
{
DynamicList<CollisionRecord<Type> > updatedRecords;
// Returning the first record that matches the relative position.
// Two records with the same relative position is not supported.
forAll(*this, i)
forAll(wallRecords_, i)
{
if ((*this)[i].accessed())
WallCollisionRecord<WallType>& wCR = wallRecords_[i];
if (wCR.match(pRel, radius))
{
(*this)[i].setUnaccessed();
wCR.setAccessed();
updatedRecords.append((*this)[i]);
return wCR;
}
}
DynamicList<CollisionRecord<Type> >::operator=(updatedRecords);
// Record not found, create a new one and return it as the last
// member of the list. The status of the record will be accessed
// by construction.
wallRecords_.append(WallCollisionRecord<WallType>(pRel));
return wallRecords_.last();
}
template<class PairType, class WallType>
void Foam::CollisionRecordList<PairType, WallType>::update()
{
{
DynamicList<PairCollisionRecord<PairType> > updatedRecords;
forAll(pairRecords_, i)
{
if (pairRecords_[i].accessed())
{
pairRecords_[i].setUnaccessed();
updatedRecords.append(pairRecords_[i]);
}
}
pairRecords_ = updatedRecords;
}
{
DynamicList<WallCollisionRecord<WallType> > updatedRecords;
forAll(wallRecords_, i)
{
if (wallRecords_[i].accessed())
{
wallRecords_[i].setUnaccessed();
updatedRecords.append(wallRecords_[i]);
}
}
wallRecords_ = updatedRecords;
}
}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
template<class PairType, class WallType>
void Foam::CollisionRecordList<PairType, WallType>::operator=
(
const CollisionRecordList<PairType, WallType>& rhs
)
{
// Check for assignment to self
if (this == &rhs)
{
FatalErrorIn
(
"Foam::CollisionRecordList<PairType, WallType>::operator="
"(const Foam::CollisionRecordList<PairType, WallType>&)"
)
<< "Attempted assignment to self"
<< abort(FatalError);
}
pairRecords_ = rhs.pairRecords_;
wallRecords_ = rhs.wallRecords_;
}
// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
template<class PairType, class WallType>
inline bool Foam::operator==
(
const CollisionRecordList<PairType, WallType>& a,
const CollisionRecordList<PairType, WallType>& b
)
{
return
(
a.pairRecords_ == b.pairRecords_
&& a.wallRecords_ == b.wallRecords_
);
}
template<class PairType, class WallType>
inline bool Foam::operator!=
(
const CollisionRecordList<PairType, WallType>& a,
const CollisionRecordList<PairType, WallType>& b
)
{
return !(a == b);
}
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
template<class PairType, class WallType>
Foam::Istream& Foam::operator>>
(
Istream& is,
CollisionRecordList<PairType, WallType>& cRL
)
{
is >> cRL.pairRecords_ >> cRL.wallRecords_;
// Check state of Istream
is.check
(
"Foam::Istream& Foam::operator>>"
"(Foam::Istream&, Foam::CollisionRecordList<PairType, WallType>&)"
);
return is;
}
template<class PairType, class WallType>
Foam::Ostream& Foam::operator<<
(
Ostream& os,
const CollisionRecordList<PairType, WallType>& cRL
)
{
os << cRL.pairRecords_ << cRL.wallRecords_;
// Check state of Ostream
os.check
(
"Foam::Ostream& Foam::operator<<(Foam::Ostream&, "
"const Foam::CollisionRecordList<PairType, WallType>&)"
);
return os;
}
// ************************************************************************* //

94
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/CollisionRecordList.H
View File

@ -37,22 +37,53 @@ SourceFiles
#define CollisionRecordList_H
#include "DynamicList.H"
#include "CollisionRecord.H"
#include "PairCollisionRecord.H"
#include "WallCollisionRecord.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of friend functions and operators
template<class PairType, class WallType>
class CollisionRecordList;
template<class PairType, class WallType>
inline bool operator==
(
const CollisionRecordList<PairType, WallType>&,
const CollisionRecordList<PairType, WallType>&
);
template<class PairType, class WallType>
inline bool operator!=
(
const CollisionRecordList<PairType, WallType>&,
const CollisionRecordList<PairType, WallType>&
);
template<class PairType, class WallType>
Istream& operator>>(Istream&, CollisionRecordList<PairType, WallType>&);
template<class PairType, class WallType>
Ostream& operator<<(Ostream&, const CollisionRecordList<PairType, WallType>&);
/*---------------------------------------------------------------------------*\
Class CollisionRecordList Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
template<class PairType, class WallType>
class CollisionRecordList
:
public DynamicList<CollisionRecord<Type> >
{
// Private data
//- List of active pair collisions
DynamicList<PairCollisionRecord<PairType> > pairRecords_;
//- List of active wall collisions
DynamicList<WallCollisionRecord<WallType> > wallRecords_;
public:
@ -72,19 +103,66 @@ public:
// Member Functions
//- Enquires if the proc and id pair of the other particle are
// present in the records. If so, return access to the
// collisionData and mark the CollisionRecord as accessed this
// step, if not, create the record and return access to it.
CollisionRecord<Type>& matchRecord
// present in the records. If so, return non-const access to
// the PairCollisionRecord (hence the data) and mark the
// PairCollisionRecord as accessed this step, if not, create
// the record and return access to it.
PairCollisionRecord<PairType>& matchPairRecord
(
label origProcOfOther,
label origIdOfOther
);
//- Enquires if the position of wall impact relative to the
// particle centre is present in the records. If so, return
// access to the WallCollisionRecord (hence the data) and
// mark the WallCollisionRecord as accesses this step, if
// not, create the record and return access to it.
WallCollisionRecord<WallType>& matchWallRecord
(
const vector& pRel,
scalar radius
);
//- Update the collision records, deleting any records not
// marked as having been accessed, then mark all records as
// not accessed ready for the next evaluation
void update();
// Member Operators
void operator=(const CollisionRecordList&);
// Friend Operators
friend bool operator== <PairType, WallType>
(
const CollisionRecordList<PairType, WallType>&,
const CollisionRecordList<PairType, WallType>&
);
friend bool operator!= <PairType, WallType>
(
const CollisionRecordList<PairType, WallType>&,
const CollisionRecordList<PairType, WallType>&
);
// IOstream Operators
friend Istream& operator>> <PairType, WallType>
(
Istream&,
CollisionRecordList<PairType, WallType>&
);
friend Ostream& operator<< <PairType, WallType>
(
Ostream&,
const CollisionRecordList<PairType, WallType>&
);
};

30
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/CollisionRecord/CollisionRecord.C → src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/PairCollisionRecord/PairCollisionRecord.C
View File

@ -23,12 +23,12 @@ License
\*---------------------------------------------------------------------------*/
#include "CollisionRecord.H"
#include "PairCollisionRecord.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::CollisionRecord<Type>::CollisionRecord()
Foam::PairCollisionRecord<Type>::PairCollisionRecord()
:
origProcOfOther_(-VGREAT),
origIdOfOther_(-VGREAT),
@ -37,7 +37,7 @@ Foam::CollisionRecord<Type>::CollisionRecord()
template<class Type>
Foam::CollisionRecord<Type>::CollisionRecord
Foam::PairCollisionRecord<Type>::PairCollisionRecord
(
label origProcOfOther,
label origIdOfOther,
@ -51,33 +51,39 @@ Foam::CollisionRecord<Type>::CollisionRecord
template<class Type>
Foam::CollisionRecord<Type>::CollisionRecord(const CollisionRecord<Type>& cR)
Foam::PairCollisionRecord<Type>::PairCollisionRecord
(
const PairCollisionRecord<Type>& pCR
)
:
origProcOfOther_(cR.origProcOfOther() + 1),
origIdOfOther_(cR.origIdOfOther_),
data_(cR.data_)
origProcOfOther_(pCR.origProcOfOther() + 1),
origIdOfOther_(pCR.origIdOfOther_),
data_(pCR.data_)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::CollisionRecord<Type>::~CollisionRecord()
Foam::PairCollisionRecord<Type>::~PairCollisionRecord()
{}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
template<class Type>
void Foam::CollisionRecord<Type>::operator=(const CollisionRecord<Type>& rhs)
void Foam::PairCollisionRecord<Type>::operator=
(
const PairCollisionRecord<Type>& rhs
)
{
// Check for assignment to self
if (this == &rhs)
{
FatalErrorIn
(
"Foam::CollisionRecord<Type>::operator="
"(const Foam::CollisionRecord<Type>&)"
"Foam::PairCollisionRecord<Type>::operator="
"(const Foam::PairCollisionRecord<Type>&)"
)
<< "Attempted assignment to self"
<< abort(FatalError);
@ -91,7 +97,7 @@ void Foam::CollisionRecord<Type>::operator=(const CollisionRecord<Type>& rhs)
// * * * * * * * * * * * * * * IOStream operators * * * * * * * * * * * * * //
#include "CollisionRecordIO.C"
#include "PairCollisionRecordIO.C"
// ************************************************************************* //

58
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/CollisionRecord/CollisionRecord.H → src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/PairCollisionRecord/PairCollisionRecord.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::CollisionRecord
Foam::PairCollisionRecord
Description
@ -35,14 +35,14 @@ Description
positive means that it has.
SourceFiles
CollisionRecordI.H
CollisionRecord.C
CollisionRecordIO.C
PairCollisionRecordI.H
PairCollisionRecord.C
PairCollisionRecordIO.C
\*---------------------------------------------------------------------------*/
#ifndef CollisionRecord_H
#define CollisionRecord_H
#ifndef PairCollisionRecord_H
#define PairCollisionRecord_H
#include "label.H"
#include "vector.H"
@ -54,35 +54,35 @@ namespace Foam
// Forward declaration of friend functions and operators
template<class Type>
class CollisionRecord;
class PairCollisionRecord;
template<class Type>
inline bool operator==
(
const CollisionRecord<Type>&,
const CollisionRecord<Type>&
const PairCollisionRecord<Type>&,
const PairCollisionRecord<Type>&
);
template<class Type>
inline bool operator!=
(
const CollisionRecord<Type>&,
const CollisionRecord<Type>&
const PairCollisionRecord<Type>&,
const PairCollisionRecord<Type>&
);
template<class Type>
Istream& operator>>(Istream&, CollisionRecord<Type>&);
Istream& operator>>(Istream&, PairCollisionRecord<Type>&);
template<class Type>
Ostream& operator<<(Ostream&, const CollisionRecord<Type>&);
Ostream& operator<<(Ostream&, const PairCollisionRecord<Type>&);
/*---------------------------------------------------------------------------*\
Class CollisionRecord Declaration
Class PairCollisionRecord Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class CollisionRecord
class PairCollisionRecord
{
// Private data
@ -103,10 +103,10 @@ public:
// Constructors
//- Construct null
CollisionRecord();
PairCollisionRecord();
//- Construct from components
CollisionRecord
PairCollisionRecord
(
label origProcOfOther,
label origIdOfOther,
@ -114,14 +114,14 @@ public:
);
//- Construct from Istream
CollisionRecord(Istream&);
PairCollisionRecord(Istream&);
//- Construct as copy
CollisionRecord(const CollisionRecord&);
PairCollisionRecord(const PairCollisionRecord&);
//- Destructor
~CollisionRecord();
~PairCollisionRecord();
// Member Functions
@ -165,21 +165,21 @@ public:
// Member Operators
void operator=(const CollisionRecord&);
void operator=(const PairCollisionRecord&);
// Friend Operators
friend bool operator== <Type>
(
const CollisionRecord<Type>&,
const CollisionRecord<Type>&
const PairCollisionRecord<Type>&,
const PairCollisionRecord<Type>&
);
friend bool operator!= <Type>
(
const CollisionRecord<Type>&,
const CollisionRecord<Type>&
const PairCollisionRecord<Type>&,
const PairCollisionRecord<Type>&
);
@ -188,13 +188,13 @@ public:
friend Istream& operator>> <Type>
(
Istream&,
CollisionRecord<Type>&
PairCollisionRecord<Type>&
);
friend Ostream& operator<< <Type>
(
Ostream&,
const CollisionRecord<Type>&
const PairCollisionRecord<Type>&
);
};
@ -205,12 +205,12 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "CollisionRecordI.H"
#include "PairCollisionRecordI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "CollisionRecord.C"
# include "PairCollisionRecord.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

25
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/CollisionRecord/CollisionRecordI.H → src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/PairCollisionRecord/PairCollisionRecordI.H
View File

@ -26,7 +26,7 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
inline bool Foam::CollisionRecord<Type>::match
inline bool Foam::PairCollisionRecord<Type>::match
(
label queryOrigProcOfOther,
label queryOrigIdOfOther
@ -41,14 +41,14 @@ inline bool Foam::CollisionRecord<Type>::match
template<class Type>
inline Foam::label Foam::CollisionRecord<Type>::origProcOfOther() const
inline Foam::label Foam::PairCollisionRecord<Type>::origProcOfOther() const
{
return mag(origProcOfOther_) - 1;
}
template<class Type>
inline Foam::label Foam::CollisionRecord<Type>::origIdOfOther() const
inline Foam::label Foam::PairCollisionRecord<Type>::origIdOfOther() const
{
return origIdOfOther_;
}
@ -56,35 +56,35 @@ inline Foam::label Foam::CollisionRecord<Type>::origIdOfOther() const
template<class Type>
inline const Type&
Foam::CollisionRecord<Type>::collisionData() const
Foam::PairCollisionRecord<Type>::collisionData() const
{
return data_;
}
template<class Type>
inline Type& Foam::CollisionRecord<Type>::collisionData()
inline Type& Foam::PairCollisionRecord<Type>::collisionData()
{
return data_;
}
template<class Type>
inline bool Foam::CollisionRecord<Type>::accessed() const
inline bool Foam::PairCollisionRecord<Type>::accessed() const
{
return pos(origProcOfOther_);
}
template<class Type>
inline void Foam::CollisionRecord<Type>::setAccessed()
inline void Foam::PairCollisionRecord<Type>::setAccessed()
{
origProcOfOther_ = origProcOfOther() + 1;
}
template<class Type>
inline void Foam::CollisionRecord<Type>::setUnaccessed()
inline void Foam::PairCollisionRecord<Type>::setUnaccessed()
{
origProcOfOther_ = -(origProcOfOther() + 1);
}
@ -95,8 +95,8 @@ inline void Foam::CollisionRecord<Type>::setUnaccessed()
template<class Type>
inline bool Foam::operator==
(
const CollisionRecord<Type>& a,
const CollisionRecord<Type>& b
const PairCollisionRecord<Type>& a,
const PairCollisionRecord<Type>& b
)
{
return
@ -107,11 +107,12 @@ inline bool Foam::operator==
);
}
template<class Type>
inline bool Foam::operator!=
(
const CollisionRecord<Type>& a,
const CollisionRecord<Type>& b
const PairCollisionRecord<Type>& a,
const PairCollisionRecord<Type>& b
)
{
return !(a == b);

29
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/CollisionRecord/CollisionRecordIO.C → src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/PairCollisionRecord/PairCollisionRecordIO.C
View File

@ -23,35 +23,38 @@ License
\*---------------------------------------------------------------------------*/
#include "CollisionRecord.H"
#include "PairCollisionRecord.H"
#include "IOstreams.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::CollisionRecord<Type>::CollisionRecord(Istream& is)
Foam::PairCollisionRecord<Type>::PairCollisionRecord(Istream& is)
:
origProcOfOther_(readLabel(is)),
origIdOfOther_(readLabel(is)),
data_(is)
{
// Check state of Istream
is.check("Foam::CollisionRecord<Type>::CollisionRecord(Foam::Istream&)");
is.check
(
"Foam::PairCollisionRecord<Type>::PairCollisionRecord(Foam::Istream&)"
);
}
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
template<class Type>
Foam::Istream& Foam::operator>>(Istream& is, CollisionRecord<Type>& cR)
Foam::Istream& Foam::operator>>(Istream& is, PairCollisionRecord<Type>& pCR)
{
is >> cR.origProcOfOther_ >> cR.origIdOfOther_ >> cR.data_;
is >> pCR.origProcOfOther_ >> pCR.origIdOfOther_ >> pCR.data_;
// Check state of Istream
is.check
(
"Foam::Istream&"
"Foam::operator>>(Foam::Istream&, Foam::CollisionRecord<Type>&)"
"Foam::operator>>(Foam::Istream&, Foam::PairCollisionRecord<Type>&)"
);
return is;
@ -59,17 +62,21 @@ Foam::Istream& Foam::operator>>(Istream& is, CollisionRecord<Type>& cR)
template<class Type>
Foam::Ostream& Foam::operator<<(Ostream& os, const CollisionRecord<Type>& cR)
Foam::Ostream& Foam::operator<<
(
Ostream& os,
const PairCollisionRecord<Type>& pCR
)
{
os << cR.origProcOfOther_
<< token::SPACE << cR.origIdOfOther_
<< token::SPACE << cR.data_;
os << pCR.origProcOfOther_
<< token::SPACE << pCR.origIdOfOther_
<< token::SPACE << pCR.data_;
// Check state of Ostream
os.check
(
"Foam::Ostream& Foam::operator<<(Foam::Ostream&, "
"const Foam::CollisionRecord<Type>&)"
"const Foam::PairCollisionRecord<Type>&)"
);
return os;

102
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/WallCollisionRecord/WallCollisionRecord.C Normal file
View File

@ -0,0 +1,102 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2010 OpenCFD Ltd.
\\/ 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 "WallCollisionRecord.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::WallCollisionRecord<Type>::WallCollisionRecord()
:
accessed_(false),
pRel_(),
data_(pTraits<Type>::zero)
{}
template<class Type>
Foam::WallCollisionRecord<Type>::WallCollisionRecord
(
const vector& pRel,
const Type& data
)
:
accessed_(true),
pRel_(pRel),
data_(data)
{}
template<class Type>
Foam::WallCollisionRecord<Type>::WallCollisionRecord
(
const WallCollisionRecord<Type>& wCR
)
:
accessed_(wCR.accessed_),
pRel_(wCR.pRel_),
data_(wCR.data_)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::WallCollisionRecord<Type>::~WallCollisionRecord()
{}
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
template<class Type>
void Foam::WallCollisionRecord<Type>::operator=
(
const WallCollisionRecord<Type>& rhs
)
{
// Check for assignment to self
if (this == &rhs)
{
FatalErrorIn
(
"Foam::WallCollisionRecord<Type>::operator="
"(const Foam::WallCollisionRecord<Type>&)"
)
<< "Attempted assignment to self"
<< abort(FatalError);
}
accessed_ = rhs.accessed_;
pRel_ = rhs.pRel_;
data_ = rhs.data_;
}
// * * * * * * * * * * * * * * IOStream operators * * * * * * * * * * * * * //
#include "WallCollisionRecordIO.C"
// ************************************************************************* //

204
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/WallCollisionRecord/WallCollisionRecord.H Normal file
View File

@ -0,0 +1,204 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2010 OpenCFD Ltd.
\\/ 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::WallCollisionRecord
Description
Record of a collision between the particle holding the record and
a wall face at the position relative to the centre of the particle.
SourceFiles
WallCollisionRecordI.H
WallCollisionRecord.C
WallCollisionRecordIO.C
\*---------------------------------------------------------------------------*/
#ifndef WallCollisionRecord_H
#define WallCollisionRecord_H
#include "vector.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of friend functions and operators
template<class Type>
class WallCollisionRecord;
template<class Type>
inline bool operator==
(
const WallCollisionRecord<Type>&,
const WallCollisionRecord<Type>&
);
template<class Type>
inline bool operator!=
(
const WallCollisionRecord<Type>&,
const WallCollisionRecord<Type>&
);
template<class Type>
Istream& operator>>(Istream&, WallCollisionRecord<Type>&);
template<class Type>
Ostream& operator<<(Ostream&, const WallCollisionRecord<Type>&);
/*---------------------------------------------------------------------------*\
Class WallCollisionRecord Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class WallCollisionRecord
{
// Private data
// //- Recording whether or not this record has been accessed
bool accessed_;
//- The position of wall impact relative to the cell centre
vector pRel_;
//- Collision data, stored as if the storing particle was the
// first particle (particle A) in the collision.
Type data_;
public:
// Constructors
//- Construct null
WallCollisionRecord();
//- Construct from components
WallCollisionRecord
(
const vector& pRel,
const Type& data = pTraits<Type>::zero
);
//- Construct from Istream
WallCollisionRecord(Istream&);
//- Construct as copy
WallCollisionRecord(const WallCollisionRecord&);
//- Destructor
~WallCollisionRecord();
// Member Functions
// Access
//- Return the pRel data
inline const vector& pRel() const;
//- Return access to the collision data
inline const Type& collisionData() const;
//- Return access to the collision data
inline Type& collisionData();
// Check
inline bool match(const vector& pRel, scalar radius);
//- Return the accessed status of the record
inline bool accessed() const;
// Edit
//- Set the accessed property of the record to accessed
inline void setAccessed();
//- Set the accessed property of the record to unaccessed
inline void setUnaccessed();
// Member Operators
void operator=(const WallCollisionRecord&);
// Friend Operators
friend bool operator== <Type>
(
const WallCollisionRecord<Type>&,
const WallCollisionRecord<Type>&
);
friend bool operator!= <Type>
(
const WallCollisionRecord<Type>&,
const WallCollisionRecord<Type>&
);
// IOstream Operators
friend Istream& operator>> <Type>
(
Istream&,
WallCollisionRecord<Type>&
);
friend Ostream& operator<< <Type>
(
Ostream&,
const WallCollisionRecord<Type>&
);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "WallCollisionRecordI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "WallCollisionRecord.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

143
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/WallCollisionRecord/WallCollisionRecordI.H Normal file
View File

@ -0,0 +1,143 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2010 OpenCFD Ltd.
\\/ 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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
inline bool Foam::WallCollisionRecord<Type>::match
(
const vector& pRel,
scalar radius
)
{
scalar magpRel_= mag(pRel_);
scalar magpRel = mag(pRel);
// Using the new data as the acceptance criterion
scalar cosAcceptanceAngle = magpRel/radius;
if (cosAcceptanceAngle > 1.0)
{
Info<< "pRel_ " << pRel_ << " " << magpRel_ << nl
<< "pRel " << pRel << " " << magpRel << nl
<< "unit vector dot product " << (pRel & pRel_)/(magpRel_*magpRel)
<< nl << "cosAcceptanceAngle " << cosAcceptanceAngle
<< endl;
FatalErrorIn
(
"inline bool Foam::WallCollisionRecord<Type>::match"
"("
"const vector& pRel,"
"scalar radius"
") const"
)
<< "Problem with matching WallCollisionRecord." << nl
<< "The given radius, " << radius << ", is smaller than distance "
<< "to the relative position of the WallInteractionSite, "
<< magpRel << nl
<< abort(FatalError);
}
// Are the test and recorded pRel (relative position vectors)
// aligned to within the calculated tolerance?
bool matched = (pRel & pRel_)/(magpRel_*magpRel) > cosAcceptanceAngle;
if (matched)
{
pRel_ = pRel;
}
return matched;
}
template<class Type>
inline const Type&
Foam::WallCollisionRecord<Type>::collisionData() const
{
return data_;
}
template<class Type>
inline Type& Foam::WallCollisionRecord<Type>::collisionData()
{
return data_;
}
template<class Type>
inline bool Foam::WallCollisionRecord<Type>::accessed() const
{
return accessed_;
}
template<class Type>
inline void Foam::WallCollisionRecord<Type>::setAccessed()
{
accessed_ = true;
}
template<class Type>
inline void Foam::WallCollisionRecord<Type>::setUnaccessed()
{
accessed_ = false;
}
// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
template<class Type>
inline bool Foam::operator==
(
const WallCollisionRecord<Type>& a,
const WallCollisionRecord<Type>& b
)
{
return
(
a.accessed_ == b.accessed_
&& a.pRel_ == b.pRel_
&& a.data_ == b.data_
);
}
template<class Type>
inline bool Foam::operator!=
(
const WallCollisionRecord<Type>& a,
const WallCollisionRecord<Type>& b
)
{
return !(a == b);
}
// ************************************************************************* //

86
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/CollisionRecordList/WallCollisionRecord/WallCollisionRecordIO.C Normal file
View File

@ -0,0 +1,86 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2010 OpenCFD Ltd.
\\/ 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 "WallCollisionRecord.H"
#include "IOstreams.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::WallCollisionRecord<Type>::WallCollisionRecord(Istream& is)
:
accessed_(is),
pRel_(is),
data_(is)
{
// Check state of Istream
is.check
(
"Foam::WallCollisionRecord<Type>::WallCollisionRecord(Foam::Istream&)"
);
}
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
template<class Type>
Foam::Istream& Foam::operator>>(Istream& is, WallCollisionRecord<Type>& wCR)
{
is >> wCR.accessed_ >> wCR.pRel_ >> wCR.data_;
// Check state of Istream
is.check
(
"Foam::Istream&"
"Foam::operator>>(Foam::Istream&, Foam::WallCollisionRecord<Type>&)"
);
return is;
}
template<class Type>
Foam::Ostream& Foam::operator<<
(
Ostream& os,
const WallCollisionRecord<Type>& wCR
)
{
os << wCR.accessed_
<< token::SPACE << wCR.pRel_
<< token::SPACE << wCR.data_;
// Check state of Ostream
os.check
(
"Foam::Ostream& Foam::operator<<(Foam::Ostream&, "
"const Foam::WallCollisionRecord<Type>&)"
);
return os;
}
// ************************************************************************* //

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

@ -268,7 +268,7 @@ protected:
vector UTurb_;
//- Particle collision records
CollisionRecordList<vector> collisionRecords_;
CollisionRecordList<vector, vector> collisionRecords_;
// Cell-based quantities
@ -400,7 +400,8 @@ public:
inline const vector& UTurb() const;
//- Return const access to the collision records
inline const CollisionRecordList<vector>& collisionRecords() const;
inline const CollisionRecordList<vector, vector>&
collisionRecords() const;
// Edit
@ -439,7 +440,7 @@ public:
inline vector& UTurb();
//- Return access to collision records
inline CollisionRecordList<vector>& collisionRecords();
inline CollisionRecordList<vector, vector>& collisionRecords();
// Helper functions

4
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelI.H
View File

@ -348,7 +348,7 @@ inline bool& Foam::KinematicParcel<ParcelType>::active()
template <class ParcelType>
inline const Foam::CollisionRecordList<Foam::vector>&
inline const Foam::CollisionRecordList<Foam::vector, Foam::vector>&
Foam::KinematicParcel<ParcelType>::collisionRecords() const
{
return collisionRecords_;
@ -426,7 +426,7 @@ inline Foam::vector& Foam::KinematicParcel<ParcelType>::UTurb()
template <class ParcelType>
inline Foam::CollisionRecordList<Foam::vector>&
inline Foam::CollisionRecordList<Foam::vector, Foam::vector>&
Foam::KinematicParcel<ParcelType>::collisionRecords()
{
return collisionRecords_;

2
src/lagrangian/intermediate/particleForces/particleForces.C
View File

@ -61,6 +61,7 @@ Foam::particleForces::particleForces
dict_(dict.subDict("particleForces")),
g_(g),
gradUPtr_(NULL),
HdotGradHInterPtr_(NULL),
gravity_(dict_.lookup("gravity")),
virtualMass_(dict_.lookup("virtualMass")),
Cvm_(0.0),
@ -88,6 +89,7 @@ Foam::particleForces::particleForces(const particleForces& f)
dict_(f.dict_),
g_(f.g_),
gradUPtr_(f.gradUPtr_),
HdotGradHInterPtr_(f.HdotGradHInterPtr_),
gravity_(f.gravity_),
virtualMass_(f.virtualMass_),
Cvm_(f.Cvm_),

4
src/lagrangian/intermediate/submodels/Kinematic/CollisionModel/PairCollision/PairModel/PairSpringSliderDashpot/PairSpringSliderDashpot.C
View File

@ -198,14 +198,14 @@ void Foam::PairSpringSliderDashpot<CloudType>::evaluatePair
scalar deltaT = this->owner().mesh().time().deltaTValue();
vector& tangentialOverlap_AB =
pA.collisionRecords().matchRecord
pA.collisionRecords().matchPairRecord
(
pB.origProc(),
pB.origId()
).collisionData();
vector& tangentialOverlap_BA =
pB.collisionRecords().matchRecord
pB.collisionRecords().matchPairRecord
(
pA.origProc(),
pA.origId()

2
src/lagrangian/intermediate/submodels/Kinematic/CollisionModel/PairCollision/PairModel/PairSpringSliderDashpot/PairSpringSliderDashpot.H
View File

@ -33,7 +33,7 @@ Description
#define PairSpringSliderDashpot_H
#include "PairModel.H"
#include "CollisionRecord.H"
#include "CollisionRecordList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

9
src/lagrangian/intermediate/submodels/Kinematic/CollisionModel/PairCollision/WallModel/WallSpringSliderDashpot/WallSpringSliderDashpot.C
View File

@ -100,11 +100,10 @@ void Foam::WallSpringSliderDashpot<CloudType>::evaluateWall
scalar deltaT = this->owner().mesh().time().deltaTValue();
// For remembering previous overlap
// vector deltaTangentialOverlap_PW = USlip_PW * deltaT;
// tangentialOverlap_PW += deltaTangentialOverlap_PW;
vector& tangentialOverlap_PW =
p.collisionRecords().matchWallRecord(-r_PW, pREff).collisionData();
vector tangentialOverlap_PW = USlip_PW * deltaT;
tangentialOverlap_PW += USlip_PW*deltaT;
scalar tangentialOverlapMag = mag(tangentialOverlap_PW);
@ -124,7 +123,7 @@ void Foam::WallSpringSliderDashpot<CloudType>::evaluateWall
fT_PW = -mu_*mag(fN_PW)*USlip_PW/mag(USlip_PW);
// tangentialOverlap_PW = vector::zero;
tangentialOverlap_PW = vector::zero;
}
else
{

4
src/turbulenceModels/compressible/RAS/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.C
View File

@ -330,11 +330,11 @@ void Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::updateCoeffs()
Info<< patch().boundaryMesh().mesh().name() << ':'
<< patch().name() << ':'
<< this->dimensionedInternalField().name() << " -> "
<< this->dimensionedInternalField().name() << " <- "
<< nbrMesh.name() << ':'
<< nbrPatch.name() << ':'
<< this->dimensionedInternalField().name() << " :"
<< " heatFlux:" << Q
<< " heat[W]:" << Q
<< " walltemperature "
<< " min:" << gMin(*this)
<< " max:" << gMax(*this)

6
src/turbulenceModels/compressible/RAS/derivedFvPatchFields/turbulentTemperatureCoupledBaffleMixed/turbulentTemperatureCoupledBaffleMixedFvPatchScalarField.C
View File

@ -198,7 +198,7 @@ void turbulentTemperatureCoupledBaffleMixedFvPatchScalarField::updateCoeffs()
// Get the coupling information from the directMappedPatchBase
const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
(
this->patch().patch()
patch().patch()
);
const polyMesh& nbrMesh = mpp.sampleMesh();
const fvPatch& nbrPatch = refCast<const fvMesh>
@ -285,11 +285,11 @@ void turbulentTemperatureCoupledBaffleMixedFvPatchScalarField::updateCoeffs()
Info<< patch().boundaryMesh().mesh().name() << ':'
<< patch().name() << ':'
<< this->dimensionedInternalField().name() << " -> "
<< this->dimensionedInternalField().name() << " <- "
<< nbrMesh.name() << ':'
<< nbrPatch.name() << ':'
<< this->dimensionedInternalField().name() << " :"
<< " heatFlux:" << Q
<< " heat[W]:" << Q
<< " walltemperature "
<< " min:" << gMin(*this)
<< " max:" << gMax(*this)

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/boundaryT
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volScalarField;
location "0";
object boundaryT;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform 0;
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/boundaryU
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volVectorField;
location "0";
object boundaryU;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform (0 0 0);
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/dsmcRhoN
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volScalarField;
location "0";
object dsmcRhoN;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform 0;
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/fD
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volVectorField;
location "0";
object fD;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform (0 0 0);
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/iDof
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volScalarField;
location "0";
object iDof;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform 0;
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/internalE
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volScalarField;
location "0";
object internalE;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform 0;
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/linearKE
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volScalarField;
location "0";
object linearKE;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform 0;
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/momentum
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volVectorField;
location "0";
object momentum;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform (0 0 0);
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/q
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volScalarField;
location "0";
object q;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform 0;
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/rhoM
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volScalarField;
location "0";
object rhoM;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform 0;
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

38
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/0/rhoN
View File

@ -1,8 +1,8 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
@ -10,6 +10,7 @@ FoamFile
version 2.0;
format ascii;
class volScalarField;
location "0";
object rhoN;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -20,20 +21,31 @@ internalField uniform 0;
boundaryField
{
xPeriodic
xPeriodic_half0
{
type cyclic;
}
yPeriodic_half0
{
type cyclic;
}
zPeriodic_half0
{
type cyclic;
}
yPeriodic_half1
{
type cyclic;
}
zPeriodic_half1
{
type cyclic;
}
xPeriodic_half1
{
type cyclic;
}
}
yPeriodic
{
type cyclic;
}
zPeriodic
{
type cyclic;
}
}
// ************************************************************************* //

4
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/constant/dsmcProperties
View File

@ -27,7 +27,6 @@ nEquivalentParticles 1e12;
WallInteractionModel SpecularReflection;
SpecularReflectionCoeffs {}
// Binary Collision Model
// ~~~~~~~~~~~~~~~~~~~~~~
@ -43,9 +42,8 @@ LarsenBorgnakkeVariableHardSphereCoeffs
// Inflow Boundary Model
// ~~~~~~~~~~~~~~~~~~~~~
InflowBoundaryModel NoInflow;
InflowBoundaryModel none;
NoInflowCoeffs {}
// Molecular species
// ~~~~~~~~~~~~~~~~~

43
tutorials/discreteMethods/dsmcFoam/freeSpacePeriodic/constant/polyMesh/boundary
View File

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
@ -15,28 +15,49 @@ FoamFile
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
3
6
(
xPeriodic
xPeriodic_half0
{
type cyclic;
nFaces 512;
nFaces 256;
startFace 14464;
featureCos 0.9;
neighbourPatch xPeriodic_half1;
}
yPeriodic
xPeriodic_half1
{
type cyclic;
nFaces 640;
nFaces 256;
startFace 14720;
neighbourPatch xPeriodic_half0;
}
yPeriodic_half0
{
type cyclic;
nFaces 320;
startFace 14976;
featureCos 0.9;
neighbourPatch yPeriodic_half1;
}
zPeriodic
yPeriodic_half1
{
type cyclic;
nFaces 640;
nFaces 320;
startFace 15296;
neighbourPatch yPeriodic_half0;
}
zPeriodic_half0
{
type cyclic;
nFaces 320;
startFace 15616;
featureCos 0.9;
neighbourPatch zPeriodic_half1;
}
zPeriodic_half1
{
type cyclic;
nFaces 320;
startFace 15936;
neighbourPatch zPeriodic_half0;
}
)

42
tutorials/discreteMethods/dsmcFoam/freeSpaceStream/0/interpolaterhoN
View File

@ -1,42 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class surfaceScalarField;
location "0";
object interpolaterhoN;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 -3 0 0 0 0 0];
internalField uniform 0;
boundaryField
{
outlet
{
type calculated;
value uniform 0;
}
inlet
{
type calculated;
value uniform 0;
}
sides
{
type calculated;
value uniform 0;
}
}
// ************************************************************************* //

2
tutorials/discreteMethods/dsmcFoam/freeSpaceStream/constant/dsmcProperties
View File

@ -27,8 +27,6 @@ nEquivalentParticles 1e12;
WallInteractionModel MaxwellianThermal;
MaxwellianThermalCoeffs {}
// Binary Collision Model
// ~~~~~~~~~~~~~~~~~~~~~~

17
tutorials/discreteMethods/dsmcFoam/supersonicCorner/constant/dsmcProperties
View File

@ -25,39 +25,24 @@ nEquivalentParticles 1.2e12;
// Wall Interaction Model
// ~~~~~~~~~~~~~~~~~~~~~~
//WallInteractionModel SpecularReflection;
WallInteractionModel MaxwellianThermal;
SpecularReflectionCoeffs {}
MaxwellianThermalCoeffs {}
// Binary Collision Model
// ~~~~~~~~~~~~~~~~~~~~~~
//BinaryCollisionModel VariableHardSphere;
BinaryCollisionModel LarsenBorgnakkeVariableHardSphere;
BinaryCollisionModel VariableHardSphere;
VariableHardSphereCoeffs
{
Tref 273;
}
LarsenBorgnakkeVariableHardSphereCoeffs
{
Tref 273;
relaxationCollisionNumber 5.0;
}
// Inflow Boundary Model
// ~~~~~~~~~~~~~~~~~~~~~
InflowBoundaryModel FreeStream;
//InflowBoundaryModel NoInflow;
NoInflowCoeffs {}
FreeStreamCoeffs
{

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/boundaryT
View File

@ -32,9 +32,9 @@ boundaryField
value uniform 550;
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/boundaryU
View File

@ -32,9 +32,9 @@ boundaryField
value uniform (0 0 0);
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/dsmcRhoN
View File

@ -30,9 +30,9 @@ boundaryField
type zeroGradient;
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/fD
View File

@ -31,9 +31,9 @@ boundaryField
value uniform (0 0 0);
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/iDof
View File

@ -31,9 +31,9 @@ boundaryField
value uniform 0;
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/internalE
View File

@ -31,9 +31,9 @@ boundaryField
value uniform 0;
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/linearKE
View File

@ -31,9 +31,9 @@ boundaryField
value uniform 0;
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/momentum
View File

@ -31,9 +31,9 @@ boundaryField
value uniform (0 0 0);
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/q
View File

@ -31,9 +31,9 @@ boundaryField
value uniform 0;
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/rhoM
View File

@ -31,9 +31,9 @@ boundaryField
value uniform 0;
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/0/rhoN
View File

@ -31,9 +31,9 @@ boundaryField
value uniform 0;
}
periodic
frontAndBack
{
type cyclic;
type empty;
}
}

4
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/constant/dsmcProperties
View File

@ -27,8 +27,6 @@ nEquivalentParticles 5e12;
WallInteractionModel MaxwellianThermal;
MaxwellianThermalCoeffs {}
// Binary Collision Model
// ~~~~~~~~~~~~~~~~~~~~~~
@ -47,8 +45,6 @@ LarsenBorgnakkeVariableHardSphereCoeffs
InflowBoundaryModel FreeStream;
NoInflowCoeffs {}
FreeStreamCoeffs
{
numberDensities

30
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/constant/polyMesh/blockMeshDict
View File

@ -18,26 +18,26 @@ convertToMeters 1;
vertices
(
(-0.15242 0 -0.05)
( 0 0 -0.05)
( 0.3048 0.081670913853 -0.05)
(-0.15242 0.3 -0.05)
( 0 0.3 -0.05)
( 0.3048 0.3 -0.05)
(-0.15242 0 -0.0042)
( 0 0 -0.0042)
( 0.3048 0.081670913853 -0.0042)
(-0.15242 0.3 -0.0042)
( 0 0.3 -0.0042)
( 0.3048 0.3 -0.0042)
(-0.15242 0 0.05)
( 0 0 0.05)
( 0.3048 0.081670913853 0.05)
(-0.15242 0.3 0.05)
( 0 0.3 0.05)
( 0.3048 0.3 0.05)
(-0.15242 0 0.0042)
( 0 0 0.0042)
( 0.3048 0.081670913853 0.0042)
(-0.15242 0.3 0.0042)
( 0 0.3 0.0042)
( 0.3048 0.3 0.0042)
);
blocks
(
hex (0 1 4 3 6 7 10 9 ) (20 40 12) simpleGrading (1 1 1)
hex (1 2 5 4 7 8 11 10) (40 40 12) simpleGrading (1 1 1)
hex (0 1 4 3 6 7 10 9 ) (20 40 1) simpleGrading (1 1 1)
hex (1 2 5 4 7 8 11 10) (40 40 1) simpleGrading (1 1 1)
);
edges
@ -58,7 +58,7 @@ patches
(
(1 2 8 7)
)
cyclic periodic
empty frontAndBack
(
(0 3 4 1)
(1 4 5 2)

17
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/constant/polyMesh/boundary
View File

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
@ -20,21 +20,20 @@ FoamFile
flow
{
type patch;
nFaces 1920;
startFace 82800;
nFaces 160;
startFace 4700;
}
obstacle
{
type wall;
nFaces 480;
startFace 84720;
nFaces 40;
startFace 4860;
}
periodic
frontAndBack
{
type cyclic;
type empty;
nFaces 4800;
startFace 85200;
featureCos 0.9;
startFace 4900;
}
)

5
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/controlDict
View File

@ -23,14 +23,13 @@ startTime 0;
stopAt endTime;
endTime 0.00125;
// endTime 0.01;
endTime 0.02;
deltaT 2e-6;
writeControl runTime;
writeInterval 1e-4;
writeInterval 1e-3;
purgeWrite 0;

2
tutorials/discreteMethods/dsmcFoam/wedge15Ma5/system/decomposeParDict
View File

@ -21,7 +21,7 @@ method simple;
simpleCoeffs
{
n ( 1 1 4 );
n ( 2 2 1 );
delta 0.001;
}

41
tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeArgon/constant/polyMesh/boundary
View File

@ -15,28 +15,49 @@ FoamFile
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
3
6
(
periodicX
periodicX_half0
{
type cyclic;
nFaces 288;
nFaces 144;
startFace 4752;
featureCos 0.9;
neighbourPatch periodicX_half1;
}
periodicY
periodicX_half1
{
type cyclic;
nFaces 288;
nFaces 144;
startFace 4896;
neighbourPatch periodicX_half0;
}
periodicY_half0
{
type cyclic;
nFaces 144;
startFace 5040;
featureCos 0.9;
neighbourPatch periodicY_half1;
}
periodicZ
periodicY_half1
{
type cyclic;
nFaces 288;
nFaces 144;
startFace 5184;
neighbourPatch periodicY_half0;
}
periodicZ_half0
{
type cyclic;
nFaces 144;
startFace 5328;
featureCos 0.9;
neighbourPatch periodicZ_half1;
}
periodicZ_half1
{
type cyclic;
nFaces 144;
startFace 5472;
neighbourPatch periodicZ_half0;
}
)

43
tutorials/discreteMethods/molecularDynamics/mdEquilibrationFoam/periodicCubeWater/constant/polyMesh/boundary
View File

@ -1,7 +1,7 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
@ -15,28 +15,49 @@ FoamFile
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
3
6
(
periodicX
periodicX_half0
{
type cyclic;
nFaces 264;
nFaces 132;
startFace 4344;
featureCos 0.9;
neighbourPatch periodicX_half1;
}
periodicY
periodicX_half1
{
type cyclic;
nFaces 264;
nFaces 132;
startFace 4476;
neighbourPatch periodicX_half0;
}
periodicY_half0
{
type cyclic;
nFaces 132;
startFace 4608;
featureCos 0.9;
neighbourPatch periodicY_half1;
}
periodicZ
periodicY_half1
{
type cyclic;
nFaces 288;
nFaces 132;
startFace 4740;
neighbourPatch periodicY_half0;
}
periodicZ_half0
{
type cyclic;
nFaces 144;
startFace 4872;
featureCos 0.9;
neighbourPatch periodicZ_half1;
}
periodicZ_half1
{
type cyclic;
nFaces 144;
startFace 5016;
neighbourPatch periodicZ_half0;
}
)