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' into cvm

Browse Source 
Conflicts:
	applications/utilities/surface/surfaceFeatureConvert/surfaceFeatureConvert.C
	applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C
	src/Allwmake
	src/edgeMesh/Make/files
	src/edgeMesh/edgeMesh.C
	src/edgeMesh/edgeMesh.H
	src/edgeMesh/edgeMeshI.H
	src/edgeMesh/edgeMeshIO.C
	src/edgeMesh/featureEdgeMesh.C
	src/edgeMesh/featureEdgeMesh.H
	src/edgeMesh/featureEdgeMesh/featureEdgeMesh.C
	src/edgeMesh/featureEdgeMesh/featureEdgeMesh.H
	src/meshTools/searchableSurface/closedTriSurfaceMesh.C
	src/meshTools/searchableSurface/closedTriSurfaceMesh.H

Merged Mark's work on edgeMesh with my featureEdgeMesh.
This commit is contained in:
graham
2009-12-21 15:52:03 +00:00
parent bd81a6643d d241c43ac7
commit ff671ff1bb
1006 changed files with 499018 additions and 58103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
applications/solvers/basic/potentialFoam/potentialFoam.C
View File

@ -38,11 +38,9 @@ Description
int main(int argc, char *argv[])
{
argList::validOptions.insert("writep", "");
argList::addBoolOption("writep", "write the final pressure field");
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
# include "createFields.H"

4
applications/solvers/combustion/PDRFoam/XiEqns
View File

@ -22,7 +22,7 @@
volScalarField GEta = GEtaCoef/tauEta;
volScalarField XiEqEta = 1.0 + XiCoef*sqrt(up/(Su + SuMin))*Reta;
volScalarField R =
volScalarField R =
GEta*XiEqEta/(XiEqEta - 0.999) + GIn*XiIn/(XiIn - 0.999);
volScalarField XiEqStar = R/(R - GEta - GIn);
@ -42,7 +42,7 @@
volScalarField GEta = GEtaCoef/tauEta;
volScalarField XiEqEta = 1.0 + XiCoef*sqrt(up/(Su + SuMin))*Reta;
volScalarField R =
volScalarField R =
GEta*XiEqEta/(XiEqEta - 0.999) + GIn*XiIn/(XiIn - 0.999);
volScalarField XiEqStar = R/(R - GEta - GIn);

2
applications/solvers/combustion/PDRFoam/XiModels/algebraic/algebraic.C
View File

@ -91,7 +91,7 @@ bool Foam::XiModels::algebraic::read(const dictionary& XiProperties)
XiModel::read(XiProperties);
XiModelCoeffs_.lookup("XiShapeCoef") >> XiShapeCoef;
return true;
}

2
applications/solvers/combustion/PDRFoam/laminarFlameSpeed/SCOPE/SCOPELaminarFlameSpeed.C
View File

@ -117,7 +117,7 @@ inline Foam::scalar Foam::laminarFlameSpeedModels::SCOPE::polyPhi
{
scalar x = phi - 1.0;
return
return
a[0]
*(
scalar(1)

2
applications/solvers/combustion/PDRFoam/setDeltaT.H
View File

@ -45,7 +45,7 @@ if (adjustTimeStep)
maxDeltaT
)
);
Info<< "deltaT = " << runTime.deltaTValue() << endl;
}

2
applications/solvers/combustion/dieselEngineFoam/createFields.H
View File

@ -88,7 +88,7 @@ volScalarField DpDt =
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll (Y, i)
forAll(Y, i)
{
fields.add(Y[i]);
}

2
applications/solvers/combustion/reactingFoam/createFields.H
View File

@ -77,7 +77,7 @@ volScalarField DpDt =
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll (Y, i)
forAll(Y, i)
{
fields.add(Y[i]);
}

2
applications/solvers/combustion/rhoReactingFoam/createFields.H
View File

@ -77,7 +77,7 @@ volScalarField DpDt =
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll (Y, i)
forAll(Y, i)
{
fields.add(Y[i]);
}

2
applications/solvers/compressible/rhoCentralFoam/Allwmake
View File

