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 ssh://noisy/home/noisy3/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
henry
2010-01-28 16:08:17 +00:00
parent 200b5d4f29 3295abef5c
commit 6fb475b439
149 changed files with 2189 additions and 288989 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
applications/solvers/heatTransfer/chtMultiRegionFoam/Make/files
View File

@ -1,6 +1,10 @@
regionProperties/regionProperties.C
derivedFvPatchFields/solidWallHeatFluxTemperature/solidWallHeatFluxTemperatureFvPatchScalarField.C
derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.C
fluid/compressibleCourantNo.C
solid/solidRegionDiffNo.C
chtMultiRegionFoam.C

4
applications/solvers/heatTransfer/chtMultiRegionFoam/Make/options
View File

@ -2,11 +2,11 @@ EXE_INC = \
-Ifluid \
-Isolid \
-IregionProperties \
-Iinclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
-I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude
-I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel
EXE_LIBS = \
-lbasicThermophysicalModels \

18
applications/solvers/heatTransfer/chtMultiRegionFoam/chtMultiRegionFoam.C
View File

@ -37,6 +37,7 @@ Description
#include "fixedGradientFvPatchFields.H"
#include "regionProperties.H"
#include "compressibleCourantNo.H"
#include "solidRegionDiffNo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -56,23 +57,24 @@ int main(int argc, char *argv[])
#include "initContinuityErrs.H"
#include "readTimeControls.H"
#include "readSolidTimeControls.H"
if (fluidRegions.size())
{
#include "compressibleMultiRegionCourantNo.H"
#include "setInitialDeltaT.H"
}
#include "solidRegionDiffusionNo.H"
#include "setInitialMultiRegionDeltaT.H"
while (runTime.run())
{
#include "readTimeControls.H"
#include "readSolidTimeControls.H"
#include "readPIMPLEControls.H"
if (fluidRegions.size())
{
#include "compressibleMultiRegionCourantNo.H"
#include "setDeltaT.H"
}
#include "solidRegionDiffusionNo.H"
#include "setMultiRegionDeltaT.H"
runTime++;

382
applications/solvers/heatTransfer/chtMultiRegionFoam/derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.C Normal file
View File

@ -0,0 +1,382 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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 "solidWallMixedTemperatureCoupledFvPatchScalarField.H"
#include "addToRunTimeSelectionTable.H"
#include "fvPatchFieldMapper.H"
#include "volFields.H"
#include "directMappedPatchBase.H"
#include "regionProperties.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
bool Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::interfaceOwner
(
const polyMesh& nbrRegion
) const
{
const fvMesh& myRegion = patch().boundaryMesh().mesh();
const regionProperties& props =
myRegion.objectRegistry::parent().lookupObject<regionProperties>
(
"regionProperties"
);
label myIndex = findIndex(props.fluidRegionNames(), myRegion.name());
if (myIndex == -1)
{
label i = findIndex(props.solidRegionNames(), myRegion.name());
if (i == -1)
{
FatalErrorIn
(
"solidWallMixedTemperatureCoupledFvPatchScalarField"
"::interfaceOwner(const polyMesh&) const"
) << "Cannot find region " << myRegion.name()
<< " neither in fluids " << props.fluidRegionNames()
<< " nor in solids " << props.solidRegionNames()
<< exit(FatalError);
}
myIndex = props.fluidRegionNames().size() + i;
}
label nbrIndex = findIndex(props.fluidRegionNames(), nbrRegion.name());
if (nbrIndex == -1)
{
label i = findIndex(props.solidRegionNames(), nbrRegion.name());
if (i == -1)
{
FatalErrorIn("coupleManager::interfaceOwner(const polyMesh&) const")
<< "Cannot find region " << nbrRegion.name()
<< " neither in fluids " << props.fluidRegionNames()
<< " nor in solids " << props.solidRegionNames()
<< exit(FatalError);
}
nbrIndex = props.fluidRegionNames().size() + i;
}
return myIndex < nbrIndex;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
solidWallMixedTemperatureCoupledFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF
)
:
mixedFvPatchScalarField(p, iF),
neighbourFieldName_("undefined-neighbourFieldName"),
KName_("undefined-K")
{
this->refValue() = 0.0;
this->refGrad() = 0.0;
this->valueFraction() = 1.0;
this->fixesValue_ = true;
}
Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
solidWallMixedTemperatureCoupledFvPatchScalarField
(
const solidWallMixedTemperatureCoupledFvPatchScalarField& ptf,
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
mixedFvPatchScalarField(ptf, p, iF, mapper),
neighbourFieldName_(ptf.neighbourFieldName_),
KName_(ptf.KName_),
fixesValue_(ptf.fixesValue_)
{}
Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
solidWallMixedTemperatureCoupledFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
mixedFvPatchScalarField(p, iF),
neighbourFieldName_(dict.lookup("neighbourFieldName")),
KName_(dict.lookup("K"))
{
if (!isA<directMappedPatchBase>(this->patch().patch()))
{
FatalErrorIn
(
"solidWallMixedTemperatureCoupledFvPatchScalarField::"
"solidWallMixedTemperatureCoupledFvPatchScalarField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<scalar, volMesh>& iF,\n"
" const dictionary& dict\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not type '" << directMappedPatchBase::typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << dimensionedInternalField().name()
<< " in file " << dimensionedInternalField().objectPath()
<< exit(FatalError);
}
fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
if (dict.found("refValue"))
{
// Full restart
refValue() = scalarField("refValue", dict, p.size());
refGrad() = scalarField("refGradient", dict, p.size());
valueFraction() = scalarField("valueFraction", dict, p.size());
fixesValue_ = readBool(dict.lookup("fixesValue"));
}
else
{
// Start from user entered data. Assume fixedValue.
refValue() = *this;
refGrad() = 0.0;
valueFraction() = 1.0;
fixesValue_ = true;
}
}
Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::
solidWallMixedTemperatureCoupledFvPatchScalarField
(
const solidWallMixedTemperatureCoupledFvPatchScalarField& wtcsf,
const DimensionedField<scalar, volMesh>& iF
)
:
mixedFvPatchScalarField(wtcsf, iF),
neighbourFieldName_(wtcsf.neighbourFieldName_),
KName_(wtcsf.KName_),
fixesValue_(wtcsf.fixesValue_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::fvPatchScalarField&
Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::K() const
{
return this->patch().lookupPatchField<volScalarField, scalar>(KName_);
}
void Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
// Get the coupling information from the directMappedPatchBase
const directMappedPatchBase& mpp = refCast<const directMappedPatchBase>
(
patch().patch()
);
const polyMesh& nbrMesh = mpp.sampleMesh();
// Force recalculation of mapping and schedule
const mapDistribute& distMap = mpp.map();
(void)distMap.schedule();
tmp<scalarField> intFld = patchInternalField();
if (interfaceOwner(nbrMesh))
{
// Note: other side information could be cached - it only needs
// to be updated the first time round the iteration (i.e. when
// switching regions) but unfortunately we don't have this information.
const fvPatch& nbrPatch = refCast<const fvMesh>
(
nbrMesh
).boundary()[mpp.samplePolyPatch().index()];
// Calculate the temperature by harmonic averaging
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
const solidWallMixedTemperatureCoupledFvPatchScalarField& nbrField =
refCast<const solidWallMixedTemperatureCoupledFvPatchScalarField>
(
nbrPatch.lookupPatchField<volScalarField, scalar>
(
neighbourFieldName_
)
);
// Swap to obtain full local values of neighbour internal field
scalarField nbrIntFld = nbrField.patchInternalField();
mapDistribute::distribute
(
Pstream::defaultCommsType,
distMap.schedule(),
distMap.constructSize(),
distMap.subMap(), // what to send
distMap.constructMap(), // what to receive
nbrIntFld
);
// Swap to obtain full local values of neighbour K*delta
scalarField nbrKDelta = nbrField.K()*nbrPatch.deltaCoeffs();
mapDistribute::distribute
(
Pstream::defaultCommsType,
distMap.schedule(),
distMap.constructSize(),
distMap.subMap(), // what to send
distMap.constructMap(), // what to receive
nbrKDelta
);
tmp<scalarField> myKDelta = K()*patch().deltaCoeffs();
// Calculate common wall temperature. Reuse *this to store common value.
scalarField Twall
(
(myKDelta()*intFld() + nbrKDelta*nbrIntFld)
/ (myKDelta() + nbrKDelta)
);
// Assign to me
fvPatchScalarField::operator=(Twall);
// Distribute back and assign to neighbour
mapDistribute::distribute
(
Pstream::defaultCommsType,
distMap.schedule(),
nbrField.size(),
distMap.constructMap(), // reverse : what to send
distMap.subMap(),
Twall
);
const_cast<solidWallMixedTemperatureCoupledFvPatchScalarField&>
(
nbrField
).fvPatchScalarField::operator=(Twall);
}
// Switch between fixed value (of harmonic avg) or gradient
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
label nFixed = 0;
// Like snGrad but bypass switching on refValue/refGrad.
tmp<scalarField> normalGradient = (*this-intFld())*patch().deltaCoeffs();
if (debug)
{
scalar Q = gSum(K()*patch().magSf()*normalGradient());
Info<< "solidWallMixedTemperatureCoupledFvPatchScalarField::"
<< "updateCoeffs() :"
<< " patch:" << patch().name()
<< " heatFlux:" << Q
<< " walltemperature "
<< " min:" << gMin(*this)
<< " max:" << gMax(*this)
<< " avg:" << gAverage(*this)
<< endl;
}
forAll(*this, i)
{
// if outgoing flux use fixed value.
if (normalGradient()[i] < 0.0)
{
this->refValue()[i] = operator[](i);
this->refGrad()[i] = 0.0; // not used by me
this->valueFraction()[i] = 1.0;
nFixed++;
}
else
{
// Fixed gradient. Make sure to have valid refValue (even though
// I am not using it - other boundary conditions might)
this->refValue()[i] = operator[](i);
this->refGrad()[i] = normalGradient()[i];
this->valueFraction()[i] = 0.0;
}
}
reduce(nFixed, sumOp<label>());
fixesValue_ = (nFixed > 0);
if (debug)
{
label nTotSize = returnReduce(this->size(), sumOp<label>());
Info<< "solidWallMixedTemperatureCoupledFvPatchScalarField::"
<< "updateCoeffs() :"
<< " patch:" << patch().name()
<< " out of:" << nTotSize
<< " fixedBC:" << nFixed
<< " gradient:" << nTotSize-nFixed << endl;
}
mixedFvPatchScalarField::updateCoeffs();
}
void Foam::solidWallMixedTemperatureCoupledFvPatchScalarField::write
(
Ostream& os
) const
{
mixedFvPatchScalarField::write(os);
os.writeKeyword("neighbourFieldName")<< neighbourFieldName_
<< token::END_STATEMENT << nl;
os.writeKeyword("K") << KName_ << token::END_STATEMENT << nl;
os.writeKeyword("fixesValue") << fixesValue_ << token::END_STATEMENT << nl;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makePatchTypeField
(
fvPatchScalarField,
solidWallMixedTemperatureCoupledFvPatchScalarField
);
} // End namespace Foam
// ************************************************************************* //

193
applications/solvers/heatTransfer/chtMultiRegionFoam/derivedFvPatchFields/solidWallMixedTemperatureCoupled/solidWallMixedTemperatureCoupledFvPatchScalarField.H Normal file
View File

@ -0,0 +1,193 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
solidWallMixedTemperatureCoupledFvPatchScalarField
Description
Mixed boundary condition for temperature, to be used by the
conjugate heat transfer solver.
If my temperature is T1, neighbour is T2:
T1 > T2: my side becomes fixedValue T2 bc, other side becomes fixedGradient.
Example usage:
myInterfacePatchName
{
type solidWallMixedTemperatureCoupled;
neighbourFieldName T;
K K;
value uniform 300;
}
Needs to be on underlying directMapped(Wall)FvPatch.
Note: runs in parallel with arbitrary decomposition. Uses directMapped
functionality to calculate exchange.
Note: lags interface data so both sides use same data.
- problem: schedule to calculate average would interfere
with standard processor swaps.
- so: updateCoeffs sets both to same Twall. Only need to do
this for last outer iteration but don't have access to this.
SourceFiles
solidWallMixedTemperatureCoupledFvPatchScalarField.C
\*---------------------------------------------------------------------------*/
#ifndef solidWallMixedTemperatureCoupledFvPatchScalarField_H
#define solidWallMixedTemperatureCoupledFvPatchScalarField_H
#include "fvPatchFields.H"
#include "mixedFvPatchFields.H"
#include "fvPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class solidWallMixedTemperatureCoupledFvPatchScalarField Declaration
\*---------------------------------------------------------------------------*/
class solidWallMixedTemperatureCoupledFvPatchScalarField
:
public mixedFvPatchScalarField
{
// Private data
//- Name of field on the neighbour region
const word neighbourFieldName_;
//- Name of thermal conductivity field
const word KName_;
bool fixesValue_;
// Private Member Functions
//- Am I or neighbour owner of interface
bool interfaceOwner(const polyMesh& nbrRegion) const;
public:
//- Runtime type information
TypeName("solidWallMixedTemperatureCoupled");
// Constructors
//- Construct from patch and internal field
solidWallMixedTemperatureCoupledFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&
);
//- Construct from patch, internal field and dictionary
solidWallMixedTemperatureCoupledFvPatchScalarField
(
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const dictionary&
);
//- Construct by mapping given
// solidWallMixedTemperatureCoupledFvPatchScalarField onto a new patch
solidWallMixedTemperatureCoupledFvPatchScalarField
(
const solidWallMixedTemperatureCoupledFvPatchScalarField&,
const fvPatch&,
const DimensionedField<scalar, volMesh>&,
const fvPatchFieldMapper&
);
//- Construct and return a clone
virtual tmp<fvPatchScalarField> clone() const
{
return tmp<fvPatchScalarField>
(
new solidWallMixedTemperatureCoupledFvPatchScalarField(*this)
);
}
//- Construct as copy setting internal field reference
solidWallMixedTemperatureCoupledFvPatchScalarField
(
const solidWallMixedTemperatureCoupledFvPatchScalarField&,
const DimensionedField<scalar, volMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<fvPatchScalarField> clone
(
const DimensionedField<scalar, volMesh>& iF
) const
{
return tmp<fvPatchScalarField>
(
new solidWallMixedTemperatureCoupledFvPatchScalarField
(
*this,
iF
)
);
}
// Member functions
//- Get corresponding K field
const fvPatchScalarField& K() const;
//- Return true if this patch field fixes a value.
// Needed to check if a level has to be specified while solving
// Poissons equations.
virtual bool fixesValue() const
{
return fixesValue_;
}
//- Update the coefficients associated with the patch field
virtual void updateCoeffs();
//- Write
virtual void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

4
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleCourantNo.C
View File

@ -47,10 +47,10 @@ Foam::scalar Foam::compressibleCourantNo
/ fvc::interpolate(rho);
CoNum = max(SfUfbyDelta/mesh.magSf())
.value()*runTime.deltaTValue();
.value()*runTime.deltaT().value();
meanCoNum = (sum(SfUfbyDelta)/sum(mesh.magSf()))
.value()*runTime.deltaTValue();
.value()*runTime.deltaT().value();
}
Info<< "Region: " << mesh.name() << " Courant Number mean: " << meanCoNum

3
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/compressibleMultiRegionCourantNo.H
View File

@ -1,4 +1,6 @@
scalar CoNum = -GREAT;
if (fluidRegions.size())
{
forAll(fluidRegions, regionI)
{
CoNum = max
@ -13,3 +15,4 @@
CoNum
);
}
}

36
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/createFluidFields.H
View File

@ -41,6 +41,24 @@
)
);
Info<< " Adding to KFluid\n" << endl;
KFluid.set
(
i,
new volScalarField
(
IOobject
(
"K",
runTime.timeName(),
fluidRegions[i],
IOobject::NO_READ,
IOobject::NO_WRITE
),
thermoFluid[i].Cp()*thermoFluid[i].alpha()
)
);
Info<< " Adding to UFluid\n" << endl;
UFluid.set
(
@ -111,24 +129,6 @@
).ptr()
);
Info<< " Adding to KFluid\n" << endl;
KFluid.set
(
i,
new volScalarField
(
IOobject
(
"K",
runTime.timeName(),
fluidRegions[i],
IOobject::NO_READ,
IOobject::NO_WRITE
),
thermoFluid[i].Cp()*turbulence[i].alphaEff()
)
);
Info<< " Adding to DpDtFluid\n" << endl;
DpDtFluid.set
(

60
applications/solvers/heatTransfer/chtMultiRegionFoam/include/setInitialMultiRegionDeltaT.H Normal file
View File

@ -0,0 +1,60 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2010-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 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
Global
setInitialDeltaT
Description
Set the initial timestep for the CHT MultiRegion solver.
\*---------------------------------------------------------------------------*/
if (adjustTimeStep)
{
if ((runTime.timeIndex() == 0) && ((CoNum > SMALL) || (DiNum > SMALL)))
{
if (CoNum == -GREAT)
{
CoNum = SMALL;
}
if (DiNum == -GREAT)
{
DiNum = SMALL;
}
runTime.setDeltaT
(
min
(
min(maxCo/CoNum, maxDi/DiNum)*runTime.deltaT().value(),
maxDeltaT
)
);
Info<< "deltaT = " << runTime.deltaT().value() << endl;
}
}
// ************************************************************************* //

69
applications/solvers/heatTransfer/chtMultiRegionFoam/include/setMultiRegionDeltaT.H Normal file
View File

@ -0,0 +1,69 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2010-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 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
Global
setMultiRegionDeltaT
Description
Reset the timestep to maintain a constant maximum courant and diffusion
Numbers. Reduction of time-step is immediate, but increase is damped to avoid
unstable oscillations.
\*---------------------------------------------------------------------------*/
if (adjustTimeStep)
{
if (CoNum == -GREAT)
{
CoNum = SMALL;
}
if (DiNum == -GREAT)
{
DiNum = SMALL;
}
scalar maxDeltaTFluid = maxCo/(CoNum + SMALL);
scalar maxDeltaTSolid = maxDi/(DiNum + SMALL);
scalar deltaTFluid =
min
(
min(maxDeltaTFluid, 1.0 + 0.1*maxDeltaTFluid),
1.2
);
runTime.setDeltaT
(
min
(
min(deltaTFluid, maxDeltaTSolid)*runTime.deltaT().value(),
maxDeltaT
)
);
Info<< "deltaT = " << runTime.deltaT().value() << endl;
}
// ************************************************************************* //

58
src/lagrangian/intermediate/submodels/IO/IOList/makeParcelIOList.H → applications/solvers/heatTransfer/chtMultiRegionFoam/regionProperties/regionProperties.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,32 +22,48 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Macros for defining parcel IOLists
\*---------------------------------------------------------------------------*/
#ifndef makeParcelIOList_H
#define makeParcelIOList_H
#include "regionProperties.H"
#include "IOPtrList.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Foam::regionProperties::regionProperties(const Time& runTime)
:
IOdictionary
(
IOobject
(
"regionProperties",
runTime.time().constant(),
runTime.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
fluidRegionNames_(lookup("fluidRegionNames")),
solidRegionNames_(lookup("solidRegionNames"))
{}
#define makeParcelIOList(ParcelType) \
\
typedef IOPtrList<ParcelType> IOPtrList##ParcelType; \
\
defineTemplateTypeNameAndDebugWithName \
( \
IOPtrList##ParcelType, \
"IOPtrList<"#ParcelType">", \
0 \
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::regionProperties::~regionProperties()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::List<Foam::word>& Foam::regionProperties::fluidRegionNames() const
{
return fluidRegionNames_;
}
const Foam::List<Foam::word>& Foam::regionProperties::solidRegionNames() const
{
return solidRegionNames_;
}
#endif
// ************************************************************************* //

106
applications/solvers/heatTransfer/chtMultiRegionFoam/regionProperties/regionProperties.H Normal file
View File

@ -0,0 +1,106 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
regionProperties
Description
Simple class to hold region information for coupled region simulations
SourceFiles
regionProperties.C
\*---------------------------------------------------------------------------*/
#ifndef regionProperties_H
#define regionProperties_H
#include "IOdictionary.H"
#include "Time.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class regionProperties Declaration
\*---------------------------------------------------------------------------*/
class regionProperties
:
public IOdictionary
{
// Private data
//- List of the fluid region names
List<word> fluidRegionNames_;
//- List of the solid region names
List<word> solidRegionNames_;
// Private Member Functions
//- Disallow default bitwise copy construct
regionProperties(const regionProperties&);
//- Disallow default bitwise assignment
void operator=(const regionProperties&);
public:
// Constructors
//- Construct from components
regionProperties(const Time& runTime);
// Destructor
~regionProperties();
// Member Functions
// Access
//- Return const reference to the list of fluid region names
const List<word>& fluidRegionNames() const;
//- Return const reference to the list of solid region names
const List<word>& solidRegionNames() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

35
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/readSolidTimeControls.H Normal file
View File

@ -0,0 +1,35 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2010-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 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
Global
readSolidTimeControls
Description
Read the control parameters used in the solid
\*---------------------------------------------------------------------------*/
scalar maxDi = runTime.controlDict().lookupOrDefault<scalar>("maxDi", 10.0);
// ************************************************************************* //

61
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffNo.C Normal file
View File

@ -0,0 +1,61 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2010-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 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 "solidRegionDiffNo.H"
#include "fvc.H"
Foam::scalar Foam::solidRegionDiffNo
(
const fvMesh& mesh,
const Time& runTime,
const volScalarField& Cprho,
const volScalarField& K
)
{
scalar DiNum = 0.0;
scalar meanDiNum = 0.0;
//- Can have fluid domains with 0 cells so do not test.
if (mesh.nInternalFaces())
{
surfaceScalarField KrhoCpbyDelta =
mesh.surfaceInterpolation::deltaCoeffs()
* fvc::interpolate(K)
/ fvc::interpolate(Cprho);
DiNum = max(KrhoCpbyDelta.internalField())*runTime.deltaT().value();
meanDiNum = (average(KrhoCpbyDelta)).value()*runTime.deltaT().value();
}
Info<< "Region: " << mesh.name() << " Diffusion Number mean: " << meanDiNum
<< " max: " << DiNum << endl;
return DiNum;
}
// ************************************************************************* //

49
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffNo.H Normal file
View File

@ -0,0 +1,49 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2010-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 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
Description
Calculates and outputs the mean and maximum Diffusion Numbers for the solid
regions
\*---------------------------------------------------------------------------*/
#ifndef solidRegionDiff_H
#define solidRegionDiff_H
#include "fvMesh.H"
namespace Foam
{
scalar solidRegionDiffNo
(
const fvMesh& mesh,
const Time& runTime,
const volScalarField& Cprho,
const volScalarField& K
);
}
#endif
// ************************************************************************* //

18
applications/solvers/heatTransfer/chtMultiRegionFoam/solid/solidRegionDiffusionNo.H Normal file
View File

@ -0,0 +1,18 @@
scalar DiNum = -GREAT;
if (solidRegions.size())//
{
forAll(solidRegions, regionI)
{
DiNum = max
(
solidRegionDiffNo
(
solidRegions[regionI],
runTime,
rhosCps[regionI],
Ks[regionI]
),
DiNum
);
}
}

13
applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
View File

@ -47,6 +47,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
Info<< " <<Writing " << nNonAligned
<< " points on non-aligned edges to set "
<< nonAlignedPoints.name() << endl;
nonAlignedPoints.instance() = mesh.pointsInstance();
nonAlignedPoints.write();
}
}
@ -67,6 +68,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
{
Info<< " <<Writing " << nNonClosed
<< " non closed cells to set " << cells.name() << endl;
cells.instance() = mesh.pointsInstance();
cells.write();
}
}
@ -78,6 +80,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
Info<< " <<Writing " << nHighAspect
<< " cells with high aspect ratio to set "
<< aspectCells.name() << endl;
aspectCells.instance() = mesh.pointsInstance();
aspectCells.write();
}
}
@ -94,6 +97,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
{
Info<< " <<Writing " << nFaces
<< " zero area faces to set " << faces.name() << endl;
faces.instance() = mesh.pointsInstance();
faces.write();
}
}
@ -111,6 +115,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
{
Info<< " <<Writing " << nCells
<< " zero volume cells to set " << cells.name() << endl;
cells.instance() = mesh.pointsInstance();
cells.write();
}
}
@ -129,6 +134,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
{
Info<< " <<Writing " << nFaces
<< " non-orthogonal faces to set " << faces.name() << endl;
faces.instance() = mesh.pointsInstance();
faces.write();
}
}
@ -147,6 +153,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
Info<< " <<Writing " << nFaces
<< " faces with incorrect orientation to set "
<< faces.name() << endl;
faces.instance() = mesh.pointsInstance();
faces.write();
}
}
@ -164,6 +171,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
{
Info<< " <<Writing " << nFaces
<< " skew faces to set " << faces.name() << endl;
faces.instance() = mesh.pointsInstance();
faces.write();
}
}
@ -184,6 +192,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
Info<< " <<Writing " << nPoints
<< " points on short edges to set " << points.name()
<< endl;
points.instance() = mesh.pointsInstance();
points.write();
}
}
@ -202,6 +211,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
Info<< " <<Writing " << nPoints
<< " near (closer than " << Foam::sqrt(minDistSqr)
<< " apart) points to set " << nearPoints.name() << endl;
nearPoints.instance() = mesh.pointsInstance();
nearPoints.write();
}
}
@ -221,6 +231,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
Info<< " <<Writing " << nFaces
<< " faces with concave angles to set " << faces.name()
<< endl;
faces.instance() = mesh.pointsInstance();
faces.write();
}
}
@ -239,6 +250,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
{
Info<< " <<Writing " << nFaces
<< " warped faces to set " << faces.name() << endl;
faces.instance() = mesh.pointsInstance();
faces.write();
}
}
@ -255,6 +267,7 @@ Foam::label Foam::checkGeometry(const polyMesh& mesh, const bool allGeometry)
Info<< " <<Writing " << nCells
<< " under-determined cells to set " << cells.name() << endl;
cells.instance() = mesh.pointsInstance();
cells.write();
}
}

