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 \

24
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"
#include "compressibleMultiRegionCourantNo.H"
#include "solidRegionDiffusionNo.H"
#include "setInitialMultiRegionDeltaT.H"
if (fluidRegions.size())
{
#include "compressibleMultiRegionCourantNo.H"
#include "setInitialDeltaT.H"
}
while (runTime.run())
{
#include "readTimeControls.H"
#include "readSolidTimeControls.H"
#include "readPIMPLEControls.H"
if (fluidRegions.size())
{
#include "compressibleMultiRegionCourantNo.H"
#include "setDeltaT.H"
}
#include "compressibleMultiRegionCourantNo.H"
#include "solidRegionDiffusionNo.H"
#include "setMultiRegionDeltaT.H"
runTime++;
@ -117,7 +119,7 @@ int main(int argc, char *argv[])
<< nl << endl;
}
Info<< "End\n" << endl;
Info << "End\n" << endl;
return 0;
}

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

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

@ -1,15 +1,18 @@
scalar CoNum = -GREAT;
forAll(fluidRegions, regionI)
if (fluidRegions.size())
{
CoNum = max
(
compressibleCourantNo
forAll(fluidRegions, regionI)
{
CoNum = max
(
fluidRegions[regionI],
runTime,
rhoFluid[regionI],
phiFluid[regionI]
),
CoNum
);
compressibleCourantNo
(
fluidRegions[regionI],
runTime,
rhoFluid[regionI],
phiFluid[regionI]
),
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.

62
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,
0, // size
startFaceI,
insertPatchI,
polyPatches
polyPatches,
insertPatchI, //index
0, //size
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"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

10
applications/utilities/postProcessing/graphics/PV3Readers/PV3FoamReader/vtkPV3Foam/vtkPV3FoamLagrangianFields.H
View File

@ -67,11 +67,11 @@ void Foam::vtkPV3Foam::convertLagrangianField
{
const label nComp = pTraits<Type>::nComponents;
vtkFloatArray *pointData = vtkFloatArray::New();
pointData->SetNumberOfTuples( tf.size() );
pointData->SetNumberOfComponents( nComp );
pointData->Allocate( nComp*tf.size() );
pointData->SetName( tf.name().c_str() );
vtkFloatArray* pointData = vtkFloatArray::New();
pointData->SetNumberOfTuples(tf.size());
pointData->SetNumberOfComponents(nComp);
pointData->Allocate(nComp*tf.size());
pointData->SetName(tf.name().c_str());
if (debug)
{

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

@ -130,7 +130,7 @@ void Foam::vtkPV3Foam::updateInfoInternalMesh
// Determine mesh parts (internalMesh, patches...)
//- Add internal mesh as first entry
arrayRangeVolume_.reset( arraySelection->GetNumberOfArrays() );
arrayRangeVolume_.reset(arraySelection->GetNumberOfArrays());
arraySelection->AddArray
(
"internalMesh"
@ -173,7 +173,7 @@ void Foam::vtkPV3Foam::updateInfoLagrangian
readDir(dbPtr_->timePath()/lagrangianPrefix, fileName::DIRECTORY)
);
arrayRangeLagrangian_.reset( arraySelection->GetNumberOfArrays() );
arrayRangeLagrangian_.reset(arraySelection->GetNumberOfArrays());
int nClouds = 0;
forAll(cloudDirs, cloudI)
@ -209,7 +209,7 @@ void Foam::vtkPV3Foam::updateInfoPatches
<< " [meshPtr=" << (meshPtr_ ? "set" : "NULL") << "]" << endl;
}
arrayRangePatches_.reset( arraySelection->GetNumberOfArrays() );
arrayRangePatches_.reset(arraySelection->GetNumberOfArrays());
int nPatches = 0;
if (meshPtr_)
@ -319,7 +319,7 @@ void Foam::vtkPV3Foam::updateInfoZones
namesLst = readZoneNames("cellZones");
}
arrayRangeCellZones_.reset( arraySelection->GetNumberOfArrays() );
arrayRangeCellZones_.reset(arraySelection->GetNumberOfArrays());
forAll(namesLst, elemI)
{
arraySelection->AddArray
@ -342,7 +342,7 @@ void Foam::vtkPV3Foam::updateInfoZones
namesLst = readZoneNames("faceZones");
}
arrayRangeFaceZones_.reset( arraySelection->GetNumberOfArrays() );
arrayRangeFaceZones_.reset(arraySelection->GetNumberOfArrays());
forAll(namesLst, elemI)
{
arraySelection->AddArray
@ -365,7 +365,7 @@ void Foam::vtkPV3Foam::updateInfoZones
namesLst = readZoneNames("pointZones");
}
arrayRangePointZones_.reset( arraySelection->GetNumberOfArrays() );
arrayRangePointZones_.reset(arraySelection->GetNumberOfArrays());
forAll(namesLst, elemI)
{
arraySelection->AddArray
@ -408,8 +408,21 @@ 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_.reset(arraySelection->GetNumberOfArrays());
arrayRangeCellSets_ += addToSelection<cellSet>
(
arraySelection,
@ -417,7 +430,7 @@ void Foam::vtkPV3Foam::updateInfoSets
" - cellSet"
);
arrayRangeFaceSets_.reset( arraySelection->GetNumberOfArrays() );
arrayRangeFaceSets_.reset(arraySelection->GetNumberOfArrays());
arrayRangeFaceSets_ += addToSelection<faceSet>
(
arraySelection,
@ -425,7 +438,7 @@ void Foam::vtkPV3Foam::updateInfoSets
" - faceSet"
);
arrayRangePointSets_.reset( arraySelection->GetNumberOfArrays() );
arrayRangePointSets_.reset(arraySelection->GetNumberOfArrays());
arrayRangePointSets_ += addToSelection<pointSet>
(
arraySelection,

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
# -----------------------------------------------------------------------------

25
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,9 +209,8 @@ public:
HashTable(const Xfer<HashTable<T, Key, Hash> >&);
// Destructor
~HashTable();
//- Destructor
~HashTable();
// Member Functions
@ -247,6 +246,7 @@ public:
//- Print information
Ostream& printInfo(Ostream&) const;
// Edit
//- Insert a new hashedEntry
@ -291,7 +291,7 @@ public:
void transfer(HashTable<T, Key, Hash>&);
//- Transfer contents to the Xfer container
inline Xfer< HashTable<T, Key, Hash> > xfer();
inline Xfer<HashTable<T, Key, Hash> > xfer();
// Member Operators
@ -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>&
);
};

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

@ -97,11 +97,10 @@ Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
{}
template<class T, class Key, class Hash>
Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
(
const Xfer< StaticHashTable<T, Key, Hash> >& ht
const Xfer<StaticHashTable<T, Key, Hash> >& ht
)
:
StaticHashTableCore(),
@ -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
(

16
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:
@ -183,11 +179,11 @@ public:
StaticHashTable(const StaticHashTable<T, Key, Hash>&);
//- Construct by transferring the parameter contents
StaticHashTable(const Xfer< StaticHashTable<T, Key, Hash> >&);
StaticHashTable(const Xfer<StaticHashTable<T, Key, Hash> >&);
// Destructor
~StaticHashTable();
//- Destructor
~StaticHashTable();
// Member Functions
@ -251,7 +247,7 @@ public:
void transfer(StaticHashTable<T, Key, Hash>&);
//- Transfer contents to the Xfer container
inline Xfer< StaticHashTable<T, Key, Hash> > xfer();
inline Xfer<StaticHashTable<T, Key, Hash> > xfer();
// Member Operators
@ -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

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

@ -79,7 +79,7 @@ inline bool Foam::StaticHashTable<T, Key, Hash>::set
template<class T, class Key, class Hash>
inline Foam::Xfer< Foam::StaticHashTable<T, Key, Hash> >
inline Foam::Xfer<Foam::StaticHashTable<T, Key, Hash> >
Foam::StaticHashTable<T, Key, Hash>::xfer()
{
return xferMove(*this);
@ -417,6 +417,4 @@ Foam::StaticHashTable<T, Key, Hash>::end() const
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// ************************************************************************* //

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

@ -74,7 +74,7 @@ public:
(
const UList<T>& posList,
const UList<T>& negList,
const Xfer< List<label> >&
const Xfer<List<label> >&
);
@ -102,7 +102,7 @@ public:
//- Reset addressing
inline void resetAddressing(const UList<label>&);
inline void resetAddressing(const Xfer< List<label> >&);
inline void resetAddressing(const Xfer<List<label> >&);
// Member Operators

4
src/OpenFOAM/containers/Lists/BiIndirectList/BiIndirectListI.H
View File

@ -45,7 +45,7 @@ inline Foam::BiIndirectList<T>::BiIndirectList
(
const UList<T>& posList,
const UList<T>& negList,
const Xfer< List<label> >& addr
const Xfer<List<label> >& addr
)
:
posList_(const_cast<UList<T>&>(posList)),
@ -105,7 +105,7 @@ inline void Foam::BiIndirectList<T>::resetAddressing
template<class T>
inline void Foam::BiIndirectList<T>::resetAddressing
(
const Xfer< List<label> >& addr
const Xfer<List<label> >& addr
)
{
addressing_.transfer(addr());

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
);
}

148
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
@ -115,7 +115,7 @@ public:
explicit inline DynamicList(const UIndirectList<T>&);
//- Construct by transferring the parameter contents
explicit inline DynamicList(const Xfer< List<T> >&);
explicit inline DynamicList(const Xfer<List<T> >&);
//- Construct from Istream. Size set to size of read list.
explicit DynamicList(Istream&);
@ -125,103 +125,105 @@ public:
// Access
//- Size of the underlying storage.
inline label capacity() const;
//- Size of the underlying storage.
inline label capacity() const;
// Edit
//- Alter the size of the underlying storage.
// The addressed size will be truncated if needed to fit, but will
// remain otherwise untouched.
// Use this or reserve() in combination with append().
inline void setCapacity(const label);
//- Alter the size of the underlying storage.
// The addressed size will be truncated if needed to fit, but will
// remain otherwise untouched.
// Use this or reserve() in combination with append().
inline void setCapacity(const label);
//- Alter the addressed list size.
// New space will be allocated if required.
// Use this to resize the list prior to using the operator[] for
// setting values (as per List usage).
inline void setSize(const label);
//- Alter the addressed list size.
// New space will be allocated if required.
// Use this to resize the list prior to using the operator[] for
// setting values (as per List usage).
inline void setSize(const label);
//- Alter the addressed list size and fill new space with a constant.
inline void setSize(const label, const T&);
//- Alter the addressed list size and fill new space with a constant.
inline void setSize(const label, const T&);
//- Alter the addressed list size.
// New space will be allocated if required.
// Use this to resize the list prior to using the operator[] for
// setting values (as per List usage).
inline void resize(const label);
//- Alter the addressed list size.
// New space will be allocated if required.
// Use this to resize the list prior to using the operator[] for
// setting values (as per List usage).
inline void resize(const label);
//- Alter the addressed list size and fill new space with a constant.
inline void resize(const label, const T&);
//- Alter the addressed list size and fill new space with a constant.
inline void resize(const label, const T&);
//- Reserve allocation space for at least this size.
// Never shrinks the allocated size, use setCapacity() for that.
inline void reserve(const label);
//- Reserve allocation space for at least this size.
// Never shrinks the allocated size, use setCapacity() for that.
inline void reserve(const label);
//- Clear the addressed list, i.e. set the size to zero.
// Allocated size does not change
inline void clear();
//- Clear the addressed list, i.e. set the size to zero.
// Allocated size does not change
inline void clear();
//- Clear the list and delete storage.
inline void clearStorage();
//- Clear the list and delete storage.
inline void clearStorage();
//- Shrink the allocated space to the number of elements used.
// Returns a reference to the DynamicList.
inline DynamicList<T, SizeInc, SizeMult, SizeDiv>& shrink();
//- Shrink the allocated space to the number of elements used.
// Returns a reference to the DynamicList.
inline DynamicList<T, SizeInc, SizeMult, SizeDiv>& shrink();
//- Transfer contents of the argument List into this DynamicList
inline void transfer(List<T>&);
//- Transfer contents of the argument List into this DynamicList
inline void transfer(List<T>&);
//- Transfer contents of the argument DynamicList into this DynamicList
inline void transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>&);
//- Transfer contents of the argument DynamicList into this DynamicList
inline void transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>&);
//- Transfer contents to the Xfer container as a plain List
inline Xfer< List<T> > xfer();
//- 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
inline void append(const T&);
// Member Operators
//- Append a List at the end of this list
inline void append(const UList<T>&);
//- Append an element at the end of the list
inline void append(const T&);
//- Append a UIndirectList at the end of this list
inline void append(const UIndirectList<T>&);
//- Append a List at the end of this list
inline void append(const UList<T>&);
//- Remove and return the top element
inline T remove();
//- Append a UIndirectList at the end of this list
inline void append(const UIndirectList<T>&);
//- Return non-const access to an element, resizing list if necessary
inline T& operator()(const label);
//- Remove and return the top element
inline T remove();
//- Assignment of all addressed entries to the given value
inline void operator=(const T&);
//- Return non-const access to an element, resizing list if necessary
inline T& operator()(const label);
//- Assignment from DynamicList
inline void operator=
(
const DynamicList<T, SizeInc, SizeMult, SizeDiv>&
);
//- Assignment of all addressed entries to the given value
inline void operator=(const T&);
//- Assignment from UList
inline void operator=(const UList<T>&);
//- Assignment from DynamicList
inline void operator=
(
const DynamicList<T, SizeInc, SizeMult, SizeDiv>&
);
// IOstream operators
//- Assignment from UList
inline void operator=(const UList<T>&);
// Write DynamicList to Ostream.
friend Ostream& operator<< <T, SizeInc, SizeMult, SizeDiv>
(
Ostream&,
const DynamicList<T, SizeInc, SizeMult, SizeDiv>&
);
//- Read from Istream, discarding contents of existing DynamicList.
friend Istream& operator>> <T, SizeInc, SizeMult, SizeDiv>
(
Istream&,
DynamicList<T, SizeInc, SizeMult, SizeDiv>&
);
// IOstream operators
// Write DynamicList to Ostream.
friend Ostream& operator<< <T, SizeInc, SizeMult, SizeDiv>
(
Ostream&,
const DynamicList<T, SizeInc, SizeMult, SizeDiv>&
);
//- Read from Istream, discarding contents of existing DynamicList.
friend Istream& operator>> <T, SizeInc, SizeMult, SizeDiv>
(
Istream&,
DynamicList<T, SizeInc, SizeMult, SizeDiv>&
);
};

