// Construct from components
eulerianScalarField::eulerianScalarField
(
const dictionary& dict,
cfdemCloud& sm,
word modelType,
int modelID
)
:
dict_(dict),
particleCloud_(sm),
fieldName_(modelType),
cpVolumetricFieldName_(dict_.lookupOrDefault<word>("cpVolumetricFieldName", "na")),
cpVolumetric_(dict_.lookupOrDefault<scalar>("cpVolumetric", 0.0)),
updateMixtureProperties_(dict_.lookupOrDefault<bool>("updateMixtureProperties", false)),
rho_(dict_.lookupOrDefault<scalar>("rho"+fieldName_, -1)),
rhoCarrier_(dict_.lookupOrDefault<scalar>("rhoCarrier", -1)),
cp_(dict_.lookupOrDefault<scalar>("cp"+fieldName_, -1)),
cpCarrier_(dict_.lookupOrDefault<scalar>("cpCarrier", -1)),
m_
( IOobject
(
fieldName_,
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
sm.mesh()
),
mSource_
( IOobject
(
fieldName_+"Source",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
sm.mesh()
),
mSourceKImpl_
( IOobject
(
fieldName_+"SourceKImpl",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
0.0*mSource_ /( m_ + dimensionedScalar("dummy", m_.dimensions(), 1e-32) ) //initi with zero
),
fieldType_("undefined")
#ifndef versionExt32
,fvOptions_(sm.mesh())
#endif
{
if ( m_.dimensions() == dimensionSet(0, 0, 0, 1, 0) )
{
speciesID_ = -1;
fieldType_ = "temperature";
Info << "eulerianScalarField:: found a Temperature field! " << endl;
}
else
{
speciesID_ = modelID;
fieldType_ = "species";
Info << "eulerianScalarField:: found a species field, will assign speciesID: "
<< speciesID_
<< endl;
}
#ifndef versionExt32
fvOptions_.reset(dict.subDict("fvOptions"+fieldName_));
#endif
if( (cpVolumetricFieldName_=="na"||!updateMixtureProperties_) && cpVolumetric_<=0.0)
FatalError <<"You did not specify a cpVolumetricFieldName (or you do not updateMixtureProperties) and also cpVolumetric is zero (or negative)! Either provide the field name, or set cpVolumetric to a reasonable value. \n"
<< abort(FatalError);
if(speciesID_>-1 && updateMixtureProperties_ && (rho_<=0 || cp_<=0) )
FatalError <<"You like to update the phase properties, but density and cp of the eulerianScalarField with name '"
<< fieldName_
<<"' are not specified or zero. \n"
<< abort(FatalError);
if(speciesID_>-1 && updateMixtureProperties_ && (rhoCarrier_<=0 || cpCarrier_<=0) )
FatalError <<"You like to update the phase properties, but density and cp of the carrier phase are not specified or zero \n"
<< abort(FatalError);
//Report options for cp
if(fieldType_=="temperature")
{
if(cpVolumetric_!=0.0 && cpVolumetricFieldName_!="na")
FatalError <<"eulerianScalarField:: You have specified 'cpVolumetric' and 'cpVolumetricFieldName' in a dictionary in '/constant'. This might be confusing. Please unset one of these two inputs to avoid confusion. \n"
<< abort(FatalError);
if(cpVolumetricFieldName_=="na" || !updateMixtureProperties_) //use also if mixture properties are not updated
Info << "eulerianScalarField:: will use the following FIXED VOLUMETRIC HEAT CAPACITY: "
<< cpVolumetric_ << " [J/K/m³]" << endl;
else
Info << "eulerianScalarField:: will use the a SPATIALLY-VARAIBLE VOLUMETRIC HEAT CAPACITY with name: " << cpVolumetricFieldName_ << endl;
}
}
Foam::specie::specie(const dictionary& dict)
:
// name_(dict.dictName()),
nMoles_(readScalar(dict.subDict("specie").lookup("nMoles"))),
molWeight_(readScalar(dict.subDict("specie").lookup("molWeight")))
{}
// Construct from components
polyVelocityBounded::polyVelocityBounded
(
Time& t,
polyMoleculeCloud& molCloud,
const dictionary& dict
)
:
polyStateController(t, molCloud, dict),
propsDict_(dict.subDict(typeName + "Properties")),
molIds_(),
bb_(),
// avMass_(0.0),
lambda_(readScalar(propsDict_.lookup("lambda"))),
deltaT_(t.deltaT().value()),
accumulatedTime_(0.0),
startTime_(0.0),
endTime_(GREAT),
X_(false),
Y_(false),
Z_(false)
{
writeInTimeDir_ = false;
writeInCase_ = false;
// singleValueController() = true;
setBoundBox();
molIds_.clear();
selectIds ids
(
molCloud_.cP(),
propsDict_
);
molIds_ = ids.molIds();
velocity_ = propsDict_.lookup("velocity");
if (propsDict_.found("componentControl"))
{
componentControl_ = Switch(propsDict_.lookup("componentControl"));
if(componentControl_)
{
if (propsDict_.found("X"))
{
X_ = Switch(propsDict_.lookup("X"));
}
if (propsDict_.found("Y"))
{
Y_ = Switch(propsDict_.lookup("Y"));
}
if (propsDict_.found("Z"))
{
Z_ = Switch(propsDict_.lookup("Z"));
}
if(!X_ && !Y_ && !Z_)
{
FatalErrorIn("polyVelocityBounded::polyVelocityBounded()")
<< "At least one component (X, Y, Z) should be chosen " << nl << "in: "
<< time_.time().system()/"controllersDict"
<< exit(FatalError);
}
}
}
if (propsDict_.found("startAtTime"))
{
startTime_ = readScalar(propsDict_.lookup("startAtTime"));
}
if (propsDict_.found("endAtTime"))
{
endTime_ = readScalar(propsDict_.lookup("endAtTime"));
}
}
Foam::searchableSurfaces::searchableSurfaces
(
const IOobject& io,
const dictionary& topDict
)
:
PtrList<searchableSurface>(topDict.size()),
names_(topDict.size()),
regionNames_(topDict.size()),
allSurfaces_(identity(topDict.size()))
{
label surfI = 0;
forAllConstIter(dictionary, topDict, iter)
{
const word& key = iter().keyword();
if (!topDict.isDict(key))
{
FatalErrorIn
(
"searchableSurfaces::searchableSurfaces"
"( const IOobject&, const dictionary&)"
) << "Found non-dictionary entry " << iter()
<< " in top-level dictionary " << topDict
<< exit(FatalError);
}
const dictionary& dict = topDict.subDict(key);
names_[surfI] = key;
dict.readIfPresent("name", names_[surfI]);
// Make IOobject with correct name
autoPtr<IOobject> namedIO(io.clone());
// Note: we would like to e.g. register triSurface 'sphere.stl' as
// 'sphere'. Unfortunately
// no support for having object read from different location than
// their object name. Maybe have stlTriSurfaceMesh which appends .stl
// when reading/writing?
namedIO().rename(key); // names_[surfI]
// Create and hook surface
set
(
surfI,
searchableSurface::New
(
dict.lookup("type"),
namedIO(),
dict
)
);
const searchableSurface& s = operator[](surfI);
// Construct default region names by prepending surface name
// to region name.
const wordList& localNames = s.regions();
wordList& rNames = regionNames_[surfI];
rNames.setSize(localNames.size());
forAll(localNames, regionI)
{
rNames[regionI] = names_[surfI] + '_' + localNames[regionI];
}
// See if dictionary provides any global region names.
if (dict.found("regions"))
{
const dictionary& regionsDict = dict.subDict("regions");
forAllConstIter(dictionary, regionsDict, iter)
{
const word& key = iter().keyword();
if (regionsDict.isDict(key))
{
// Get the dictionary for region iter.keyword()
const dictionary& regionDict = regionsDict.subDict(key);
label index = findIndex(localNames, key);
if (index == -1)
{
FatalErrorIn
(
"searchableSurfaces::searchableSurfaces"
"( const IOobject&, const dictionary&)"
) << "Unknown region name " << key
<< " for surface " << s.name() << endl
<< "Valid region names are " << localNames
<< exit(FatalError);
}
rNames[index] = word(regionDict.lookup("name"));
}
}
}
surfI++;
}
Foam::C10H22::C10H22(const dictionary& dict)
:
liquidProperties(dict),
rho_(dict.subDict("rho")),
pv_(dict.subDict("pv")),
hl_(dict.subDict("hl")),
Cp_(dict.subDict("Cp")),
h_(dict.subDict("h")),
Cpg_(dict.subDict("Cpg")),
B_(dict.subDict("B")),
mu_(dict.subDict("mu")),
mug_(dict.subDict("mug")),
K_(dict.subDict("K")),
Kg_(dict.subDict("Kg")),
sigma_(dict.subDict("sigma")),
D_(dict.subDict("D"))
{}
Foam::Leonov::Leonov
(
const word& name,
const volScalarField& alpha,
const volVectorField& U,
const surfaceScalarField& phi,
const dictionary& dict
)
:
viscoelasticLaw(name, alpha, U, phi),
sigma_
(
IOobject
(
"sigma" + name,
U.time().timeName(),
U.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
U.mesh()
),
tau_
(
IOobject
(
"tau" + name,
U.time().timeName(),
U.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
U.mesh(),
dimensionedSymmTensor
(
"zero",
dimensionSet(1, -1, -2, 0, 0, 0, 0),
symmTensor::zero
)
),
I_
(
dimensionedSymmTensor
(
"I",
dimensionSet(0, 0, 0, 0, 0, 0, 0),
symmTensor
(
1, 0, 0,
1, 0,
1
)
)
),
rho1_(dict.subDict("phase1").lookup("rho")),
rho2_(dict.subDict("phase2").lookup("rho")),
etaS1_(dict.subDict("phase1").lookup("etaS")),
etaS2_(dict.subDict("phase2").lookup("etaS")),
etaP1_(dict.subDict("phase1").lookup("etaP")),
etaP2_(dict.subDict("phase2").lookup("etaP")),
lambda1_(dict.subDict("phase1").lookup("lambda")),
lambda2_(dict.subDict("phase2").lookup("lambda"))
{}
bool Foam::combustionModel::read(const dictionary& combustionProps)
{
coeffs_ = combustionProps.subDict(type() + "Coeffs");
return true;
}
Foam::phaseModel::phaseModel
(
const fvMesh& mesh,
const dictionary& transportProperties,
const word& phaseName
)
:
dict_
(
transportProperties.subDict("phase" + phaseName)
),
name_(phaseName),
d_
(
dict_.lookup("d")
),
nu_
(
dict_.lookup("nu")
),
rho_
(
dict_.lookup("rho")
),
U_
(
IOobject
(
"U" + phaseName,
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
)
{
const word phiName = "phi" + phaseName;
IOobject phiHeader
(
phiName,
mesh.time().timeName(),
mesh,
IOobject::NO_READ
);
if (phiHeader.headerOk())
{
Info<< "Reading face flux field " << phiName << endl;
phiPtr_.reset
(
new surfaceScalarField
(
IOobject
(
phiName,
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh
)
);
}
else
{
Info<< "Calculating face flux field " << phiName << endl;
wordList phiTypes
(
U_.boundaryField().size(),
calculatedFvPatchScalarField::typeName
);
for (label i=0; i<U_.boundaryField().size(); i++)
{
if (isA<fixedValueFvPatchVectorField>(U_.boundaryField()[i]))
{
phiTypes[i] = fixedValueFvPatchScalarField::typeName;
}
}
phiPtr_.reset
(
new surfaceScalarField
(
IOobject
(
phiName,
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
fvc::interpolate(U_) & mesh.Sf(),
phiTypes
)
);
}
}
// from components
Feta_PTT::Feta_PTT
(
const word& name,
const volScalarField& alpha,
const volVectorField& U,
const surfaceScalarField& phi,
const dictionary& dict
)
:
viscoelasticLaw(name, alpha, U, phi),
tau_
(
IOobject
(
"tau" + name,
U.time().timeName(),
U.mesh(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
U.mesh()
),
etaS1_(dict.subDict("phase1").lookup("etaS")),
etaS2_(dict.subDict("phase2").lookup("etaS")),
etaP1_(dict.subDict("phase1").lookup("etaP")),
etaP2_(dict.subDict("phase2").lookup("etaP")),
lambda1_(dict.subDict("phase1").lookup("lambda")),
lambda2_(dict.subDict("phase2").lookup("lambda")),
epsilon1_(dict.subDict("phase1").lookup("epsilon")),
epsilon2_(dict.subDict("phase2").lookup("epsilon")),
zeta1_(dict.subDict("phase1").lookup("zeta")),
zeta2_(dict.subDict("phase2").lookup("zeta")),
A1_(dict.subDict("phase1").lookup("A")),
A2_(dict.subDict("phase2").lookup("A")),
a1_(dict.subDict("phase1").lookup("a")),
a2_(dict.subDict("phase2").lookup("a")),
b1_(dict.subDict("phase1").lookup("b")),
b2_(dict.subDict("phase2").lookup("b")),
alpha1f_
(
IOobject
(
"alpha1f" + name,
U.time().timeName(),
U.mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
min(max(alpha, scalar(0)), scalar(1))
),
etaPEff_
(
IOobject
(
"etaPEff" + name,
U.time().timeName(),
U.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
(etaP1_/( Foam::pow(scalar(1) + A1_*Foam::pow(0.5*( Foam::sqr(tr(tau_)) - tr(tau_ & tau_) ) * Foam::sqr(lambda1_) / Foam::sqr(etaP1_), a1_), b1_) ) )*alpha1f_ + (etaP2_/( Foam::pow(scalar(1) + A2_*Foam::pow(0.5*( Foam::sqr(tr(tau_)) - tr(tau_ & tau_) ) * Foam::sqr(lambda2_) / Foam::sqr(etaP2_), a2_), b2_) ) )*(scalar(1) - alpha1f_)
),
lambdaEff_
(
IOobject
(
"lambdaEff" + name,
U.time().timeName(),
U.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
(lambda1_ / (scalar(1) + epsilon1_*lambda1_*tr(tau_) / etaP1_) )*alpha1f_ + (lambda2_ / (scalar(1) + epsilon2_*lambda2_*tr(tau_) / etaP2_) )*(scalar(1) - alpha1f_)
)
{}
Foam::radiation::greyMeanAbsorptionEmission::greyMeanAbsorptionEmission
(
const dictionary& dict,
const fvMesh& mesh
)
:
absorptionEmissionModel(dict, mesh),
coeffsDict_((dict.subDict(typeName + "Coeffs"))),
speciesNames_(0),
specieIndex_(0),
lookUpTable_
(
fileName(coeffsDict_.lookup("lookUpTableFileName")),
mesh.time().constant(),
mesh
),
thermo_(mesh.lookupObject<basicThermo>("thermophysicalProperties")),
EhrrCoeff_(readScalar(coeffsDict_.lookup("EhrrCoeff"))),
Yj_(nSpecies_)
{
label nFunc = 0;
const dictionary& functionDicts = dict.subDict(typeName + "Coeffs");
forAllConstIter(dictionary, functionDicts, iter)
{
// safety:
if (!iter().isDict())
{
continue;
}
const word& key = iter().keyword();
speciesNames_.insert(key, nFunc);
const dictionary& dict = iter().dict();
coeffs_[nFunc].initialise(dict);
nFunc++;
}
// Check that all the species on the dictionary are present in the
// look-up table and save the corresponding indices of the look-up table
label j = 0;
forAllConstIter(HashTable<label>, speciesNames_, iter)
{
if (mesh.foundObject<volScalarField>("ft"))
{
if (lookUpTable_.found(iter.key()))
{
label index = lookUpTable_.findFieldIndex(iter.key());
Info<< "specie: " << iter.key() << " found on look-up table "
<< " with index: " << index << endl;
specieIndex_[iter()] = index;
}
else if (mesh.foundObject<volScalarField>(iter.key()))
{
volScalarField& Y =
const_cast<volScalarField&>
(
mesh.lookupObject<volScalarField>(iter.key())
);
Yj_.set(j, &Y);
specieIndex_[iter()] = 0;
j++;
Info<< "specie: " << iter.key() << " is being solved" << endl;
}
else
{
FatalErrorIn
(
"Foam::radiation::greyMeanAbsorptionEmission(const"
"dictionary& dict, const fvMesh& mesh)"
) << "specie: " << iter.key()
<< " is neither in look-up table: "
<< lookUpTable_.tableName()
<< " nor is being solved" << nl
<< exit(FatalError);
}
}
else
{
FatalErrorIn
(
"Foam::radiation::greyMeanAbsorptionEmission(const"
"dictionary& dict, const fvMesh& mesh)"
) << "specie ft is not present " << nl
<< exit(FatalError);
}
}
}
void Foam::multiSolver::buildDictionary
(
dictionary& outputDict,
const dictionary& inputDict,
const word& solverDomainName
)
{
outputDict.remove("sameAs");
outputDict.remove("multiLoad");
wordList alreadyMerged(0);
wordList mergeMe(0);
if (inputDict.found("default"))
{
if (outputDict.found("multiLoad"))
{
mergeMe = wordList(outputDict.lookup("multiLoad"));
outputDict.remove("multiLoad");
}
if (outputDict.found("sameAs"))
{
label newIndex(mergeMe.size());
mergeMe.setSize(newIndex + 1);
mergeMe[newIndex] = word(outputDict.lookup("sameAs"));
outputDict.remove("sameAs");
}
}
// We load solverDomain last, but we need its sameAs / multiLoad now
if (inputDict.found(solverDomainName))
{
const dictionary& solverDict(inputDict.subDict(solverDomainName));
if (solverDict.found("multiLoad"))
{
mergeMe.append(wordList(solverDict.lookup("multiLoad")));
}
if (solverDict.found("sameAs"))
{
label newIndex(mergeMe.size());
mergeMe.setSize(newIndex + 1);
mergeMe[newIndex] = word(solverDict.lookup("sameAs"));
}
}
label mergeI(-1);
while ((mergeI + 1) < mergeMe.size())
{
mergeI++;
bool skipMe(false);
forAll(alreadyMerged, alreadyI)
{
if (mergeMe[mergeI] == alreadyMerged[alreadyI])
{
skipMe = true;
break;
}
}
if (skipMe)
{
break;
}
outputDict.merge(inputDict.subDict(mergeMe[mergeI]));
// Add to alreadyMerged
label mergedIndex(alreadyMerged.size());
alreadyMerged.setSize(mergedIndex + 1);
alreadyMerged[mergedIndex] = mergeMe[mergeI];
// Recursive search
if (outputDict.found("multiLoad"))
{
mergeMe.append(wordList(outputDict.lookup("multiLoad")));
outputDict.remove("multiLoad");
}
if (outputDict.found("sameAs"))
{
label newMergeMeIndex(mergeMe.size());
mergeMe.setSize(newMergeMeIndex + 1);
mergeMe[newMergeMeIndex] = word(outputDict.lookup("sameAs"));
outputDict.remove("sameAs");
}
}
// Merge the solverDomain name, even if it already has merged
if (inputDict.found(solverDomainName))
{
outputDict.merge(inputDict.subDict(solverDomainName));
// These have been handled already
outputDict.remove("sameAs");
outputDict.remove("multiLoad");
}
}
pythonInterpreterWrapper::pythonInterpreterWrapper
(
const objectRegistry& obr,
const dictionary& dict,
bool forceToNamespace
):
generalInterpreterWrapperCRTP<pythonInterpreterWrapper>(
obr,
dict,
forceToNamespace,
"python"
),
pythonState_(NULL),
useNumpy_(dict.lookupOrDefault<bool>("useNumpy",true)),
useIPython_(dict.lookupOrDefault<bool>("useIPython",true)),
triedIPython_(false),
oldIPython_(false)
{
if(generalInterpreterWrapper::debug>debug) {
debug=1;
}
Pbug << "Starting constructor" << endl;
syncParallel();
#ifdef FOAM_HAS_LOCAL_DEBUGSWITCHES
debug=dict.lookupOrDefault<label>("debugPythonWrapper",debug());
#else
debug=dict.lookupOrDefault<label>("debugPythonWrapper",debug);
#endif
if(!dict.found("useNumpy")) {
WarningIn("pythonInterpreterWrapper::pythonInterpreterWrapper")
<< "Switch 'useNumpy' not found in " << dict.name() << nl
<< "Assuming it to be 'true' (if that is not what you want "
<< "set it. Also set it to make this warning go away)"
<< endl;
}
if(!dict.found("useIPython")) {
WarningIn("pythonInterpreterWrapper::pythonInterpreterWrapper")
<< "Switch 'useIPython' not found in " << dict.name() << nl
<< "Assuming it to be 'true' (if that is not what you want "
<< "set it. Also set it to make this warning go away)"
<< endl;
}
if(interpreterCount==0) {
Pbug << "Initializing Python" << endl;
Py_Initialize();
if(debug) {
PyThreadState *current=PyGILState_GetThisThreadState();
Pbug << "GIL-state before thread" << getHex(current) << endl;
}
PyEval_InitThreads();
if(debug) {
PyThreadState *current=PyGILState_GetThisThreadState();
Pbug << "GIL-state after thread" << getHex(current) << endl;
}
// importLib("scipy.stats","stats"); - OK
mainThreadState = PyEval_SaveThread();
// importLib("scipy.stats","stats"); - segFault
Pbug << "Main thread state: " << getHex(mainThreadState) << endl;
// PyRun_SimpleString("import IPython\n" // here it works as expected
// "IPython.embed()\n");
}
if(Pstream::parRun()) {
Pbug << "This is a parallel run" << endl;
parallelMasterOnly_=readBool(dict.lookup("parallelMasterOnly"));
}
if(parallelNoRun(true)) {
Pbug << "Getting out because of 'parallelNoRun'" << endl;
return;
}
interpreterCount++;
Pbug << "Getting new interpreter" << endl;
pythonState_=Py_NewInterpreter();
Pbug << "Interpreter state: " << getHex(pythonState_) << endl;
// interactiveLoop("Clean");
initIPython();
Pbug << "Currently " << interpreterCount
<< " Python interpreters (created one)" << endl;
if(
interactiveAfterExecute_
||
interactiveAfterException_
) {
} else {
if(useIPython_) {
WarningIn("pythonInterpreterWrapper::pythonInterpreterWrapper")
<< "'useIPython' not needed in " << dict.name()
<< " if there is no interactivity"
<< endl;
}
}
if(useNumpy_) {
Dbug << "Attempting to import numpy" << endl;
static bool warnedNumpy=false;
if(!warnedNumpy) {
if(getEnv("FOAM_SIGFPE")!="false") {
WarningInFunction
<< "Attempting to import numpy. On some platforms that will raise a "
<< "(harmless) floating point exception. To avoid switch off "
<< "by setting the environment variable 'FOAM_SIGFPE' to 'false'"
<< endl;
}
warnedNumpy=true;
}
int fail=!importLib("numpy");
if(fail) {
FatalErrorIn("pythonInterpreterWrapper::pythonInterpreterWrapper")
<< "Problem during import of numpy." << nl
<< "Switch if off with 'useNumpy false;' if it is not needed"
<< endl
<< exit(FatalError);
}
fail=PyRun_SimpleString(
// "def _swak_wrapOpenFOAMField_intoNumpy(address,typestr,size,nr=None):\n"
// " class iWrap(object):\n"
// " def __init__(self):\n"
// " self.__array_interface__={}\n"
// " self.__array_interface__['data']=(int(address,16),False)\n"
// " if nr:\n"
// " self.__array_interface__['shape']=(size,nr)\n"
// " else:\n"
// " self.__array_interface__['shape']=(size,)\n"
// " self.__array_interface__['version']=3\n"
// " self.__array_interface__['typestr']=typestr\n"
// " return numpy.asarray(iWrap())\n"
"class OpenFOAMFieldArray(numpy.ndarray):\n"
" def __new__(cls,address,typestr,size,nr=None,names=None):\n"
" obj=type('Temporary',(object,),{})\n"
" obj.__array_interface__={}\n"
" obj.__array_interface__['data']=(address,False)\n"
" if nr:\n"
" obj.__array_interface__['shape']=(size,nr)\n"
" else:\n"
" obj.__array_interface__['shape']=(size,)\n"
// " obj.__array_interface__['descr']=[('x',typestr)]\n"
" obj.__array_interface__['version']=3\n"
" obj.__array_interface__['typestr']=typestr\n"
" obj=numpy.asarray(obj).view(cls)\n"
" if names:\n"
" for i,n in enumerate(names):\n"
" def f(ind):\n"
" return obj[:,ind]\n"
" setattr(obj,n,f(i))\n"
" return obj\n"
" def __array_finalize__(self,obj):\n"
" if obj is None: return\n"
);
}
if(dict.found("importLibs")) {
const dictionary &libList=dict.subDict("importLibs");
forAllConstIter(dictionary,libList,iter) {
word as=(*iter).keyword();
word full((*iter).stream());
if(full=="") {
full=as;
}
importLib(full,as,true);
}
} else {
// Construct from dictionary
Foam::engineValve::engineValve
(
const word& name,
const polyMesh& mesh,
const dictionary& dict
)
:
name_(name),
mesh_(mesh),
engineDB_(refCast<const engineTime>(mesh_.time())),
csPtr_
(
coordinateSystem::New
(
"coordinateSystem",
dict.subDict("coordinateSystem")
)
),
bottomPatch_(dict.lookup("bottomPatch"), mesh.boundaryMesh()),
poppetPatch_(dict.lookup("poppetPatch"), mesh.boundaryMesh()),
stemPatch_(dict.lookup("stemPatch"), mesh.boundaryMesh()),
curtainInPortPatch_
(
dict.lookup("curtainInPortPatch"),
mesh.boundaryMesh()
),
curtainInCylinderPatch_
(
dict.lookup("curtainInCylinderPatch"),
mesh.boundaryMesh()
),
detachInCylinderPatch_
(
dict.lookup("detachInCylinderPatch"),
mesh.boundaryMesh()
),
detachInPortPatch_
(
dict.lookup("detachInPortPatch"),
mesh.boundaryMesh()
),
detachFaces_(dict.lookup("detachFaces")),
liftProfile_
(
"theta",
"lift",
name_,
IFstream
(
mesh.time().path()/mesh.time().constant()/
word(dict.lookup("liftProfileFile"))
)()
),
liftProfileStart_(min(liftProfile_.x())),
liftProfileEnd_(max(liftProfile_.x())),
minLift_(readScalar(dict.lookup("minLift"))),
minTopLayer_(readScalar(dict.lookup("minTopLayer"))),
maxTopLayer_(readScalar(dict.lookup("maxTopLayer"))),
minBottomLayer_(readScalar(dict.lookup("minBottomLayer"))),
maxBottomLayer_(readScalar(dict.lookup("maxBottomLayer"))),
diameter_(readScalar(dict.lookup("diameter")))
{}
// Construct from dictionary
Foam::dirichletNeumannFriction::dirichletNeumannFriction
(
const word& name,
const fvPatch& patch,
const dictionary& dict,
const label masterPatchID,
const label slavePatchID,
const label masterFaceZoneID,
const label slaveFaceZoneID
)
:
frictionContactModel
(
name,
patch,
dict,
masterPatchID,
slavePatchID,
masterFaceZoneID,
slaveFaceZoneID
),
frictionContactModelDict_(dict.subDict(name+"FrictionModelDict")),
frictionLawPtr_(NULL),
mesh_(patch.boundaryMesh().mesh()),
slaveDisp_(mesh().boundaryMesh()[slavePatchID].size(), vector::zero),
oldSlaveDisp_(slaveDisp_),
oldSlip_(slaveDisp_.size(), vector::zero),
slaveTraction_(mesh().boundaryMesh()[slavePatchID].size(), vector::zero),
oldSlaveTraction_(slaveTraction_),
slaveValueFrac_(mesh_.boundaryMesh()[slavePatchID].size(), symmTensor::zero),
oldSlaveValueFrac_(slaveValueFrac_),
relaxationFactor_
(readScalar(frictionContactModelDict_.lookup("relaxationFactor"))),
contactIterNum_(0),
infoFreq_(readInt(frictionContactModelDict_.lookup("infoFrequency"))),
oscillationCorr_(frictionContactModelDict_.lookup("oscillationCorrection")),
smoothingSteps_(readInt(frictionContactModelDict_.lookup("smoothingSteps"))),
oldStickSlip_(slaveDisp_.size(), 0.0),
contactFilePtr_(NULL)
{
// create friction law
frictionLawPtr_ = frictionLaw::New(
frictionContactModelDict_.lookup("frictionLaw"),
frictionContactModelDict_
).ptr();
// master proc open contact info file
if (Pstream::master())
{
word masterName = mesh_.boundary()[masterPatchID].name();
word slaveName = mesh_.boundary()[slavePatchID].name();
contactFilePtr_ =
new OFstream
(fileName("frictionContact_"+masterName+"_"+slaveName+".txt"));
OFstream& contactFile = *contactFilePtr_;
int width = 20;
contactFile << "time";
contactFile.width(width);
contactFile << "iterNum";
contactFile.width(width);
contactFile << "relaxationFactor";
contactFile.width(width);
contactFile << "slipFaces";
contactFile.width(width);
contactFile << "stickFaces";
contactFile.width(width);
contactFile << "maxMagSlaveTraction" << endl;
}
}