8
applications/utilities/mesh/manipulation/checkMesh/checkTopology.C
View File

@ -89,6 +89,7 @@ Foam::label Foam::checkTopology
Info<< " <<Writing " << nPoints
<< " unused points to set " << points.name() << endl;
points.instance() = mesh.pointsInstance();
points.write();
}
}
@ -106,6 +107,7 @@ Foam::label Foam::checkTopology
{
Info<< " <<Writing " << nFaces
<< " unordered faces to set " << faces.name() << endl;
faces.instance() = mesh.pointsInstance();
faces.write();
}
}
@ -122,6 +124,7 @@ Foam::label Foam::checkTopology
Info<< " <<Writing " << nCells
<< " cells with over used edges to set " << cells.name()
<< endl;
cells.instance() = mesh.pointsInstance();
cells.write();
}
}
@ -137,6 +140,7 @@ Foam::label Foam::checkTopology
Info<< " <<Writing " << nFaces
<< " faces with out-of-range or duplicate vertices to set "
<< faces.name() << endl;
faces.instance() = mesh.pointsInstance();
faces.write();
}
}
@ -153,6 +157,7 @@ Foam::label Foam::checkTopology
Info<< " <<Writing " << nFaces
<< " faces with incorrect edges to set " << faces.name()
<< endl;
faces.instance() = mesh.pointsInstance();
faces.write();
}
}
@ -203,6 +208,7 @@ Foam::label Foam::checkTopology
<< " cells with with single non-boundary face to set "
<< oneCells.name()
<< endl;
oneCells.instance() = mesh.pointsInstance();
oneCells.write();
}
@ -214,6 +220,7 @@ Foam::label Foam::checkTopology
<< " cells with with single non-boundary face to set "
<< twoCells.name()
<< endl;
twoCells.instance() = mesh.pointsInstance();
twoCells.write();
}
}
@ -354,6 +361,7 @@ Foam::label Foam::checkTopology
<< " conflicting points to set "
<< points.name() << endl;
points.instance() = mesh.pointsInstance();
points.write();
}

