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

single operations only

Browse Source
This commit is contained in:
andy
2009-02-10 17:39:00 +00:00
parent 03f950341f
commit 5235d41622
7 changed files with 226 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
src/postProcessing/foamCalcFunctions/field/components/components.C
View File

@ -57,8 +57,8 @@ Foam::calcTypes::components::~components()
void Foam::calcTypes::components::init() void Foam::calcTypes::components::init()
{ {
Foam::argList::validArgs.append("components"); argList::validArgs.append("components");
argList::validArgs.append("fieldName1 .. fieldNameN"); argList::validArgs.append("fieldName");
} }
@ -68,14 +68,7 @@ void Foam::calcTypes::components::preCalc
const Time& runTime, const Time& runTime,
const fvMesh& mesh const fvMesh& mesh
) )
{ {}
if (args.additionalArgs().size() < 2)
{
Info<< nl << "must specify one or more fields" << nl;
args.printUsage();
FatalError.exit();
}
}
void Foam::calcTypes::components::calc void Foam::calcTypes::components::calc
@ -85,49 +78,39 @@ void Foam::calcTypes::components::calc
const fvMesh& mesh const fvMesh& mesh
) )
{ {
const stringList& params = args.additionalArgs(); const word& fieldName = args.additionalArgs()[1];
for (label fieldi=1; fieldi<params.size(); fieldi++) IOobject fieldHeader
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// Check field exists
if (fieldHeader.headerOk())
{ {
const word fieldName(params[fieldi]); bool processed = false;
IOobject fieldHeader writeComponentFields<vector>(fieldHeader, mesh, processed);
( writeComponentFields<sphericalTensor>(fieldHeader, mesh, processed);
fieldName, writeComponentFields<symmTensor>(fieldHeader, mesh, processed);
runTime.timeName(), writeComponentFields<tensor>(fieldHeader, mesh, processed);
mesh,
IOobject::MUST_READ
);
// Check field exists if (!processed)
if (fieldHeader.headerOk())
{ {
bool processed = false; FatalError
<< "Unable to process " << fieldName << nl
writeComponentFields<vector>(fieldHeader, mesh, processed); << "No call to components for fields of type "
writeComponentFields<sphericalTensor> << fieldHeader.headerClassName() << nl << nl
( << exit(FatalError);
fieldHeader,
mesh,
processed
);
writeComponentFields<symmTensor>(fieldHeader, mesh, processed);
writeComponentFields<tensor>(fieldHeader, mesh, processed);
if (!processed)
{
FatalError
<< "Unable to process " << fieldName << nl
<< "No call to components for fields of type "
<< fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
}
}
else
{
Info<< " No " << fieldName << endl;
} }
} }
else
{
Info<< " No " << fieldName << endl;
}
} }

66
src/postProcessing/foamCalcFunctions/field/div/div.C
View File

