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

Merge branch 'master' of /home/dm4/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
andy
2013-06-20 11:30:40 +01:00
parent 68ca453590 b482e3e45f
commit 9539e7d375
62 changed files with 869 additions and 581 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
applications/solvers/incompressible/potentialFreeSurfaceFoam/resetPhiPatches.H
View File

@ -1,8 +0,0 @@
FieldField<fvsPatchField, scalar>& phibf = phi.boundaryField();
const FieldField<fvPatchField, vector>& Ubf = U.boundaryField();
const FieldField<fvsPatchField, vector>& Sfbf = mesh.Sf().boundaryField();
forAll(phibf, patchI)
{
phibf[patchI] = (Ubf[patchI] & Sfbf[patchI]);
}

0
applications/solvers/incompressible/potentialFreeSurfaceFoam/Make/files → applications/solvers/multiphase/potentialFreeSurfaceFoam/Make/files
View File

0
applications/solvers/incompressible/potentialFreeSurfaceFoam/Make/options → applications/solvers/multiphase/potentialFreeSurfaceFoam/Make/options
View File

0
applications/solvers/incompressible/potentialFreeSurfaceFoam/UEqn.H → applications/solvers/multiphase/potentialFreeSurfaceFoam/UEqn.H
View File

0
applications/solvers/incompressible/potentialFreeSurfaceFoam/createFields.H → applications/solvers/multiphase/potentialFreeSurfaceFoam/createFields.H
View File

5
applications/solvers/incompressible/potentialFreeSurfaceFoam/pEqn.H → applications/solvers/multiphase/potentialFreeSurfaceFoam/pEqn.H
View File

@ -1,5 +1,3 @@
#include "resetPhiPatches.H"
volScalarField rAU(1.0/UEqn().A());
surfaceScalarField rAUf("Dp", fvc::interpolate(rAU));
@ -22,6 +20,9 @@ adjustPhi(phiHbyA, U, p_gh);
fvOptions.relativeFlux(phiHbyA);
// Update the phi BCs from U before p BCs are updated
phi.boundaryField() = mesh.Sf().boundaryField() & U.boundaryField();
// Non-orthogonal pressure corrector loop
while (pimple.correctNonOrthogonal())
{

0
applications/solvers/incompressible/potentialFreeSurfaceFoam/potentialFreeSurfaceFoam.C → applications/solvers/multiphase/potentialFreeSurfaceFoam/potentialFreeSurfaceFoam.C
View File

2
applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C
View File

@ -1783,7 +1783,7 @@ int main(int argc, char *argv[])
{
extrudeMeshShadowFaces[nShadowFaces] = fz[j];
zoneShadowFlipMap[nShadowFaces] = fz.flipMap()[j];
zoneShadowID[nShadowFaces] = zoneShadowIDs[i];
zoneShadowID[nShadowFaces] = i;
nShadowFaces++;
}
}

2
applications/utilities/mesh/generation/foamyHexMesh/foamyHexMesh.C
View File

@ -111,6 +111,8 @@ int main(int argc, char *argv[])
conformalVoronoiMesh::debug = true;
Info<< "Create mesh for time = " << runTime.timeName() << nl << endl;
conformalVoronoiMesh mesh(runTime, foamyHexMeshDict);

47
src/OpenFOAM/containers/LinkedLists/accessTypes/UILList/UILList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -79,6 +79,9 @@ public:
class const_iterator;
friend class const_iterator;
class const_reverse_iterator;
friend class const_reverse_iterator;
// Constructors
@ -254,6 +257,48 @@ public:
};
// STL const_reverse_iterator
typedef typename LListBase::const_reverse_iterator
LListBase_const_reverse_iterator;
//- An STL-conforming const_reverse_iterator
class const_reverse_iterator
:
public LListBase_const_reverse_iterator
{
public:
//- Construct from base const_reverse_iterator
const_reverse_iterator(LListBase_const_reverse_iterator baseIter)
:
LListBase_const_reverse_iterator(baseIter)
{}
// Member operators
const T& operator*()
{
return
static_cast<const T&>
(LListBase_const_reverse_iterator::operator*());
}
const T& operator()()
{
return operator*();
}
const_reverse_iterator& operator++()
{
LListBase_const_reverse_iterator::operator++();
return *this;
}
};
// STL member operators
//- Equality operation on ULists of the same type.

8
src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBase.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -42,6 +42,12 @@ Foam::DLListBase::const_iterator Foam::DLListBase::endConstIter_
reinterpret_cast<const link*>(0)
);
Foam::DLListBase::const_reverse_iterator Foam::DLListBase::endConstRevIter_
(
static_cast<const DLListBase&>(DLListBase()),
reinterpret_cast<const link*>(0)
);
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //

45
src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBase.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -100,6 +100,9 @@ public:
class const_iterator;
friend class const_iterator;
class const_reverse_iterator;
friend class const_reverse_iterator;
// Constructors
@ -260,6 +263,43 @@ public:
inline const_iterator begin() const;
inline const const_iterator& end() const;
// STL const_reverse_iterator
//- An STL-conforming const_reverse_iterator
class const_reverse_iterator
{
// Private data
//- Reference to the list this is an reverse_iterator for
const DLListBase& curList_;
//- Current element
const link* curElmt_;
public:
//- Construct for a given DLListBase and link
inline const_reverse_iterator(const DLListBase&, const link*);
// Member operators
inline void operator=(const const_reverse_iterator&);
inline bool operator==(const const_reverse_iterator&) const;
inline bool operator!=(const const_reverse_iterator&) const;
inline const link& operator*();
inline const_reverse_iterator& operator++();
inline const_reverse_iterator operator++(int);
};
inline const_reverse_iterator crbegin() const;
inline const const_reverse_iterator& crend() const;
inline const_reverse_iterator rbegin() const;
inline const const_reverse_iterator& rend() const;
private:
//- iterator returned by end()
@ -268,6 +308,9 @@ private:
//- const_iterator returned by end()
static const_iterator endConstIter_;
//- const_reverse_iterator returned by end()
static const_reverse_iterator endConstRevIter_;
};

109
src/OpenFOAM/containers/LinkedLists/linkTypes/DLListBase/DLListBaseI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -383,4 +383,111 @@ Foam::DLListBase::end() const
}
// * * * * * * * * * * STL const_reverse_iterator * * * * * * * * * * * * * //
inline Foam::DLListBase::const_reverse_iterator::const_reverse_iterator
(
const DLListBase& s,
const link* elmt
)
:
curList_(s),
curElmt_(elmt)
{}
inline void Foam::DLListBase::const_reverse_iterator::operator=
(
const const_reverse_iterator& iter
)
{
curElmt_ = iter.curElmt_;
}
inline bool Foam::DLListBase::const_reverse_iterator::operator==
(
const const_reverse_iterator& iter
) const
{
return curElmt_ == iter.curElmt_;
}
inline bool Foam::DLListBase::const_reverse_iterator::operator!=
(
const const_reverse_iterator& iter
) const
{
return curElmt_ != iter.curElmt_;
}
inline const Foam::DLListBase::link&
Foam::DLListBase::const_reverse_iterator::operator*()
{
return *curElmt_;
}
inline Foam::DLListBase::const_reverse_iterator&
Foam::DLListBase::const_reverse_iterator::operator++()
{
if (curElmt_ == curList_.first_)
{
curElmt_ = 0;
}
else
{
curElmt_ = curElmt_->prev_;
}
return *this;
}
inline Foam::DLListBase::const_reverse_iterator
Foam::DLListBase::const_reverse_iterator::operator++(int)
{
const_reverse_iterator tmp = *this;
++*this;
return tmp;
}
inline Foam::DLListBase::const_reverse_iterator
Foam::DLListBase::crbegin() const
{
if (size())
{
return const_reverse_iterator(*this, last());
}
else
{
return endConstRevIter_;
}
}
inline const Foam::DLListBase::const_reverse_iterator&
Foam::DLListBase::crend() const
{
return endConstRevIter_;
}
inline Foam::DLListBase::const_reverse_iterator
Foam::DLListBase::rbegin() const
{
return this->crbegin();
}
inline const Foam::DLListBase::const_reverse_iterator&
Foam::DLListBase::rend() const
{
return endConstRevIter_;
}
// ************************************************************************* //