2
applications/utilities/mesh/manipulation/createPatch/createPatchDict
View File

@ -43,6 +43,8 @@ FoamFile
matchTolerance 1E-3;
// Do a synchronisation of coupled points after creation of any patches.
// Note: this does not work with points that are on multiple coupled patches
// with transformations.
pointSync true;
// Patches to create.

60
applications/utilities/mesh/manipulation/splitMeshRegions/splitMeshRegions.C
View File

@ -64,6 +64,7 @@ Description
#include "syncTools.H"
#include "ReadFields.H"
#include "directMappedWallPolyPatch.H"
#include "zeroGradientFvPatchFields.H"
using namespace Foam;
@ -164,25 +165,24 @@ void reorderPatchFields(fvMesh& mesh, const labelList& oldToNew)
// Adds patch if not yet there. Returns patchID.
template<class PatchType>
label addPatch(fvMesh& mesh, const word& patchName)
label addPatch(fvMesh& mesh, const polyPatch& patch)
{
polyBoundaryMesh& polyPatches =
const_cast<polyBoundaryMesh&>(mesh.boundaryMesh());
label patchI = polyPatches.findPatchID(patchName);
label patchI = polyPatches.findPatchID(patch.name());
if (patchI != -1)
{
if (isA<PatchType>(polyPatches[patchI]))
if (polyPatches[patchI].type() == patch.type())
{
// Already there
return patchI;
}
else
{
FatalErrorIn("addPatch<PatchType>(fvMesh&, const word&)")
<< "Already have patch " << patchName
<< " but of type " << PatchType::typeName
FatalErrorIn("addPatch(fvMesh&, const polyPatch*)")
<< "Already have patch " << patch.name()
<< " but of type " << patch.type()
<< exit(FatalError);
}
}
@ -219,14 +219,12 @@ label addPatch(fvMesh& mesh, const word& patchName)
polyPatches.set
(
sz,
polyPatch::New
patch.clone
(
PatchType::typeName,
patchName,
polyPatches,
insertPatchI, //index
0, //size
startFaceI,
insertPatchI,
polyPatches
startFaceI //start
)
);
fvPatches.setSize(sz+1);
@ -1086,16 +1084,37 @@ EdgeMap<label> addRegionPatches
if (interfaceSizes[e] > 0)
{
label patchI = addPatch<directMappedWallPolyPatch>
const word inter1 = regionNames[e[0]] + "_to_" + regionNames[e[1]];
const word inter2 = regionNames[e[1]] + "_to_" + regionNames[e[0]];
directMappedWallPolyPatch patch1
(
mesh,
regionNames[e[0]] + "_to_" + regionNames[e[1]]
inter1,
0, // overridden
0, // overridden
0, // overridden
regionNames[e[1]], // sampleRegion
directMappedPatchBase::NEARESTPATCHFACE,
inter2, // samplePatch
point::zero, // offset
mesh.boundaryMesh()
);
addPatch<directMappedWallPolyPatch>
label patchI = addPatch(mesh, patch1);
directMappedWallPolyPatch patch2
(
mesh,
regionNames[e[1]] + "_to_" + regionNames[e[0]]
inter2,
0,
0,
0,
regionNames[e[0]], // sampleRegion
directMappedPatchBase::NEARESTPATCHFACE,
inter1,
point::zero, // offset
mesh.boundaryMesh()
);
addPatch(mesh, patch2);
Info<< "For interface between region " << e[0]
<< " and " << e[1] << " added patch " << patchI
@ -1495,7 +1514,8 @@ int main(int argc, char *argv[])
false
),
mesh,
dimensionedScalar("zero", dimless, 0)
dimensionedScalar("zero", dimless, 0),
zeroGradientFvPatchScalarField::typeName
);
forAll(cellRegion, cellI)
{

2
applications/utilities/parallelProcessing/decomposePar/lagrangianFieldDecomposer.C
View File

@ -80,6 +80,4 @@ Foam::lagrangianFieldDecomposer::lagrangianFieldDecomposer
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// ************************************************************************* //

4
applications/utilities/postProcessing/dataConversion/foamToTecplot360/tecplotWriterTemplates.C
View File

@ -24,14 +24,14 @@ License
\*---------------------------------------------------------------------------*/
#include "tecplotWriter.H"
//extern "C"
//{
#include "MASTER.h"
#include "GLOBAL.h"
//}
#include "tecplotWriter.H"
#include "fvc.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

13
applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamUpdateInfo.C
View File

@ -408,6 +408,19 @@ void Foam::vtkPV3Foam::updateInfoSets
meshDir_/"sets"
);
if (debug)
{
Info<< " Foam::vtkPV3Foam::updateInfoSets read "
<< objects.names() << " from "
<< dbPtr_().findInstance
(
meshDir_,
"faces",
IOobject::READ_IF_PRESENT
)
<< endl;
}
arrayRangeCellSets_.reset(arraySelection->GetNumberOfArrays());
arrayRangeCellSets_ += addToSelection<cellSet>

12
applications/utilities/postProcessing/sampling/sample/sampleDict
View File

@ -83,9 +83,9 @@ sets
type uniform;
axis distance;
//- cavity
start (0.02 0.051 0.005);
end (0.06 0.051 0.005);
//- cavity. Slightly perturbed so not to align with face or edge.
start (0.0201 0.05101 0.00501);
end (0.0601 0.05101 0.00501);
nPoints 10;
}
@ -103,8 +103,8 @@ sets
//end ( 1 0.05 0.005);
//- cavity
start (0.0 0.51 0.005);
end (2 0.51 0.005);
start (0.001 0.5101 0.00501);
end (2.01 0.5101 0.00501);
nPoints 10;
}
@ -112,7 +112,7 @@ sets
{
type cloud;
axis xyz;
points ((0.049 0.049 0.005)(0.051 0.049 0.005));
points ((0.049 0.049 0.00501)(0.051 0.049 0.00501));
}
);

1
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.C
View File

@ -1,4 +1,3 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox

12608
applications/utilities/surface/surfaceInertia/cylinder.obj
View File

File diff suppressed because it is too large Load Diff

13174
applications/utilities/surface/surfaceInertia/dangermouse.obj
View File

File diff suppressed because it is too large Load Diff

261982
applications/utilities/surface/surfaceInertia/sphere.obj
View File

File diff suppressed because it is too large Load Diff

2
bin/mpirunDebug
View File

@ -1,4 +1,4 @@
#!/bin/sh
#!/bin/bash
#------------------------------------------------------------------------------
# ========= |
# \\ / F ield | OpenFOAM: The Open Source CFD Toolbox

10
etc/apps/paraview3/cshrc
View File

@ -44,8 +44,8 @@ foreach cmake ( cmake-2.6.4 cmake-2.6.2 cmake-2.4.6 )
endif
end
set paraviewMajor=paraview-3.6
setenv ParaView_VERSION 3.6.1
if ( ! $?ParaView_MAJOR ) setenv ParaView_MAJOR paraview-3.6
if ( ! $?ParaView_VERSION ) setenv ParaView_VERSION 3.6.1
setenv ParaView_INST_DIR $WM_THIRD_PARTY_DIR/paraview-$ParaView_VERSION
setenv ParaView_DIR $ParaView_INST_DIR/platforms/$WM_ARCH$WM_COMPILER
@ -54,9 +54,9 @@ setenv ParaView_DIR $ParaView_INST_DIR/platforms/$WM_ARCH$WM_COMPILER
set paraviewPython=$ParaView_DIR/Utilities/VTKPythonWrapping
if ( -r $paraviewPython ) then
if ($?PYTHONPATH) then
setenv PYTHONPATH ${PYTHONPATH}:${paraviewPython}:$ParaView_DIR/lib/${paraviewMajor}
setenv PYTHONPATH ${PYTHONPATH}:${paraviewPython}:$ParaView_DIR/lib/${ParaView_MAJOR}
else
setenv PYTHONPATH ${paraviewPython}:$ParaView_DIR/lib/${paraviewMajor}
setenv PYTHONPATH ${paraviewPython}:$ParaView_DIR/lib/${ParaView_MAJOR}
endif
endif
@ -65,5 +65,5 @@ if ( -r $ParaView_INST_DIR ) then
setenv PV_PLUGIN_PATH $FOAM_LIBBIN/paraview
endif
unset cmake paraviewMajor paraviewPython
unset cmake paraviewPython
# -----------------------------------------------------------------------------

21
src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
View File