@ -57,8 +57,8 @@ Foam::calcTypes::div::~div()
void Foam::calcTypes::div::init() void Foam::calcTypes::div::init()
{ {
Foam::argList::validArgs.append("div"); argList::validArgs.append("div");
argList::validArgs.append("fieldName1 .. fieldNameN"); argList::validArgs.append("fieldName");
} }
@ -68,14 +68,7 @@ void Foam::calcTypes::div::preCalc
const Time& runTime, const Time& runTime,
const fvMesh& mesh const fvMesh& mesh
) )
{ {}
if (args.additionalArgs().size() < 2)
{
Info<< nl << "must specify one or more fields" << nl;
args.printUsage();
FatalError.exit();
}
}
void Foam::calcTypes::div::calc void Foam::calcTypes::div::calc
@ -85,42 +78,37 @@ void Foam::calcTypes::div::calc
const fvMesh& mesh const fvMesh& mesh
) )
{ {
const stringList& params = args.additionalArgs(); const word& fieldName = args.additionalArgs()[1];
for (label fieldi=1; fieldi<params.size(); fieldi++) IOobject fieldHeader
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// Check field exists
if (fieldHeader.headerOk())
{ {
const word fieldName(params[fieldi]); bool processed = false;
IOobject fieldHeader writeDivField<surfaceScalarField>(fieldHeader, mesh, processed);
( writeDivField<volVectorField>(fieldHeader, mesh, processed);
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// Check field exists if (!processed)
if (fieldHeader.headerOk())
{ {
bool processed = false; FatalError
<< "Unable to process " << fieldName << nl
writeDivField<surfaceScalarField>(fieldHeader, mesh, processed); << "No call to div for fields of type "
writeDivField<volVectorField>(fieldHeader, mesh, processed); << fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
if (!processed)
{
FatalError
<< "Unable to process " << fieldName << nl
<< "No call to div for fields of type "
<< fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
}
}
else
{
Info<< " No " << fieldName << endl;
} }
} }
else
{
Info<< " No " << fieldName << endl;
}
} }

75
src/postProcessing/foamCalcFunctions/field/interpolate/interpolate.C
View File

@ -58,7 +58,7 @@ Foam::calcTypes::interpolate::~interpolate()
void Foam::calcTypes::interpolate::init() void Foam::calcTypes::interpolate::init()
{ {
Foam::argList::validArgs.append("interpolate"); Foam::argList::validArgs.append("interpolate");
argList::validArgs.append("fieldName1 .. fieldNameN"); argList::validArgs.append("fieldName");
} }
@ -68,14 +68,7 @@ void Foam::calcTypes::interpolate::preCalc
const Time& runTime, const Time& runTime,
const fvMesh& mesh const fvMesh& mesh
) )
{ {}
if (args.additionalArgs().size() < 2)
{
Info<< nl << "must specify one or more fields" << nl;
args.printUsage();
FatalError.exit();
}
}
void Foam::calcTypes::interpolate::calc void Foam::calcTypes::interpolate::calc
@ -85,50 +78,40 @@ void Foam::calcTypes::interpolate::calc
const fvMesh& mesh const fvMesh& mesh
) )
{ {
const stringList& params = args.additionalArgs(); const word& fieldName = args.additionalArgs()[1];
for (label fieldi=1; fieldi<params.size(); fieldi++) IOobject fieldHeader
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// Check field exists
if (fieldHeader.headerOk())
{ {
const word fieldName(params[fieldi]); bool processed = false;
IOobject fieldHeader writeInterpolateField<scalar>(fieldHeader, mesh, processed);
( writeInterpolateField<vector>(fieldHeader, mesh, processed);
fieldName, writeInterpolateField<sphericalTensor>(fieldHeader, mesh, processed);
runTime.timeName(), writeInterpolateField<symmTensor>(fieldHeader, mesh, processed);
mesh, writeInterpolateField<tensor>(fieldHeader, mesh, processed);
IOobject::MUST_READ
);
// Check field exists if (!processed)
if (fieldHeader.headerOk())
{ {
bool processed = false; FatalError
<< "Unable to process " << fieldName << nl
writeInterpolateField<scalar>(fieldHeader, mesh, processed); << "No call to interpolate for fields of type "
writeInterpolateField<vector>(fieldHeader, mesh, processed); << fieldHeader.headerClassName() << nl << nl
writeInterpolateField<sphericalTensor> << exit(FatalError);
(
fieldHeader,
mesh,
processed
);
writeInterpolateField<symmTensor>(fieldHeader, mesh, processed);
writeInterpolateField<tensor>(fieldHeader, mesh, processed);
if (!processed)
{
FatalError
<< "Unable to process " << fieldName << nl
<< "No call to interpolate for fields of type "
<< fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
}
}
else
{
Info<< " No " << fieldName << endl;
} }
} }
else
{
Info<< " No " << fieldName << endl;
}
} }

72
src/postProcessing/foamCalcFunctions/field/mag/mag.C
View File

@ -57,8 +57,8 @@ Foam::calcTypes::mag::~mag()
void Foam::calcTypes::mag::init() void Foam::calcTypes::mag::init()
{ {
Foam::argList::validArgs.append("mag"); argList::validArgs.append("mag");
argList::validArgs.append("fieldName1 .. fieldNameN"); argList::validArgs.append("fieldName");
} }
@ -68,14 +68,7 @@ void Foam::calcTypes::mag::preCalc
const Time& runTime, const Time& runTime,
const fvMesh& mesh const fvMesh& mesh
) )
{ {}
if (args.additionalArgs().size() < 2)
{
Info<< nl << "must specify one or more fields" << nl;
args.printUsage();
FatalError.exit();
}
}
void Foam::calcTypes::mag::calc void Foam::calcTypes::mag::calc
@ -85,45 +78,40 @@ void Foam::calcTypes::mag::calc
const fvMesh& mesh const fvMesh& mesh
) )
{ {
const stringList& params = args.additionalArgs(); const word& fieldName = args.additionalArgs()[1];
for (label fieldi=1; fieldi<params.size(); fieldi++) IOobject fieldHeader
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// Check field exists
if (fieldHeader.headerOk())
{ {
const word fieldName(params[fieldi]); bool processed = false;
IOobject fieldHeader writeMagField<scalar>(fieldHeader, mesh, processed);
( writeMagField<vector>(fieldHeader, mesh, processed);
fieldName, writeMagField<sphericalTensor>(fieldHeader, mesh, processed);
runTime.timeName(), writeMagField<symmTensor>(fieldHeader, mesh, processed);
mesh, writeMagField<tensor>(fieldHeader, mesh, processed);
IOobject::MUST_READ
);
// Check field exists if (!processed)
if (fieldHeader.headerOk())
{ {
bool processed = false; FatalError
<< "Unable to process " << fieldName << nl
writeMagField<scalar>(fieldHeader, mesh, processed); << "No call to mag for fields of type "
writeMagField<vector>(fieldHeader, mesh, processed); << fieldHeader.headerClassName() << nl << nl
writeMagField<sphericalTensor>(fieldHeader, mesh, processed); << exit(FatalError);
writeMagField<symmTensor>(fieldHeader, mesh, processed);
writeMagField<tensor>(fieldHeader, mesh, processed);
if (!processed)
{
FatalError
<< "Unable to process " << fieldName << nl
<< "No call to mag for fields of type "
<< fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
}
}
else
{
Info<< " No " << fieldName << endl;
} }
} }
else
{
Info<< " No " << fieldName << endl;
}
} }