2
src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
View File

@ -298,7 +298,7 @@ Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::transfer
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
inline Foam::Xfer< Foam::List<T> >
inline Foam::Xfer<Foam::List<T> >
Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::xfer()
{
return xferMoveTo< List<T> >(*this);

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

@ -64,7 +64,8 @@ public:
inline IndirectList(const UList<T>&, const UList<label>&);
//- Construct given the complete list and by transferring addressing
inline IndirectList(const UList<T>&, const Xfer< List<label> >&);
inline IndirectList(const UList<T>&, const Xfer<List<label> >&);
// Member Functions
@ -94,11 +95,12 @@ public:
//- Return the list addressing
inline const List<label>& addressing() const;
// Edit
//- Reset addressing
inline void resetAddressing(const UList<label>&);
inline void resetAddressing(const Xfer< List<label> >&);
inline void resetAddressing(const Xfer<List<label> >&);
// Member Operators

4
src/OpenFOAM/containers/Lists/IndirectList/IndirectListI.H
View File

@ -42,7 +42,7 @@ template<class T>
inline Foam::IndirectList<T>::IndirectList
(
const UList<T>& completeList,
const Xfer< List<label> >& addr
const Xfer<List<label> >& addr
)
:
completeList_(const_cast<UList<T>&>(completeList)),
@ -121,7 +121,7 @@ inline void Foam::IndirectList<T>::resetAddressing
template<class T>
inline void Foam::IndirectList<T>::resetAddressing
(
const Xfer< List<label> >& addr
const Xfer<List<label> >& addr
)
{
addressing_.transfer(addr());

2
src/OpenFOAM/containers/Lists/List/List.C
View File

@ -114,7 +114,7 @@ Foam::List<T>::List(const List<T>& a)
// Construct by transferring the parameter contents
template<class T>
Foam::List<T>::List(const Xfer< List<T> >& lst)
Foam::List<T>::List(const Xfer<List<T> >& lst)
{
transfer(lst());
}

10
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
@ -109,7 +110,7 @@ public:
List(const List<T>&);
//- Construct by transferring the parameter contents
List(const Xfer< List<T> >&);
List(const Xfer<List<T> >&);
//- Construct as copy or re-use as specified.
List(List<T>&, bool reUse);
@ -147,9 +148,8 @@ public:
inline autoPtr<List<T> > clone() const;
// Destructor
~List();
//- Destructor
~List();
// Related types
@ -201,7 +201,7 @@ public:
void transfer(SortableList<T>&);
//- Transfer contents to the Xfer container
inline Xfer< List<T> > xfer();
inline Xfer<List<T> > xfer();
//- Return subscript-checked element of UList.
inline T& newElmt(const label);

2
src/OpenFOAM/containers/Lists/List/ListI.H
View File

@ -88,7 +88,7 @@ inline Foam::label Foam::List<T>::size() const
template<class T>
inline Foam::Xfer< Foam::List<T> > Foam::List<T>::xfer()
inline Foam::Xfer<Foam::List<T> > Foam::List<T>::xfer()
{
return xferMove(*this);
}

171
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
@ -171,7 +174,7 @@ public:
inline PackedList(const PackedList<nBits>&);
//- Construct by transferring the parameter contents
inline PackedList(const Xfer< PackedList<nBits> >&);
inline PackedList(const Xfer<PackedList<nBits> >&);
//- Construct from a list of labels
explicit PackedList(const UList<label>&);
@ -179,123 +182,126 @@ public:
//- Clone
inline autoPtr< PackedList<nBits> > clone() const;
// Member Functions
// Access
//- The number of elements that can be stored before reallocating
inline label capacity() const;
//- The number of elements that can be stored before reallocating
inline label capacity() const;
//- Number of entries.
inline label size() const;
//- Number of entries.
inline label size() const;
//- Return true if the list is empty (ie, size() is zero).
inline bool empty() const;
//- Return true if the list is empty (ie, size() is zero).
inline bool empty() const;
//- Get value at index I.
// Never auto-vivify entries.
inline unsigned int get(const label) const;
//- Get value at index I.
// Never auto-vivify entries.
inline unsigned int get(const label) const;
//- Set value at index I. Return true if value changed.
// Does auto-vivify for non-existent entries.
// Default value set is the max_value.
inline bool set(const label, const unsigned int val = ~0u);
//- Set value at index I. Return true if value changed.
// Does auto-vivify for non-existent entries.
// Default value set is the max_value.
inline bool set(const label, const unsigned int val = ~0u);
//- Unset the entry at index I. Return true if value changed.
// Never auto-vivify entries.
inline bool unset(const label);
//- Unset the entry at index I. Return true if value changed.
// Never auto-vivify entries.
inline bool unset(const label);
//- Return the underlying packed storage
inline List<unsigned int>& storage();
//- Return the underlying packed storage
inline List<unsigned int>& storage();
//- Return the underlying packed storage
inline const List<unsigned int>& storage() const;
//- Return the underlying packed storage
inline const List<unsigned int>& storage() const;
//- Count number of bits set, O(log(n))
// Uses the Hamming weight (population count) method
// http://en.wikipedia.org/wiki/Hamming_weight
unsigned int count() const;
//- Count number of bits set, O(log(n))
// Uses the Hamming weight (population count) method
// http://en.wikipedia.org/wiki/Hamming_weight
unsigned int count() const;
//- Return the values as a labelList
labelList values() const;
//- Return the values as a labelList
labelList values() const;
//- Print values and information
Ostream& print(Ostream&) const;
//- Print values and information
Ostream& print(Ostream&) const;
// Edit
//- Trim any trailing zero elements
bool trim();
//- Trim any trailing zero elements
bool trim();
//- Invert the bits in the addressable region.
void flip();
//- Invert the bits in the addressable region.
void flip();
//- Alter the size of the underlying storage.
// The addressed size will be truncated if needed to fit, but will
// remain otherwise untouched.
inline void setCapacity(const label);
//- Alter the size of the underlying storage.
// The addressed size will be truncated if needed to fit, but will
// remain otherwise untouched.
inline void setCapacity(const label);
//- Reset addressable list size, does not shrink the allocated size.
// Optionally specify a value for new elements.
inline void resize(const label, const unsigned int& val = 0);
//- Reset addressable list size, does not shrink the allocated size.
// Optionally specify a value for new elements.
inline void resize(const label, const unsigned int& val = 0);
//- Alias for resize()
inline void setSize(const label, const unsigned int& val = 0);
//- Alias for resize()
inline void setSize(const label, const unsigned int& val = 0);
//- Reserve allocation space for at least this size.
// Never shrinks the allocated size.
// The list size is adjusted as per DynamicList with
// SizeInc=0, SizeMult=2, SizeDiv=1
inline void reserve(const label);
//- Reserve allocation space for at least this size.
// Never shrinks the allocated size.
// The list size is adjusted as per DynamicList with
// SizeInc=0, SizeMult=2, SizeDiv=1
inline void reserve(const label);
//- Clear the list, i.e. set addressable size to zero.
// Does not adjust the underlying storage
inline void clear();
//- Clear the list, i.e. set addressable size to zero.
// Does not adjust the underlying storage
inline void clear();
//- Clear the list and delete storage.
inline void clearStorage();
//- Clear the list and delete storage.
inline void clearStorage();
//- Shrink the allocated space to what is actually used.
inline void shrink();
//- Shrink the allocated space to what is actually used.
inline void shrink();
//- Transfer the contents of the argument list into this list
// and annul the argument list.
inline void transfer(PackedList<nBits>&);
//- Transfer the contents of the argument list into this list
// and annul the argument list.
inline void transfer(PackedList<nBits>&);
//- Transfer contents to the Xfer container
inline Xfer< PackedList<nBits> > xfer();
//- Transfer contents to the Xfer container
inline Xfer<PackedList<nBits> > xfer();
// Member operators
//- Append a value at the end of the list
inline void append(const unsigned int val);
//- Append a value at the end of the list
inline void append(const unsigned int val);
//- Remove and return the last element
inline unsigned int remove();
//- Remove and return the last element
inline unsigned int remove();
//- Get value at index I
// Never auto-vivify entries.
inline unsigned int operator[](const label) const;
//- Get value at index I
// Never auto-vivify entries.
inline unsigned int operator[](const label) const;
//- Set value at index I.
// Returns iterator to perform the actual operation.
// Does not auto-vivify entries, but will when assigned to.
inline iteratorBase operator[](const label);
//- Set value at index I.
// Returns iterator to perform the actual operation.
// Does not auto-vivify entries, but will when assigned to.
inline iteratorBase operator[](const label);
//- Assignment of all entries to the given value. Takes linear time.
inline void operator=(const unsigned int val);
//- Assignment of all entries to the given value. Takes linear time.
inline void operator=(const unsigned int val);
//- Assignment operator. Takes linear time.
void operator=(const PackedList<nBits>&);
//- Assignment operator. Takes linear time.
void operator=(const PackedList<nBits>&);
//- Assignment operator. Takes linear time.
void operator=(const UList<label>&);
//- Assignment operator. Takes linear time.
void operator=(const UList<label>&);
// Ostream operator
// // Write PackedList to Ostream.
// friend Ostream& operator<< <nBits> (Ostream&, const PackedList<nBits>&);
// Ostream operator
// // Write PackedList to Ostream.
// friend Ostream& operator<< <nBits> (Ostream&, const PackedList<nBits>&);
// Iterators and helpers
@ -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);
}

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