@ -109,7 +109,6 @@ struct HashTableCore
{
return iteratorEnd();
}
};
@ -139,6 +138,7 @@ class HashTable
//- Construct from key, next pointer and object
inline hashedEntry(const Key&, hashedEntry* next, const T&);
private:
//- Disallow default bitwise copy construct
hashedEntry(const hashedEntry&);
@ -209,8 +209,7 @@ public:
HashTable(const Xfer<HashTable<T, Key, Hash> >&);
// Destructor
//- Destructor
~HashTable();
@ -247,6 +246,7 @@ public:
//- Print information
Ostream& printInfo(Ostream&) const;
// Edit
//- Insert a new hashedEntry
@ -356,9 +356,8 @@ public:
//- Current hash index
label hashIndex_;
protected:
// Protected Member Functions
protected:
// Constructors
@ -380,6 +379,8 @@ public:
);
// Protected Member Functions
//- Increment to the next position
inline void increment();
@ -392,6 +393,7 @@ public:
//- Return const access to referenced object
inline const T& cobject() const;
public:
// Member operators
@ -434,6 +436,7 @@ public:
const label hashIndex
);
public:
// Constructors
@ -444,13 +447,12 @@ public:
//- Construct end iterator
inline iterator(const iteratorEnd& unused);
// Member operators
//- Conversion to a const_iterator
inline operator const_iterator() const;
// Access
//- Return referenced hash value
inline T& operator*();
inline T& operator()();
@ -492,6 +494,7 @@ public:
const label hashIndex
);
public:
// Constructors
@ -502,9 +505,8 @@ public:
//- Construct end iterator
inline const_iterator(const iteratorEnd& unused);
// Member operators
// Access
// Member operators
//- Return referenced hash value
inline const T& operator*() const;
@ -536,7 +538,6 @@ public:
Ostream&,
const HashTable<T, Key, Hash>&
);
};

2
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.C
View File

@ -97,7 +97,6 @@ Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
{}
template<class T, class Key, class Hash>
Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
(
@ -452,7 +451,6 @@ void Foam::StaticHashTable<T, Key, Hash>::clearStorage()
}
template<class T, class Key, class Hash>
void Foam::StaticHashTable<T, Key, Hash>::transfer
(

10
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.H
View File

@ -72,10 +72,6 @@ template<class T, class Key, class Hash> Ostream& operator<<
);
/*---------------------------------------------------------------------------*\
Class StaticHashTableName Declaration
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
Class StaticHashTableCore Declaration
\*---------------------------------------------------------------------------*/
@ -100,7 +96,6 @@ struct StaticHashTableCore
iteratorEnd()
{}
};
};
@ -135,6 +130,7 @@ class StaticHashTable
//- Assign a new hashed entry to a possibly already existing key
bool set(const Key&, const T& newElmt, bool protect);
public:
@ -185,8 +181,8 @@ public:
//- Construct by transferring the parameter contents
StaticHashTable(const Xfer<StaticHashTable<T, Key, Hash> >&);
// Destructor
//- Destructor
~StaticHashTable();
@ -275,6 +271,7 @@ public:
//- The opposite of the equality operation.
bool operator!=(const StaticHashTable<T, Key, Hash>&) const;
// STL type definitions
//- Type of values the StaticHashTable contains.
@ -317,6 +314,7 @@ public:
//- Index of current element at hashIndex
label elemIndex_;
public:
// Constructors

2
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableI.H
View File

@ -417,6 +417,4 @@ Foam::StaticHashTable<T, Key, Hash>::end() const
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// ************************************************************************* //

4
src/OpenFOAM/containers/Lists/CompactListList/CompactListListI.H
View File

@ -224,7 +224,7 @@ inline Foam::UList<T> Foam::CompactListList<T, Container>::operator[]
)
{
label start = offsets_[i];
return UList<T>(&m_[start], offsets_[i+1] - start);
return UList<T>((m_.size() ? &m_[start] : NULL), offsets_[i+1] - start);
}
@ -238,7 +238,7 @@ Foam::CompactListList<T, Container>::operator[]
label start = offsets_[i];
return UList<T>
(
const_cast<T*>(&m_[start]),
(m_.size() ? const_cast<T*>(&m_[start]) : NULL),
offsets_[i+1] - start
);
}

4
src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
View File

@ -84,7 +84,6 @@ class DynamicList
//- The capacity (allocated size) of the underlying list.
label capacity_;
// Private Member Functions
public:
@ -93,6 +92,7 @@ public:
//- Declare friendship with the List class
friend class List<T>;
// Constructors
//- Construct null
@ -178,6 +178,7 @@ public:
//- Transfer contents to the Xfer container as a plain List
inline Xfer<List<T> > xfer();
// Member Operators
//- Append an element at the end of the list
@ -207,6 +208,7 @@ public:
//- Assignment from UList
inline void operator=(const UList<T>&);
// IOstream operators
// Write DynamicList to Ostream.

2
src/OpenFOAM/containers/Lists/IndirectList/IndirectList.H
View File

@ -66,6 +66,7 @@ public:
//- Construct given the complete list and by transferring addressing
inline IndirectList(const UList<T>&, const Xfer<List<label> >&);
// Member Functions
// Access
@ -94,6 +95,7 @@ public:
//- Return the list addressing
inline const List<label>& addressing() const;
// Edit
//- Reset addressing

4
src/OpenFOAM/containers/Lists/List/List.H
View File

@ -87,6 +87,7 @@ protected:
// Use with care.
inline void size(const label);
public:
// Static Member Functions
@ -147,8 +148,7 @@ public:
inline autoPtr<List<T> > clone() const;
// Destructor
//- Destructor
~List();

13
src/OpenFOAM/containers/Lists/PackedList/PackedList.H
View File

@ -132,6 +132,7 @@ class PackedList
//- Calculate the list length when packed
inline static label packedLength(const label);
public:
// Public data
@ -150,12 +151,14 @@ public:
//- Masking for all bits below the offset
inline static unsigned int maskLower(unsigned offset);
// Forward declaration of iterators
class iteratorBase;
class iterator;
class const_iterator;
// Constructors
//- Null constructor
@ -179,6 +182,7 @@ public:
//- Clone
inline autoPtr< PackedList<nBits> > clone() const;
// Member Functions
// Access
@ -292,11 +296,13 @@ public:
//- Assignment operator. Takes linear time.
void operator=(const UList<label>&);
// Ostream operator
// // Write PackedList to Ostream.
// friend Ostream& operator<< <nBits> (Ostream&, const PackedList<nBits>&);
// Iterators and helpers
//- The iterator base for PackedList
@ -317,6 +323,7 @@ public:
//- Element index
label index_;
// Protected Member Functions
//- Get value as unsigned, no range-checking
@ -325,6 +332,7 @@ public:
//- Set value, returning true if changed, no range-checking
inline bool set(unsigned int);
// Constructors
//- Construct null
@ -333,6 +341,7 @@ public:
//- Construct from base list and position index
inline iteratorBase(const PackedList*, const label);
public:
// Member Operators
@ -370,6 +379,7 @@ public:
//- Disallow assignment from const_iterator - violates const-ness!
void operator=(const const_iterator&);
public:
// Constructors
@ -385,6 +395,7 @@ public:
//- Construct from base list and position index
inline iterator(const PackedList*, const label);
// Member Operators
//- Compare positions (not values)
@ -445,6 +456,7 @@ public:
//- Construct from iterator
inline const_iterator(const iterator&);
// Member operators
//- Compare positions (not values)
@ -466,7 +478,6 @@ public:
inline const_iterator& operator--();
inline const_iterator operator--(int);
};

11
src/OpenFOAM/containers/Lists/PackedList/PackedListI.H
View File

@ -334,7 +334,6 @@ inline bool Foam::PackedList<nBits>::iterator::operator!=
}
template<unsigned nBits>
inline bool Foam::PackedList<nBits>::const_iterator::operator==
(
@ -355,7 +354,6 @@ inline bool Foam::PackedList<nBits>::const_iterator::operator!=
}
template<unsigned nBits>
inline typename Foam::PackedList<nBits>::iterator&
Foam::PackedList<nBits>::iterator::operator=(const iteratorBase& iter)
@ -712,16 +710,14 @@ inline void Foam::PackedList<nBits>::shrink()
}
template<unsigned nBits>
inline Foam::List<unsigned int>&
Foam::PackedList<nBits>::storage()
inline Foam::List<unsigned int>& Foam::PackedList<nBits>::storage()
{
return static_cast<StorageList&>(*this);
}
template<unsigned nBits>
inline const Foam::List<unsigned int>&
Foam::PackedList<nBits>::storage() const
inline const Foam::List<unsigned int>& Foam::PackedList<nBits>::storage() const
{
return static_cast<const StorageList&>(*this);
}
@ -738,8 +734,7 @@ inline void Foam::PackedList<nBits>::transfer(PackedList<nBits>& lst)
template<unsigned nBits>
inline Foam::Xfer< Foam::PackedList<nBits> >
Foam::PackedList<nBits>::xfer()
inline Foam::Xfer<Foam::PackedList<nBits> > Foam::PackedList<nBits>::xfer()
{
return xferMove(*this);
}

3
src/OpenFOAM/containers/Lists/PtrList/PtrList.H
View File

@ -146,8 +146,7 @@ public:
PtrList(Istream&);
// Destructor
//- Destructor
~PtrList();

27
src/OpenFOAM/containers/Lists/PtrList/PtrListI.H
View File