66
src/postProcessing/foamCalcFunctions/field/magGrad/magGrad.C
View File

@ -57,8 +57,8 @@ Foam::calcTypes::magGrad::~magGrad()
void Foam::calcTypes::magGrad::init() void Foam::calcTypes::magGrad::init()
{ {
Foam::argList::validArgs.append("magGrad"); argList::validArgs.append("magGrad");
argList::validArgs.append("fieldName1 .. fieldNameN"); argList::validArgs.append("fieldName");
} }
@ -68,14 +68,7 @@ void Foam::calcTypes::magGrad::preCalc
const Time& runTime, const Time& runTime,
const fvMesh& mesh const fvMesh& mesh
) )
{ {}
if (args.additionalArgs().size() < 2)
{
Info<< nl << "must specify one or more fields" << nl;
args.printUsage();
FatalError.exit();
}
}
void Foam::calcTypes::magGrad::calc void Foam::calcTypes::magGrad::calc
@ -85,42 +78,37 @@ void Foam::calcTypes::magGrad::calc
const fvMesh& mesh const fvMesh& mesh
) )
{ {
const stringList& params = args.additionalArgs(); const word& fieldName = args.additionalArgs()[1];
for (label fieldi=1; fieldi<params.size(); fieldi++) IOobject fieldHeader
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// Check field exists
if (fieldHeader.headerOk())
{ {
const word fieldName(params[fieldi]); bool processed = false;
IOobject fieldHeader writeMagGradField<scalar>(fieldHeader, mesh, processed);
( writeMagGradField<vector>(fieldHeader, mesh, processed);
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// Check field exists if (!processed)
if (fieldHeader.headerOk())
{ {
bool processed = false; FatalError
<< "Unable to process " << fieldName << nl
writeMagGradField<scalar>(fieldHeader, mesh, processed); << "No call to magGrad for fields of type "
writeMagGradField<vector>(fieldHeader, mesh, processed); << fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
if (!processed)
{
FatalError
<< "Unable to process " << fieldName << nl
<< "No call to magGrad for fields of type "
<< fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
}
}
else
{
Info<< " No " << fieldName << endl;
} }
} }
else
{
Info<< " No " << fieldName << endl;
}
} }

71
src/postProcessing/foamCalcFunctions/field/magSqr/magSqr.C
View File

@ -58,7 +58,7 @@ Foam::calcTypes::magSqr::~magSqr()
void Foam::calcTypes::magSqr::init() void Foam::calcTypes::magSqr::init()
{ {
Foam::argList::validArgs.append("magSqr"); Foam::argList::validArgs.append("magSqr");
argList::validArgs.append("fieldName1 .. fieldNameN"); argList::validArgs.append("fieldName");
} }
@ -68,14 +68,7 @@ void Foam::calcTypes::magSqr::preCalc
const Time& runTime, const Time& runTime,
const fvMesh& mesh const fvMesh& mesh
) )
{ {}
if (args.additionalArgs().size() < 2)
{
Info<< nl << "must specify one or more fields" << nl;
args.printUsage();
FatalError.exit();
}
}
void Foam::calcTypes::magSqr::calc void Foam::calcTypes::magSqr::calc
@ -85,47 +78,43 @@ void Foam::calcTypes::magSqr::calc
const fvMesh& mesh const fvMesh& mesh
) )
{ {
const stringList& params = args.additionalArgs(); const word& fieldName = args.additionalArgs()[1];
for (label fieldi=1; fieldi<params.size(); fieldi++) IOobject fieldHeader
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// Check field exists
if (fieldHeader.headerOk())
{ {
const word fieldName(params[fieldi]); bool processed = false;
IOobject fieldHeader writeMagSqrField<scalar>(fieldHeader, mesh, processed);
( writeMagSqrField<vector>(fieldHeader, mesh, processed);
fieldName, writeMagSqrField<sphericalTensor>(fieldHeader, mesh, processed);
runTime.timeName(), writeMagSqrField<symmTensor>(fieldHeader, mesh, processed);
mesh, writeMagSqrField<tensor>(fieldHeader, mesh, processed);
IOobject::MUST_READ
);
// Check field exists if (!processed)
if (fieldHeader.headerOk())
{ {
bool processed = false; FatalError
<< "Unable to process " << fieldName << nl
writeMagSqrField<scalar>(fieldHeader, mesh, processed); << "No call to magSqr for fields of type "
writeMagSqrField<vector>(fieldHeader, mesh, processed); << fieldHeader.headerClassName() << nl << nl
writeMagSqrField<sphericalTensor>(fieldHeader, mesh, processed); << exit(FatalError);
writeMagSqrField<symmTensor>(fieldHeader, mesh, processed);
writeMagSqrField<tensor>(fieldHeader, mesh, processed);
if (!processed)
{
FatalError
<< "Unable to process " << fieldName << nl
<< "No call to magSqr for fields of type "
<< fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
}
}
else
{
Info<< " No " << fieldName << endl;
} }
} }
else
{
Info<< " No " << fieldName << endl;
}
} }
// ************************************************************************* // // ************************************************************************* //