432
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -628,197 +628,245 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define PRODUCT_OPERATOR(product, op, opFunc) \
\
template<template<class> class Field, class Type1, class Type2> \
void opFunc \
( \
FieldField<Field, typename product<Type1, Type2>::type>& f, \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \
) \
{ \
forAll(f, i) \
{ \
opFunc(f[i], f1[i], f2[i]); \
} \
} \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
opFunc(tRes(), f1, f2); \
return tRes; \
} \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
reuseTmpFieldField<Field, productType, Type2>::New(tf2) \
); \
opFunc(tRes(), f1, tf2()); \
reuseTmpFieldField<Field, productType, Type2>::clear(tf2); \
return tRes; \
} \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const FieldField<Field, Type2>& f2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
reuseTmpFieldField<Field, productType, Type1>::New(tf1) \
); \
opFunc(tRes(), tf1(), f2); \
reuseTmpFieldField<Field, productType, Type1>::clear(tf1); \
return tRes; \
} \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type2> >& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
reuseTmpTmpFieldField<Field, productType, Type1, Type1, Type2>::New \
(tf1, tf2) \
); \
opFunc(tRes(), tf1(), tf2()); \
reuseTmpTmpFieldField<Field, productType, Type1, Type1, Type2>::clear \
(tf1, tf2); \
return tRes; \
} \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
void opFunc \
( \
FieldField<Field, typename product<Type, Form>::type>& f, \
const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
forAll(f, i) \
{ \
opFunc(f[i], f1[i], vs); \
} \
} \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
operator op \
( \
const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
opFunc(tRes(), f1, static_cast<const Form&>(vs)); \
return tRes; \
} \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
operator op \
( \
const tmp<FieldField<Field, Type> >& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \
opFunc(tRes(), tf1(), static_cast<const Form&>(vs)); \
reuseTmpFieldField<Field, productType, Type>::clear(tf1); \
return tRes; \
} \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
void opFunc \
( \
FieldField<Field, typename product<Form, Type>::type>& f, \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \
) \
{ \
forAll(f, i) \
{ \
opFunc(f[i], vs, f1[i]); \
} \
} \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
opFunc(tRes(), static_cast<const Form&>(vs), f1); \
return tRes; \
} \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<FieldField<Field, Type> >& tf1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \
opFunc(tRes(), static_cast<const Form&>(vs), tf1()); \
reuseTmpFieldField<Field, productType, Type>::clear(tf1); \
return tRes; \
#define PRODUCT_OPERATOR(product, op, opFunc) \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
void opFunc \
( \
FieldField<Field1, typename product<Type1, Type2>::type>& f, \
const FieldField<Field1, Type1>& f1, \
const FieldField<Field2, Type2>& f2 \
) \
{ \
forAll(f, i) \
{ \
opFunc(f[i], f1[i], f2[i]); \
} \
} \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field1, Type1>& f1, \
const FieldField<Field2, Type2>& f2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType> > tRes \
( \
FieldField<Field1, productType>::NewCalculatedType(f1) \
); \
opFunc(tRes(), f1, f2); \
return tRes; \
} \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
reuseTmpFieldField<Field, productType, Type2>::New(tf2) \
); \
opFunc(tRes(), f1, tf2()); \
reuseTmpFieldField<Field, productType, Type2>::clear(tf2); \
return tRes; \
} \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field1, Type1>& f1, \
const tmp<FieldField<Field2, Type2> >& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType> > tRes \
( \
FieldField<Field1, productType>::NewCalculatedType(f1) \
); \
opFunc(tRes(), f1, tf2()); \
tf2.clear(); \
return tRes; \
} \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
operator op \
( \
const tmp<FieldField<Field1, Type1> >& tf1, \
const FieldField<Field2, Type2>& f2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType> > tRes \
( \
reuseTmpFieldField<Field1, productType, Type1>::New(tf1) \
); \
opFunc(tRes(), tf1(), f2); \
reuseTmpFieldField<Field1, productType, Type1>::clear(tf1); \
return tRes; \
} \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
operator op \
( \
const tmp<FieldField<Field1, Type1> >& tf1, \
const tmp<FieldField<Field2, Type2> >& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType> > tRes \
( \
reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::New \
(tf1, tf2) \
); \
opFunc(tRes(), tf1(), tf2()); \
reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::clear \
(tf1, tf2); \
return tRes; \
} \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
void opFunc \
( \
FieldField<Field, typename product<Type, Form>::type>& f, \
const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
forAll(f, i) \
{ \
opFunc(f[i], f1[i], vs); \
} \
} \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
operator op \
( \
const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
opFunc(tRes(), f1, static_cast<const Form&>(vs)); \
return tRes; \
} \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
operator op \
( \
const tmp<FieldField<Field, Type> >& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \
opFunc(tRes(), tf1(), static_cast<const Form&>(vs)); \
reuseTmpFieldField<Field, productType, Type>::clear(tf1); \
return tRes; \
} \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
void opFunc \
( \
FieldField<Field, typename product<Form, Type>::type>& f, \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \
) \
{ \
forAll(f, i) \
{ \
opFunc(f[i], vs, f1[i]); \
} \
} \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
opFunc(tRes(), static_cast<const Form&>(vs), f1); \
return tRes; \
} \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<FieldField<Field, Type> >& tf1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<FieldField<Field, productType> > tRes \
( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \
opFunc(tRes(), static_cast<const Form&>(vs), tf1()); \
reuseTmpFieldField<Field, productType, Type>::clear(tf1); \
return tRes; \
}
PRODUCT_OPERATOR(typeOfSum, +, add)