@ -170,30 +170,35 @@ inline Foam::PtrList<T>::iterator::iterator(T** ptr)
ptr_(ptr)
{}
template<class T>
inline bool Foam::PtrList<T>::iterator::operator==(const iterator& iter) const
{
return ptr_ == iter.ptr_;
}
template<class T>
inline bool Foam::PtrList<T>::iterator::operator!=(const iterator& iter) const
{
return ptr_ != iter.ptr_;
}
template<class T>
inline T& Foam::PtrList<T>::iterator::operator*()
{
return **ptr_;
}
template<class T>
inline T& Foam::PtrList<T>::iterator::operator()()
{
return operator*();
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::PtrList<T>::iterator::operator++()
@ -202,6 +207,7 @@ Foam::PtrList<T>::iterator::operator++()
return *this;
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::PtrList<T>::iterator::operator++(int)
@ -211,6 +217,7 @@ Foam::PtrList<T>::iterator::operator++(int)
return tmp;
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::PtrList<T>::iterator::operator--()
@ -219,6 +226,7 @@ Foam::PtrList<T>::iterator::operator--()
return *this;
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::PtrList<T>::iterator::operator--(int)
@ -228,6 +236,7 @@ Foam::PtrList<T>::iterator::operator--(int)
return tmp;
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::PtrList<T>::iterator::operator+=(label n)
@ -236,6 +245,7 @@ Foam::PtrList<T>::iterator::operator+=(label n)
return *this;
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::operator+(const typename PtrList<T>::iterator& iter, label n)
@ -244,6 +254,7 @@ Foam::operator+(const typename PtrList<T>::iterator& iter, label n)
return tmp += n;
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::operator+(label n, const typename PtrList<T>::iterator& iter)
@ -252,6 +263,7 @@ Foam::operator+(label n, const typename PtrList<T>::iterator& iter)
return tmp += n;
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::PtrList<T>::iterator::operator-=(label n)
@ -260,6 +272,7 @@ Foam::PtrList<T>::iterator::operator-=(label n)
return *this;
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::operator-(const typename PtrList<T>::iterator& iter, label n)
@ -268,6 +281,7 @@ Foam::operator-(const typename PtrList<T>::iterator& iter, label n)
return tmp -= n;
}
template<class T>
inline Foam::label Foam::operator-
(
@ -278,46 +292,51 @@ inline Foam::label Foam::operator-
return (iter1.ptr_ - iter2.ptr_)/sizeof(T*);
}
template<class T>
inline T& Foam::PtrList<T>::iterator::operator[](label n)
{
return *(*this + n);
}
template<class T>
inline bool Foam::PtrList<T>::iterator::operator<(const iterator& iter) const
{
return ptr_ < iter.ptr_;
}
template<class T>
inline bool Foam::PtrList<T>::iterator::operator>(const iterator& iter) const
{
return ptr_ > iter.ptr_;
}
template<class T>
inline bool Foam::PtrList<T>::iterator::operator<=(const iterator& iter) const
{
return ptr_ <= iter.ptr_;
}
template<class T>
inline bool Foam::PtrList<T>::iterator::operator>=(const iterator& iter) const
{
return ptr_ >= iter.ptr_;
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::PtrList<T>::begin()
inline typename Foam::PtrList<T>::iterator Foam::PtrList<T>::begin()
{
return ptrs_.begin();
}
template<class T>
inline typename Foam::PtrList<T>::iterator
Foam::PtrList<T>::end()
inline typename Foam::PtrList<T>::iterator Foam::PtrList<T>::end()
{
return ptrs_.end();
}

2
src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
View File

@ -1138,7 +1138,7 @@ void Foam::fvMeshDistribute::sendMesh
{
const cellZoneMesh& cellZones = mesh.cellZones();
labelList rowSizes(pointZoneNames.size(), 0);
labelList rowSizes(cellZoneNames.size(), 0);
forAll(cellZoneNames, nameI)
{

5
src/edgeMesh/edgeFormats/edgeFormatsCore.H
View File

@ -45,7 +45,7 @@ SourceFiles
namespace Foam
{
// Forward declaration of friend functions and operators
// Forward declaration of classes
class IFstream;
class Time;
@ -61,10 +61,13 @@ class edgeFormatsCore
{
protected:
// Protected Member Functions
//- Read non-comment line
static string getLineNoComment(IFstream&);
public:
// Static Data
//- The file extension corresponding to 'native' edge format

4
src/edgeMesh/edgeFormats/emesh/EMESHedgeFormat.C
View File

@ -29,7 +29,6 @@ License
#include "IFstream.H"
#include "clock.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::fileFormats::EMESHedgeFormat::EMESHedgeFormat
@ -119,8 +118,7 @@ bool Foam::fileFormats::EMESHedgeFormat::read
}
Foam::Ostream&
Foam::fileFormats::EMESHedgeFormat::write
Foam::Ostream& Foam::fileFormats::EMESHedgeFormat::write
(
Ostream& os,
const pointField& pointLst,

1
src/edgeMesh/edgeFormats/emesh/EMESHedgeFormat.H
View File

@ -79,6 +79,7 @@ protected:
const edgeList&
);
public:
// Constructors

4
src/edgeMesh/edgeFormats/starcd/STARCDedgeFormat.C
View File

@ -160,7 +160,6 @@ bool Foam::fileFormats::STARCDedgeFormat::readPoints
}
void Foam::fileFormats::STARCDedgeFormat::writePoints
(
Ostream& os,
@ -177,8 +176,7 @@ void Foam::fileFormats::STARCDedgeFormat::writePoints
forAll(pointLst, ptI)
{
os
<< ptI + 1 << " "
os << ptI + 1 << " "
<< pointLst[ptI].x() << " "
<< pointLst[ptI].y() << " "
<< pointLst[ptI].z() << nl;

1
src/edgeMesh/edgeFormats/starcd/STARCDedgeFormat.H
View File

@ -105,6 +105,7 @@ protected:
const label nEdges
);
public:
// Constructors

6
src/edgeMesh/edgeFormats/vtk/VTKedgeFormat.C
View File

@ -60,8 +60,7 @@ void Foam::fileFormats::VTKedgeFormat::writeEdges
const UList<edge>& edgeLst
)
{
os << "LINES " << edgeLst.size() << ' '
<< 3*edgeLst.size() << nl;
os << "LINES " << edgeLst.size() << ' ' << 3*edgeLst.size() << nl;
forAll(edgeLst, edgeI)
{
@ -72,8 +71,6 @@ void Foam::fileFormats::VTKedgeFormat::writeEdges
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::fileFormats::VTKedgeFormat::VTKedgeFormat()
@ -104,4 +101,5 @@ void Foam::fileFormats::VTKedgeFormat::write
writeEdges(os, eMesh.edges());
}
// ************************************************************************* //

1
src/edgeMesh/edgeFormats/vtk/VTKedgeFormat.H
View File

@ -76,6 +76,7 @@ protected:
//- Write edges
static void writeEdges(Ostream&, const UList<edge>&);
public:
// Constructors

7
src/edgeMesh/edgeMesh.C
View File

@ -38,11 +38,13 @@ namespace Foam
defineMemberFunctionSelectionTable(edgeMesh,write,fileExtension);
}
Foam::wordHashSet Foam::edgeMesh::readTypes()
{
return wordHashSet(*fileExtensionConstructorTablePtr_);
}
Foam::wordHashSet Foam::edgeMesh::writeTypes()
{
return wordHashSet(*writefileExtensionMemberFunctionTablePtr_);
@ -66,6 +68,7 @@ bool Foam::edgeMesh::canReadType
);
}
bool Foam::edgeMesh::canWriteType
(
const word& ext,
@ -215,7 +218,6 @@ void Foam::edgeMesh::reset
// connectivity likely changed
pointEdgesPtr_.clear();
}
}
@ -227,8 +229,7 @@ void Foam::edgeMesh::transfer(edgeMesh& mesh)
}
Foam::Xfer< Foam::edgeMesh >
Foam::edgeMesh::xfer()
Foam::Xfer<Foam::edgeMesh> Foam::edgeMesh::xfer()
{
return xferMove(*this);
}

6
src/edgeMesh/edgeMesh.H
View File

@ -101,6 +101,7 @@ public:
//- Runtime type information
TypeName("edgeMesh");
// Static
//- Can we read this file format?
@ -115,6 +116,7 @@ public:
static wordHashSet readTypes();
static wordHashSet writeTypes();
// Constructors
//- Construct null
@ -142,6 +144,7 @@ public:
//- Construct from Istream
edgeMesh(Istream&);
// Declare run-time constructor selection table
declareRunTimeSelectionTable
@ -155,6 +158,7 @@ public:
(name)
);
// Selectors
//- Select constructed from filename (explicit extension)
@ -248,8 +252,6 @@ public:
void writeStats(Ostream&) const;
// Write
//- Generic write routine. Chooses writer based on extension.
virtual void write(const fileName& name) const
{

2
src/edgeMesh/edgeMeshNew.C
View File

@ -28,7 +28,6 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::autoPtr< Foam::edgeMesh >
Foam::edgeMesh::New(const fileName& name, const word& ext)
{
@ -62,4 +61,5 @@ Foam::edgeMesh::New(const fileName& name)
return New(name, ext);
}
// ************************************************************************* //

2
src/finiteVolume/cfdTools/general/fieldSources/pressureGradientExplicitSource/pressureGradientExplicitSource.H
View File

@ -84,7 +84,7 @@ class pressureGradientExplicitSource
//- Name of cell source
word cellSource_;
//- The method by which the cells will be selecetd
//- The method by which the cells will be selected
autoPtr<topoSetSource> cellSelector_;
//- The set of selected cells

2
src/finiteVolume/cfdTools/general/fieldSources/timeActivatedExplicitSource/timeActivatedExplicitSource.H
View File

@ -28,7 +28,7 @@ Class
Description
Base class for field sources. Provides:
- name
- references to mesh and time
- references to mesh and time databases
- dimensions
- volume type
- startTime

20
src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
View File

@ -84,7 +84,7 @@ activeBaffleVelocityFvPatchVectorField
)
:
fixedValueFvPatchVectorField(p, iF),
pName_("p"),
pName_(dict.lookupOrDefault<word>("p", "p")),
cyclicPatchName_(dict.lookup("cyclicPatch")),
cyclicPatchLabel_(p.patch().boundaryMesh().findPatchID(cyclicPatchName_)),
orientation_(readLabel(dict.lookup("orientation"))),
@ -96,11 +96,6 @@ activeBaffleVelocityFvPatchVectorField
curTimeIndex_(-1)
{
fvPatchVectorField::operator=(vector::zero);
if (dict.found("p"))
{
dict.lookup("p") >> pName_;
}
}
@ -219,7 +214,10 @@ void Foam::activeBaffleVelocityFvPatchVectorField::updateCoeffs()
}
openFraction_ =
max(min(
max
(
min
(
openFraction_
+ max
(
@ -227,7 +225,10 @@ void Foam::activeBaffleVelocityFvPatchVectorField::updateCoeffs()
maxOpenFractionDelta_
)
*(orientation_*sign(forceDiff)),
1 - 1e-6), 1e-6);
1 - 1e-6
),
1e-6
);
Info<< "openFraction = " << openFraction_ << endl;
@ -264,8 +265,7 @@ void Foam::activeBaffleVelocityFvPatchVectorField::write(Ostream& os) const
<< maxOpenFractionDelta_ << token::END_STATEMENT << nl;
os.writeKeyword("openFraction")
<< openFraction_ << token::END_STATEMENT << nl;
os.writeKeyword("p")
<< pName_ << token::END_STATEMENT << nl;
writeEntryIfDifferent<word>(os, "p", "p", pName_);
writeEntry("value", os);
}

22
src/finiteVolume/fields/fvPatchFields/derived/directMappedVelocityFluxFixedValue/directMappedVelocityFluxFixedValueFvPatchField.C
View File

@ -46,7 +46,7 @@ directMappedVelocityFluxFixedValueFvPatchField
)
:
fixedValueFvPatchVectorField(p, iF),
phiName_("undefinedPhi")
phiName_("phi")
{}
@ -93,22 +93,22 @@ directMappedVelocityFluxFixedValueFvPatchField
)
:
fixedValueFvPatchVectorField(p, iF, dict),
phiName_(dict.lookup("phi"))
phiName_(dict.lookupOrDefault<word>("phi", "phi"))
{
if (!isA<directMappedPatchBase>(this->patch().patch()))
{
FatalErrorIn
(
"directMappedVelocityFluxFixedValueFvPatchField::"
"directMappedVelocityFluxFixedValueFvPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<vector, volMesh>& iF,\n"
" const dictionary& dict\n"
")\n"
) << "\n patch type '" << p.type()
"directMappedVelocityFluxFixedValueFvPatchField"
"("
"const fvPatch&, "
"const DimensionedField<vector, volMesh>& iF, "
"const dictionary&"
")"
) << "patch type '" << p.type()
<< "' not type '" << directMappedPatchBase::typeName << "'"
<< "\n for patch " << p.name()
<< " for patch " << p.name()
<< " of field " << dimensionedInternalField().name()
<< " in file " << dimensionedInternalField().objectPath()
<< exit(FatalError);
@ -274,7 +274,7 @@ void directMappedVelocityFluxFixedValueFvPatchField::updateCoeffs()
void directMappedVelocityFluxFixedValueFvPatchField::write(Ostream& os) const
{
fvPatchVectorField::write(os);
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
this->writeEntry("value", os);
}

15
src/finiteVolume/fields/fvPatchFields/derived/fixedFluxPressure/fixedFluxPressureFvPatchScalarField.C
View File

@ -161,18 +161,9 @@ void Foam::fixedFluxPressureFvPatchScalarField::updateCoeffs()
void Foam::fixedFluxPressureFvPatchScalarField::write(Ostream& os) const
{
fvPatchScalarField::write(os);
if (UName_ != "U")
{
os.writeKeyword("U") << UName_ << token::END_STATEMENT << nl;
}
if (phiName_ != "phi")
{
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
}
if (rhoName_ != "rho")
{
os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
}
writeEntryIfDifferent<word>(os, "U", "U", UName_);
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
os.writeKeyword("adjoint") << adjoint_ << token::END_STATEMENT << nl;
gradient().writeEntry("gradient", os);
}

6
src/finiteVolume/fields/fvPatchFields/derived/fixedPressureCompressibleDensity/fixedPressureCompressibleDensityFvPatchScalarField.C
View File

@ -45,7 +45,7 @@ fixedPressureCompressibleDensityFvPatchScalarField
)
:
fixedValueFvPatchField<scalar>(p, iF),
pName_("pNameIsUndefined")
pName_("p")
{}
@ -72,7 +72,7 @@ fixedPressureCompressibleDensityFvPatchScalarField
)
:
fixedValueFvPatchField<scalar>(p, iF, dict),
pName_(dict.lookup("p"))
pName_(dict.lookupOrDefault<word>("p", "p"))
{}
@ -134,7 +134,7 @@ void fixedPressureCompressibleDensityFvPatchScalarField::write
) const
{
fvPatchField<scalar>::write(os);
os.writeKeyword("p") << pName_ << token::END_STATEMENT << nl;
writeEntryIfDifferent<word>(os, "p", "p", pName_);
writeEntry("value", os);
}

10
src/finiteVolume/fields/fvPatchFields/derived/fluxCorrectedVelocity/fluxCorrectedVelocityFvPatchVectorField.C
View File

@ -143,14 +143,8 @@ void Foam::fluxCorrectedVelocityFvPatchVectorField::evaluate
void Foam::fluxCorrectedVelocityFvPatchVectorField::write(Ostream& os) const
{
fvPatchVectorField::write(os);
if (phiName_ != "phi")
{
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
}
if (rhoName_ != "rho")
{
os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
}
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
writeEntry("value", os);
}

17
src/finiteVolume/fields/fvPatchFields/derived/inletOutletTotalTemperature/inletOutletTotalTemperatureFvPatchScalarField.C
View File