122
src/postProcessing/foamCalcFunctions/field/randomise/randomise.C
View File

@ -59,7 +59,7 @@ void Foam::calcTypes::randomise::init()
{ {
argList::validArgs.append("randomise"); argList::validArgs.append("randomise");
argList::validArgs.append("perturbation"); argList::validArgs.append("perturbation");
argList::validArgs.append("fieldName1 .. fieldNameN"); argList::validArgs.append("fieldName");
} }
@ -69,17 +69,7 @@ void Foam::calcTypes::randomise::preCalc
const Time& runTime, const Time& runTime,
const fvMesh& mesh const fvMesh& mesh
) )
{ {}
if (args.additionalArgs().size() < 3)
{
Info<< nl
<< "must specify perturbation magnitude and one"
<< "or more fields"
<< nl;
args.printUsage();
FatalError.exit();
}
}
void Foam::calcTypes::randomise::calc void Foam::calcTypes::randomise::calc
@ -91,73 +81,69 @@ void Foam::calcTypes::randomise::calc
{ {
const stringList& params = args.additionalArgs(); const stringList& params = args.additionalArgs();
const scalar pertMag = readScalar(IStringStream(params[1])()); const scalar pertMag = readScalar(IStringStream(params[1])());
const word& fieldName = params[2];
Random rand(1234567); Random rand(1234567);
for (label fieldi=2; fieldi<params.size(); fieldi++) IOobject fieldHeader
{ (
const word fieldName(params[fieldi]); fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
IOobject fieldHeader // Check field exists
if (fieldHeader.headerOk())
{
bool processed = false;
writeRandomField<vector>
( (
fieldName, fieldHeader,
runTime.timeName(), pertMag,
rand,
mesh, mesh,
IOobject::MUST_READ processed
);
writeRandomField<sphericalTensor>
(
fieldHeader,
pertMag,
rand,
mesh,
processed
);
writeRandomField<symmTensor>
(
fieldHeader,
pertMag,
rand,
mesh,
processed
);
writeRandomField<tensor>
(
fieldHeader,
pertMag,
rand,
mesh,
processed
); );
// Check field exists if (!processed)
if (fieldHeader.headerOk())
{ {
bool processed = false; FatalError
<< "Unable to process " << fieldName << nl
writeRandomField<vector> << "No call to randomise for fields of type "
( << fieldHeader.headerClassName() << nl << nl
fieldHeader, << exit(FatalError);
pertMag,
rand,
mesh,
processed
);
writeRandomField<sphericalTensor>
(
fieldHeader,
pertMag,
rand,
mesh,
processed
);
writeRandomField<symmTensor>
(
fieldHeader,
pertMag,
rand,
mesh,
processed
);
writeRandomField<tensor>
(
fieldHeader,
pertMag,
rand,
mesh,
processed
);
if (!processed)
{
FatalError
<< "Unable to process " << fieldName << nl
<< "No call to randomise for fields of type "
<< fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
}
}
else
{
Info<< " No " << fieldName << endl;
} }
} }
else
{
Info<< " No " << fieldName << endl;
}
} }