@ -130,7 +130,7 @@ public:
PtrList(const PtrList<T>&, const CloneArg&);
//- Construct by transferring the parameter contents
PtrList(const Xfer< PtrList<T> >&);
PtrList(const Xfer<PtrList<T> >&);
//- Construct as copy or re-use as specified.
PtrList(PtrList<T>&, bool reUse);
@ -146,9 +146,8 @@ public:
PtrList(Istream&);
// Destructor
~PtrList();
//- Destructor
~PtrList();
// Member functions
@ -196,7 +195,7 @@ public:
void transfer(PtrList<T>&);
//- Transfer contents to the Xfer container
inline Xfer< PtrList<T> > xfer();
inline Xfer<PtrList<T> > xfer();
//- Is element set
inline bool set(const label) const;

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();
}

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

@ -111,7 +111,7 @@ public:
explicit UPtrList(const label);
//- Construct by transferring the parameter contents
UPtrList(const Xfer< UPtrList<T> >&);
UPtrList(const Xfer<UPtrList<T> >&);
//- Construct as copy or re-use as specified.
UPtrList(UPtrList<T>&, bool reUse);
@ -160,7 +160,7 @@ public:
void transfer(UPtrList<T>&);
//- Transfer contents to the Xfer container
inline Xfer< UPtrList<T> > xfer();
inline Xfer<UPtrList<T> > xfer();
//- Is element set
inline bool set(const label) const;