@ -30,8 +30,6 @@ License
#include "volFields.H"
#include "surfaceFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::inletOutletTotalTemperatureFvPatchScalarField::
@ -193,18 +191,9 @@ void Foam::inletOutletTotalTemperatureFvPatchScalarField::write(Ostream& os)
const
{
fvPatchScalarField::write(os);
if (UName_ != "U")
{
os.writeKeyword("U") << UName_ << token::END_STATEMENT << nl;
}
if (phiName_ != "phi")
{
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
}
if (phiName_ != "psi")
{
os.writeKeyword("psi") << psiName_ << token::END_STATEMENT << nl;
}
writeEntryIfDifferent<word>(os, "U", "U", UName_);
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
writeEntryIfDifferent<word>(os, "psi", "psi", psiName_);
os.writeKeyword("gamma") << gamma_ << token::END_STATEMENT << nl;
T0_.writeEntry("T0", os);
writeEntry("value", os);

22
src/finiteVolume/fields/fvPatchFields/derived/movingWallVelocity/movingWallVelocityFvPatchVectorField.C
View File

@ -43,7 +43,8 @@ movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
const DimensionedField<vector, volMesh>& iF
)
:
fixedValueFvPatchVectorField(p, iF)
fixedValueFvPatchVectorField(p, iF),
UName_("U")
{}
@ -55,7 +56,8 @@ movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
const fvPatchFieldMapper& mapper
)
:
fixedValueFvPatchVectorField(ptf, p, iF, mapper)
fixedValueFvPatchVectorField(ptf, p, iF, mapper),
UName_(ptf.UName_)
{}
@ -66,7 +68,8 @@ movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
const dictionary& dict
)
:
fixedValueFvPatchVectorField(p, iF)
fixedValueFvPatchVectorField(p, iF),
UName_(dict.lookupOrDefault<word>("U", "U"))
{
fvPatchVectorField::operator=(vectorField("value", dict, p.size()));
}
@ -74,20 +77,22 @@ movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
(
const movingWallVelocityFvPatchVectorField& pivpvf
const movingWallVelocityFvPatchVectorField& mwvpvf
)
:
fixedValueFvPatchVectorField(pivpvf)
fixedValueFvPatchVectorField(mwvpvf),
UName_(mwvpvf.UName_)
{}
movingWallVelocityFvPatchVectorField::movingWallVelocityFvPatchVectorField
(
const movingWallVelocityFvPatchVectorField& pivpvf,
const movingWallVelocityFvPatchVectorField& mwvpvf,
const DimensionedField<vector, volMesh>& iF
)
:
fixedValueFvPatchVectorField(pivpvf, iF)
fixedValueFvPatchVectorField(mwvpvf, iF),
UName_(mwvpvf.UName_)
{}
@ -114,7 +119,7 @@ void movingWallVelocityFvPatchVectorField::updateCoeffs()
vectorField Up = (pp.faceCentres() - oldFc)/mesh.time().deltaTValue();
const volVectorField& U = db().lookupObject<volVectorField>("U");
const volVectorField& U = db().lookupObject<volVectorField>(UName_);
scalarField phip =
p.patchField<surfaceScalarField, scalar>(fvc::meshPhi(U));
@ -132,6 +137,7 @@ void movingWallVelocityFvPatchVectorField::updateCoeffs()
void movingWallVelocityFvPatchVectorField::write(Ostream& os) const
{
fvPatchVectorField::write(os);
writeEntryIfDifferent<word>(os, "U", "U", UName_);
writeEntry("value", os);
}

5
src/finiteVolume/fields/fvPatchFields/derived/movingWallVelocity/movingWallVelocityFvPatchVectorField.H
View File

@ -52,6 +52,11 @@ class movingWallVelocityFvPatchVectorField
:
public fixedValueFvPatchVectorField
{
// Private data
//- Name of velocity field
word UName_;
public:

10
src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C
View File

@ -196,14 +196,8 @@ void pressureDirectedInletOutletVelocityFvPatchVectorField::
write(Ostream& os) const
{
fvPatchVectorField::write(os);
if (phiName_ != "phi")
{
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
}
if (rhoName_ != "rho")
{
os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
}
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
inletDir_.writeEntry("inletDirection", os);
writeEntry("value", os);
}

10
src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletVelocity/pressureDirectedInletVelocityFvPatchVectorField.C
View File

@ -184,14 +184,8 @@ void pressureDirectedInletVelocityFvPatchVectorField::updateCoeffs()
void pressureDirectedInletVelocityFvPatchVectorField::write(Ostream& os) const
{
fvPatchVectorField::write(os);
if (phiName_ != "phi")
{
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
}
if (rhoName_ != "rho")
{
os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
}
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
inletDir_.writeEntry("inletDirection", os);
writeEntry("value", os);
}

5
src/finiteVolume/fields/fvPatchFields/derived/pressureInletOutletVelocity/pressureInletOutletVelocityFvPatchVectorField.C
View File

@ -188,10 +188,7 @@ void pressureInletOutletVelocityFvPatchVectorField::updateCoeffs()
void pressureInletOutletVelocityFvPatchVectorField::write(Ostream& os) const
{
fvPatchVectorField::write(os);
if (phiName_ != "phi")
{
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
}
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
if (tangentialVelocity_.size())
{
tangentialVelocity_.writeEntry("tangentialVelocity", os);

10
src/finiteVolume/fields/fvPatchFields/derived/pressureInletVelocity/pressureInletVelocityFvPatchVectorField.C
View File

@ -146,14 +146,8 @@ void pressureInletVelocityFvPatchVectorField::updateCoeffs()
void pressureInletVelocityFvPatchVectorField::write(Ostream& os) const
{
fvPatchVectorField::write(os);
if (phiName_ != "phi")
{
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
}
if (rhoName_ != "rho")
{
os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
}
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
writeEntryIfDifferent<word>(os, "rho", "rho", rhoName_);
writeEntry("value", os);
}

10
src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformTotalPressure/timeVaryingUniformTotalPressureFvPatchScalarField.C
View File

@ -218,14 +218,8 @@ void Foam::timeVaryingUniformTotalPressureFvPatchScalarField::
write(Ostream& os) const
{
fvPatchScalarField::write(os);
if (UName_ != "U")
{
os.writeKeyword("U") << UName_ << token::END_STATEMENT << nl;
}
if (phiName_ != "phi")
{
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
}
writeEntryIfDifferent<word>(os, "U", "U", UName_);
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
os.writeKeyword("psi") << psiName_ << token::END_STATEMENT << nl;
os.writeKeyword("gamma") << gamma_ << token::END_STATEMENT << nl;

17
src/finiteVolume/fields/fvPatchFields/derived/totalTemperature/totalTemperatureFvPatchScalarField.C
View File

@ -30,8 +30,6 @@ License
#include "volFields.H"
#include "surfaceFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::totalTemperatureFvPatchScalarField::totalTemperatureFvPatchScalarField
@ -180,18 +178,9 @@ void Foam::totalTemperatureFvPatchScalarField::updateCoeffs()
void Foam::totalTemperatureFvPatchScalarField::write(Ostream& os) const
{
fvPatchScalarField::write(os);
if (UName_ != "U")
{
os.writeKeyword("U") << UName_ << token::END_STATEMENT << nl;
}
if (phiName_ != "phi")
{
os.writeKeyword("phi") << phiName_ << token::END_STATEMENT << nl;
}
if (psiName_ != "psi")
{
os.writeKeyword("psi") << psiName_ << token::END_STATEMENT << nl;
}
writeEntryIfDifferent<word>(os, "U", "U", UName_);
writeEntryIfDifferent<word>(os, "phi", "phi", phiName_);
writeEntryIfDifferent<word>(os, "psi", "psi", psiName_);
os.writeKeyword("gamma") << gamma_ << token::END_STATEMENT << nl;
T0_.writeEntry("T0", os);
writeEntry("value", os);

8
src/finiteVolume/fields/fvPatchFields/derived/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.C
View File

@ -40,6 +40,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
)
:
fixedValueFvPatchField<scalar>(p, iF),
UName_("U"),
intensity_(0.05)
{}
@ -53,6 +54,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
)
:
fixedValueFvPatchField<scalar>(ptf, p, iF, mapper),
UName_(ptf.UName_),
intensity_(ptf.intensity_)
{}
@ -65,6 +67,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
)
:
fixedValueFvPatchField<scalar>(p, iF, dict),
UName_(dict.lookupOrDefault<word>("U", "U")),
intensity_(readScalar(dict.lookup("intensity")))
{
if (intensity_ < 0 || intensity_ > 1)
@ -92,6 +95,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
)
:
fixedValueFvPatchField<scalar>(ptf),
UName_(ptf.UName_),
intensity_(ptf.intensity_)
{}
@ -104,6 +108,7 @@ turbulentIntensityKineticEnergyInletFvPatchScalarField
)
:
fixedValueFvPatchField<scalar>(ptf, iF),
UName_(ptf.UName_),
intensity_(ptf.intensity_)
{}
@ -119,7 +124,7 @@ updateCoeffs()
}
const fvPatchField<vector>& Up =
patch().lookupPatchField<volVectorField, vector>("U");
patch().lookupPatchField<volVectorField, vector>(UName_);
operator==(1.5*sqr(intensity_)*magSqr(Up));
@ -133,6 +138,7 @@ void Foam::turbulentIntensityKineticEnergyInletFvPatchScalarField::write
) const
{
fvPatchField<scalar>::write(os);
writeEntryIfDifferent<word>(os, "U", "U", UName_);
os.writeKeyword("intensity") << intensity_ << token::END_STATEMENT << nl;
writeEntry("value", os);
}

4
src/finiteVolume/fields/fvPatchFields/derived/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.H
View File

