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()
{
Foam::argList::validArgs.append("components");
argList::validArgs.append("fieldName1 .. fieldNameN");
argList::validArgs.append("components");
argList::validArgs.append("fieldName");
}
@ -68,14 +68,7 @@ void Foam::calcTypes::components::preCalc
const Time& runTime,
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
@ -85,49 +78,39 @@ void Foam::calcTypes::components::calc
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
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
writeComponentFields<vector>(fieldHeader, mesh, processed);
writeComponentFields<sphericalTensor>(fieldHeader, mesh, processed);
writeComponentFields<symmTensor>(fieldHeader, mesh, processed);
writeComponentFields<tensor>(fieldHeader, mesh, processed);
// Check field exists
if (fieldHeader.headerOk())
if (!processed)
{
bool processed = false;
writeComponentFields<vector>(fieldHeader, mesh, processed);
writeComponentFields<sphericalTensor>
(
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;
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;
}
}

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

@ -57,8 +57,8 @@ Foam::calcTypes::div::~div()
void Foam::calcTypes::div::init()
{
Foam::argList::validArgs.append("div");
argList::validArgs.append("fieldName1 .. fieldNameN");
argList::validArgs.append("div");
argList::validArgs.append("fieldName");
}
@ -68,14 +68,7 @@ void Foam::calcTypes::div::preCalc
const Time& runTime,
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
@ -85,42 +78,37 @@ void Foam::calcTypes::div::calc
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
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
writeDivField<surfaceScalarField>(fieldHeader, mesh, processed);
writeDivField<volVectorField>(fieldHeader, mesh, processed);
// Check field exists
if (fieldHeader.headerOk())
if (!processed)
{
bool processed = false;
writeDivField<surfaceScalarField>(fieldHeader, mesh, processed);
writeDivField<volVectorField>(fieldHeader, mesh, processed);
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;
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;
}
}

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

@ -58,7 +58,7 @@ Foam::calcTypes::interpolate::~interpolate()
void Foam::calcTypes::interpolate::init()
{
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 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
@ -85,50 +78,40 @@ void Foam::calcTypes::interpolate::calc
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
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
writeInterpolateField<scalar>(fieldHeader, mesh, processed);
writeInterpolateField<vector>(fieldHeader, mesh, processed);
writeInterpolateField<sphericalTensor>(fieldHeader, mesh, processed);
writeInterpolateField<symmTensor>(fieldHeader, mesh, processed);
writeInterpolateField<tensor>(fieldHeader, mesh, processed);
// Check field exists
if (fieldHeader.headerOk())
if (!processed)
{
bool processed = false;
writeInterpolateField<scalar>(fieldHeader, mesh, processed);
writeInterpolateField<vector>(fieldHeader, mesh, processed);
writeInterpolateField<sphericalTensor>
(
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;
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;
}
}

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

@ -57,8 +57,8 @@ Foam::calcTypes::mag::~mag()
void Foam::calcTypes::mag::init()
{
Foam::argList::validArgs.append("mag");
argList::validArgs.append("fieldName1 .. fieldNameN");
argList::validArgs.append("mag");
argList::validArgs.append("fieldName");
}
@ -68,14 +68,7 @@ void Foam::calcTypes::mag::preCalc
const Time& runTime,
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
@ -85,45 +78,40 @@ void Foam::calcTypes::mag::calc
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
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
writeMagField<scalar>(fieldHeader, mesh, processed);
writeMagField<vector>(fieldHeader, mesh, processed);
writeMagField<sphericalTensor>(fieldHeader, mesh, processed);
writeMagField<symmTensor>(fieldHeader, mesh, processed);
writeMagField<tensor>(fieldHeader, mesh, processed);
// Check field exists
if (fieldHeader.headerOk())
if (!processed)
{
bool processed = false;
writeMagField<scalar>(fieldHeader, mesh, processed);
writeMagField<vector>(fieldHeader, mesh, processed);
writeMagField<sphericalTensor>(fieldHeader, mesh, processed);
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;
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;
}
}

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

@ -57,8 +57,8 @@ Foam::calcTypes::magGrad::~magGrad()
void Foam::calcTypes::magGrad::init()
{
Foam::argList::validArgs.append("magGrad");
argList::validArgs.append("fieldName1 .. fieldNameN");
argList::validArgs.append("magGrad");
argList::validArgs.append("fieldName");
}
@ -68,14 +68,7 @@ void Foam::calcTypes::magGrad::preCalc
const Time& runTime,
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
@ -85,42 +78,37 @@ void Foam::calcTypes::magGrad::calc
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
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
writeMagGradField<scalar>(fieldHeader, mesh, processed);
writeMagGradField<vector>(fieldHeader, mesh, processed);
// Check field exists
if (fieldHeader.headerOk())
if (!processed)
{
bool processed = false;
writeMagGradField<scalar>(fieldHeader, mesh, processed);
writeMagGradField<vector>(fieldHeader, mesh, processed);
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;
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;
}
}

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

@ -58,7 +58,7 @@ Foam::calcTypes::magSqr::~magSqr()
void Foam::calcTypes::magSqr::init()
{
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 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
@ -85,47 +78,43 @@ void Foam::calcTypes::magSqr::calc
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
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
writeMagSqrField<scalar>(fieldHeader, mesh, processed);
writeMagSqrField<vector>(fieldHeader, mesh, processed);
writeMagSqrField<sphericalTensor>(fieldHeader, mesh, processed);
writeMagSqrField<symmTensor>(fieldHeader, mesh, processed);
writeMagSqrField<tensor>(fieldHeader, mesh, processed);
// Check field exists
if (fieldHeader.headerOk())
if (!processed)
{
bool processed = false;
writeMagSqrField<scalar>(fieldHeader, mesh, processed);
writeMagSqrField<vector>(fieldHeader, mesh, processed);
writeMagSqrField<sphericalTensor>(fieldHeader, mesh, processed);
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;
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;
}
}
// ************************************************************************* //

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("perturbation");
argList::validArgs.append("fieldName1 .. fieldNameN");
argList::validArgs.append("fieldName");
}
@ -69,17 +69,7 @@ void Foam::calcTypes::randomise::preCalc
const Time& runTime,
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
@ -91,73 +81,69 @@ void Foam::calcTypes::randomise::calc
{
const stringList& params = args.additionalArgs();
const scalar pertMag = readScalar(IStringStream(params[1])());
const word& fieldName = params[2];
Random rand(1234567);
for (label fieldi=2; fieldi<params.size(); fieldi++)
{
const word fieldName(params[fieldi]);
IOobject fieldHeader
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
IOobject fieldHeader
// Check field exists
if (fieldHeader.headerOk())
{
bool processed = false;
writeRandomField<vector>
(
fieldName,
runTime.timeName(),
fieldHeader,
pertMag,
rand,
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 (fieldHeader.headerOk())
if (!processed)
{
bool processed = false;
writeRandomField<vector>
(
fieldHeader,
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;
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;
}
}