2
src/OpenFOAM/db/IOstreams/Tstreams/ITstream.H
View File

@ -89,7 +89,7 @@ public:
ITstream
(
const string& name,
const Xfer< List<token> >& tokens,
const Xfer<List<token> >& tokens,
streamFormat format=ASCII,
versionNumber version=currentVersion
)

2
src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.C
View File

@ -107,7 +107,7 @@ Foam::primitiveEntry::primitiveEntry
Foam::primitiveEntry::primitiveEntry
(
const keyType& key,
const Xfer< List<token> >& tokens
const Xfer<List<token> >& tokens
)
:
entry(key),

2
src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.H
View File

@ -114,7 +114,7 @@ public:
primitiveEntry(const keyType&, const UList<token>&);
//- Construct from keyword and by transferring a list of tokens
primitiveEntry(const keyType&, const Xfer< List<token> >&);
primitiveEntry(const keyType&, const Xfer<List<token> >&);
//- Construct from keyword and a T
template<class T>

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/obj/OBJedgeFormat.C
View File

@ -64,7 +64,7 @@ bool Foam::fileFormats::OBJedgeFormat::read
}
DynamicList<point> dynPoints;
DynamicList<edge> dynEdges;
DynamicList<edge> dynEdges;
DynamicList<label> dynUsedPoints;
while (is.good())
@ -195,7 +195,7 @@ void Foam::fileFormats::OBJedgeFormat::write
)
{
const pointField& pointLst = mesh.points();
const edgeList& edgeLst = mesh.edges();
const edgeList& edgeLst = mesh.edges();
OFstream os(filename);
if (!os.good())

6
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;
@ -367,7 +365,7 @@ void Foam::fileFormats::STARCDedgeFormat::write
)
{
const pointField& pointLst = mesh.points();
const edgeList& edgeLst = mesh.edges();
const edgeList& edgeLst = mesh.edges();
fileName baseName = filename.lessExt();

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

@ -90,20 +90,21 @@ protected:
// Protected Member Functions
static bool readHeader(IFstream&, const word&);
static bool readHeader(IFstream&, const word&);
static void writeHeader(Ostream&, const char* filetype);
static void writeHeader(Ostream&, const char* filetype);
static bool readPoints(IFstream&, pointField&, labelList& ids);
static bool readPoints(IFstream&, pointField&, labelList& ids);
static void writePoints(Ostream&, const pointField&);
static void writePoints(Ostream&, const pointField&);
static void writeCase
(
Ostream&,
const pointField&,
const label nEdges
);
static void writeCase
(
Ostream&,
const pointField&,
const label nEdges
);
public:

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

11
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,
@ -197,8 +200,8 @@ void Foam::edgeMesh::clear()
void Foam::edgeMesh::reset
(
const Xfer< pointField >& pointLst,
const Xfer< edgeList >& edgeLst
const Xfer<pointField>& pointLst,
const Xfer<edgeList>& edgeLst
)
{
// Take over new primitive data.
@ -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);
}