228
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -267,100 +267,138 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define PRODUCT_OPERATOR(product, op, opFunc) \
\
template<template<class> class Field, class Type1, class Type2> \
void opFunc \
( \
FieldField<Field, typename product<Type1, Type2>::type>& f, \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \
); \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \
); \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
); \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const FieldField<Field, Type2>& f2 \
); \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type2> >& tf2 \
); \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
void opFunc \
( \
FieldField<Field, typename product<Type, Form>::type>& f, \
const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
operator op \
( \
const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
operator op \
( \
const tmp<FieldField<Field, Type> >& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
void opFunc \
( \
FieldField<Field, typename product<Form, Type>::type>& f, \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \
); \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \
); \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<FieldField<Field, Type> >& tf1 \
#define PRODUCT_OPERATOR(product, op, opFunc) \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
void opFunc \
( \
FieldField<Field1, typename product<Type1, Type2>::type>& f, \
const FieldField<Field1, Type1>& f1, \
const FieldField<Field2, Type2>& f2 \
); \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field1, Type1>& f1, \
const FieldField<Field2, Type2>& f2 \
); \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
); \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
operator op \
( \
const FieldField<Field1, Type1>& f1, \
const tmp<FieldField<Field2, Type2> >& tf2 \
); \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
operator op \
( \
const tmp<FieldField<Field1, Type1> >& tf1, \
const FieldField<Field2, Type2>& f2 \
); \
\
template \
< \
template<class> class Field1, \
template<class> class Field2, \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
operator op \
( \
const tmp<FieldField<Field1, Type1> >& tf1, \
const tmp<FieldField<Field2, Type2> >& tf2 \
); \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
void opFunc \
( \
FieldField<Field, typename product<Type, Form>::type>& f, \
const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
operator op \
( \
const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
operator op \
( \
const tmp<FieldField<Field, Type> >& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
void opFunc \
( \
FieldField<Field, typename product<Form, Type>::type>& f, \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \
); \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \
); \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<FieldField<Field, Type> >& tf1 \
);
PRODUCT_OPERATOR(typeOfSum, +, add)

55
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C
View File

@ -50,7 +50,8 @@ readField
}
// 1. Handle explicit patch names
// 1. Handle explicit patch names. Note that there can be only one explicit
// patch name since is key of dictionary.
forAllConstIter(dictionary, dict, iter)
{
if (iter().isDict() && !iter().keyword().isPattern())
@ -76,33 +77,45 @@ readField
// 2. Patch-groups. (using non-wild card entries of dictionaries)
// (patchnames already matched above)
// Note: in order of entries in the dictionary (first patchGroups wins)
forAllConstIter(dictionary, dict, iter)
// Note: in reverse order of entries in the dictionary (last
// patchGroups wins). This is so is consistent with dictionary wildcard
// behaviour
if (dict.size())
{
if (iter().isDict() && !iter().keyword().isPattern())
for
(
IDLList<entry>::const_reverse_iterator iter = dict.rbegin();
iter != dict.rend();
++iter
)
{
const labelList patchIDs = bmesh_.findIndices
(
iter().keyword(),
true // use patchGroups
);
const entry& e = iter();
forAll(patchIDs, i)
if (e.isDict() && !e.keyword().isPattern())
{
label patchi = patchIDs[i];
const labelList patchIDs = bmesh_.findIndices
(
e.keyword(),
true // use patchGroups
);
if (!this->set(patchi))
forAll(patchIDs, i)
{
this->set
(
patchi,
PatchField<Type>::New
label patchi = patchIDs[i];
if (!this->set(patchi))
{
this->set
(
bmesh_[patchi],
field,
iter().dict()
)
);
patchi,
PatchField<Type>::New
(
bmesh_[patchi],
field,
e.dict()
)
);
}
}
}
}

4
src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGSolverInterpolate.C
View File

@ -90,10 +90,6 @@ void Foam::GAMGSolver::interpolate
{
corrC[restrictAddressing[celli]] += diagPtr[celli]*psiPtr[celli];
diagC[restrictAddressing[celli]] += diagPtr[celli];
//corrC[restrictAddressing[celli]] += psiPtr[celli]/diagPtr[celli];
//diagC[restrictAddressing[celli]] += 1.0/diagPtr[celli];
//corrC[restrictAddressing[celli]] += psiPtr[celli];
//diagC[restrictAddressing[celli]] += 1.0;
}
for (register label ccelli=0; ccelli<nCCells; ccelli++)

2
src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/GAMGSolverSolve.C
View File

@ -313,7 +313,7 @@ void Foam::GAMGSolver::Vcycle
scalarField& ACfRef =
const_cast<scalarField&>(ACf.operator const scalarField&());
if (interpolateCorrection_ && leveli < coarsestLevel - 2)
if (interpolateCorrection_) //&& leveli < coarsestLevel - 2)
{
interpolate
(

12
src/OpenFOAM/meshes/pointMesh/pointPatches/basic/coupled/coupledPointPatch.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -98,16 +98,6 @@ public:
//- Destructor
virtual ~coupledPointPatch();
// Member Functions
// Access
//- Return true because this patch is coupled
virtual bool coupled() const
{
return true;
}
};

13
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.H
View File

@ -115,19 +115,6 @@ public:
// Member functions
//- Return true if running parallel
virtual bool coupled() const
{
if (Pstream::parRun())
{
return true;
}
else
{
return false;
}
}
//- Return message tag to use for communication
virtual int tag() const
{

8
src/OpenFOAM/meshes/pointMesh/pointPatches/facePointPatch/facePointPatch.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -171,6 +171,12 @@ public:
return polyPatch_.index();
}
//- Return true if this patch field is coupled
virtual bool coupled() const
{
return polyPatch_.coupled();
}
//- Return mesh points
virtual const labelList& meshPoints() const
{

23
src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomerate.C
View File

@ -38,7 +38,7 @@ makeCompactCellFaceAddressingAndFaceWeights
const lduAddressing& fineAddressing,
List<idxtype>& cellCells,
List<idxtype>& cellCellOffsets,
const vectorField& Si,
const scalarField& magSi,
List<scalar>& faceWeights
)
{
@ -87,8 +87,8 @@ makeCompactCellFaceAddressingAndFaceWeights
cellCells[l1] = nei;
cellCells[l2] = own;
faceWeights[l1] = mag(Si[facei]);
faceWeights[l2] = mag(Si[facei]);
faceWeights[l1] = magSi[facei];
faceWeights[l2] = magSi[facei];
}
}
@ -100,8 +100,8 @@ Foam::tmp<Foam::labelField> Foam::MGridGenGAMGAgglomeration::agglomerate
const label maxSize,
const lduAddressing& fineAddressing,
const scalarField& V,
const vectorField& Sf,
const scalarField& Sb
const scalarField& magSf,
const scalarField& magSb
)
{
const label nFineCells = fineAddressing.size();
@ -119,15 +119,15 @@ Foam::tmp<Foam::labelField> Foam::MGridGenGAMGAgglomeration::agglomerate
fineAddressing,
cellCells,
cellCellOffsets,
Sf,
magSf,
faceWeights
);
// agglomeration options.
List<int> options(4, 0);
options[0] = 4; // globular agglom
options[1] = 6; // objective F3 and F2
options[2] = 128; // debugging output level
options[0] = 4; // globular agglom
options[1] = 6; // objective F3 and F2
options[2] = 128; // debugging output level
options[3] = fvMesh_.nGeometricD(); // Dimensionality of the grid
@ -140,7 +140,7 @@ Foam::tmp<Foam::labelField> Foam::MGridGenGAMGAgglomeration::agglomerate
nFineCells,
cellCellOffsets.begin(),
const_cast<scalar*>(V.begin()),
const_cast<scalar*>(Sb.begin()),
const_cast<scalar*>(magSb.begin()),
cellCells.begin(),
faceWeights.begin(),
minSize,
@ -157,8 +157,7 @@ Foam::tmp<Foam::labelField> Foam::MGridGenGAMGAgglomeration::agglomerate
bool ok = checkRestriction
(
newRestrictAddr,
nNewCoarseCells
,
nNewCoarseCells,
fineAddressing,
finalAgglom,
nCoarseCells

65
src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C
View File

@ -25,6 +25,7 @@ License
#include "MGridGenGAMGAgglomeration.H"
#include "fvMesh.H"
#include "processorPolyPatch.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -60,20 +61,19 @@ Foam::MGridGenGAMGAgglomeration::MGridGenGAMGAgglomeration
// Start geometric agglomeration from the cell volumes and areas of the mesh
scalarField* VPtr = const_cast<scalarField*>(&fvMesh_.cellVolumes());
vectorField magFaceAreas(vector::one*mag(fvMesh_.faceAreas()));
SubField<vector> Sf(magFaceAreas, fvMesh_.nInternalFaces());
//SubField<vector> Sf(fvMesh_.faceAreas(), fvMesh_.nInternalFaces());
scalarField magFaceAreas(sqrt(3.0)*mag(fvMesh_.faceAreas()));
SubField<scalar> magSf(magFaceAreas, fvMesh_.nInternalFaces());
vectorField* SfPtr = const_cast<vectorField*>
scalarField* magSfPtr = const_cast<scalarField*>
(
&Sf.operator const vectorField&()
&magSf.operator const scalarField&()
);
// Create the boundary area cell field
scalarField* SbPtr(new scalarField(fvMesh_.nCells(), 0));
scalarField* magSbPtr(new scalarField(fvMesh_.nCells(), 0));
{
scalarField& Sb = *SbPtr;
scalarField& magSb = *magSbPtr;
const labelList& own = fvMesh_.faceOwner();
const vectorField& Sf = fvMesh_.faceAreas();
@ -82,11 +82,32 @@ Foam::MGridGenGAMGAgglomeration::MGridGenGAMGAgglomeration
{
if (!fvMesh_.isInternalFace(facei))
{
Sb[own[facei]] += mag(Sf[facei]);
magSb[own[facei]] += mag(Sf[facei]);
}
}
}
/*
{
scalarField& magSb = *magSbPtr;
const polyBoundaryMesh& patches = fvMesh_.boundaryMesh();
forAll(patches, patchi)
{
const polyPatch& pp = patches[patchi];
if (!(Pstream::parRun() && isA<processorPolyPatch>(pp)))
{
const labelUList& faceCells = pp.faceCells();
const vectorField& pSf = pp.faceAreas();
forAll(faceCells, pfi)
{
magSb[faceCells[pfi]] += mag(pSf[pfi]);
}
}
}
}
*/
// Agglomerate until the required number of cells in the coarsest level
// is reached
@ -104,8 +125,8 @@ Foam::MGridGenGAMGAgglomeration::MGridGenGAMGAgglomeration
maxSize,
meshLevel(nCreatedLevels).lduAddr(),
*VPtr,
*SfPtr,
*SbPtr
*magSfPtr,
*magSbPtr
);
if (continueAgglomerating(nCoarseCells))
@ -140,37 +161,37 @@ Foam::MGridGenGAMGAgglomeration::MGridGenGAMGAgglomeration
// Agglomerate the face areas field for the next level
{
vectorField* aggSfPtr
scalarField* aggMagSfPtr
(
new vectorField
new scalarField
(
meshLevels_[nCreatedLevels].upperAddr().size(),
vector::zero
0
)
);
restrictFaceField(*aggSfPtr, *SfPtr, nCreatedLevels);
restrictFaceField(*aggMagSfPtr, *magSfPtr, nCreatedLevels);
if (nCreatedLevels)
{
delete SfPtr;
delete magSfPtr;
}
SfPtr = aggSfPtr;
magSfPtr = aggMagSfPtr;
}
// Agglomerate the cell boundary areas field for the next level
{
scalarField* aggSbPtr
scalarField* aggMagSbPtr
(
new scalarField(meshLevels_[nCreatedLevels].size())
);
// Restrict but no parallel agglomeration (not supported)
restrictField(*aggSbPtr, *SbPtr, nCreatedLevels, false);
restrictField(*aggMagSbPtr, *magSbPtr, nCreatedLevels, false);
delete SbPtr;
SbPtr = aggSbPtr;
delete magSbPtr;
magSbPtr = aggMagSbPtr;
}
nCreatedLevels++;
@ -183,9 +204,9 @@ Foam::MGridGenGAMGAgglomeration::MGridGenGAMGAgglomeration
if (nCreatedLevels)
{
delete VPtr;
delete SfPtr;
delete magSfPtr;
}
delete SbPtr;
delete magSbPtr;
}