@ -2,7 +2,7 @@
cd ${0%/*} || exit 1 # run from this directory
set -x
wmake libso BCs
wmake libso BCs
wmake
# ----------------------------------------------------------------- end-of-file

2
applications/solvers/compressible/rhoCentralFoam/BCs/Make/options
View File

@ -6,5 +6,5 @@ EXE_INC = \
EXE_LIBS = \
-lfiniteVolume \
-lbasicThermophysicalModels \
-lspecie
-lspecie

2
applications/solvers/compressible/rhoCentralFoam/BCs/U/maxwellSlipUFvPatchVectorField.C
View File

@ -22,8 +22,6 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
\*---------------------------------------------------------------------------*/
#include "maxwellSlipUFvPatchVectorField.H"

2
applications/solvers/compressible/rhoCentralFoam/BCs/mixedFixedValueSlip/mixedFixedValueSlipFvPatchFields.C
View File

@ -22,8 +22,6 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Description
\*---------------------------------------------------------------------------*/
#include "mixedFixedValueSlipFvPatchFields.H"

2
applications/solvers/compressible/rhoSonicFoam/rhoSonicFoam.C
View File

@ -84,7 +84,7 @@ int main(int argc, char *argv[])
(
fvm::ddt(rhoU)
+ fvm::div(phiv, rhoU)
==
==
- fvc::grad(p)
);

2
applications/solvers/compressible/rhopSonicFoam/Allwmake
View File

@ -2,7 +2,7 @@
cd ${0%/*} || exit 1 # run from this directory
set -x
wmake libso BCs
wmake libso BCs
wmake
# ----------------------------------------------------------------- end-of-file

4
applications/solvers/compressible/rhopSonicFoam/BCs/p/inviscidWallPFvPatchScalarField.C
View File

@ -131,7 +131,7 @@ void inviscidWallPFvPatchScalarField::updateCoeffs()
const fvPatchField<vector>& rhoUp =
patch().lookupPatchField<volVectorField, vector>("rhoU");
const fvsPatchField<scalar>& phip =
const fvsPatchField<scalar>& phip =
patch().lookupPatchField<surfaceScalarField, scalar>("phi");
const fvsPatchField<scalar>& rAp =
@ -147,7 +147,7 @@ void inviscidWallPFvPatchScalarField::updateCoeffs()
void inviscidWallPFvPatchScalarField::write(Ostream& os) const
{
fixedGradientFvPatchScalarField::write(os);
os.writeKeyword("fluxFraction")
os.writeKeyword("fluxFraction")
<< fluxFraction_ << token::END_STATEMENT << nl;
writeEntry("value", os);
}

4
applications/solvers/compressible/rhopSonicFoam/BCs/rhoE/mixedRhoEFvPatchScalarField.C
View File

@ -145,7 +145,7 @@ void mixedRhoEFvPatchScalarField::updateCoeffs()
const volScalarField& T = db().lookupObject<volScalarField>("T");
const label patchi = patch().index();
fvPatchScalarField& Tp =
fvPatchScalarField& Tp =
const_cast<fvPatchScalarField&>(T.boundaryField()[patchi]);
Tp.evaluate();
@ -164,7 +164,7 @@ void mixedRhoEFvPatchScalarField::updateCoeffs()
refGrad() =
rhop*Cv.value()*Tp.snGrad()
+ (
refValue()
refValue()
- (0.5*rhop.patchInternalField()*
magSqr(rhoUp.patchInternalField()/rhop.patchInternalField()))
)*patch().deltaCoeffs();

2
applications/solvers/compressible/rhopSonicFoam/BCs/rhoU/fixedRhoUFvPatchVectorField.H
View File

@ -66,7 +66,7 @@ public:
const dictionary&
);
//- Construct by mapping given fixedRhoUFvPatchVectorField
//- Construct by mapping given fixedRhoUFvPatchVectorField
// onto a new patch
fixedRhoUFvPatchVectorField
(

2
applications/solvers/electromagnetics/electrostaticFoam/Make/files
View File

@ -1,3 +1,3 @@
electrostaticFoam.C
electrostaticFoam.C
EXE = $(FOAM_APPBIN)/electrostaticFoam

2
applications/solvers/incompressible/icoFoam/Make/files
View File

@ -1,3 +1,3 @@
icoFoam.C
icoFoam.C
EXE = $(FOAM_APPBIN)/icoFoam

2
applications/solvers/incompressible/nonNewtonianIcoFoam/Make/files
View File

@ -1,3 +1,3 @@
nonNewtonianIcoFoam.C
nonNewtonianIcoFoam.C
EXE = $(FOAM_APPBIN)/nonNewtonianIcoFoam

2
applications/solvers/incompressible/simpleFoam/Make/files
View File

@ -1,3 +1,3 @@
simpleFoam.C
simpleFoam.C
EXE = $(FOAM_APPBIN)/simpleFoam

2
applications/solvers/lagrangian/coalChemistryFoam/createFields.H
View File

@ -28,7 +28,7 @@
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll (Y, i)
forAll(Y, i)
{
fields.add(Y[i]);
}

2
applications/solvers/lagrangian/porousExplicitSourceReactingParcelFoam/createFields.H
View File

@ -84,7 +84,7 @@
Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll (Y, i)
forAll(Y, i)
{
fields.add(Y[i]);
}

2
applications/solvers/lagrangian/reactingParcelFoam/createFields.H
View File

@ -90,7 +90,7 @@
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
forAll (Y, i)
forAll(Y, i)
{
fields.add(Y[i]);
}

6
applications/solvers/lagrangian/uncoupledKinematicParcelFoam/createFields.H
View File

@ -47,8 +47,10 @@
)
);
word kinematicCloudName("kinematicCloud");
args.optionReadIfPresent("cloudName", kinematicCloudName);
const word kinematicCloudName
(
args.optionLookupOrDefault<word>("cloudName", "kinematicCloud")
);
Info<< "Constructing kinematicCloud " << kinematicCloudName << endl;
basicKinematicCloud kinematicCloud

2
applications/solvers/lagrangian/uncoupledKinematicParcelFoam/uncoupledKinematicParcelFoam.C
View File

@ -42,7 +42,7 @@ Description
int main(int argc, char *argv[])
{
argList::validOptions.insert("cloudName", "cloud name");
argList::addOption("cloudName", "cloud name");
#include "setRootCase.H"
#include "createTime.H"

2
applications/solvers/multiphase/bubbleFoam/UEqns.H
View File

@ -41,7 +41,7 @@ fvVectorMatrix UbEqn(Ub, Ub.dimensions()*dimVol/dimTime);
- fvc::interpolate(nuEffb)
*mesh.magSf()*fvc::snGrad(beta)/fvc::interpolate(beta + scalar(0.001));
UbEqn =
UbEqn =
(
(scalar(1) + Cvm*rhob*alpha/rhob)*
(

2
applications/solvers/multiphase/cavitatingFoam/CourantNo.H
View File

@ -36,7 +36,7 @@ scalar acousticCoNum = 0.0;
if (mesh.nInternalFaces())
{
surfaceScalarField SfUfbyDelta =
surfaceScalarField SfUfbyDelta =
mesh.surfaceInterpolation::deltaCoeffs()*mag(phiv);
CoNum = max(SfUfbyDelta/mesh.magSf())

4
applications/solvers/multiphase/cavitatingFoam/continuityErrs.H
View File

@ -3,12 +3,12 @@
dimensionedScalar totalMass = fvc::domainIntegrate(rho);
scalar sumLocalContErr =
scalar sumLocalContErr =
(
fvc::domainIntegrate(mag(rho - thermoRho))/totalMass
).value();
scalar globalContErr =
scalar globalContErr =
(
fvc::domainIntegrate(rho - thermoRho)/totalMass
).value();

2
applications/solvers/multiphase/cavitatingFoam/setDeltaT.H
View File

@ -47,7 +47,7 @@ if (adjustTimeStep)
maxDeltaT
)
);
Info<< "deltaT = " << runTime.deltaTValue() << endl;
}

2
applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/alphaContactAngle/alphaContactAngleFvPatchScalarField.C
View File

@ -63,7 +63,7 @@ Ostream& operator<<
)
{
os << tp.theta0_ << token::SPACE
<< tp.uTheta_ << token::SPACE
<< tp.uTheta_ << token::SPACE
<< tp.thetaA_ << token::SPACE
<< tp.thetaR_;

2
applications/solvers/multiphase/multiphaseInterFoam/multiphaseMixture/phase/phase.C
View File

@ -28,7 +28,7 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::phase::phase
Foam::phase::phase
(
const word& name,
const dictionary& phaseDict,

2
applications/solvers/multiphase/settlingFoam/correctViscosity.H
View File

@ -1,5 +1,5 @@
{
mul = muc +
mul = muc +
plasticViscosity
(
plasticViscosityCoeff,

2
applications/solvers/multiphase/twoPhaseEulerFoam/UEqns.H
View File

@ -56,7 +56,7 @@ fvVectorMatrix UbEqn(Ub, Ub.dimensions()*dimVol/dimTime);
-fvc::interpolate(nuEffb)*mesh.magSf()*fvc::snGrad(beta)
/fvc::interpolate(beta + scalar(0.001));
UbEqn =
UbEqn =
(
(scalar(1) + Cvm*rhob*alpha/rhob)*
(

2
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/GidaspowErgunWenYu/GidaspowErgunWenYu.C
View File

@ -89,7 +89,7 @@ Foam::tmp<Foam::volScalarField> Foam::GidaspowErgunWenYu::K
volScalarField& KWenYu = tKWenYu();
// Ergun
forAll (beta, cellj)
forAll(beta, cellj)
{
if (beta[cellj] <= 0.8)
{

2
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/SyamlalOBrien/SyamlalOBrien.C
View File

@ -73,7 +73,7 @@ Foam::tmp<Foam::volScalarField> Foam::SyamlalOBrien::K
volScalarField A = pow(beta, 4.14);
volScalarField B = 0.8*pow(beta, 1.28);
forAll (beta, celli)
forAll(beta, celli)
{
if (beta[celli] > 0.85)
{

4
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/conductivityModel/conductivityModel/newConductivityModel.C
View File

@ -35,9 +35,9 @@ Foam::autoPtr<Foam::conductivityModel> Foam::conductivityModel::New
{
word conductivityModelType(dict.lookup("conductivityModel"));
Info<< "Selecting conductivityModel "
Info<< "Selecting conductivityModel "
<< conductivityModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(conductivityModelType);

6
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/frictionalStressModel/JohnsonJackson/JohnsonJacksonFrictionalStress.C
View File

@ -73,7 +73,7 @@ frictionalPressure
) const
{
return
return
Fr*pow(max(alpha - alphaMinFriction, scalar(0)), eta)
/pow(max(alphaMax - alpha, scalar(5.0e-2)), p);
}
@ -104,9 +104,9 @@ Foam::tmp<Foam::volScalarField> Foam::JohnsonJacksonFrictionalStress::muf
const dimensionedScalar& alphaMax,
const volScalarField& pf,
const volTensorField& D,
const dimensionedScalar& phi
const dimensionedScalar& phi
) const
{
{
return dimensionedScalar("0.5", dimTime, 0.5)*pf*sin(phi);
}

2
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/frictionalStressModel/Schaeffer/SchaefferFrictionalStress.C
View File

@ -125,7 +125,7 @@ Foam::tmp<Foam::volScalarField> Foam::SchaefferFrictionalStress::muf
volScalarField& muff = tmuf();
forAll (D, celli)
forAll(D, celli)
{
if (alpha[celli] > alphaMax.value()-5e-2)
{

4
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/frictionalStressModel/frictionalStressModel/newFrictionalStressModel.C
View File

@ -35,9 +35,9 @@ Foam::autoPtr<Foam::frictionalStressModel> Foam::frictionalStressModel::New
{
word frictionalStressModelType(dict.lookup("frictionalStressModel"));
Info<< "Selecting frictionalStressModel "
Info<< "Selecting frictionalStressModel "
<< frictionalStressModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(frictionalStressModelType);

4
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/granularPressureModel/granularPressureModel/newGranularPressureModel.C
View File

@ -35,9 +35,9 @@ Foam::autoPtr<Foam::granularPressureModel> Foam::granularPressureModel::New
{
word granularPressureModelType(dict.lookup("granularPressureModel"));
Info<< "Selecting granularPressureModel "
Info<< "Selecting granularPressureModel "
<< granularPressureModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(granularPressureModelType);

6
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/CarnahanStarling/CarnahanStarlingRadial.C
View File

@ -65,7 +65,7 @@ Foam::tmp<Foam::volScalarField> Foam::CarnahanStarlingRadial::g0
) const
{
return
return
1.0/(1.0 - alpha)
+ 3.0*alpha/(2.0*sqr(1.0 - alpha))
+ sqr(alpha)/(2.0*pow(1.0 - alpha, 3));
@ -78,8 +78,8 @@ Foam::tmp<Foam::volScalarField> Foam::CarnahanStarlingRadial::g0prime
const dimensionedScalar& alphaMax
) const
{
return
- alpha/sqr(1.0 - alpha)
return
- alpha/sqr(1.0 - alpha)
+ (3.0*(1.0 - alpha) + 6.0*sqr(alpha))/(2.0*(1.0 - alpha))
+ (2.0*alpha*(1.0 - alpha) + 3.0*pow(alpha, 3))
/(2.0*pow(1.0 - alpha, 4));

2
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/Gidaspow/GidaspowRadial.C
View File

@ -74,7 +74,7 @@ Foam::tmp<Foam::volScalarField> Foam::GidaspowRadial::g0prime
const dimensionedScalar& alphaMax
) const
{
return
return
(-1.0/5.0)*pow(alpha/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha/alphaMax, 1.0/3.0)));
}

2
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/SinclairJackson/SinclairJacksonRadial.C
View File

@ -74,7 +74,7 @@ Foam::tmp<Foam::volScalarField> Foam::SinclairJacksonRadial::g0prime
const dimensionedScalar& alphaMax
) const
{
return
return
(-1.0/3.0)*pow(alpha/alphaMax, -2.0/3.0)
/(alphaMax*sqr(1.0 - pow(alpha/alphaMax, 1.0/3.0)));
}

4
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/radialModel/radialModel/newRadialModel.C
View File

@ -35,9 +35,9 @@ Foam::autoPtr<Foam::radialModel> Foam::radialModel::New
{
word radialModelType(dict.lookup("radialModel"));
Info<< "Selecting radialModel "
Info<< "Selecting radialModel "
<< radialModelType << endl;
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(radialModelType);

2
applications/solvers/multiphase/twoPhaseEulerFoam/pEqn.H
View File

@ -42,7 +42,7 @@
phib = (fvc::interpolate(Ub) & mesh.Sf()) + fvc::ddtPhiCorr(rUbA, Ub, phib)
+ phiDragb;
phi = alphaf*phia + betaf*phib;
surfaceScalarField Dp("(rho*(1|A(U)))", alphaf*rUaAf/rhoa + betaf*rUbAf/rhob);

10
applications/solvers/multiphase/twoPhaseEulerFoam/packingLimiter.H
View File

@ -7,20 +7,20 @@
labelListList neighbour = mesh.cellCells();
scalarField cellVolumes = mesh.cellVolumes();
forAll (alphaEx, celli)
forAll(alphaEx, celli)
{
// Finding the labels of the neighbouring cells
labelList neighbourCell = neighbour[celli];
// Initializing neighbouring cells contribution
scalar neighboursEx = 0.0;
forAll (neighbourCell, cellj)
forAll(neighbourCell, cellj)
{
labelList neighboursNeighbour = neighbour[neighbourCell[cellj]];
scalar neighboursNeighbourCellVolumes = 0.0;
forAll (neighboursNeighbour, cellk)
forAll(neighboursNeighbour, cellk)
{
neighboursNeighbourCellVolumes +=
cellVolumes[neighboursNeighbour[cellk]];

4
applications/solvers/stressAnalysis/solidDisplacementFoam/tractionDisplacement/tractionDisplacementFvPatchVectorField.C
View File

@ -177,7 +177,7 @@ void tractionDisplacementFvPatchVectorField::updateCoeffs()
gradient() =
(
(traction_ + pressure_*n)/rho.value()
+ twoMuLambda*fvPatchField<vector>::snGrad() - (n & sigmaD)
+ twoMuLambda*fvPatchField<vector>::snGrad() - (n & sigmaD)
)/twoMuLambda;
Switch thermalStress(thermalProperties.lookup("thermalStress"));
@ -187,7 +187,7 @@ void tractionDisplacementFvPatchVectorField::updateCoeffs()
dimensionedScalar alpha(thermalProperties.lookup("alpha"));
dimensionedScalar threeKalpha = threeK*alpha;
const fvPatchField<scalar>& T =
const fvPatchField<scalar>& T =
patch().lookupPatchField<volScalarField, scalar>("T");
gradient() += n*threeKalpha.value()*T/twoMuLambda;

2
applications/solvers/stressAnalysis/solidEquilibriumDisplacementFoam/solidEquilibriumDisplacementFoam.C
View File

@ -72,7 +72,7 @@ int main(int argc, char *argv[])
{
volTensorField gradDcorr = fvc::grad(Dcorr);
sigmaExp =
sigmaExp =
(lambda - mu)*gradDcorr + mu*gradDcorr.T()
+ (lambda*I)*tr(gradDcorr);

2
applications/solvers/stressAnalysis/solidEquilibriumDisplacementFoam/tractionDisplacementCorrection/tractionDisplacementCorrectionFvPatchVectorField.C
View File

@ -171,7 +171,7 @@ void tractionDisplacementCorrectionFvPatchVectorField::updateCoeffs()
const fvPatchField<symmTensor>& sigmaD =
patch().lookupPatchField<volSymmTensorField, symmTensor>("sigmaD");
const fvPatchField<tensor>& sigmaExp =
const fvPatchField<tensor>& sigmaExp =
patch().lookupPatchField<volTensorField, tensor>("sigmaExp");
gradient() =

3
applications/test/BSpline/Make/files
View File

@ -1,3 +0,0 @@
BSplineTest.C
EXE = $(FOAM_USER_APPBIN)/BSplineTest

69
applications/test/BSpline/test-splines
View File

@ -1,69 +0,0 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
(
// Upper body longitudinal splines.
(
(-0.22685 -0.01125166 0) // 7
(-0.21685 -0.01340204 0)
(-0.20685 -0.01529684 0)
(-0.19685 -0.01694748 0)
(-0.18685 -0.01836538 0)
(-0.17685 -0.01956197 0)
(-0.16685 -0.02054868 0)
(-0.15685 -0.02133693 0)
(-0.14685 -0.02193816 0)
(-0.13685 -0.02236377 0)
(-0.12685 -0.02262521 0)
(-0.11685 -0.02273389 0) // 2
)
(
(-0.22685 0 0.01125166) // 8
(-0.21685 0 0.01340204)
(-0.20685 0 0.01529684)
(-0.19685 0 0.01694748)
(-0.18685 0 0.01836538)
(-0.17685 0 0.01956197)
(-0.16685 0 0.02054868)
(-0.15685 0 0.02133693)
(-0.14685 0 0.02193816)
(-0.13685 0 0.02236377)
(-0.12685 0 0.02262521)
(-0.11685 0 0.02273389) // 3
)
(
(-0.22685 0.01125166 0) // 9
(-0.21685 0.01340204 0)
(-0.20685 0.01529684 0)
(-0.19685 0.01694748 0)
(-0.18685 0.01836538 0)
(-0.17685 0.01956197 0)
(-0.16685 0.02054868 0)
(-0.15685 0.02133693 0)
(-0.14685 0.02193816 0)
(-0.13685 0.02236377 0)
(-0.12685 0.02262521 0)
(-0.11685 0.02273389 0) // 4
)
(
(-0.22685 0 -0.01125166) // 6
(-0.21685 0 -0.01340204)
(-0.20685 0 -0.01529684)
(-0.19685 0 -0.01694748)
(-0.18685 0 -0.01836538)
(-0.17685 0 -0.01956197)
(-0.16685 0 -0.02054868)
(-0.15685 0 -0.02133693)
(-0.14685 0 -0.02193816)
(-0.13685 0 -0.02236377)
(-0.12685 0 -0.02262521)
(-0.11685 0 -0.02273389) // 1
)
);

10
applications/test/List/ListTest.C
View File

@ -47,11 +47,11 @@ using namespace Foam;
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validOptions.insert("reList", "reList");
argList::validOptions.insert("wordList", "wordList");
argList::validOptions.insert("stringList", "stringList");
argList::validOptions.insert("float", "xx");
argList::validOptions.insert("flag", "");
argList::addOption("reList", "reList");
argList::addOption("wordList", "wordList");
argList::addOption("stringList", "stringList");
argList::addOption("float", "xx");
argList::addBoolOption("flag");
# include "setRootCase.H"

10
applications/test/PackedList/PackedListTest.C
View File

@ -82,9 +82,13 @@ int main(int argc, char *argv[])
argList::noParallel();
argList::validArgs.insert("file .. fileN");
argList::validOptions.insert("mask", "");
argList::validOptions.insert("count", "");
argList::validOptions.insert("info", "");
argList::addBoolOption("mask", "report information about the bit masks");
argList::addBoolOption("count", "test the count() method");
argList::addBoolOption
(
"info",
"print an ascii representation of the storage"
);
argList args(argc, argv, false, true);

6
applications/test/PackedList1/PackedListTest1.C
View File

@ -58,9 +58,15 @@ int main(int argc, char *argv[])
list1.print(Info);
Info<< "\ntest set() with default argument (max_value)\n";
list1.set(1);
list1.set(3);
list1.print(Info);
Info<< "\ntest unset() with in-range and out-of-range\n";
list1.unset(3);
list1.unset(100000);
list1.print(Info);
Info<< "\ntest assign between references\n";
list1[2] = 3;
list1[4] = list1[2];

3
applications/test/PackedList3/Make/files Normal file
View File

@ -0,0 +1,3 @@
PackedListTest3.C
EXE = $(FOAM_USER_APPBIN)/PackedListTest3

0
applications/test/PackedList3/Make/options Normal file
View File

50
applications/test/BSpline/BSplineTest.C → applications/test/PackedList3/PackedListTest3.C
View File

@ -22,43 +22,51 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "argList.H"
Application
#include "vector.H"
#include "IFstream.H"
#include "BSpline.H"
Description
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "boolList.H"
#include "HashSet.H"
#include "StaticHashTable.H"
#include "cpuTime.H"
#include <vector>
#include "PackedList.H"
#include "PackedBoolList.H"
using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validArgs.insert("file .. fileN");
const label n = 100000000;
const label nReport = 1000000;
argList args(argc, argv, false, true);
cpuTime timer;
forAll(args.additionalArgs(), argI)
// test inserts
// PackedBoolList
PackedBoolList packed;
for (label i = 0; i < n; i++)
{
const string& srcFile = args.additionalArgs()[argI];
Info<< nl << "reading " << srcFile << nl;
IFstream ifs(srcFile);
List<pointField> splinePointFields(ifs);
forAll(splinePointFields, splineI)
if ((i % nReport) == 0 && i)
{
Info<<"convert " << splinePointFields[splineI] << " to bspline" << endl;
BSpline spl(splinePointFields[splineI], vector::zero, vector::zero);
Info<< "1/2 = " << spl.position(0.5) << endl;
Info<< "i:" << i << " in " << timer.cpuTimeIncrement() << " s"
<<endl;
}
packed[i] = 1;
}
Info<< "insert test: " << n << " elements in "
<< timer.cpuTimeIncrement() << " s\n\n";
Info << "\nEnd\n" << endl;
return 0;
}

3
applications/test/Polynomial/Make/files Normal file
View File

@ -0,0 +1,3 @@
PolynomialTest.C
EXE = $(FOAM_USER_APPBIN)/PolynomialTest

3
applications/test/Polynomial/Make/options Normal file
View File

@ -0,0 +1,3 @@
EXE_INC = \
EXE_LIBS = \

128
applications/test/Polynomial/PolynomialTest.C Normal file
View File

@ -0,0 +1,128 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-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
Application
PolynomialTest
Description
Test application for the templated Polynomial class
\*---------------------------------------------------------------------------*/
#include "IFstream.H"
#include "Polynomial.H"
#include "Random.H"
using namespace Foam;
scalar polyValue(const scalar x)
{
// Hard-coded polynomial 8 coeff (7th order)
return
0.11
+ 0.45*x
- 0.94*sqr(x)
+ 1.58*pow3(x)
- 2.58*pow4(x)
+ 0.08*pow5(x)
+ 3.15*pow6(x)
- 4.78*x*pow6(x);
}
scalar intPolyValue(const scalar x)
{
// Hard-coded integrated form of above polynomial
return
0.11*x
+ 0.45/2.0*sqr(x)
- 0.94/3.0*pow3(x)
+ 1.58/4.0*pow4(x)
- 2.58/5.0*pow5(x)
+ 0.08/6.0*pow6(x)
+ 3.15/7.0*x*pow6(x)
- 4.78/8.0*x*x*pow6(x);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
int main(int argc, char *argv[])
{
IFstream is("polyTestInput");
Polynomial<8> poly("testPoly", is);
Polynomial<9> intPoly(poly.integrate(0.0));
Info<< "poly = " << poly << endl;
Info<< "intPoly = " << intPoly << nl << endl;
Info<< "2*poly = " << 2*poly << endl;
Info<< "poly+poly = " << poly + poly << nl << endl;
Info<< "3*poly = " << 3*poly << endl;
Info<< "poly+poly+poly = " << poly + poly + poly << nl << endl;
Info<< "3*poly - 2*poly = " << 3*poly - 2*poly << nl << endl;
Polynomial<8> polyCopy = poly;
Info<< "poly, polyCopy = " << poly << ", " << polyCopy << nl << endl;
polyCopy = 2.5*poly;
Info<< "2.5*polyCopy = " << polyCopy << nl << endl;
Random rnd(123456);
for (int i=0; i<10; i++)
{
scalar x = rnd.scalar01()*100;
scalar px = polyValue(x);
scalar ipx = intPolyValue(x);
scalar pxTest = poly.evaluate(x);
scalar ipxTest = intPoly.evaluate(x);
Info<<"\nx = " << x << endl;
Info<< " px, pxTest = " << px << ", " << pxTest << endl;
Info<< " ipx, ipxTest = " << ipx << ", " << ipxTest << endl;
if (mag(px - pxTest) > SMALL)
{
Info<< " *** WARNING: px != pxTest: " << px - pxTest << endl;
}
if (mag(ipx - ipxTest) > SMALL)
{
Info<< " *** WARNING: ipx != ipxTest: " << ipx - ipxTest << endl;
}
Info<< endl;
}
Info<< nl << "Done." << endl;
return 0;
}
// ************************************************************************* //

11
applications/test/Polynomial/polyTestInput Normal file
View File

@ -0,0 +1,11 @@
testPoly
(
0.11
0.45
-0.94
1.58
-2.58
0.08
3.15
-4.78
)

5
applications/test/dictionary/Make/files
View File

@ -1,4 +1,7 @@
calcEntry/calcEntry.C
dictionaryTest.C
calcEntry/calcEntry.C
calcEntry/calcEntryParser.cpp
calcEntry/calcEntryScanner.cpp
EXE = $(FOAM_USER_APPBIN)/dictionaryTest

141
applications/test/dictionary/calcEntry/CocoParserErrors.H Normal file
View File

@ -0,0 +1,141 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Class
Foam::CocoParserErrors
Description
Templated class to shadow the error handling for Coco/R parsers
\*---------------------------------------------------------------------------*/
#ifndef CocoParserErrors_H
#define CocoParserErrors_H
#include "error.H"
#include "wchar.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class CocoParserErrors Declaration
\*---------------------------------------------------------------------------*/
template<class BaseClass>
class CocoParserErrors
:
public BaseClass
{
// Private data
//- The name issued in warnings and errors
word name_;
public:
// Constructors
//- Construct with given name
CocoParserErrors(const word& name)
:
BaseClass(),
name_(name)
{}
//- Destructor
virtual ~CocoParserErrors()
{}
// Member functions
//- Return the name issued for warnings
virtual const word& name() const
{
return name_;
}
//- Return the name issued for warnings
virtual word& name()
{
return name_;
}
// Error Handling
//- Handle a general warning 'msg'
virtual void Warning(const wchar_t* msg)
{
WarningIn(name_)
<< msg << endl;
}
//- Handle a general warning 'msg'
virtual void Warning(int line, int col, const wchar_t* msg)
{
WarningIn(name_)
<<"line " << line << " col " << col << ": "
<< msg << endl;
}
//- Handle general error 'msg' (eg, a semantic error)
virtual void Error(int line, int col, const wchar_t* msg)
{
FatalErrorIn(name_)
<< "line " << line << " col " << col <<": " << msg << endl
<< exit(FatalError);
}
//- Handle general error 'msg' (eg, a semantic error)
virtual void Error(const wchar_t* msg)
{
FatalErrorIn(name_)
<< msg << endl
<< exit(FatalError);
}
//- Handle a general exception 'msg'
virtual void Exception(const wchar_t* msg)
{
this->Error(msg);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

225
applications/test/dictionary/calcEntry/SimpleCalc.atg Normal file
View File

@ -0,0 +1,225 @@
/*-------------------------------------------------------------------------
compile with:
Coco \
-frames $WM_THIRD_PARTY_DIR/coco-r \
-prefix calcEntry \
-namespace Foam::functionEntries::calcEntryInternal \
SimpleCalc.atg
-------------------------------------------------------------------------*/
#include "dictionary.H"
#include "scalar.H"
#include "error.H"
#include "wchar.H"
COMPILER SimpleCalc
// Simple four function calculator for OpenFOAM dictionaries
//! with debug
static const int debug = 0;
//! The parent dictionary
mutable dictionary* dict_;
//! The calculation result
scalar val;
//! token -> scalar
scalar getScalar() const
{
return coco_string_toDouble(t->val);
}
//! token -> string
std::string getString() const
{
char* str = coco_string_create_char(t->val);
std::string s(str);
coco_string_delete(str);
return s;
}
//! attach a dictionary
void dict(const dictionary& dict) const
{
dict_ = const_cast<dictionary*>(&dict);
}
//! lookup dictionary entry
scalar getDictLookup() const
{
scalar dictValue = 0;
if (!dict_)
{
FatalErrorIn
(
"SimpleCalc::getDictEntry() const"
) << "No dictionary attached!"
<< exit(FatalError);
return 0;
}
char* chars = coco_string_create_char
(
t->val,
1,
(coco_string_length(t->val) - 1)
);
word keyword(chars);
coco_string_delete(chars);
if (debug)
{
Info<<"lookup: " << keyword << nl;
}
entry* entryPtr = dict_->lookupEntryPtr(keyword, true, false);
if (entryPtr && !entryPtr->isDict())
{
entryPtr->stream() >> dictValue;
}
else
{
FatalErrorIn
(
"SimpleCalc::getDictEntry() const"
) << "keyword " << keyword << " is undefined in dictionary "
<< exit(FatalError);
}
return dictValue;
}
scalar Result() const
{
return val;
}
// * * * * * * * * * * * * * * * CHARACTERS * * * * * * * * * * * * * * * * //
CHARACTERS
letter = 'A'..'Z' + 'a'..'z'.
qualifier = '_' + ':'.
dollar = '$'.
digit = "0123456789".
sign = '+' + '-'.
cr = '\r'.
lf = '\n'.
tab = '\t'.
stringCh = ANY - '"' - '\\' - cr - lf.
printable = '\u0020' .. '\u007e'.
// * * * * * * * * * * * * * * * * TOKENS * * * * * * * * * * * * * * * * * //
TOKENS
// identifier
ident =
letter { letter | digit | qualifier }.
// string
string =
'"' { stringCh | '\\' printable } '"'.
// dictionary lookup identifier
// starts with '$' and otherwise limited to a normal indentifier
variable =
dollar letter { letter | digit | qualifier }.
// floating point and integer numbers
number =
[sign] ('.' digit { digit } ) | ( digit { digit } [ '.' { digit } ])
[ ('E' | 'e') [sign] digit { digit } ].
// * * * * * * * * * * * PRAGMAS / COMMENTS / IGNORE * * * * * * * * * * * //
COMMENTS FROM "/*" TO "*/" NESTED
COMMENTS FROM "//" TO lf
// ignore unprintables
IGNORE ANY - printable
// * * * * * * * * * * * * * * * PRODUCTIONS * * * * * * * * * * * * * * * //
PRODUCTIONS
SimpleCalc (. val = 0;
if (debug){Info<<"start val"<< nl;}
.)
=
( '{' Expr<val> '}' | Expr<val> )
EOF
.
/*---------------------------------------------------------------------------*/
Expr<scalar& val> (. scalar val2 = 0;
if (debug) {Info<<"Expr:"<< val<< nl;}
.)
=
Term<val>
{
"+" Term<val2> (. if (debug) {Info<<"+Term:"<<val2 <<nl;}
val += val2;
if (debug) {Info<<"="<< val << nl;}
.)
| "-" Term<val2> (. if (debug) {Info<<"-Term:"<<val2 <<nl;}
val -= val2;
if (debug) {Info<<"="<< val << nl;}
.)
}
.
/*---------------------------------------------------------------------------*/
Term<scalar& val> (. scalar val2 = 0;
if (debug) {Info<<"Term:"<< val<< nl;}
.)
=
Factor<val>
{
"*" Factor<val2> (. if (debug) {Info<<"*Factor:"<<val2 << nl;}
val *= val2;
if (debug) {Info<<"="<< val << nl; }
.)
| "/" Factor<val2> (. if (debug) {Info<<"/Factor:"<<val2 << nl;}
val /= val2;
if (debug) {Info<<"="<< val << nl; }
.)
}
.
/*---------------------------------------------------------------------------*/
Factor<scalar& val>
=
variable (. val = getDictLookup();
if (debug) {Info<<"lookup:"<<val<<nl;}
.)
| number (. val = getScalar();
if (debug) {Info<<"got num:"<<val<<nl;}
.)
| '-' '(' Expr<val> ')' (. val = -val;
if (debug) {Info<<"inv:"<<val<<nl;}
.)
| '(' Expr<val> ')' (. if (debug){Info<<"got Expr:"<<val<<nl;} .)
.
/*---------------------------------------------------------------------------*/
END SimpleCalc.
// ************************************************************************* //

11
applications/test/dictionary/calcEntry/build.sh Executable file
View File

@ -0,0 +1,11 @@
#/bin/sh
cd ${0%/*} || exit 1 # run from this directory
# this will have to do until we make a makefile rule
Coco \
-frames $WM_THIRD_PARTY_DIR/coco-r \
-prefix calcEntry \
-namespace Foam::functionEntries::calcEntryInternal \
SimpleCalc.atg

125
applications/test/dictionary/calcEntry/calcEntry.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -30,6 +30,10 @@ License
#include "OStringStream.H"
#include "addToMemberFunctionSelectionTable.H"
#include "ISstream.H"
#include "CocoParserErrors.H"
#include "calcEntryParser.h"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
@ -56,14 +60,121 @@ bool Foam::functionEntries::calcEntry::execute
(
const dictionary& parentDict,
primitiveEntry& entry,
Istream& is
Istream& istr
)
{
dictionary args(parentDict, is);
OStringStream resultStream;
resultStream
<< (args.lookup("x")[0].number() + args.lookup("y")[0].number());
entry.read(parentDict, IStringStream(resultStream.str())());
static const int maxLen = 1024;
static const int errLen = 80; // truncate error message for readability
static char buf[maxLen];
ISstream& is = dynamicCast<ISstream>(istr);
// get the { ... } argument without the enclosing brace brackets
//
// THIS NEEDS REWORKING (LATER) ...
char c = 0;
if (!is.read(c).good() || c != token::BEGIN_BLOCK)
{
is.setBad();
FatalIOErrorIn("functionEntries::calcEntry::execute()", is)
<< "Expected a '" << token::BEGIN_BLOCK
<< "', found '" << c << "'" << exit(FatalIOError);
return false;
}
register int nChar = 0;
buf[nChar++] = token::BEGIN_BLOCK;
int listDepth = 1; // already saw the first '{'
while (is.get(c).good())
{
buf[nChar++] = c;
if (nChar == maxLen)
{
buf[errLen] = '\0';
FatalIOErrorIn("functionEntries::calcEntry::execute()", is)
<< "argument \"" << buf << "...\"\n"
<< " is too long (max. " << maxLen << " characters)"
<< exit(FatalIOError);
return false;
}
// handle nested blocks, even if we don't know what they'd
// be useful for
if (c == token::BEGIN_BLOCK)
{
++listDepth;
}
else if (c == token::END_BLOCK)
{
if (--listDepth == 0)
{
// done reading - overwrite the final '}'
// --nChar;
break;
}
}
}
buf[nChar] = '\0';
// emit some info
Info<< "grabbed " << nChar << " characters:" << nl
<< "----------\n"
<< buf << nl
<< "----------\n"
<< nl;
// define parser error handler
CocoParserErrors<calcEntryInternal::Errors>
myErrorHandler("calcEntry::Parser--");
calcEntryInternal::Scanner scanner(buf, nChar);
calcEntryInternal::Parser parser(&scanner, &myErrorHandler);
// Attach dictionary context
parser.dict(parentDict);
parser.Parse();
// Info<<"got: " << parser.Result() << endl;
tokenList tokens(2);
tokens[0] = parser.Result();
tokens[1] = token::END_STATEMENT;
// Info<<"tokens[0] = " << tokens[0].info() <<nl;
// Info<<"tokens[1] = " << tokens[1].info() <<nl;
//
// {
// const tokenList& toks = entry;
//
// forAll(toks, tokI)
// {
// Info<< tokI <<":= " << toks[tokI].info() << endl;
// }
// }
ITstream its("ParserResult", tokens);
entry.read(parentDict, its);
// Info<< "size: " << entry.size() << endl;
// entry = newente;
// entry.print(Info);
/// const tokenList& toks = entry;
///
/// forAll(toks, tokI)
/// {
/// Info<< tokI <<":= " << toks[tokI].info() << endl;
/// }
///
return true;
}

6
applications/test/dictionary/calcEntry/calcEntry.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,6 +26,8 @@ Class
Foam::functionEntries::calcEntry
Description
This dictionary function entry may or may not do anything particularly
useful - depending upon what is currently being used to test.
SourceFiles
calcEntry.C
@ -45,7 +47,7 @@ namespace functionEntries
{
/*---------------------------------------------------------------------------*\
Class calcEntry Declaration
Class calcEntry Declaration
\*---------------------------------------------------------------------------*/
class calcEntry

324
applications/test/dictionary/calcEntry/calcEntryParser.cpp Normal file
View File

@ -0,0 +1,324 @@
#include <wchar.h>
#include "calcEntryParser.h"
namespace Foam {
namespace functionEntries {
namespace calcEntryInternal {
// ----------------------------------------------------------------------------
// Parser Implementation
// ----------------------------------------------------------------------------
void Parser::SynErr(int n) {
if (errDist >= minErrDist) errors->SynErr(la->line, la->col, n);
errDist = 0;
}
void Parser::SemErr(const wchar_t* msg) {
if (errDist >= minErrDist) errors->Error(t->line, t->col, msg);
errDist = 0;
}
void Parser::Get() {
for (;;) {
t = la;
la = scanner->Scan();
if (la->kind <= maxT) {
++errDist;
break;
}
if (dummyToken != t) {
dummyToken->kind = t->kind;
dummyToken->pos = t->pos;
dummyToken->col = t->col;
dummyToken->line = t->line;
dummyToken->next = NULL;
coco_string_delete(dummyToken->val);
dummyToken->val = coco_string_create(t->val);
t = dummyToken;
}
la = t;
}
}
void Parser::Expect(int n) {
if (la->kind == n) {
Get();
}
else {
SynErr(n);
}
}
void Parser::ExpectWeak(int n, int follow) {
if (la->kind == n) {
Get();
}
else {
SynErr(n);
while (!StartOf(follow)) {
Get();
}
}
}
bool Parser::WeakSeparator(int n, int syFol, int repFol) {
if (la->kind == n) {
Get();
return true;
}
else if (StartOf(repFol)) {
return false;
}
else {
SynErr(n);
while (!(StartOf(syFol) || StartOf(repFol) || StartOf(0))) {
Get();
}
return StartOf(syFol);
}
}
void Parser::SimpleCalc() {
val = 0;
if (debug){Info<<"start val"<< nl;}
if (la->kind == 5) {
Get();
Expr(val);
Expect(6);
} else if (StartOf(1)) {
Expr(val);
} else SynErr(14);
Expect(0);
}
void Parser::Expr(scalar& val) {
scalar val2 = 0;
if (debug) {Info<<"Expr:"<< val<< nl;}
Term(val);
while (la->kind == 7 || la->kind == 8) {
if (la->kind == 7) {
Get();
Term(val2);
if (debug) {Info<<"+Term:"<<val2 <<nl;}
val += val2;
if (debug) {Info<<"="<< val << nl;}
} else {
Get();
Term(val2);
if (debug) {Info<<"-Term:"<<val2 <<nl;}
val -= val2;
if (debug) {Info<<"="<< val << nl;}
}
}
}
void Parser::Term(scalar& val) {
scalar val2 = 0;
if (debug) {Info<<"Term:"<< val<< nl;}
Factor(val);
while (la->kind == 9 || la->kind == 10) {
if (la->kind == 9) {
Get();
Factor(val2);
if (debug) {Info<<"*Factor:"<<val2 << nl;}
val *= val2;
if (debug) {Info<<"="<< val << nl; }
} else {
Get();
Factor(val2);
if (debug) {Info<<"/Factor:"<<val2 << nl;}
val /= val2;
if (debug) {Info<<"="<< val << nl; }
}
}
}
void Parser::Factor(scalar& val) {
if (la->kind == 3) {
Get();
val = getDictLookup();
if (debug) {Info<<"lookup:"<<val<<nl;}
} else if (la->kind == 4) {
Get();
val = getScalar();
if (debug) {Info<<"got num:"<<val<<nl;}
} else if (la->kind == 8) {
Get();
Expect(11);
Expr(val);
Expect(12);
val = -val;
if (debug) {Info<<"inv:"<<val<<nl;}
} else if (la->kind == 11) {
Get();
Expr(val);
Expect(12);
if (debug){Info<<"got Expr:"<<val<<nl;}
} else SynErr(15);
}
void Parser::Parse() {
t = NULL;
if (dummyToken) { // safety: someone might call Parse() twice
delete dummyToken;
}
la = dummyToken = new Token();
la->val = coco_string_create(L"Dummy Token");
Get();
SimpleCalc();
Expect(0);
}
Parser::Parser(Scanner* scan, Errors* err)
:
dummyToken(NULL),
deleteErrorsDestruct_(!err),
minErrDist(2),
errDist(minErrDist),
scanner(scan),
errors(err),
t(NULL),
la(NULL)
{
maxT = 13;
if (!errors) { // add in default error handling
errors = new Errors();
}
}
bool Parser::StartOf(int s) {
const bool T = true;
const bool x = false;
static bool set[2][15] = {
{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
{x,x,x,T, T,x,x,x, T,x,x,T, x,x,x}
};
return set[s][la->kind];
}
Parser::~Parser() {
if (deleteErrorsDestruct_) { // delete default error handling
delete errors;
}
delete dummyToken;
}
// ----------------------------------------------------------------------------
// Errors Implementation
// ----------------------------------------------------------------------------
Errors::Errors()
:
count(0)
{}
Errors::~Errors()
{}
void Errors::clear() {
count = 0;
}
wchar_t* Errors::strerror(int n)
{
wchar_t* s;
switch (n) {
case 0: s = coco_string_create(L"EOF expected"); break;
case 1: s = coco_string_create(L"ident expected"); break;
case 2: s = coco_string_create(L"string expected"); break;
case 3: s = coco_string_create(L"variable expected"); break;
case 4: s = coco_string_create(L"number expected"); break;
case 5: s = coco_string_create(L"\"{\" expected"); break;
case 6: s = coco_string_create(L"\"}\" expected"); break;
case 7: s = coco_string_create(L"\"+\" expected"); break;
case 8: s = coco_string_create(L"\"-\" expected"); break;
case 9: s = coco_string_create(L"\"*\" expected"); break;
case 10: s = coco_string_create(L"\"/\" expected"); break;
case 11: s = coco_string_create(L"\"(\" expected"); break;
case 12: s = coco_string_create(L"\")\" expected"); break;
case 13: s = coco_string_create(L"??? expected"); break;
case 14: s = coco_string_create(L"invalid SimpleCalc"); break;
case 15: s = coco_string_create(L"invalid Factor"); break;
default:
{
wchar_t format[20];
coco_swprintf(format, 20, L"error %d", n);
s = coco_string_create(format);
}
break;
}
return s;
}
void Errors::Warning(const wchar_t* msg) {
wprintf(L"%ls\n", msg);
}
void Errors::Warning(int line, int col, const wchar_t* msg) {
wprintf(L"-- line %d col %d: %ls\n", line, col, msg);
}
void Errors::Error(int line, int col, const wchar_t* msg) {
wprintf(L"-- line %d col %d: %ls\n", line, col, msg);
count++;
}
void Errors::SynErr(int line, int col, int n) {
wchar_t* msg = this->strerror(n);
this->Error(line, col, msg);
coco_string_delete(msg);
}
void Errors::Exception(const wchar_t* msg) {
wprintf(L"%ls", msg);
::exit(1);
}
} // namespace
} // namespace
} // namespace

192
applications/test/dictionary/calcEntry/calcEntryParser.h Normal file
View File

@ -0,0 +1,192 @@
#ifndef COCO_calcEntryPARSER_H__
#define COCO_calcEntryPARSER_H__
#include "dictionary.H"
#include "scalar.H"
#include "error.H"
#include "wchar.H"
#include "calcEntryScanner.h"
namespace Foam {
namespace functionEntries {
namespace calcEntryInternal {
//! Parser error handing
class Errors {
public:
int count; //!< The number of errors detected
//! Allocate and return a string describing the given error code.
/** It is the responsibility of the caller to free this string,
* eg, with coco_string_delete()
*/
static wchar_t* strerror(int n);
Errors(); //!< Construct null - start with no errors
virtual ~Errors(); //!< Destructor
virtual void clear(); //!< Clear the error count
//! Handle a general warning 'msg'
virtual void Warning(const wchar_t* msg);
//! Handle a general warning 'msg'
virtual void Warning(int line, int col, const wchar_t* msg);
//! Handle general error 'msg' (eg, a semantic error)
virtual void Error(int line, int col, const wchar_t* msg);
//! Handle syntax error 'n', uses strerror for the message, calls Error()
virtual void SynErr(int line, int col, int n);
//! Handle a general exception 'msg'
virtual void Exception(const wchar_t* msg);
}; // Errors
//! A Coco/R Parser
class Parser {
private:
enum {
_EOF=0,
_ident=1,
_string=2,
_variable=3,
_number=4,
};
int maxT;
Token *dummyToken;
bool deleteErrorsDestruct_; //!< delete the 'errors' member in destructor
int minErrDist;
int errDist;
void SynErr(int n); //!< Handle syntax error 'n'
void Get();
void Expect(int n);
bool StartOf(int s);
void ExpectWeak(int n, int follow);
bool WeakSeparator(int n, int syFol, int repFol);
public:
Scanner *scanner;
Errors *errors;
Token *t; //!< last recognized token
Token *la; //!< lookahead token
static const int debug = 0;
//! The parent dictionary
mutable dictionary* dict_;
//! The calculation result
scalar val;
//! token -> scalar
scalar getScalar() const
{
return coco_string_toDouble(t->val);
}
//! token -> string
std::string getString() const
{
char* str = coco_string_create_char(t->val);
std::string s(str);
coco_string_delete(str);
return s;
}
//! attach a dictionary
void dict(const dictionary& dict) const
{
dict_ = const_cast<dictionary*>(&dict);
}
//! lookup dictionary entry
scalar getDictLookup() const
{
scalar dictValue = 0;
if (!dict_)
{
FatalErrorIn
(
"SimpleCalc::getDictEntry() const"
) << "No dictionary attached!"
<< exit(FatalError);
return 0;
}
char* chars = coco_string_create_char
(
t->val,
1,
(coco_string_length(t->val) - 1)
);
word keyword(chars);
coco_string_delete(chars);
if (debug)
{
Info<<"lookup: " << keyword << nl;
}
entry* entryPtr = dict_->lookupEntryPtr(keyword, true, false);
if (entryPtr && !entryPtr->isDict())
{
entryPtr->stream() >> dictValue;
}
else
{
FatalErrorIn
(
"SimpleCalc::getDictEntry() const"
) << "keyword " << keyword << " is undefined in dictionary "
<< exit(FatalError);
}
return dictValue;
}
scalar Result() const
{
return val;
}
// * * * * * * * * * * * * * * * CHARACTERS * * * * * * * * * * * * * * * * //
//! Construct for the specified scanner
/**
* Use the default error handling, or optionally provide an error
* handler, which will not be deleted upon destruction.
*/
Parser(Scanner* scan, Errors* err = 0);
~Parser(); //!< Destructor - cleanup errors and dummyToken
void SemErr(const wchar_t* msg); //!< Handle semantic error
void SimpleCalc();
void Expr(scalar& val);
void Term(scalar& val);
void Factor(scalar& val);
void Parse(); //!< Execute the parse operation
}; // end Parser
} // namespace
} // namespace
} // namespace
#endif // COCO_calcEntryPARSER_H__

825
applications/test/dictionary/calcEntry/calcEntryScanner.cpp Normal file
View File

@ -0,0 +1,825 @@
#include <memory.h>
#include <string.h>
#include "calcEntryScanner.h"
namespace Foam {
namespace functionEntries {
namespace calcEntryInternal {
// * * * * * * * * * * Wide Character String Routines * * * * * * * * * * * //
// string handling, wide character
wchar_t* coco_string_create(const wchar_t* str) {
int len = coco_string_length(str);
wchar_t* dest = new wchar_t[len + 1];
if (len) {
wcsncpy(dest, str, len);
}
dest[len] = 0;
return dest;
}
wchar_t* coco_string_create(const wchar_t* str, int index, int length) {
int len = coco_string_length(str);
if (len) {
len = length;
}
wchar_t* dest = new wchar_t[len + 1];
if (len) {
wcsncpy(dest, &(str[index]), len);
}
dest[len] = 0;
return dest;
}
wchar_t* coco_string_create_upper(const wchar_t* str) {
if (!str) { return NULL; }
return coco_string_create_upper(str, 0, wcslen(str));
}
wchar_t* coco_string_create_upper(const wchar_t* str, int index, int len) {
if (!str) { return NULL; }
wchar_t* dest = new wchar_t[len + 1];
for (int i = 0; i < len; i++) {
const wchar_t ch = str[index + i];
if ((L'a' <= ch) && (ch <= L'z')) {
dest[i] = ch + (L'A' - L'a');
}
else {
dest[i] = ch;
}
}
dest[len] = L'\0';
return dest;
}
wchar_t* coco_string_create_lower(const wchar_t* str) {
if (!str) { return NULL; }
return coco_string_create_lower(str, 0, wcslen(str));
}
wchar_t* coco_string_create_lower(const wchar_t* str, int index, int len) {
if (!str) { return NULL; }
wchar_t* dest = new wchar_t[len + 1];
for (int i = 0; i < len; i++) {
const wchar_t ch = str[index + i];
if ((L'A' <= ch) && (ch <= L'Z')) {
dest[i] = ch - (L'A' - L'a');
}
else {
dest[i] = ch;
}
}
dest[len] = L'\0';
return dest;
}
wchar_t* coco_string_create_append(const wchar_t* str1, const wchar_t* str2) {
int str1Len = coco_string_length(str1);
int str2Len = coco_string_length(str2);
wchar_t* dest = new wchar_t[str1Len + str2Len + 1];
if (str1Len) { wcscpy(dest, str1); }
if (str2Len) { wcscpy(dest + str1Len, str2); }
dest[str1Len + str2Len] = 0;
return dest;
}
wchar_t* coco_string_create_append(const wchar_t* str1, const wchar_t ch) {
int len = coco_string_length(str1);
wchar_t* dest = new wchar_t[len + 2];
wcsncpy(dest, str1, len); // or use if (len) { wcscpy(dest, str1); }
dest[len] = ch;
dest[len + 1] = 0;
return dest;
}
void coco_string_delete(wchar_t* &str) {
delete [] str;
str = NULL;
}
int coco_string_length(const wchar_t* str) {
return str ? wcslen(str) : 0;
}
bool coco_string_endswith(const wchar_t* str, const wchar_t* endstr) {
int strLen = wcslen(str);
int endLen = wcslen(endstr);
return (endLen <= strLen) && (wcscmp(str + strLen - endLen, endstr) == 0);
}
int coco_string_indexof(const wchar_t* str, const wchar_t ch) {
const wchar_t* fnd = wcschr(str, ch);
return fnd ? (fnd - str) : -1;
}
int coco_string_lastindexof(const wchar_t* str, const wchar_t ch) {
const wchar_t* fnd = wcsrchr(str, ch);
return fnd ? (fnd - str) : -1;
}
void coco_string_merge(wchar_t* &dest, const wchar_t* str) {
if (!str) { return; }
wchar_t* newstr = coco_string_create_append(dest, str);
delete [] dest;
dest = newstr;
}
bool coco_string_equal(const wchar_t* str1, const wchar_t* str2) {
return wcscmp(str1, str2) == 0;
}
int coco_string_compareto(const wchar_t* str1, const wchar_t* str2) {
return wcscmp(str1, str2);
}
int coco_string_hash(const wchar_t* str) {
int h = 0;
if (!str) { return 0; }
while (*str != 0) {
h = (h * 7) ^ *str;
++str;
}
if (h < 0) { h = -h; }
return h;
}
double coco_string_toDouble(const wchar_t* str)
{
return str ? wcstod(str, NULL) : 0;
}
float coco_string_toFloat(const wchar_t* str)
{
return str ? wcstof(str, NULL) : 0;
}
//
// string handling, byte character
//
wchar_t* coco_string_create(const char* str) {
int len = str ? strlen(str) : 0;
wchar_t* dest = new wchar_t[len + 1];
for (int i = 0; i < len; ++i) {
dest[i] = (wchar_t) str[i];
}
dest[len] = 0;
return dest;
}
wchar_t* coco_string_create(const char* str, int index, int length) {
int len = str ? length : 0;
wchar_t* dest = new wchar_t[len + 1];
for (int i = 0; i < len; ++i) {
dest[i] = (wchar_t) str[index + i];
}
dest[len] = 0;
return dest;
}
char* coco_string_create_char(const wchar_t* str) {
int len = coco_string_length(str);
char *dest = new char[len + 1];
for (int i = 0; i < len; ++i)
{
dest[i] = (char) str[i];
}
dest[len] = 0;
return dest;
}
char* coco_string_create_char(const wchar_t* str, int index, int length) {
int len = coco_string_length(str);
if (len) {
len = length;
}
char *dest = new char[len + 1];
for (int i = 0; i < len; ++i) {
dest[i] = (char) str[index + i];
}
dest[len] = 0;
return dest;
}
void coco_string_delete(char* &str) {
delete [] str;
str = NULL;
}
double coco_string_toDouble(const char* str)
{
return str ? strtod(str, NULL) : 0;
}
float coco_string_toFloat(const char* str)
{
return str ? strtof(str, NULL) : 0;
}
// * * * * * * * * * End of Wide Character String Routines * * * * * * * * * //
Token::Token()
:
kind(0),
pos(0),
col(0),
line(0),
val(NULL),
next(NULL)
{}
Token::~Token() {
coco_string_delete(val);
}
Buffer::Buffer(FILE* s, bool isUserStream) {
// ensure binary read on windows
#if _MSC_VER >= 1300
_setmode(_fileno(s), _O_BINARY);
#endif
stream = s; this->isUserStream = isUserStream;
if (CanSeek()) {
fseek(s, 0, SEEK_END);
fileLen = ftell(s);
fseek(s, 0, SEEK_SET);
bufLen = (fileLen < MAX_BUFFER_LENGTH) ? fileLen : MAX_BUFFER_LENGTH;
bufStart = INT_MAX; // nothing in the buffer so far
}
else {
fileLen = bufLen = bufStart = 0;
}
bufCapacity = (bufLen > 0) ? bufLen : MIN_BUFFER_LENGTH;
buf = new unsigned char[bufCapacity];
if (fileLen > 0) SetPos(0); // setup buffer to position 0 (start)
else bufPos = 0; // index 0 is already after the file, thus Pos = 0 is invalid
if (bufLen == fileLen && CanSeek()) Close();
}
Buffer::Buffer(Buffer* b) {
buf = b->buf;
bufCapacity = b->bufCapacity;
b->buf = NULL;
bufStart = b->bufStart;
bufLen = b->bufLen;
fileLen = b->fileLen;
bufPos = b->bufPos;
stream = b->stream;
b->stream = NULL;
isUserStream = b->isUserStream;
}
Buffer::Buffer(const unsigned char* buf, int len) {
this->buf = new unsigned char[len];
memcpy(this->buf, buf, len*sizeof(unsigned char));
bufStart = 0;
bufCapacity = bufLen = len;
fileLen = len;
bufPos = 0;
stream = NULL;
}
Buffer::Buffer(const char* buf, int len) {
this->buf = new unsigned char[len];
memcpy(this->buf, buf, len*sizeof(unsigned char));
bufStart = 0;
bufCapacity = bufLen = len;
fileLen = len;
bufPos = 0;
stream = NULL;
}
Buffer::~Buffer() {
Close();
if (buf != NULL) {
delete [] buf;
buf = NULL;
}
}
void Buffer::Close() {
if (!isUserStream && stream != NULL) {
fclose(stream);
stream = NULL;
}
}
int Buffer::Read() {
if (bufPos < bufLen) {
return buf[bufPos++];
} else if (GetPos() < fileLen) {
SetPos(GetPos()); // shift buffer start to Pos
return buf[bufPos++];
} else if ((stream != NULL) && !CanSeek() && (ReadNextStreamChunk() > 0)) {
return buf[bufPos++];
} else {
return EoF;
}
}
int Buffer::Peek() {
int curPos = GetPos();
int ch = Read();
SetPos(curPos);
return ch;
}
wchar_t* Buffer::GetString(int beg, int end) {
int len = 0;
wchar_t *buf = new wchar_t[end - beg];
int oldPos = GetPos();
SetPos(beg);
while (GetPos() < end) buf[len++] = (wchar_t) Read();
SetPos(oldPos);
wchar_t *res = coco_string_create(buf, 0, len);
coco_string_delete(buf);
return res;
}
int Buffer::GetPos() {
return bufPos + bufStart;
}
void Buffer::SetPos(int value) {
if ((value >= fileLen) && (stream != NULL) && !CanSeek()) {
// Wanted position is after buffer and the stream
// is not seek-able e.g. network or console,
// thus we have to read the stream manually till
// the wanted position is in sight.
while ((value >= fileLen) && (ReadNextStreamChunk() > 0))
{}
}
if ((value < 0) || (value > fileLen)) {
wprintf(L"--- buffer out of bounds access, position: %d\n", value);
::exit(1);
}
if ((value >= bufStart) && (value < (bufStart + bufLen))) { // already in buffer
bufPos = value - bufStart;
} else if (stream != NULL) { // must be swapped in
fseek(stream, value, SEEK_SET);
bufLen = fread(buf, sizeof(unsigned char), bufCapacity, stream);
bufStart = value; bufPos = 0;
} else {
bufPos = fileLen - bufStart; // make Pos return fileLen
}
}
// Read the next chunk of bytes from the stream, increases the buffer
// if needed and updates the fields fileLen and bufLen.
// Returns the number of bytes read.
int Buffer::ReadNextStreamChunk() {
int freeLen = bufCapacity - bufLen;
if (freeLen == 0) {
// in the case of a growing input stream
// we can neither seek in the stream, nor can we
// foresee the maximum length, thus we must adapt
// the buffer size on demand.
bufCapacity = bufLen * 2;
unsigned char *newBuf = new unsigned char[bufCapacity];
memcpy(newBuf, buf, bufLen*sizeof(unsigned char));
delete [] buf;
buf = newBuf;
freeLen = bufLen;
}
int read = fread(buf + bufLen, sizeof(unsigned char), freeLen, stream);
if (read > 0) {
fileLen = bufLen = (bufLen + read);
return read;
}
// end of stream reached
return 0;
}
bool Buffer::CanSeek() {
return (stream != NULL) && (ftell(stream) != -1);
}
int UTF8Buffer::Read() {
int ch;
do {
ch = Buffer::Read();
// until we find a utf8 start (0xxxxxxx or 11xxxxxx)
} while ((ch >= 128) && ((ch & 0xC0) != 0xC0) && (ch != EoF));
if (ch < 128 || ch == EoF) {
// nothing to do, first 127 chars are the same in ascii and utf8
// 0xxxxxxx or end of file character
} else if ((ch & 0xF0) == 0xF0) {
// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
int c1 = ch & 0x07; ch = Buffer::Read();
int c2 = ch & 0x3F; ch = Buffer::Read();
int c3 = ch & 0x3F; ch = Buffer::Read();
int c4 = ch & 0x3F;
ch = (((((c1 << 6) | c2) << 6) | c3) << 6) | c4;
} else if ((ch & 0xE0) == 0xE0) {
// 1110xxxx 10xxxxxx 10xxxxxx
int c1 = ch & 0x0F; ch = Buffer::Read();
int c2 = ch & 0x3F; ch = Buffer::Read();
int c3 = ch & 0x3F;
ch = (((c1 << 6) | c2) << 6) | c3;
} else if ((ch & 0xC0) == 0xC0) {
// 110xxxxx 10xxxxxx
int c1 = ch & 0x1F; ch = Buffer::Read();
int c2 = ch & 0x3F;
ch = (c1 << 6) | c2;
}
return ch;
}
Scanner::Scanner(const unsigned char* buf, int len) {
buffer = new Buffer(buf, len);
Init();
}
Scanner::Scanner(const char* buf, int len) {
buffer = new Buffer(buf, len);
Init();
}
Scanner::Scanner(const wchar_t* fileName) {
FILE* stream;
char *chFileName = coco_string_create_char(fileName);
if ((stream = fopen(chFileName, "rb")) == NULL) {
wprintf(L"--- Cannot open file %ls\n", fileName);
::exit(1);
}
coco_string_delete(chFileName);
buffer = new Buffer(stream, false);
Init();
}
Scanner::Scanner(FILE* s) {
buffer = new Buffer(s, true);
Init();
}
Scanner::~Scanner() {
char* cur = (char*) firstHeap;
while (cur != NULL) {
cur = *(char**) (cur + HEAP_BLOCK_SIZE);
free(firstHeap);
firstHeap = cur;
}
delete [] tval;
delete buffer;
}
void Scanner::Init() {
maxT = 13;
noSym = 13;
int i;
for (i = 65; i <= 90; ++i) start.set(i, 1);
for (i = 97; i <= 122; ++i) start.set(i, 1);
for (i = 36; i <= 36; ++i) start.set(i, 5);
start.set(45, 20);
for (i = 48; i <= 57; ++i) start.set(i, 9);
start.set(34, 2);
start.set(46, 7);
start.set(123, 14);
start.set(125, 15);
start.set(43, 21);
start.set(42, 16);
start.set(47, 17);
start.set(40, 18);
start.set(41, 19);
start.set(Buffer::EoF, -1);
tvalLength = 128;
tval = new wchar_t[tvalLength]; // text of current token
// HEAP_BLOCK_SIZE byte heap + pointer to next heap block
heap = malloc(HEAP_BLOCK_SIZE + sizeof(void*));
firstHeap = heap;
heapEnd = (void**) (((char*) heap) + HEAP_BLOCK_SIZE);
*heapEnd = 0;
heapTop = heap;
if (sizeof(Token) > HEAP_BLOCK_SIZE) {
wprintf(L"--- Too small HEAP_BLOCK_SIZE\n");
::exit(1);
}
pos = -1; line = 1; col = 0;
oldEols = 0;
NextCh();
if (ch == 0xEF) { // check optional byte order mark for UTF-8
NextCh(); int ch1 = ch;
NextCh(); int ch2 = ch;
if (ch1 != 0xBB || ch2 != 0xBF) {
wprintf(L"Illegal byte order mark at start of file");
::exit(1);
}
Buffer *oldBuf = buffer;
buffer = new UTF8Buffer(buffer); col = 0;
delete oldBuf; oldBuf = NULL;
NextCh();
}
pt = tokens = CreateToken(); // first token is a dummy
}
void Scanner::NextCh() {
if (oldEols > 0) {
ch = EOL;
oldEols--;
}
else {
pos = buffer->GetPos();
ch = buffer->Read(); col++;
// replace isolated '\r' by '\n' in order to make
// eol handling uniform across Windows, Unix and Mac
if (ch == L'\r' && buffer->Peek() != L'\n') ch = EOL;
if (ch == EOL) { line++; col = 0; }
}
}
void Scanner::AddCh() {
if (tlen >= tvalLength) {
tvalLength *= 2;
wchar_t *newBuf = new wchar_t[tvalLength];
memcpy(newBuf, tval, tlen*sizeof(wchar_t));
delete [] tval;
tval = newBuf;
}
if (ch != Buffer::EoF) {
tval[tlen++] = ch;
NextCh();
}
}
bool Scanner::Comment0() {
int level = 1, pos0 = pos, line0 = line, col0 = col;
NextCh();
if (ch == L'/') {
NextCh();
for(;;) {
if (ch == 10) {
level--;
if (level == 0) { oldEols = line - line0; NextCh(); return true; }
NextCh();
} else if (ch == buffer->EoF) return false;
else NextCh();
}
} else {
buffer->SetPos(pos0); NextCh(); line = line0; col = col0;
}
return false;
}
bool Scanner::Comment1() {
int level = 1, pos0 = pos, line0 = line, col0 = col;
NextCh();
if (ch == L'*') {
NextCh();
for(;;) {
if (ch == L'*') {
NextCh();
if (ch == L'/') {
level--;
if (level == 0) { oldEols = line - line0; NextCh(); return true; }
NextCh();
}
} else if (ch == L'/') {
NextCh();
if (ch == L'*') {
level++; NextCh();
}
} else if (ch == buffer->EoF) return false;
else NextCh();
}
} else {
buffer->SetPos(pos0); NextCh(); line = line0; col = col0;
}
return false;
}
void Scanner::CreateHeapBlock() {
void* newHeap;
char* cur = (char*) firstHeap;
while (((char*) tokens < cur) || ((char*) tokens > (cur + HEAP_BLOCK_SIZE))) {
cur = *((char**) (cur + HEAP_BLOCK_SIZE));
free(firstHeap);
firstHeap = cur;
}
// HEAP_BLOCK_SIZE byte heap + pointer to next heap block
newHeap = malloc(HEAP_BLOCK_SIZE + sizeof(void*));
*heapEnd = newHeap;
heapEnd = (void**) (((char*) newHeap) + HEAP_BLOCK_SIZE);
*heapEnd = 0;
heap = newHeap;
heapTop = heap;
}
Token* Scanner::CreateToken() {
Token *t;
if (((char*) heapTop + (int) sizeof(Token)) >= (char*) heapEnd) {
CreateHeapBlock();
}
t = (Token*) heapTop;
heapTop = (void*) ((char*) heapTop + sizeof(Token));
t->val = NULL;
t->next = NULL;
return t;
}
void Scanner::AppendVal(Token *t) {
int reqMem = (tlen + 1) * sizeof(wchar_t);
if (((char*) heapTop + reqMem) >= (char*) heapEnd) {
if (reqMem > HEAP_BLOCK_SIZE) {
wprintf(L"--- Too long token value\n");
::exit(1);
}
CreateHeapBlock();
}
t->val = (wchar_t*) heapTop;
heapTop = (void*) ((char*) heapTop + reqMem);
wcsncpy(t->val, tval, tlen);
t->val[tlen] = L'\0';
}
Token* Scanner::NextToken() {
while (ch == ' ' ||
ch <= 31 || (ch >= 127 && ch <= 65535)
) NextCh();
if ((ch == L'/' && Comment0()) || (ch == L'/' && Comment1())) return NextToken();
t = CreateToken();
t->pos = pos; t->col = col; t->line = line;
int state = start.state(ch);
tlen = 0; AddCh();
switch (state) {
case -1: { t->kind = eofSym; break; } // NextCh already done
case 0: { t->kind = noSym; break; } // NextCh already done
case 1:
case_1:
if ((ch >= L'0' && ch <= L':') || (ch >= L'A' && ch <= L'Z') || ch == L'_' || (ch >= L'a' && ch <= L'z')) {AddCh(); goto case_1;}
else {t->kind = 1; break;}
case 2:
case_2:
if (ch <= 9 || (ch >= 11 && ch <= 12) || (ch >= 14 && ch <= L'!') || (ch >= L'#' && ch <= L'[') || (ch >= L']' && ch <= 65535)) {AddCh(); goto case_2;}
else if (ch == L'"') {AddCh(); goto case_4;}
else if (ch == 92) {AddCh(); goto case_3;}
else {t->kind = noSym; break;}
case 3:
case_3:
if ((ch >= L' ' && ch <= L'~')) {AddCh(); goto case_2;}
else {t->kind = noSym; break;}
case 4:
case_4:
{t->kind = 2; break;}
case 5:
if ((ch >= L'A' && ch <= L'Z') || (ch >= L'a' && ch <= L'z')) {AddCh(); goto case_6;}
else {t->kind = noSym; break;}
case 6:
case_6:
if ((ch >= L'0' && ch <= L':') || (ch >= L'A' && ch <= L'Z') || ch == L'_' || (ch >= L'a' && ch <= L'z')) {AddCh(); goto case_6;}
else {t->kind = 3; break;}
case 7:
case_7:
if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_8;}
else {t->kind = noSym; break;}
case 8:
case_8:
if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_8;}
else {t->kind = 4; break;}
case 9:
case_9:
if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_9;}
else if (ch == L'E' || ch == L'e') {AddCh(); goto case_10;}
else if (ch == L'.') {AddCh(); goto case_13;}
else {t->kind = 4; break;}
case 10:
case_10:
if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_12;}
else if (ch == L'+' || ch == L'-') {AddCh(); goto case_11;}
else {t->kind = noSym; break;}
case 11:
case_11:
if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_12;}
else {t->kind = noSym; break;}
case 12:
case_12:
if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_12;}
else {t->kind = 4; break;}
case 13:
case_13:
if ((ch >= L'0' && ch <= L'9')) {AddCh(); goto case_13;}
else if (ch == L'E' || ch == L'e') {AddCh(); goto case_10;}
else {t->kind = 4; break;}
case 14:
{t->kind = 5; break;}
case 15:
{t->kind = 6; break;}
case 16:
{t->kind = 9; break;}
case 17:
{t->kind = 10; break;}
case 18:
{t->kind = 11; break;}
case 19:
{t->kind = 12; break;}
case 20:
if (ch == L'.') {AddCh(); goto case_7;}
else {t->kind = 8; break;}
case 21:
if (ch == L'.') {AddCh(); goto case_7;}
else {t->kind = 7; break;}
}
AppendVal(t);
return t;
}
// get the next token (possibly a token already seen during peeking)
Token* Scanner::Scan() {
if (tokens->next == NULL) {
return pt = tokens = NextToken();
} else {
pt = tokens = tokens->next;
return tokens;
}
}
// peek for the next token, ignore pragmas
Token* Scanner::Peek() {
do {
if (pt->next == NULL) {
pt->next = NextToken();
}
pt = pt->next;
} while (pt->kind > maxT); // skip pragmas
return pt;
}
// make sure that peeking starts at the current scan position
void Scanner::ResetPeek() {
pt = tokens;
}
} // namespace
} // namespace
} // namespace

379
applications/test/dictionary/calcEntry/calcEntryScanner.h Normal file
View File

@ -0,0 +1,379 @@
#ifndef COCO_calcEntrySCANNER_H__
#define COCO_calcEntrySCANNER_H__
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
// io.h and fcntl are used to ensure binary read from streams on windows
#if _MSC_VER >= 1300
#include <io.h>
#include <fcntl.h>
#endif
#if _MSC_VER >= 1400
#define coco_swprintf swprintf_s
#elif _MSC_VER >= 1300
#define coco_swprintf _snwprintf
#else
// assume every other compiler knows swprintf
#define coco_swprintf swprintf
#endif
#define COCO_WCHAR_MAX 65535
#define MIN_BUFFER_LENGTH 1024
#define MAX_BUFFER_LENGTH (64*MIN_BUFFER_LENGTH)
#define HEAP_BLOCK_SIZE (64*1024)
namespace Foam {
namespace functionEntries {
namespace calcEntryInternal {
// * * * * * * * * * * Wide Character String Routines * * * * * * * * * * * //
//
// string handling, wide character
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//! Create by copying str
wchar_t* coco_string_create(const wchar_t* str);
//! Create a substring of str starting at index and length characters long
wchar_t* coco_string_create(const wchar_t* str, int index, int length);
//! Create an uppercase string from str
wchar_t* coco_string_create_upper(const wchar_t* str);
//! Create an uppercase substring from str starting at index and length characters long
wchar_t* coco_string_create_upper(const wchar_t* str, int index, int length);
//! Create a lowercase string from str
wchar_t* coco_string_create_lower(const wchar_t* str);
//! Create a lowercase substring from str starting at index and length characters long
wchar_t* coco_string_create_lower(const wchar_t* str, int index, int length);
//! Create a string by concatenating str1 and str2
wchar_t* coco_string_create_append(const wchar_t* str1, const wchar_t* str2);
//! Create a string by concatenating a character to the end of str
wchar_t* coco_string_create_append(const wchar_t* str, const wchar_t ch);
//! Free storage and nullify the argument
void coco_string_delete(wchar_t* &str);
//! The length of the str, or 0 if the str is NULL
int coco_string_length(const wchar_t* str);
//! Return true if the str ends with the endstr
bool coco_string_endswith(const wchar_t* str, const wchar_t* endstr);
//! Return the index of the first occurrence of ch.
// Return -1 if nothing is found.
int coco_string_indexof(const wchar_t* str, const wchar_t ch);
//! Return the index of the last occurrence of ch.
// Return -1 if nothing is found.
int coco_string_lastindexof(const wchar_t* str, const wchar_t ch);
//! Append str to dest
void coco_string_merge(wchar_t* &dest, const wchar_t* str);
//! Compare strings, return true if they are equal
bool coco_string_equal(const wchar_t* str1, const wchar_t* str2);
//! Compare strings, return 0 if they are equal
int coco_string_compareto(const wchar_t* str1, const wchar_t* str2);
//! Simple string hashing function
int coco_string_hash(const wchar_t* str);
//
// String conversions
// ~~~~~~~~~~~~~~~~~~
//! Convert wide string to double
double coco_string_toDouble(const wchar_t* str);
//! Convert wide string to float
float coco_string_toFloat(const wchar_t* str);
//
// String handling, byte character
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//! Create by copying byte str
wchar_t* coco_string_create(const char* str);
//! Create a substring of byte str starting at index and length characters long
wchar_t* coco_string_create(const char* str, int index, int length);
//! Create a byte string by copying str
char* coco_string_create_char(const wchar_t* str);
//! Create a byte substring of str starting at index and length characters long
char* coco_string_create_char(const wchar_t* str, int index, int length);
//! Free storage and nullify the argument
void coco_string_delete(char* &str);
//
// String conversions, byte character
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//! Convert byte string to double
double coco_string_toDouble(const char* str);
//! Convert byte string to float
float coco_string_toFloat(const char* str);
// * * * * * * * * * End of Wide Character String Routines * * * * * * * * * //
//! Scanner Token
class Token
{
public:
int kind; //!< token kind
int pos; //!< token position in the source text (starting at 0)
int col; //!< token column (starting at 1)
int line; //!< token line (starting at 1)
wchar_t* val; //!< token value
Token *next; //!< Peek tokens are kept in linked list
Token(); //!< Construct null
~Token(); //!< Destructor - cleanup allocated val
};
//! Scanner Buffer
//
//! This Buffer supports the following cases:
//! -# seekable stream (file)
//! -# whole stream in buffer
//! -# part of stream in buffer
//! -# non seekable stream (network, console)
class Buffer {
private:
unsigned char *buf; //!< input buffer
int bufCapacity; //!< capacity of buf
int bufStart; //!< position of first byte in buffer relative to input stream
int bufLen; //!< length of buffer
int fileLen; //!< length of input stream (may change if the stream is no file)
int bufPos; //!< current position in buffer
FILE* stream; //!< input stream (seekable)
bool isUserStream; //!< was the stream opened by the user?
int ReadNextStreamChunk();
bool CanSeek(); //!< true if stream can be seeked otherwise false
public:
static const int EoF = COCO_WCHAR_MAX + 1;
Buffer(FILE*, bool isUserStream);
Buffer(const unsigned char* buf, int len);
Buffer(const char* buf, int len);
Buffer(Buffer*);
virtual ~Buffer();
virtual void Close();
virtual int Read();
virtual int Peek();
virtual wchar_t* GetString(int beg, int end);
virtual int GetPos();
virtual void SetPos(int value);
};
//! A Scanner buffer that handles UTF-8 characters
class UTF8Buffer : public Buffer {
public:
UTF8Buffer(Buffer* b) : Buffer(b) {}
virtual int Read();
};
//------------------------------------------------------------------------------
// StartStates
//------------------------------------------------------------------------------
//! maps characters to start states of tokens
class StartStates {
private:
class Elem {
public:
int key, val;
Elem *next;
Elem(int key, int val) {
this->key = key;
this->val = val;
next = NULL;
}
};
Elem **tab;
public:
StartStates() {
tab = new Elem*[128];
memset(tab, 0, 128 * sizeof(Elem*));
}
virtual ~StartStates() {
for (int i = 0; i < 128; ++i) {
Elem *e = tab[i];
while (e != NULL) {
Elem *next = e->next;
delete e;
e = next;
}
}
delete [] tab;
}
void set(int key, int val) {
Elem *e = new Elem(key, val);
int k = ((unsigned int) key) % 128;
e->next = tab[k];
tab[k] = e;
}
int state(int key) {
Elem *e = tab[((unsigned int) key) % 128];
while (e != NULL && e->key != key) e = e->next;
return e == NULL ? 0 : e->val;
}
};
//------------------------------------------------------------------------------
// KeywordMap
//------------------------------------------------------------------------------
//! maps strings to integers (identifiers to keyword kinds)
class KeywordMap {
private:
class Elem {
public:
wchar_t *key;
int val;
Elem *next;
Elem(const wchar_t *key, int val) {
this->key = coco_string_create(key);
this->val = val;
next = NULL;
}
virtual ~Elem() {
coco_string_delete(key);
}
};
Elem **tab;
public:
KeywordMap() {
tab = new Elem*[128];
memset(tab, 0, 128 * sizeof(Elem*));
}
virtual ~KeywordMap() {
for (int i = 0; i < 128; ++i) {
Elem *e = tab[i];
while (e != NULL) {
Elem *next = e->next;
delete e;
e = next;
}
}
delete [] tab;
}
void set(const wchar_t *key, int val) {
Elem *e = new Elem(key, val);
int k = coco_string_hash(key) % 128;
e->next = tab[k]; tab[k] = e;
}
int get(const wchar_t *key, int defaultVal) {
Elem *e = tab[coco_string_hash(key) % 128];
while (e != NULL && !coco_string_equal(e->key, key)) e = e->next;
return e == NULL ? defaultVal : e->val;
}
};
//! A Coco/R Scanner
class Scanner {
private:
static const unsigned char EOL = '\n'; // end-of-line character
static const int eofSym = 0; // end-of-file token id
void *firstHeap;
void *heap;
void *heapTop;
void **heapEnd;
int noSym; //!< noSym gets highest number, set in Parser
int maxT;
int charSetSize; //!< unused?
StartStates start;
KeywordMap keywords;
Token *t; //!< current token
wchar_t *tval; //!< text of current token
int tvalLength; //!< length of text of current token
int tlen; //!< length of current token
Token *tokens; //!< list of tokens already peeked (first token is a dummy)
Token *pt; //!< current peek token
int ch; //!< current input character
int pos; //!< byte position of current character
int line; //!< line number of current character
int col; //!< column number of current character
int oldEols; //!< EOLs that appeared in a comment;
void CreateHeapBlock();
Token* CreateToken();
void AppendVal(Token*);
void Init();
void NextCh();
void AddCh();
bool Comment0();
bool Comment1();
Token* NextToken();
public:
//! scanner buffer
Buffer *buffer;
//! Attach scanner to an existing character buffer
Scanner(const unsigned char* buf, int len);
//! Attach scanner to an existing character buffer
Scanner(const char* buf, int len);
//! Open a file for reading and attach scanner
Scanner(const wchar_t* fileName);
//! Using an existing open file handle for the scanner
Scanner(FILE* s);
~Scanner();
Token* Scan();
Token* Peek();
void ResetPeek();
}; // end Scanner
} // namespace
} // namespace
} // namespace
#endif // COCO_calcEntrySCANNER_H__

112
applications/test/dictionary/dictionaryTest.C
View File

@ -43,70 +43,86 @@ using namespace Foam;
int main(int argc, char *argv[])
{
argList::noParallel();
argList args(argc, argv);
argList::validArgs.insert("dict .. dictN");
argList args(argc, argv, false, true);
Info<< nl
<< "FOAM_CASE=" << getEnv("FOAM_CASE") << nl
<< "FOAM_CASENAME=" << getEnv("FOAM_CASENAME") << nl
<< endl;
if (args.additionalArgs().empty())
{
dictionary dict1(IFstream("testDict")());
Info<< "dict1: " << dict1 << nl
<< "toc: " << dict1.toc() << nl
<< "keys: " << dict1.keys() << nl
<< "patterns: " << dict1.keys(true) << endl;
{
dictionary dict1(IFstream("testDict")());
Info<< "dict1: " << dict1 << nl
<< "toc: " << dict1.toc() << nl
<< "keys: " << dict1.keys() << nl
<< "patterns: " << dict1.keys(true) << endl;
dictionary dict2(dict1.xfer());
dictionary dict2(dict1.xfer());
Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << nl
<< "dict2.toc(): " << dict2.name() << " " << dict2.toc() << endl;
Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << nl
<< "dict2.toc(): " << dict2.name() << " " << dict2.toc() << endl;
// copy back
dict1 = dict2;
Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << endl;
// copy back
dict1 = dict2;
Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << endl;
dictionary dict3(dict2.subDictPtr("boundaryField"));
dictionary dict4(dict2.subDictPtr("NONEXISTENT"));
dictionary dict3(dict2.subDictPtr("boundaryField"));
dictionary dict4(dict2.subDictPtr("NONEXISTENT"));
Info<< "dictionary construct from pointer" << nl
<< "ok = " << dict3.name() << " " << dict3.toc() << nl
<< "no = " << dict4.name() << " " << dict4.toc() << endl;
Info<< "dictionary construct from pointer" << nl
<< "ok = " << dict3.name() << " " << dict3.toc() << nl
<< "no = " << dict4.name() << " " << dict4.toc() << endl;
}
IOobject::writeDivider(Info);
{
dictionary dict(IFstream("testDictRegex")());
dict.add(keyType("fooba[rz]", true), "anything");
Info<< "dict:" << dict << nl
<< "toc: " << dict.toc() << nl
<< "keys: " << dict.keys() << nl
<< "patterns: " << dict.keys(true) << endl;
Info<< "Pattern find \"abc\" in top directory : "
<< dict.lookup("abc") << endl;
Info<< "Pattern find \"abc\" in sub directory : "
<< dict.subDict("someDict").lookup("abc")
<< endl;
Info<< "Recursive pattern find \"def\" in sub directory : "
<< dict.subDict("someDict").lookup("def", true)
<< endl;
Info<< "Recursive pattern find \"foo\" in sub directory : "
<< dict.subDict("someDict").lookup("foo", true)
<< endl;
Info<< "Recursive pattern find \"fooz\" in sub directory : "
<< dict.subDict("someDict").lookup("fooz", true)
<< endl;
Info<< "Recursive pattern find \"bar\" in sub directory : "
<< dict.subDict("someDict").lookup("bar", true)
<< endl;
Info<< "Recursive pattern find \"xxx\" in sub directory : "
<< dict.subDict("someDict").lookup("xxx", true)
<< endl;
}
}
IOobject::writeDivider(Info);
else
{
dictionary dict(IFstream("testDictRegex")());
dict.add(keyType("fooba[rz]", true), "anything");
IOobject::writeDivider(Info);
forAll(args.additionalArgs(), argI)
{
const string& dictFile = args.additionalArgs()[argI];
IFstream is(dictFile);
Info<< "dict:" << dict << nl
<< "toc: " << dict.toc() << nl
<< "keys: " << dict.keys() << nl
<< "patterns: " << dict.keys(true) << endl;
dictionary dict(is);
Info<< "Pattern find \"abc\" in top directory : "
<< dict.lookup("abc") << endl;
Info<< "Pattern find \"abc\" in sub directory : "
<< dict.subDict("someDict").lookup("abc")
<< endl;
Info<< "Recursive pattern find \"def\" in sub directory : "
<< dict.subDict("someDict").lookup("def", true)
<< endl;
Info<< "Recursive pattern find \"foo\" in sub directory : "
<< dict.subDict("someDict").lookup("foo", true)
<< endl;
Info<< "Recursive pattern find \"fooz\" in sub directory : "
<< dict.subDict("someDict").lookup("fooz", true)
<< endl;
Info<< "Recursive pattern find \"bar\" in sub directory : "
<< dict.subDict("someDict").lookup("bar", true)
<< endl;
Info<< "Recursive pattern find \"xxx\" in sub directory : "
<< dict.subDict("someDict").lookup("xxx", true)
<< endl;
Info<< dict << endl;
}
}
return 0;

33
applications/test/dictionary/testDictCalc Normal file
View File

@ -0,0 +1,33 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: Any |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
object testDictTest;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
x 10 /* what ever */ 20;
y 20;
// z #test{ // this
// 123 - 456
// // comments // are
// /* stripped
// * 10
// * {}
// */
// + 1 /*100 */ 10
// };
p #test{ 1 + 2 + 10 * 15 + $x - $y };
foo 30;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

25
applications/test/fileNameClean/fileNameCleanTest.C
View File

@ -66,17 +66,18 @@ int main(int argc, char *argv[])
argList::noBanner();
argList::noParallel();
argList::validArgs.insert("fileName .. fileNameN");
argList::addOption("istream", "fileName", "test Istream values");
argList args(argc, argv, false, true);
if (args.additionalArgs().empty())
if (args.additionalArgs().empty() && args.options().empty())
{
args.printUsage();
}
if (args.optionFound("case"))
fileName pathName;
if (args.optionReadIfPresent("case", pathName))
{
fileName pathName = args.option("case");
Info<< nl
<< "-case" << nl
<< "path = " << args.path() << nl
@ -91,7 +92,23 @@ int main(int argc, char *argv[])
forAll(args.additionalArgs(), argI)
{
fileName pathName = args.additionalArgs()[argI];
pathName = args.additionalArgs()[argI];
printCleaning(pathName);
}
if (args.optionFound("istream"))
{
args.optionLookup("istream")() >> pathName;
Info<< nl
<< "-case" << nl
<< "path = " << args.path() << nl
<< "root = " << args.rootPath() << nl
<< "case = " << args.caseName() << nl
<< "FOAM_CASE=" << getEnv("FOAM_CASE") << nl
<< "FOAM_CASENAME=" << getEnv("FOAM_CASENAME") << nl
<< endl;
printCleaning(pathName);
}

5
applications/test/fvSolutionCombine/fvSolutionCombine.C
View File

@ -98,8 +98,9 @@ bool checkDictionaryContent(const dictionary& dict1, const dictionary& dict2)
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validOptions.insert("rewrite", "");
argList::validOptions.insert("show", "");
argList::addBoolOption("rewrite");
argList::addBoolOption("show");
argList args(argc, argv);
Time runTime(args.rootPath(), args.caseName());

345
applications/test/momentOfInertia/momentOfInertiaTest.C
View File

@ -27,12 +27,14 @@ Application
Description
Calculates the inertia tensor and principal axes and moments of a
test face.
test face and tetrahedron.
\*---------------------------------------------------------------------------*/
#include "ListOps.H"
#include "face.H"
#include "tetPointRef.H"
#include "triFaceList.H"
#include "OFstream.H"
#include "meshTools.H"
@ -40,67 +42,310 @@ Description
using namespace Foam;
void massPropertiesSolid
(
const pointField& pts,
const triFaceList triFaces,
scalar density,
scalar& mass,
vector& cM,
tensor& J
)
{
// Reimplemented from: Wm4PolyhedralMassProperties.cpp
// File Version: 4.10.0 (2009/11/18)
// Geometric Tools, LC
// Copyright (c) 1998-2010
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Boost Software License - Version 1.0 - August 17th, 2003
// Permission is hereby granted, free of charge, to any person or
// organization obtaining a copy of the software and accompanying
// documentation covered by this license (the "Software") to use,
// reproduce, display, distribute, execute, and transmit the
// Software, and to prepare derivative works of the Software, and
// to permit third-parties to whom the Software is furnished to do
// so, all subject to the following:
// The copyright notices in the Software and this entire
// statement, including the above license grant, this restriction
// and the following disclaimer, must be included in all copies of
// the Software, in whole or in part, and all derivative works of
// the Software, unless such copies or derivative works are solely
// in the form of machine-executable object code generated by a
// source language processor.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
// NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
// ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
// OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
const scalar r6 = 1.0/6.0;
const scalar r24 = 1.0/24.0;
const scalar r60 = 1.0/60.0;
const scalar r120 = 1.0/120.0;
// order: 1, x, y, z, x^2, y^2, z^2, xy, yz, zx
scalarField integrals(10, 0.0);
forAll(triFaces, i)
{
const triFace& tri(triFaces[i]);
// vertices of triangle i
vector v0 = pts[tri[0]];
vector v1 = pts[tri[1]];
vector v2 = pts[tri[2]];
// cross product of edges
vector eA = v1 - v0;
vector eB = v2 - v0;
vector n = eA ^ eB;
// compute integral terms
scalar tmp0, tmp1, tmp2;
scalar f1x, f2x, f3x, g0x, g1x, g2x;
tmp0 = v0.x() + v1.x();
f1x = tmp0 + v2.x();
tmp1 = v0.x()*v0.x();
tmp2 = tmp1 + v1.x()*tmp0;
f2x = tmp2 + v2.x()*f1x;
f3x = v0.x()*tmp1 + v1.x()*tmp2 + v2.x()*f2x;
g0x = f2x + v0.x()*(f1x + v0.x());
g1x = f2x + v1.x()*(f1x + v1.x());
g2x = f2x + v2.x()*(f1x + v2.x());
scalar f1y, f2y, f3y, g0y, g1y, g2y;
tmp0 = v0.y() + v1.y();
f1y = tmp0 + v2.y();
tmp1 = v0.y()*v0.y();
tmp2 = tmp1 + v1.y()*tmp0;
f2y = tmp2 + v2.y()*f1y;
f3y = v0.y()*tmp1 + v1.y()*tmp2 + v2.y()*f2y;
g0y = f2y + v0.y()*(f1y + v0.y());
g1y = f2y + v1.y()*(f1y + v1.y());
g2y = f2y + v2.y()*(f1y + v2.y());
scalar f1z, f2z, f3z, g0z, g1z, g2z;
tmp0 = v0.z() + v1.z();
f1z = tmp0 + v2.z();
tmp1 = v0.z()*v0.z();
tmp2 = tmp1 + v1.z()*tmp0;
f2z = tmp2 + v2.z()*f1z;
f3z = v0.z()*tmp1 + v1.z()*tmp2 + v2.z()*f2z;
g0z = f2z + v0.z()*(f1z + v0.z());
g1z = f2z + v1.z()*(f1z + v1.z());
g2z = f2z + v2.z()*(f1z + v2.z());
// update integrals
integrals[0] += n.x()*f1x;
integrals[1] += n.x()*f2x;
integrals[2] += n.y()*f2y;
integrals[3] += n.z()*f2z;
integrals[4] += n.x()*f3x;
integrals[5] += n.y()*f3y;
integrals[6] += n.z()*f3z;
integrals[7] += n.x()*(v0.y()*g0x + v1.y()*g1x + v2.y()*g2x);
integrals[8] += n.y()*(v0.z()*g0y + v1.z()*g1y + v2.z()*g2y);
integrals[9] += n.z()*(v0.x()*g0z + v1.x()*g1z + v2.x()*g2z);
}
integrals[0] *= r6;
integrals[1] *= r24;
integrals[2] *= r24;
integrals[3] *= r24;
integrals[4] *= r60;
integrals[5] *= r60;
integrals[6] *= r60;
integrals[7] *= r120;
integrals[8] *= r120;
integrals[9] *= r120;
// mass
mass = integrals[0];
// center of mass
cM = vector(integrals[1], integrals[2], integrals[3])/mass;
// inertia relative to origin
J.xx() = integrals[5] + integrals[6];
J.xy() = -integrals[7];
J.xz() = -integrals[9];
J.yx() = J.xy();
J.yy() = integrals[4] + integrals[6];
J.yz() = -integrals[8];
J.zx() = J.xz();
J.zy() = J.yz();
J.zz() = integrals[4] + integrals[5];
// inertia relative to center of mass
J -= mass*((cM & cM)*I - cM*cM);
// Apply density
mass *= density;
J *= density;
}
int main(int argc, char *argv[])
{
label nPts = 6;
pointField pts(nPts);
pts[0] = point(4.495, 3.717, -4.112);
pts[1] = point(4.421, 3.932, -4.112);
pts[2] = point(4.379, 4.053, -4.112);
pts[3] = point(4.301, 4.026, -4.300);
pts[4] = point(4.294, 4.024, -4.317);
pts[5] = point(4.409, 3.687, -4.317);
scalar density = 1.0;
face f(identity(nPts));
point Cf = f.centre(pts);
tensor J = tensor::zero;
J = f.inertia(pts, Cf, density);
vector eVal = eigenValues(J);
tensor eVec = eigenVectors(J);
Info<< nl << "Inertia tensor of test face " << J << nl
<< "eigenValues (principal moments) " << eVal << nl
<< "eigenVectors (principal axes) " << eVec
<< endl;
OFstream str("momentOfInertiaTest.obj");
Info<< nl << "Writing test face and scaled principal axes to "
<< str.name() << endl;
forAll(pts, ptI)
{
meshTools::writeOBJ(str, pts[ptI]);
label nPts = 6;
pointField pts(nPts);
pts[0] = point(4.495, 3.717, -4.112);
pts[1] = point(4.421, 3.932, -4.112);
pts[2] = point(4.379, 4.053, -4.112);
pts[3] = point(4.301, 4.026, -4.300);
pts[4] = point(4.294, 4.024, -4.317);
pts[5] = point(4.409, 3.687, -4.317);
face f(identity(nPts));
point Cf = f.centre(pts);
tensor J = tensor::zero;
J = f.inertia(pts, Cf, density);
vector eVal = eigenValues(J);
tensor eVec = eigenVectors(J);
Info<< nl << "Inertia tensor of test face " << J << nl
<< "eigenValues (principal moments) " << eVal << nl
<< "eigenVectors (principal axes) " << eVec
<< endl;
OFstream str("momentOfInertiaTestFace.obj");
Info<< nl << "Writing test face and scaled principal axes to "
<< str.name() << endl;
forAll(pts, ptI)
{
meshTools::writeOBJ(str, pts[ptI]);
}
str << "l";
forAll(f, fI)
{
str << ' ' << fI + 1;
}
str << " 1" << endl;
scalar scale = mag(Cf - pts[f[0]])/eVal.component(findMin(eVal));
meshTools::writeOBJ(str, Cf);
meshTools::writeOBJ(str, Cf + scale*eVal.x()*eVec.x());
meshTools::writeOBJ(str, Cf + scale*eVal.y()*eVec.y());
meshTools::writeOBJ(str, Cf + scale*eVal.z()*eVec.z());
for (label i = nPts + 1; i < nPts + 4; i++)
{
str << "l " << nPts + 1 << ' ' << i + 1 << endl;
}
}
str << "l";
forAll(f, fI)
{
str << ' ' << fI + 1;
}
label nPts = 4;
str << " 1" << endl;
pointField pts(nPts);
scalar scale = mag(Cf - pts[f[0]])/eVal.component(findMin(eVal));
pts[0] = point(0, 0, 0);
pts[1] = point(1, 0, 0);
pts[2] = point(0.5, 1, 0);
pts[3] = point(0.5, 0.5, 1);
meshTools::writeOBJ(str, Cf);
meshTools::writeOBJ(str, Cf + scale*eVal.x()*eVec.x());
meshTools::writeOBJ(str, Cf + scale*eVal.y()*eVec.y());
meshTools::writeOBJ(str, Cf + scale*eVal.z()*eVec.z());
tetPointRef tet(pts[0], pts[1], pts[2], pts[3]);
triFaceList tetFaces(4);
tetFaces[0] = triFace(0, 2, 1);
tetFaces[1] = triFace(1, 2, 3);
tetFaces[2] = triFace(0, 3, 2);
tetFaces[3] = triFace(0, 1, 3);
scalar m = 0.0;
vector cM = vector::zero;
tensor J = tensor::zero;
massPropertiesSolid
(
pts,
tetFaces,
density,
m,
cM,
J
);
vector eVal = eigenValues(J);
tensor eVec = eigenVectors(J);
Info<< nl
<< "Mass of tetrahedron " << m << nl
<< "Centre of mass of tetrahedron " << cM << nl
<< "Inertia tensor of tetrahedron " << J << nl
<< "eigenValues (principal moments) " << eVal << nl
<< "eigenVectors (principal axes) " << eVec
<< endl;
OFstream str("momentOfInertiaTestTet.obj");
Info<< nl << "Writing test tetrahedron and scaled principal axes to "
<< str.name() << endl;
forAll(pts, ptI)
{
meshTools::writeOBJ(str, pts[ptI]);
}
forAll(tetFaces, tFI)
{
const triFace& f = tetFaces[tFI];
str << "l";
forAll(f, fI)
{
str << ' ' << f[fI] + 1;
}
str << ' ' << f[0] + 1 << endl;
}
scalar scale = mag(cM - pts[0])/eVal.component(findMin(eVal));
meshTools::writeOBJ(str, cM);
meshTools::writeOBJ(str, cM + scale*eVal.x()*eVec.x());
meshTools::writeOBJ(str, cM + scale*eVal.y()*eVec.y());
meshTools::writeOBJ(str, cM + scale*eVal.z()*eVec.z());
for (label i = nPts + 1; i < nPts + 4; i++)
{
str << "l " << nPts + 1 << ' ' << i + 1 << endl;
}
for (label i = nPts + 1; i < nPts + 4; i++)
{
str << "l " << nPts + 1 << ' ' << i + 1 << endl;
}
Info<< nl << "End" << nl << endl;

5
applications/test/mvBak/mvBakTest.C
View File

@ -39,8 +39,9 @@ int main(int argc, char *argv[])
argList::noBanner();
argList::noParallel();
argList::validArgs.insert("file .. fileN");
argList::validOptions.erase("case");
argList::validOptions.insert("ext", "bak");
argList::removeOption("case");
argList::addOption("ext", "bak");
argList args(argc, argv, false, true);

8
applications/test/nearWallDist-wave/testWallDist2.C
View File

@ -73,7 +73,7 @@ int main(int argc, char *argv[])
// Count walls
label nWalls = 0;
forAll (mesh.boundary(), patchI)
forAll(mesh.boundary(), patchI)
{
const fvPatch& patch = mesh.boundary()[patchI];
@ -87,13 +87,13 @@ int main(int argc, char *argv[])
labelList changedFaces(nWalls);
label nChangedFaces = 0;
forAll (mesh.boundary(), patchI)
forAll(mesh.boundary(), patchI)
{
const fvPatch& patch = mesh.boundary()[patchI];
if (isA<wallFvPatch>(patch))
{
forAll (patch.Cf(), patchFaceI)
forAll(patch.Cf(), patchFaceI)
{
const polyPatch& polyPatch = mesh.boundaryMesh()[patchI];
@ -170,7 +170,7 @@ int main(int argc, char *argv[])
}
// Copy boundary values
forAll (wallDistUncorrected.boundaryField(), patchI)
forAll(wallDistUncorrected.boundaryField(), patchI)
{
fvPatchScalarField& patchField =
wallDistUncorrected.boundaryField()[patchI];

4
applications/test/readCHEMKINIII/readCHEMKINIII.C
View File

@ -38,7 +38,7 @@ int main(int argc, char *argv[])
{
argList::validArgs.clear();
argList::validArgs.append("CHEMKINIIIFile");
argList::validOptions.insert("thermo", "fileName");
argList::addOption("thermo", "fileName");
argList args(argc, argv);
fileName thermoFileName = fileName::null;
@ -72,7 +72,7 @@ int main(int argc, char *argv[])
PtrList<gasReaction> testReactions(nReactions);
forAll (testReactions, i)
forAll(testReactions, i)
{
testReactions.set
(

4
applications/test/router/processorRouter.C
View File

@ -53,7 +53,7 @@ labelList procNeighbours(const polyMesh& mesh)
label nNeighbours = 0;
forAll (mesh.boundaryMesh(), patchI)
forAll(mesh.boundaryMesh(), patchI)
{
if (isA<processorPolyPatch>(mesh.boundaryMesh()[patchI]))
{
@ -65,7 +65,7 @@ labelList procNeighbours(const polyMesh& mesh)
nNeighbours = 0;
forAll (mesh.boundaryMesh(), patchI)
forAll(mesh.boundaryMesh(), patchI)
{
if (isA<processorPolyPatch>(mesh.boundaryMesh()[patchI]))
{

3
applications/test/sizeof/Make/files Normal file
View File

@ -0,0 +1,3 @@
sizeofTest.C
EXE = $(FOAM_USER_APPBIN)/sizeofTest

2
applications/test/sizeof/Make/options Normal file
View File

@ -0,0 +1,2 @@
/* EXE_INC = -I$(LIB_SRC)/cfdTools/include */
/* EXE_LIBS = -lfiniteVolume */

114
src/mesh/blockMesh/curvedEdges/legacy/spline.C → applications/test/sizeof/sizeofTest.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,73 +22,83 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
Test the sizeof various classes.
\*---------------------------------------------------------------------------*/
#include "spline.H"
#include "bool.H"
#include "Switch.H"
#include "string.H"
#include "dictionary.H"
#include "nil.H"
#include "IOstreams.H"
#include "IStringStream.H"
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
Foam::scalar Foam::spline::B(const scalar tau)
namespace Foam
{
if (tau <= -2.0 || tau >= 2.0)
{
return 0.0;
}
else if (tau <= -1.0)
{
return pow((2.0 + tau), 3.0)/6.0;
}
else if (tau <= 0.0)
{
return (4.0 - 6.0*tau*tau - 3.0*tau*tau*tau)/6.0;
}
else if (tau <= 1.0)
{
return (4.0 - 6.0*tau*tau + 3.0*tau*tau*tau)/6.0;
}
else if (tau <= 2.0)
{
return pow((2.0 - tau), 3.0)/6.0;
}
else
{
FatalErrorIn("spline::B(const scalar)")
<< "Programming error???, "
<< "tau = " << tau
<< abort(FatalError);
}
class hasBoolClass
{
public:
bool b_;
hasBoolClass(const bool val=false)
:
b_(false)
{}
};
return 0.0;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
using namespace Foam;
Foam::spline::spline(const pointField& knotPoints)
:
knots_(knotPoints)
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::point Foam::spline::position(const scalar mu) const
int main(int argc, char *argv[])
{
point loc(point::zero);
for (register label i=0; i < knots_.size(); i++)
cout<<"sizeof\n------\n";
{
loc += B((knots_.size() - 1)*mu - i)*knots_[i];
nil x;
cout<<"nil:" << sizeof(x) << nl;
}
{
bool x(0);
cout<<"bool:" << sizeof(x) << nl;
}
{
hasBoolClass x(true);
cout<<"hasBoolClass:" << sizeof(x) << nl;
}
return loc;
}
{
Switch x("n");
cout<<"Switch:" << sizeof(x) << nl;
cout<<"Switch::switchType=" << sizeof(Switch::switchType) << nl;
}
{
scalar x(0);
cout<<"scalar:" << sizeof(x) << nl;
}
{
label x(0);
cout<<"label:" << sizeof(x) << nl;
}
{
cout<<"int:" << sizeof(int) << nl;
cout<<"long:" << sizeof(long) << nl;
cout<<"float:" << sizeof(float) << nl;
cout<<"double:" << sizeof(double) << nl;
}
Foam::scalar Foam::spline::length() const
{
notImplemented("spline::length() const");
return 1.0;
Info << "---\nEnd\n" << endl;
return 0;
}

3
applications/test/spline/Make/files Normal file
View File

@ -0,0 +1,3 @@
splineTest.C
EXE = $(FOAM_USER_APPBIN)/splineTest

0
applications/test/BSpline/Make/options → applications/test/spline/Make/options
View File

137
applications/test/spline/splineTest.C Normal file
View File

@ -0,0 +1,137 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2009-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 "argList.H"
#include "vector.H"
#include "IFstream.H"
#include "BSpline.H"
#include "CatmullRomSpline.H"
using namespace Foam;
inline Ostream& printPoint(Ostream& os, const point& p)
{
os << p.x() << ' ' << p.y() << ' ' << p.z() << nl;
return os;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validArgs.insert("file .. fileN");
argList::addBoolOption("B", "B-Spline implementation");
argList::addBoolOption("CMR", "catmull-rom spline (default)");
argList::addOption
(
"n",
"INT",
"number of segments for evaluation - default 20"
);
argList args(argc, argv, false, true);
if (args.additionalArgs().empty())
{
args.printUsage();
}
bool useBSpline = args.optionFound("B");
bool useCatmullRom = args.optionFound("CMR");
label nSeg = args.optionLookupOrDefault<label>("n", 20);
if (!useCatmullRom && !useBSpline)
{
Info<<"defaulting to Catmull-Rom spline" << endl;
useCatmullRom = true;
}
forAll(args.additionalArgs(), argI)
{
const string& srcFile = args.additionalArgs()[argI];
Info<< nl << "reading " << srcFile << nl;
IFstream ifs(srcFile);
List<pointField> pointFields(ifs);
forAll(pointFields, splineI)
{
Info<<"\n# points:" << endl;
forAll(pointFields[splineI], ptI)
{
printPoint(Info, pointFields[splineI][ptI]);
}
if (useBSpline)
{
BSpline spl(pointFields[splineI]);
Info<< nl << "# B-Spline" << endl;
for (label segI = 0; segI <= nSeg; ++segI)
{
scalar lambda = scalar(segI)/scalar(nSeg);
printPoint(Info, spl.position(lambda));
}
}
if (useCatmullRom)
{
CatmullRomSpline spl(pointFields[splineI]);
Info<< nl <<"# Catmull-Rom" << endl;
for (label segI = 0; segI <= nSeg; ++segI)
{
scalar lambda = scalar(segI)/scalar(nSeg);
printPoint(Info, spl.position(lambda));
}
}
{
polyLine pl(pointFields[splineI]);
Info<< nl <<"# polyList" << endl;
for (label segI = 0; segI <= nSeg; ++segI)
{
scalar lambda = scalar(segI)/scalar(nSeg);
printPoint(Info, pl.position(lambda));
}
}
}
}
return 0;
}
// ************************************************************************* //

46
applications/test/spline/test-splines Normal file
View File

@ -0,0 +1,46 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: http://www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
(
// Upper body longitudinal splines
(
(0.22685 0.01125166 0) // 7
(0.21685 0.01340204 0)
(0.20685 0.01529684 0)
(0.19685 0.01694748 0)
(0.18685 0.01836538 0)
(0.17685 0.01956197 0)
(0.16685 0.02054868 0)
(0.15685 0.02133693 0)
(0.14685 0.02193816 0)
(0.13685 0.02236377 0)
(0.12685 0.02262521 0)
(0.11685 0.02273389 0) // 2
)
// sine function
(
(0 0 0)
(45 0.70707 0)
(90 1 0)
(135 0.70707 0)
(180 0 0)
(225 -0.70707 0)
(270 -1 0)
(315 -0.70707 0)
(360 0 0)
)
// cosine function, but with extremely few points
(
(0 1 0)
(180 -1 0)
(360 1 0)
)
);

16
applications/test/tokenizeTest/tokenizeTest.C
View File

@ -44,16 +44,14 @@ int main(int argc, char *argv[])
{
argList::noParallel();
argList::validArgs.insert("string .. stringN");
argList::validOptions.insert("file", "name");
argList::validOptions.insert("repeat", "count");
argList::addOption("file", "name");
argList::addOption("repeat", "count");
argList args(argc, argv, false, true);
label repeat = 1;
args.optionReadIfPresent<label>("repeat", repeat);
const label repeat = args.optionLookupOrDefault<label>("repeat", 1);
cpuTime timer;
for (label count = 0; count < repeat; ++count)
{
forAll(args.additionalArgs(), argI)
@ -69,9 +67,15 @@ int main(int argc, char *argv[])
while (is.good())
{
token tok(is);
// char ch;
// is.get(ch);
// is.putback(ch);
int lookahead = is.peek();
if (count == 0)
{
Info<< "token: " << tok.info() << endl;
Info<< "token: " << tok.info();
Info<< " lookahead: '" << char(lookahead) << "'" << endl;
}
}

2
applications/utilities/errorEstimation/estimateScalarError/Make/options
View File

@ -1,5 +1,5 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/errorEstimation/lnInclude
EXE_LIBS = \

2
applications/utilities/errorEstimation/icoErrorEstimate/Make/options
View File

@ -1,5 +1,5 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/errorEstimation/lnInclude
EXE_LIBS = \

2
applications/utilities/errorEstimation/icoMomentError/Make/options
View File

@ -1,5 +1,5 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/errorEstimation/lnInclude
EXE_LIBS = \

2
applications/utilities/errorEstimation/momentScalarError/Make/options
View File

@ -1,5 +1,5 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/errorEstimation/lnInclude
EXE_LIBS = \

2
applications/utilities/mesh/advanced/collapseEdges/collapseEdges.C
View File

@ -454,7 +454,7 @@ label simplifyFaces
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validOptions.insert("overwrite", "");
argList::addBoolOption("overwrite");
argList::validArgs.append("edge length [m]");
argList::validArgs.append("merge angle (degrees)");

21
applications/utilities/mesh/advanced/combinePatchFaces/combinePatchFaces.C
View File

@ -59,10 +59,6 @@ using namespace Foam;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Sin of angle between two consecutive edges on a face. If sin(angle) larger
// than this the face will be considered concave.
const scalar defaultConcaveAngle = 30;
// Same check as snapMesh
void checkSnapMesh
@ -433,9 +429,9 @@ label mergeEdges(const scalar minCos, polyMesh& mesh)
int main(int argc, char *argv[])
{
argList::validArgs.append("feature angle [0..180]");
argList::validOptions.insert("concaveAngle", "[0..180]");
argList::validOptions.insert("snapMesh", "");
argList::validOptions.insert("overwrite", "");
argList::addOption("concaveAngle", "[0..180]");
argList::addBoolOption("snapMesh");
argList::addBoolOption("overwrite");
# include "setRootCase.H"
# include "createTime.H"
@ -447,8 +443,9 @@ int main(int argc, char *argv[])
scalar minCos = Foam::cos(degToRad(featureAngle));
scalar concaveAngle = defaultConcaveAngle;
args.optionReadIfPresent("concaveAngle", concaveAngle);
// Sin of angle between two consecutive edges on a face.
// If sin(angle) larger than this the face will be considered concave.
scalar concaveAngle = args.optionLookupOrDefault("concaveAngle", 30.0);
scalar concaveSin = Foam::sin(degToRad(concaveAngle));
@ -483,8 +480,8 @@ int main(int argc, char *argv[])
// Merge points on straight edges and remove unused points
if (snapMeshDict)
{
Info<< "Merging all 'loose' points on surface edges"
<< ", regardless of the angle they make." << endl;
Info<< "Merging all 'loose' points on surface edges, "
<< "regardless of the angle they make." << endl;
// Surface bnound to be used to extrude. Merge all loose points.
nChanged += mergeEdges(-1, mesh);
@ -510,7 +507,7 @@ int main(int argc, char *argv[])
Info<< "Mesh unchanged." << endl;
}
Info<< "End\n" << endl;
Info<< "\nEnd\n" << endl;
return 0;
}

8
applications/utilities/mesh/advanced/modifyMesh/cellSplitter.C
View File

@ -22,8 +22,6 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
\*---------------------------------------------------------------------------*/
#include "cellSplitter.H"
@ -39,12 +37,8 @@ Description
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(Foam::cellSplitter, 0);
defineTypeNameAndDebug(cellSplitter, 0);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //

2
applications/utilities/mesh/advanced/modifyMesh/modifyMesh.C
View File

@ -328,7 +328,7 @@ label findCell(const primitiveMesh& mesh, const point& nearPoint)
int main(int argc, char *argv[])
{
argList::validOptions.insert("overwrite", "");
argList::addBoolOption("overwrite");
# include "setRootCase.H"
# include "createTime.H"

2
applications/utilities/mesh/advanced/refineHexMesh/refineHexMesh.C
View File

@ -52,7 +52,7 @@ using namespace Foam;
// Main program:
int main(int argc, char *argv[])
{
argList::validOptions.insert("overwrite", "");
argList::addBoolOption("overwrite");
argList::validArgs.append("cellSet");
# include "setRootCase.H"
# include "createTime.H"

11
applications/utilities/mesh/advanced/refineWallLayer/refineWallLayer.C
View File

@ -47,11 +47,12 @@ using namespace Foam;
int main(int argc, char *argv[])
{
Foam::argList::noParallel();
Foam::argList::validArgs.append("patchName");
Foam::argList::validArgs.append("edgeWeight");
Foam::argList::validOptions.insert("useSet", "cellSet");
Foam::argList::validOptions.insert("overwrite", "");
argList::noParallel();
argList::validArgs.append("patchName");
argList::validArgs.append("edgeWeight");
argList::addOption("useSet", "cellSet");
argList::addBoolOption("overwrite");
# include "setRootCase.H"
# include "createTime.H"

4
applications/utilities/mesh/advanced/refinementLevel/refinementLevel.C
View File

@ -97,7 +97,7 @@ bool limitRefinementLevel
int main(int argc, char *argv[])
{
argList::validOptions.insert("readLevel", "");
argList::addBoolOption("readLevel");
# include "setRootCase.H"
# include "createTime.H"
@ -216,7 +216,7 @@ int main(int argc, char *argv[])
List<polyPatch*> p(patches.size());
forAll (p, patchI)
forAll(p, patchI)
{
p[patchI] = patches[patchI].clone(fMesh.boundaryMesh()).ptr();
}

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