22
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
@ -126,8 +128,8 @@ public:
//- Construct by transferring components (points, edges).
edgeMesh
(
const Xfer< pointField >&,
const Xfer< edgeList >&
const Xfer<pointField>&,
const Xfer<edgeList>&
);
//- Construct as copy
@ -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)
@ -197,7 +201,7 @@ public:
void transfer(edgeMesh&);
//- Transfer contents to the Xfer container
Xfer< edgeMesh > xfer();
Xfer<edgeMesh > xfer();
// Read
@ -233,8 +237,8 @@ public:
// Note, optimized to avoid overwriting data (with Xfer::null)
virtual void reset
(
const Xfer< pointField >& points,
const Xfer< edgeList >& edges
const Xfer<pointField>& points,
const Xfer<edgeList>& edges
);
//- Scale points. A non-positive factor is ignored
@ -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
{
@ -261,10 +263,10 @@ public:
inline void operator=(const edgeMesh&);
// Ostream Operator
// Ostream Operator
friend Ostream& operator<<(Ostream&, const edgeMesh&);
friend Istream& operator>>(Istream&, edgeMesh&);
friend Ostream& operator<<(Ostream&, const edgeMesh&);
friend Istream& operator>>(Istream&, edgeMesh&);
};

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);
}
// ************************************************************************* //