8
src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -73,7 +73,7 @@ class MGridGenGAMGAgglomeration
const lduAddressing& fineAddressing,
List<idxtype>& cellCells,
List<idxtype>& cellCellOffsets,
const vectorField& Si,
const scalarField& magSi,
List<scalar>& faceWeights
);
@ -85,8 +85,8 @@ class MGridGenGAMGAgglomeration
const label maxSize,
const lduAddressing& fineAddressing,
const scalarField& V,
const vectorField& Sf,
const scalarField& Sb
const scalarField& magSf,
const scalarField& magSb
);

4
src/fvMotionSolver/pointPatchFields/derived/surfaceDisplacement/surfaceDisplacementPointPatchVectorField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -72,7 +72,7 @@ void surfaceDisplacementPointPatchVectorField::calcProjection
const scalar projectLen = mag(mesh.bounds().max()-mesh.bounds().min());
// For case of fixed projection vector:
vector projectVec;
vector projectVec(vector::zero);
if (projectMode_ == FIXEDNORMAL)
{
vector n = projectDir_/mag(projectDir_);

9
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
View File

@ -2501,7 +2501,8 @@ void Foam::autoLayerDriver::addLayers
if (debug&meshRefinement::MESH)
{
const_cast<Time&>(mesh.time())++;
Info<< "Writing baffled mesh to " << meshRefiner_.timeName() << endl;
Info<< "Writing baffled mesh to time "
<< meshRefiner_.timeName() << endl;
meshRefiner_.write
(
debug,
@ -2923,7 +2924,8 @@ void Foam::autoLayerDriver::addLayers
);
const_cast<Time&>(mesh.time())++;
Info<< "Writing shrunk mesh to " << meshRefiner_.timeName() << endl;
Info<< "Writing shrunk mesh to time "
<< meshRefiner_.timeName() << endl;
// See comment in autoSnapDriver why we should not remove meshPhi
// using mesh.clearOut().
@ -3057,7 +3059,8 @@ void Foam::autoLayerDriver::addLayers
if (debug&meshRefinement::MESH)
{
Info<< "Writing layer mesh to " << meshRefiner_.timeName() << endl;
Info<< "Writing layer mesh to time " << meshRefiner_.timeName()
<< endl;
newMesh.write();
cellSet addedCellSet
(

16
src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementProblemCells.C
View File

@ -958,13 +958,15 @@ Foam::labelList Foam::meshRefinement::markFacesOnProblemCells
// Because of isCollapsedFace one side can decide not to baffle whereas
// the other side does so sync. Baffling is prefered over not baffling.
syncTools::syncFaceList
(
mesh_,
facePatch,
maxEqOp<label>()
);
if (checkCollapse) // Or always?
{
syncTools::syncFaceList
(
mesh_,
facePatch,
maxEqOp<label>()
);
}
Info<< "markFacesOnProblemCells : marked "
<< returnReduce(nBaffleFaces, sumOp<label>())

7
src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPointPatch/cyclicAMIPointPatch.H
View File

@ -112,13 +112,6 @@ public:
// Member Functions
//- Is patch 'coupled'. Note that on AMI the geometry is not
// coupled but the fields are!
virtual bool coupled() const
{
return false;
}
//- Return the constraint type this pointPatch implements.
virtual const word& constraintType() const
{

2
tutorials/incompressible/simpleFoam/motorBike/0.org/U
View File

@ -41,7 +41,7 @@ boundaryField
value $internalField;
}
"motorBike_.*"
motorBikeGroup
{
type fixedValue;
value uniform (0 0 0);

2
tutorials/incompressible/simpleFoam/motorBike/0.org/k
View File

@ -41,7 +41,7 @@ boundaryField
value $internalField;
}
"motorBike_.*"
motorBikeGroup
{
type kqRWallFunction;
value $internalField;

2
tutorials/incompressible/simpleFoam/motorBike/0.org/nut
View File

@ -54,7 +54,7 @@ boundaryField
value uniform 0;
}
"motorBike_.*"
motorBikeGroup
{
type nutkWallFunction;
value uniform 0;

2
tutorials/incompressible/simpleFoam/motorBike/0.org/omega
View File

@ -40,7 +40,7 @@ boundaryField
value $internalField;
}
"motorBike_.*"
motorBikeGroup
{
type omegaWallFunction;
value $internalField;

2
tutorials/incompressible/simpleFoam/motorBike/0.org/p
View File

@ -41,7 +41,7 @@ boundaryField
type zeroGradient;
}
"motorBike_.*"
motorBikeGroup
{
type zeroGradient;
}

4
tutorials/incompressible/simpleFoam/motorBike/Allclean
View File

@ -3,8 +3,10 @@
# Source tutorial clean functions
. $WM_PROJECT_DIR/bin/tools/CleanFunctions
# remove surface
# remove surface and features
\rm -f constant/triSurface/motorBike.obj.gz
\rm -rf constant/extendedFeatureEdgeMesh/
\rm -f constant/triSurface/motorBike.eMesh
rm -rf 0 > /dev/null 2>&1

52
tutorials/incompressible/simpleFoam/motorBike/constant/polyMesh/boundary
View File

@ -1,52 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class polyBoundaryMesh;
location "constant/polyMesh";
object boundary;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
5
(
frontAndBack
{
type patch;
nFaces 320;
startFace 3456;
}
inlet
{
type patch;
nFaces 64;
startFace 3776;
}
outlet
{
type patch;
nFaces 64;
startFace 3840;
}
lowerWall
{
type wall;
nFaces 160;
startFace 3904;
}
upperWall
{
type patch;
nFaces 160;
startFace 4064;
}
)
// ************************************************************************* //

7
tutorials/incompressible/simpleFoam/motorBike/system/forceCoeffs
View File

@ -12,12 +12,11 @@ forceCoeffs1
functionObjectLibs ( "libforces.so" );
outputControl timeStep;
outputInterval 1;
outputControl outputTime;
log yes;
patches ( "motorBike.*" );
patches ( motorBikeGroup );
pName p;
UName U;
rhoName rhoInf; // Indicates incompressible
@ -31,6 +30,7 @@ forceCoeffs1
lRef 1.42; // Wheelbase length
Aref 0.75; // Estimated
/* - Uncomment to have forceCoeffs calculated in 20 bins
binData
{
nBin 20; // output data into 20 bins
@ -38,6 +38,7 @@ forceCoeffs1
format gnuplot;
cumulative yes;
}
*/
}

1
tutorials/incompressible/simpleFoam/motorBike/system/fvSchemes
View File

@ -22,6 +22,7 @@ ddtSchemes
gradSchemes
{
default Gauss linear;
grad(U) cellLimited Gauss linear 1;
}
divSchemes

2
tutorials/incompressible/simpleFoam/motorBike/system/fvSolution
View File

@ -20,7 +20,7 @@ solvers
{
solver GAMG;
tolerance 1e-7;
relTol 0.1;
relTol 0.01;
smoother GaussSeidel;
nPreSweeps 0;
nPostSweeps 2;

12
tutorials/incompressible/simpleFoam/motorBike/system/snappyHexMeshDict
View File

@ -92,7 +92,7 @@ castellatedMeshControls
(
{
file "motorBike.eMesh";
level 0;
level 6;
}
);
@ -119,7 +119,7 @@ castellatedMeshControls
patchInfo
{
type wall;
inGroups (motorBike);
inGroups (motorBikeGroup);
}
}
}
@ -180,10 +180,10 @@ snapControls
//- Relative distance for points to be attracted by surface feature point
// or edge. True distance is this factor times local
// maximum edge length.
tolerance 4.0;
tolerance 2.0;
//- Number of mesh displacement relaxation iterations.
nSolveIter 0;
nSolveIter 30;
//- Maximum number of snapping relaxation iterations. Should stop
// before upon reaching a correct mesh.
@ -193,14 +193,14 @@ snapControls
//- Number of feature edge snapping iterations.
// Leave out altogether to disable.
nFeatureSnapIter 0;
nFeatureSnapIter 10;
//- Detect (geometric only) features by sampling the surface
// (default=false).
implicitFeatureSnap false;
//- Use castellatedMeshControls::features (default = true)
explicitFeatureSnap false;
explicitFeatureSnap true;
//- Detect points on multiple surfaces (only for explicitFeatureSnap)
multiRegionFeatureSnap false;

6
tutorials/incompressible/simpleFoam/motorBike/system/wallBoundedStreamLines
View File

@ -16,7 +16,6 @@ near
// Output every
outputControl outputTime;
//outputInterval 1;
// Fields to be sampled. Per field original name and mapped field to
// create.
@ -27,7 +26,7 @@ near
);
// Patches/groups to sample (regular expressions)
patches (motorBike);
patches (motorBikeGroup);
// Distance to sample
distance 0.001;
@ -42,7 +41,6 @@ wallBoundedStreamLines
// Output every
outputControl outputTime;
// outputInterval 10;
setFormat vtk; //gnuplot; //xmgr; //raw; //jplot;
@ -87,7 +85,7 @@ wallBoundedStreamLines
patchSeedCoeffs
{
type patchSeed;
patches (motorBike);
patches (motorBikeGroup);
axis x; //distance;
maxPoints 20000;
}

2
tutorials/incompressible/simpleFoam/pipeCyclic/0.org/epsilon
View File

@ -40,7 +40,7 @@ boundaryField
walls
{
type epsilonWallFunction;
value uniform 0;
value $internalField;
}
}