@ -34,6 +34,7 @@ Description
inlet
{
type turbulentIntensityKineticEnergyInlet;
U U; // Name of U field (optional)
intensity 0.05; // 5% turbulence
value uniform 1; // placeholder
}
@ -64,6 +65,9 @@ class turbulentIntensityKineticEnergyInletFvPatchScalarField
{
// Private data
//- Name of belocity field
word UName_;
//- Turbulent intensity as fraction of mean velocity
scalar intensity_;

12
src/lagrangian/basic/Cloud/Cloud.H
View File

@ -87,6 +87,12 @@ class Cloud
//- Initialise cloud on IO constructor
void initCloud(const bool checkClass);
//- Read cloud properties dictionary
void readCloudUniformProperties();
//- Write cloud properties dictionary
void writeCloudUniformProperties() const;
public:
@ -104,6 +110,12 @@ public:
TypeName("Cloud");
// Static data
//- Name of cloud properties dictionary
static word cloudPropertiesName;
// Constructors
//- Construct from mesh and a list of particles

76
src/lagrangian/basic/Cloud/CloudIO.C
View File

@ -29,11 +29,85 @@ License
#include "Time.H"
#include "IOPosition.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<class ParticleType>
Foam::word Foam::Cloud<ParticleType>::cloudPropertiesName("cloudProperties");
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template<class ParticleType>
void Foam::Cloud<ParticleType>::readCloudUniformProperties()
{
IOobject uniformPropsDictHeader
(
cloudPropertiesName,
time().timeName(),
"uniform"/cloud::prefix/name(),
db(),
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
);
if (uniformPropsDictHeader.headerOk())
{
const IOdictionary uniformPropsDict(uniformPropsDictHeader);
word procName("processor" + Foam::name(Pstream::myProcNo()));
if (uniformPropsDict.found(procName))
{
uniformPropsDict.subDict(procName).lookup("particleCount")
>> particleCount_;
}
}
else
{
particleCount_ = 0;
}
}
template<class ParticleType>
void Foam::Cloud<ParticleType>::writeCloudUniformProperties() const
{
IOdictionary uniformPropsDict
(
IOobject
(
cloudPropertiesName,
time().timeName(),
"uniform"/cloud::prefix/name(),
db(),
IOobject::NO_READ,
IOobject::NO_WRITE,
false
)
);
labelList np(Pstream::nProcs(), 0);
np[Pstream::myProcNo()] = particleCount_;
Pstream::listCombineGather(np, maxEqOp<label>());
Pstream::listCombineScatter(np);
forAll(np, i)
{
word procName("processor" + Foam::name(i));
uniformPropsDict.add(procName, dictionary());
uniformPropsDict.subDict(procName).add("particleCount", np[i]);
}
uniformPropsDict.regIOobject::write();
}
template<class ParticleType>
void Foam::Cloud<ParticleType>::initCloud(const bool checkClass)
{
readCloudUniformProperties();
IOPosition<ParticleType> ioP(*this);
if (ioP.headerOk())
@ -156,6 +230,8 @@ bool Foam::Cloud<ParticleType>::writeObject
IOstream::compressionType cmp
) const
{
writeCloudUniformProperties();
if (this->size())
{
writeFields();

70
src/lagrangian/basic/IOPosition/IOPosition.C
View File

@ -26,70 +26,6 @@ License
#include "IOPosition.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<class ParticleType>
Foam::word Foam::IOPosition<ParticleType>::particlePropertiesName
(
"particleProperties"
);
// * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * * //
template<class ParticleType>
void Foam::IOPosition<ParticleType>::readParticleProperties()
{
IOobject propsDictHeader
(
particlePropertiesName,
cloud_.db().time().timeName(),
"uniform"/cloud::prefix/cloud_.name(),
cloud_.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
);
if (propsDictHeader.headerOk())
{
const IOdictionary propsDict(propsDictHeader);
word procName("processor" + Foam::name(Pstream::myProcNo()));
if (propsDict.found(procName))
{
propsDict.subDict(procName).lookup("particleCount")
>> cloud_.particleCount_;
}
}
}
template<class ParticleType>
void Foam::IOPosition<ParticleType>::writeParticleProperties() const
{
IOdictionary propsDict
(
IOobject
(
particlePropertiesName,
cloud_.db().time().timeName(),
"uniform"/cloud::prefix/cloud_.name(),
cloud_.db(),
IOobject::NO_READ,
IOobject::NO_WRITE,
false
)
);
word procName("processor" + Foam::name(Pstream::myProcNo()));
propsDict.add(procName, dictionary());
propsDict.subDict(procName).add("particleCount", cloud_.particleCount_);
propsDict.regIOobject::write();
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class ParticleType>
@ -132,9 +68,6 @@ bool Foam::IOPosition<ParticleType>::write() const
template<class ParticleType>
bool Foam::IOPosition<ParticleType>::writeData(Ostream& os) const
{
// Write global cloud data
writeParticleProperties();
os<< cloud_.size() << nl << token::BEGIN_LIST << nl;
forAllConstIter(typename Cloud<ParticleType>, cloud_, iter)
@ -161,9 +94,6 @@ void Foam::IOPosition<ParticleType>::readData
bool checkClass
)
{
// Read global cloud data. Resets count on cloud.
readParticleProperties();
Istream& is = readStream(checkClass ? typeName : "");
token firstToken(is);

12
src/lagrangian/basic/IOPosition/IOPosition.H
View File

@ -59,15 +59,6 @@ class IOPosition
const Cloud<ParticleType>& cloud_;
// Private member functions
//- Read particle properties dictionary
void readParticleProperties();
//- Write particle properties dictionary
void writeParticleProperties() const;
public:
// Static data
@ -78,9 +69,6 @@ public:
return cloud_.type();
}
//- Name of particle properties dictionary
static word particlePropertiesName;
// Constructors

5
src/lagrangian/basic/Particle/ParticleIO.C
View File

@ -60,10 +60,6 @@ Foam::Particle<ParticleType>::Particle
{
is >> origProc_ >> origId_;
}
else
{
origId_ = cloud_.getNewParticleID();
}
}
else
{
@ -91,7 +87,6 @@ Foam::Particle<ParticleType>::Particle
+ sizeof(facei_)
+ sizeof(stepFraction_)
);
origId_ = cloud_.getNewParticleID();
}
}

3
src/lagrangian/coalCombustion/include/createCoalParcelTypes.H
View File

@ -27,7 +27,6 @@ License
#ifndef createCoalParcelTypes_H
#define createCoalParcelTypes_H
#include "makeParcelIOList.H"
#include "thermoPhysicsTypes.H"
#include "CoalCloud.H"
@ -56,8 +55,6 @@ License
\
typedef ParcelType<ThermoType> ParcelType##ThermoType; \
\
makeParcelIOList(ParcelType##ThermoType); \
\
defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0); \
defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0); \
defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0); \

2
src/lagrangian/dieselSpray/parcel/parcelIO.C
View File

@ -103,6 +103,8 @@ void Foam::parcel::readFields(Cloud<parcel>& c)
return;
}
Particle<parcel>::readFields(c);
IOField<scalar> d(c.fieldIOobject("d", IOobject::MUST_READ));
c.checkFieldIOobject(c, d);

2
src/lagrangian/dsmc/parcels/Templates/DsmcParcel/DsmcParcelIO.C
View File

@ -81,6 +81,8 @@ void Foam::DsmcParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
return;
}
Particle<ParcelType>::readFields(c);
IOField<vector> U(c.fieldIOobject("U", IOobject::MUST_READ));
c.checkFieldIOobject(c, U);

6
src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
View File

@ -269,11 +269,9 @@ void Foam::KinematicCloud<ParcelType>::info() const
{
Info<< "Cloud: " << this->name() << nl
<< " Total number of parcels added = "
<< returnReduce(this->injection().parcelsAddedTotal(), sumOp<label>())
<< nl
<< this->injection().parcelsAddedTotal() << nl
<< " Total mass introduced = "
<< returnReduce(this->injection().massInjected(), sumOp<scalar>())
<< nl
<< this->injection().massInjected() << nl
<< " Current number of parcels = "
<< returnReduce(this->size(), sumOp<label>()) << nl
<< " Current mass in system = "

4
src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelIO.C
View File

@ -40,7 +40,7 @@ Foam::string Foam::KinematicParcel<ParcelType>::propHeader =
+ " (Ux Uy Uz)"
+ " rho"
+ " tTurb"
+ " UTurb";
+ " (UTurbx UTurby UTurbz)";
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -110,6 +110,8 @@ void Foam::KinematicParcel<ParcelType>::readFields(Cloud<ParcelType>& c)
return;
}
Particle<ParcelType>::readFields(c);
IOField<label> typeId(c.fieldIOobject("typeId", IOobject::MUST_READ));
c.checkFieldIOobject(c, typeId);

3
src/lagrangian/intermediate/parcels/derived/basicKinematicParcel/defineBasicKinematicParcel.C
View File

@ -26,7 +26,6 @@ License
#include "basicKinematicParcel.H"
#include "KinematicCloud.H"
#include "makeParcelIOList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -35,8 +34,6 @@ namespace Foam
defineTemplateTypeNameAndDebug(Cloud<basicKinematicParcel>, 0);
defineParcelTypeNameAndDebug(KinematicCloud<basicKinematicParcel>, 0);
makeParcelIOList(basicKinematicParcel);
};

3
src/lagrangian/intermediate/parcels/derived/basicThermoParcel/defineBasicThermoParcel.C
View File

@ -26,7 +26,6 @@ License
#include "basicThermoParcel.H"
#include "ThermoCloud.H"
#include "makeParcelIOList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -41,8 +40,6 @@ namespace Foam
defineParcelTypeNameAndDebug(KinematicCloud<basicThermoParcel>, 0);
defineParcelTypeNameAndDebug(ThermoCloud<basicThermoParcel>, 0);
makeParcelIOList(basicThermoParcel);
};

3
src/lagrangian/intermediate/parcels/include/createReactingMultiphaseParcelTypes.H
View File

@ -27,7 +27,6 @@ License
#ifndef createReactingMultiphaseParcelTypes_H
#define createReactingMultiphaseParcelTypes_H
#include "makeParcelIOList.H"
#include "thermoPhysicsTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -55,8 +54,6 @@ License
\
typedef ParcelType<ThermoType> ParcelType##ThermoType; \
\
makeParcelIOList(ParcelType##ThermoType); \
\
defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0); \
defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0); \
defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0); \

3
src/lagrangian/intermediate/parcels/include/createReactingParcelTypes.H
View File

@ -27,7 +27,6 @@ License
#ifndef createReactingParcelTypes_H
#define createReactingParcelTypes_H
#include "makeParcelIOList.H"
#include "thermoPhysicsTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -43,8 +42,6 @@ License
\
typedef ParcelType<ThermoType> ParcelType##ThermoType; \
\
makeParcelIOList(ParcelType##ThermoType); \
\
defineTemplateTypeNameAndDebug(ParcelType##ThermoType, 0); \
defineTemplateTypeNameAndDebug(Particle<ParcelType##ThermoType>, 0); \
defineTemplateTypeNameAndDebug(Cloud<ParcelType##ThermoType>, 0); \

36
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectionModel/InjectionModel.C
View File

@ -219,7 +219,6 @@ Foam::scalar Foam::InjectionModel<CloudType>::setNumberOfParticles
"const label, "
"const scalar, "
"const scalar, "
" const scalar, "
"const scalar"
")"
)<< "Unknown parcelBasis type" << nl
@ -232,18 +231,26 @@ Foam::scalar Foam::InjectionModel<CloudType>::setNumberOfParticles
template<class CloudType>
void Foam::InjectionModel<CloudType>::postInjectCheck(const label parcelsAdded)
void Foam::InjectionModel<CloudType>::postInjectCheck
(
const label parcelsAdded,
const scalar massAdded
)
{
if (parcelsAdded > 0)
const label allParcelsAdded = returnReduce(parcelsAdded, sumOp<label>());
if (allParcelsAdded > 0)
{
Pout<< nl
Info<< nl
<< "--> Cloud: " << owner_.name() << nl
<< " Added " << parcelsAdded
<< " new parcels" << nl << endl;
<< " Added " << allParcelsAdded << " new parcels" << nl << endl;
}
// Increment total number of parcels added
parcelsAddedTotal_ += parcelsAdded;
parcelsAddedTotal_ += allParcelsAdded;
// Increment total mass injected
massInjected_ += returnReduce(massAdded, sumOp<scalar>());
// Update time for start of next injection
time0_ = owner_.db().time().value();
@ -355,16 +362,12 @@ void Foam::InjectionModel<CloudType>::inject(TrackData& td)
const polyMesh& mesh = owner_.mesh();
// Prepare for next time step
label parcelsAdded = 0;
scalar massAdded = 0.0;
label newParcels = 0;
scalar newVolume = 0.0;
prepareForNextTimeStep(time, newParcels, newVolume);
// Return if no parcels are required
if (newParcels == 0)
{
postInjectCheck(0);
return;
}
prepareForNextTimeStep(time, newParcels, newVolume);
// Duration of injection period during this timestep
const scalar deltaT =
@ -374,7 +377,6 @@ void Foam::InjectionModel<CloudType>::inject(TrackData& td)
const scalar padTime = max(0.0, SOI_ - time0_);
// Introduce new parcels linearly across carrier phase timestep
label parcelsAdded = 0;
for (label parcelI=0; parcelI<newParcels; parcelI++)
{
if (validInjection(parcelI))
@ -425,13 +427,13 @@ void Foam::InjectionModel<CloudType>::inject(TrackData& td)
// Add the new parcel
td.cloud().addParticle(pPtr);
massInjected_ += pPtr->nParticle()*pPtr->mass();
massAdded += pPtr->nParticle()*pPtr->mass();
parcelsAdded++;
}
}
}
postInjectCheck(parcelsAdded);
postInjectCheck(parcelsAdded, massAdded);
}

6
src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InjectionModel/InjectionModel.H
View File

@ -188,7 +188,11 @@ protected:
);
//- Post injection checks
virtual void postInjectCheck(const label parcelsAdded);
virtual void postInjectCheck
(
const label parcelsAdded,
const scalar massAdded
);
public:

65
src/lagrangian/intermediate/submodels/Kinematic/PostProcessingModel/PatchPostProcessing/PatchPostProcessing.C
View File