4
src/edgeMesh/featureEdgeMesh/featureEdgeMesh.C
View File

@ -73,8 +73,8 @@ Foam::featureEdgeMesh::featureEdgeMesh
Foam::featureEdgeMesh::featureEdgeMesh
(
const IOobject& io,
const Xfer< pointField >& pointLst,
const Xfer< edgeList >& edgeLst
const Xfer<pointField>& pointLst,
const Xfer<edgeList>& edgeLst
)
:
regIOobject(io),

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

32
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,15 +214,21 @@ void Foam::activeBaffleVelocityFvPatchVectorField::updateCoeffs()
}
openFraction_ =
max(min(
openFraction_
+ max
max
(
min
(
this->db().time().deltaTValue()/openingTime_,
maxOpenFractionDelta_
)
*(orientation_*sign(forceDiff)),
1 - 1e-6), 1e-6);
openFraction_
+ max
(
this->db().time().deltaTValue()/openingTime_,
maxOpenFractionDelta_
)
*(orientation_*sign(forceDiff)),
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); \

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

@ -216,11 +216,10 @@ Foam::scalar Foam::InjectionModel<CloudType>::setNumberOfParticles
"Foam::scalar "
"Foam::InjectionModel<CloudType>::setNumberOfParticles"
"("
" const label, "
" const scalar, "
" const scalar, "
" const scalar, "
" const scalar"
"const label, "
"const scalar, "
"const scalar, "
"const scalar"
")"
)<< "Unknown parcelBasis type" << nl
<< exit(FatalError);
@ -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:

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