64
tutorials/incompressible/simpleFoam/pipeCyclic/constant/polyMesh/boundary
View File

@ -1,64 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class polyBoundaryMesh;
location "constant/polyMesh";
object boundary;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
5
(
inlet
{
type patch;
nFaces 28;
startFace 4422;
}
outlet
{
type patch;
nFaces 28;
startFace 4450;
}
side1
{
type cyclicAMI;
inGroups 1(cyclicAMI);
nFaces 400;
startFace 4478;
matchTolerance 0.0001;
transform rotational;
neighbourPatch side2;
rotationAxis (1 0 0);
rotationCentre (0 0 0);
}
side2
{
type cyclicAMI;
inGroups 1(cyclicAMI);
nFaces 250;
startFace 4878;
matchTolerance 0.0001;
transform rotational;
neighbourPatch side1;
rotationAxis (1 0 0);
rotationCentre (0 0 0);
}
walls
{
type wall;
nFaces 250;
startFace 5128;
}
)
// ************************************************************************* //

17
tutorials/lagrangian/icoUncoupledKinematicParcelFoam/hopper/hopperEmptying/constant/kinematicCloudProperties
View File

@ -11,7 +11,7 @@ FoamFile
format ascii;
class dictionary;
location "constant";
object reactingCloud1Properties;
object kinematicCloudProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -48,8 +48,6 @@ constantProperties
rho0 964;
youngsModulus 6e8;
poissonsRatio 0.35;
constantVolume false;
}
@ -66,18 +64,12 @@ subModels
dispersionModel none;
patchInteractionModel standardWallInteraction;
heatTransferModel none;
stochasticCollisionModel none;
patchInteractionModel none;
surfaceFilmModel none;
collisionModel pairCollision;
radiation off;
pairCollisionCoeffs
{
// Maximum possible particle diameter expected at any time
@ -123,11 +115,6 @@ subModels
}
};
}
standardWallInteractionCoeffs
{
type rebound;
}
}