@ -25,7 +25,8 @@ License
\*---------------------------------------------------------------------------*/
#include "PatchPostProcessing.H"
#include "IOPtrList.H"
#include "Pstream.H"
#include "ListListOps.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
@ -54,34 +55,57 @@ void Foam::PatchPostProcessing<CloudType>::write()
{
forAll(patchData_, patchI)
{
IOPtrList<parcelType> postObject
(
IOobject
(
patchNames_[patchI] + ".post",
this->owner().time().timeName(),
"postProcessing",
this->owner(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
patchData_[patchI].size()
);
List<List<string> > procData(Pstream::nProcs());
procData[Pstream::myProcNo()] = patchData_[patchI];
forAll(postObject, ptrI)
Pstream::gatherList(procData);
if (Pstream::master())
{
postObject.set(ptrI, patchData_[patchI][ptrI].ptr());
fileName outputDir;
if (Pstream::parRun())
{
// Put in undecomposed case (Note: gives problems for
// distributed data running)
outputDir =
mesh_.time().path()/".."/"postProcessing"/cloud::prefix/
this->owner().name()/this->owner().time().timeName();
}
else
{
outputDir =
mesh_.time().path()/"postProcessing"/cloud::prefix/
this->owner().name()/this->owner().time().timeName();
}
postObject.note() = parcelType::propHeader;
// Create directory if it doesn't exist
mkDir(outputDir);
postObject.writeObject
OFstream patchOutFile
(
outputDir/patchNames_[patchI] + ".post",
IOstream::ASCII,
IOstream::currentVersion,
mesh_.time().writeCompression()
);
List<string> globalData;
globalData = ListListOps::combine<List<string> >
(
procData,
accessOp<List<string> >()
);
sort(globalData);
patchOutFile<< "# Time " + parcelType::propHeader << nl;
forAll(globalData, i)
{
patchOutFile<< globalData[i].c_str() << nl;
}
}
patchData_[patchI].clearStorage();
}
}
@ -98,6 +122,7 @@ Foam::PatchPostProcessing<CloudType>::PatchPostProcessing
:
PostProcessingModel<CloudType>(dict, owner, typeName),
mesh_(owner.mesh()),
maxStoredParcels_(readLabel(this->coeffDict().lookup("maxStoredParcels"))),
patchNames_(this->coeffDict().lookup("patches")),
patchData_(patchNames_.size()),
patchIds_(patchNames_.size())
@ -149,7 +174,9 @@ void Foam::PatchPostProcessing<CloudType>::postPatch
label localPatchI = applyToPatch(patchI);
if (localPatchI >= 0 && patchData_[localPatchI].size() < maxStoredParcels_)
{
patchData_[localPatchI].append(p.clone());
OStringStream data;
data<< this->owner().time().timeName() << ' ' << p;
patchData_[localPatchI].append(data.str());
}
}

4
src/lagrangian/intermediate/submodels/Kinematic/PostProcessingModel/PatchPostProcessing/PatchPostProcessing.H
View File

@ -65,8 +65,8 @@ class PatchPostProcessing
//- List of patch names
wordList patchNames_;
//- List of parcel data per patch
List<DynamicList<autoPtr<parcelType> > > patchData_;
//- List of output data per patch
List<DynamicList<string> > patchData_;
//- Mapping from local to global patch ids
labelList patchIds_;

13
src/lagrangian/molecularDynamics/molecule/interactionLists/interactionLists.C
View File

@ -450,8 +450,17 @@ bool Foam::interactionLists::testPointFaceDistance
// if the algorithm hasn't returned anything by now then something has
// gone wrong.
FatalErrorIn("interactionLists.C") << nl
<< "point " << p << " to face " << faceToTest
FatalErrorIn
(
"interactionLists::testPointFaceDistance"
"("
"const vector&, "
"const labelList&, "
"const vectorList&, "
"const vector&, "
"const vector&"
") const"
) << "point " << p << " to face " << faceToTest
<< " comparison did not find a nearest point"
<< " to be inside or outside face."
<< abort(FatalError);

26
src/lagrangian/molecularDynamics/molecule/interactionLists/referredCellList/referredCellList.C
View File

@ -121,8 +121,10 @@ void Foam::referredCellList::buildReferredCellList
}
else
{
FatalErrorIn ("referredCellList.C")
<< nl << "unable to read undecomposed boundary file from "
FatalErrorIn
(
"referredCellList::buildReferredCellList(bool)"
) << "unable to read undecomposed boundary file from "
<< "constant/polyMesh" << nl
<< abort(FatalError);
}
@ -333,9 +335,10 @@ void Foam::referredCellList::buildReferredCellList
> interactionLists::transTol
)
{
FatalErrorIn ("referredCellList.C")
<< nl << "Face pairs on patch "
<< patch.name()
FatalErrorIn
(
"referredCellList::buildReferredCellList(bool)"
) << "Face pairs on patch " << patch.name()
<< ", segment " << patchNames[nUP]
<< " do not give the same referring "
<< " transformations to within tolerance of "
@ -423,9 +426,10 @@ void Foam::referredCellList::buildReferredCellList
> interactionLists::transTol
)
{
FatalErrorIn ("referredCellList.C")
<< nl << "Face pairs on patch "
<< patch.name()
FatalErrorIn
(
"referredCellList::buildReferredCellList(bool)"
) << "Face pairs on patch " << patch.name()
<< " do not give the same referring "
<< " transformations to within tolerance of "
<< interactionLists::transTol << nl
@ -1022,8 +1026,10 @@ void Foam::referredCellList::buildReferredCellList
{
if (faceT == -1)
{
FatalErrorIn ("referredCellList.C")
<< nl << "faceT == -1 encountered but "
FatalErrorIn
(
"referredCellList::buildReferredCellList(bool)"
) << "faceT == -1 encountered but "
<< meshFacesOnThisSegment.size()
<< " faces found on patch segment."
<< abort(FatalError);

2
src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C
View File

@ -105,6 +105,8 @@ void Foam::molecule::readFields(Cloud<molecule>& mC)
return;
}
Particle<molecule>::readFields(mC);
IOField<tensor> Q(mC.fieldIOobject("Q", IOobject::MUST_READ));
mC.checkFieldIOobject(mC, Q);

2
src/lagrangian/molecularDynamics/molecule/moleculeCloud/moleculeCloud.C
View File

@ -81,7 +81,7 @@ void Foam::moleculeCloud::buildConstProps()
if (siteIds[sI] == -1)
{
FatalErrorIn("moleculeCloud.C") << nl
FatalErrorIn("moleculeCloud::buildConstProps()")
<< siteId << " site not found."
<< nl << abort(FatalError);
}

4
src/lagrangian/molecularDynamics/potential/pairPotential/basic/pairPotential.C
View File

@ -101,7 +101,7 @@ Foam::scalar Foam::pairPotential::force(const scalar r) const
if (k < 0)
{
FatalErrorIn("pairPotential.C") << nl
FatalErrorIn("pairPotential::force(const scalar) const")
<< "r less than rMin in pair potential " << name_ << nl
<< abort(FatalError);
}
@ -138,7 +138,7 @@ Foam::scalar Foam::pairPotential::energy(const scalar r) const
if (k < 0)
{
FatalErrorIn("pairPotential.C") << nl
FatalErrorIn("pairPotential::energy(const scalar) const")
<< "r less than rMin in pair potential " << name_ << nl
<< abort(FatalError);
}

38
src/lagrangian/molecularDynamics/potential/potential/potential.C
View File

@ -40,7 +40,7 @@ void Foam::potential::setSiteIdList(const IOdictionary& moleculePropertiesDict)
if (!moleculePropertiesDict.found(id))
{
FatalErrorIn("potential.C") << nl
FatalErrorIn("potential::setSiteIdList(const IOdictionary&)")
<< id << " molecule subDict not found"
<< nl << abort(FatalError);
}
@ -67,7 +67,7 @@ void Foam::potential::setSiteIdList(const IOdictionary& moleculePropertiesDict)
if (findIndex(siteIdNames, siteId) == -1)
{
FatalErrorIn("potential.C") << nl
FatalErrorIn("potential::setSiteIdList(const IOdictionary&)")
<< siteId << " in pairPotentialSiteIds is not in siteIds: "
<< siteIdNames << nl << abort(FatalError);
}
@ -174,7 +174,7 @@ void Foam::potential::potential::readPotentialDict()
if (removalOrder_[rO] == -1)
{
FatalErrorIn("potentials.C") << nl
FatalErrorIn("potential::readPotentialDict()")
<< "removalOrder entry: " << remOrd[rO]
<< " not found in idList."
<< nl << abort(FatalError);
@ -187,7 +187,7 @@ void Foam::potential::potential::readPotentialDict()
if (!potentialDict.found("pair"))
{
FatalErrorIn("potentials.C") << nl
FatalErrorIn("potential::readPotentialDict()")
<< "pair potential specification subDict not found"
<< abort(FatalError);
}
@ -208,7 +208,7 @@ void Foam::potential::potential::readPotentialDict()
{
if (!potentialDict.found("tether"))
{
FatalErrorIn("potential.C") << nl
FatalErrorIn("potential::readPotentialDict()")
<< "tether potential specification subDict not found"
<< abort(FatalError);
}
@ -289,11 +289,15 @@ void Foam::potential::potential::readMdInitialiseDict
if (!moleculePropertiesDict.found(id))
{
FatalErrorIn("potential.C") << nl
<< "Molecule type "
<< id
<< " not found in moleculeProperties dictionary."
<< nl
FatalErrorIn
(
"potential::readMdInitialiseDict"
"("
"const IOdictionary&, "
"IOdictionary&"
")"
) << "Molecule type " << id
<< " not found in moleculeProperties dictionary." << nl
<< abort(FatalError);
}
@ -340,11 +344,15 @@ void Foam::potential::potential::readMdInitialiseDict
}
else
{
FatalErrorIn("potential.C") << nl
<< "Tether id "
<< tetherSiteId
<< " not found as a site of any molecule in zone."
<< nl
FatalErrorIn
(
"potential::readMdInitialiseDict"
"("
"const IOdictionary&, "
"IOdictionary&"
")"
) << "Tether id " << tetherSiteId
<< " not found as a site of any molecule in zone." << nl
<< abort(FatalError);
}
}

5
src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.C
View File

@ -670,7 +670,6 @@ void Foam::refinementSurfaces::findHigherIntersection
haveLevelField = true;
}
if (haveLevelField)
{
forAll(intersectionInfo, i)
@ -741,8 +740,8 @@ void Foam::refinementSurfaces::findHigherIntersection
}
else
{
p0[missI] = p0[pointI];
p1[missI] = p1[pointI];
p0[missI] = start[pointI];
p1[missI] = end[pointI];
intersectionToPoint[missI] = pointI;
missI++;
}

21
src/meshTools/directMapped/directMappedPolyPatch/directMappedPatchBase.C
View File

@ -623,6 +623,27 @@ Foam::directMappedPatchBase::directMappedPatchBase
{}
Foam::directMappedPatchBase::directMappedPatchBase
(
const polyPatch& pp,
const word& sampleRegion,
const sampleMode mode,
const word& samplePatch,
const vector& offset
)
:
patch_(pp),
sampleRegion_(sampleRegion),
mode_(mode),
samplePatch_(samplePatch),
uniformOffset_(true),
offset_(offset),
offsets_(0),
sameRegion_(sampleRegion_ == patch_.boundaryMesh().mesh().name()),
mapPtr_(NULL)
{}
Foam::directMappedPatchBase::directMappedPatchBase
(
const polyPatch& pp,

10
src/meshTools/directMapped/directMappedPolyPatch/directMappedPatchBase.H
View File

@ -157,6 +157,16 @@ public:
const vectorField& offset
);
//- Construct from components
directMappedPatchBase
(
const polyPatch& pp,
const word& sampleRegion,
const sampleMode sampleMode,
const word& samplePatch,
const vector& offset
);
//- Construct from dictionary
directMappedPatchBase(const polyPatch&, const dictionary&);

25
src/meshTools/directMapped/directMappedPolyPatch/directMappedPolyPatch.C
View File

@ -82,6 +82,31 @@ Foam::directMappedPolyPatch::directMappedPolyPatch
{}
Foam::directMappedPolyPatch::directMappedPolyPatch
(
const word& name,
const label size,
const label start,
const label index,
const word& sampleRegion,
const directMappedPatchBase::sampleMode mode,
const word& samplePatch,
const vector& offset,
const polyBoundaryMesh& bm
)
:
polyPatch(name, size, start, index, bm),
directMappedPatchBase
(
static_cast<const polyPatch&>(*this),
sampleRegion,
mode,
samplePatch,
offset
)
{}
Foam::directMappedPolyPatch::directMappedPolyPatch
(
const word& name,

14
src/meshTools/directMapped/directMappedPolyPatch/directMappedPolyPatch.H
View File

@ -115,6 +115,20 @@ public:
const polyBoundaryMesh& bm
);
//- Construct from components. Uniform offset.
directMappedPolyPatch
(
const word& name,
const label size,
const label start,
const label index,
const word& sampleRegion,
const directMappedPatchBase::sampleMode mode,
const word& samplePatch,
const vector& offset,
const polyBoundaryMesh& bm
);
//- Construct from dictionary
directMappedPolyPatch
(

Some files were not shown because too many files have changed in this diff Show More