17
tutorials/lagrangian/icoUncoupledKinematicParcelFoam/hopper/hopperInitialState/constant/kinematicCloudProperties
View File

@ -11,7 +11,7 @@ FoamFile
format ascii;
class dictionary;
location "constant";
object reactingCloud1Properties;
object kinematicCloudProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -40,8 +40,6 @@ constantProperties
rho0 964;
youngsModulus 6e8;
poissonsRatio 0.35;
constantVolume false;
}
subModels
@ -76,18 +74,12 @@ subModels
dispersionModel none;
patchInteractionModel standardWallInteraction;
heatTransferModel none;
stochasticCollisionModel none;
patchInteractionModel none;
surfaceFilmModel none;
collisionModel pairCollision;
radiation off;
pairCollisionCoeffs
{
// Maximum possible particle diameter expected at any time
@ -133,11 +125,6 @@ subModels
}
};
}
standardWallInteractionCoeffs
{
type rebound;
}
}

1
tutorials/mesh/foamyHexMesh/blob/system/decomposeParDict
View File

@ -1 +0,0 @@
backgroundMeshDecomposition/decomposeParDict

47
tutorials/mesh/foamyHexMesh/blob/system/decomposeParDict Normal file
View File

@ -0,0 +1,47 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object decomposeParDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
numberOfSubdomains 2;
method scotch;
//method ptscotch;
// method hierarchical;
simpleCoeffs
{
n ( 2 2 1 );
delta 0.001;
}
hierarchicalCoeffs
{
n ( 2 1 1 );
delta 0.001;
order xyz;
}
manualCoeffs
{
dataFile "";
}
distributed no;
roots ( );
// ************************************************************************* //

1
tutorials/mesh/foamyHexMesh/flange/system/decomposeParDict
View File

@ -1 +0,0 @@
backgroundMeshDecomposition/decomposeParDict

46
tutorials/mesh/foamyHexMesh/flange/system/decomposeParDict Normal file
View File

@ -0,0 +1,46 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object decomposeParDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
numberOfSubdomains 8;
//method scotch;
method hierarchical;
simpleCoeffs
{
n ( 2 2 2 );
delta 0.001;
}
hierarchicalCoeffs
{
n ( 2 2 2 );
delta 0.001;
order xyz;
}
manualCoeffs
{
dataFile "";
}
distributed no;
roots ( );
// ************************************************************************* //

1
tutorials/mesh/foamyHexMesh/mixerVessel/system/decomposeParDict
View File

@ -1 +0,0 @@
backgroundMeshDecomposition/decomposeParDict

47
tutorials/mesh/foamyHexMesh/mixerVessel/system/decomposeParDict Normal file
View File

@ -0,0 +1,47 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object decomposeParDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
numberOfSubdomains 8;
//method ptscotch;
//method hierarchical;
method scotch;
simpleCoeffs
{
n ( 2 2 1 );
delta 0.001;
}
hierarchicalCoeffs
{
n ( 2 2 2 );
delta 0.001;
order xyz;
}
manualCoeffs
{
dataFile "";
}
distributed no;
roots ( );
// ************************************************************************* //

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/0.org/U → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/0.org/U
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/0.org/p → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/0.org/p
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/0.org/p_gh → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/0.org/p_gh
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/Allclean → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/Allclean
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/Allrun → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/Allrun
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/constant/g → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/constant/g
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/constant/polyMesh/blockMeshDict → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/constant/polyMesh/blockMeshDict
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/constant/polyMesh/boundary → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/constant/polyMesh/boundary
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/constant/transportProperties → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/constant/transportProperties
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/constant/turbulenceProperties → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/constant/turbulenceProperties
View File

1
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/extractHeightData → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/extractHeightData
View File

@ -1,3 +1,2 @@
#!/bin/sh
awk '{print $1 " " $4}' postProcessing/poolHeight/0/faceSource.dat > poolHeight_vs_time

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/system/controlDict → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/system/controlDict
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/system/fvSchemes → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/system/fvSchemes
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/system/fvSolution → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/system/fvSolution
View File

0
tutorials/incompressible/potentialFreeSurfaceFoam/oscillatingBox/system/topoSetDict → tutorials/multiphase/potentialFreeSurfaceFoam/oscillatingBox/system/topoSetDict
View File