OsStatus OsFileLinux::getFileInfo(OsFileInfoBase& fileinfo) const
{
OsStatus ret = OS_INVALID;
struct stat stats;
if (stat(mFilename,&stats) == 0)
{
ret = OS_SUCCESS;
fileinfo.mbIsReadOnly = (stats.st_mode & S_IWUSR) == 0;
OsTime createTime(stats.st_ctime, 0);
fileinfo.mCreateTime = createTime;
OsTime modifiedTime(stats.st_mtime, 0);
fileinfo.mModifiedTime = modifiedTime;
fileinfo.mSize = stats.st_size;
}
return ret;
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMesh( runTime );
volScalarFieldHolder p; volVectorFieldHolder U;
surfaceScalarFieldHolder phi; singlePhaseTransportModelHolder laminarTransport;
incompressible::RASModelHolder turbulence;
label pRefCell = 0;
scalar pRefValue = 0.0;
createFields( runTime, mesh, p, U, phi, laminarTransport, turbulence, pRefCell, pRefValue );
scalar cumulativeContErr = initContinuityErrs();
simpleControlHolder simple(mesh);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (simple->loop())
{
Info<< "Time = " << runTime->timeName() << nl << endl;
p->storePrevIter();
// --- Pressure-velocity SIMPLE corrector
{
fvVectorMatrixHolder UEqn = fun_UEqn( U, phi, turbulence, p );
fun_pEqn( mesh, runTime, simple, U, phi, turbulence, p, UEqn, pRefCell, pRefValue, cumulativeContErr );
}
turbulence->correct();
runTime->write();
Info<< "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
OsStatus OsFileWnt::getFileInfo(OsFileInfoBase& fileinfo) const
{
OsStatus ret = OS_INVALID;
struct stat stats;
if (stat(mFilename,&stats) == 0)
{
ret = OS_SUCCESS;
if (stats.st_mode & _S_IWRITE)
fileinfo.mbIsReadOnly = FALSE;
else
fileinfo.mbIsReadOnly = TRUE;
OsTime createTime(stats.st_ctime,0);
fileinfo.mCreateTime = createTime;
OsTime modifiedTime(stats.st_ctime,0);
fileinfo.mCreateTime = modifiedTime;
fileinfo.mSize = stats.st_size;
}
return ret;
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMesh( runTime );
basicPsiThermoHolder pThermo; volScalarFieldHolder rho; volScalarFieldHolder p;
volScalarFieldHolder h; volScalarFieldHolder psi;
volVectorFieldHolder U; surfaceScalarFieldHolder phi;
compressible::turbulenceModelHolder turbulence;
volScalarFieldHolder DpDt;
result_createFields result = createFields( runTime, mesh, pThermo, rho, p, h, psi, U, phi, turbulence, DpDt );
dimensionedScalar rhoMax = result.m_rhoMax;
dimensionedScalar rhoMin = result.m_rhoMin;
MRFZonesHolder mrfZones;
porousZonesHolder pZones;
Switch pressureImplicitPorosity;
createZones( mesh, U, mrfZones, pZones, pressureImplicitPorosity );
scalar cumulativeContErr = initContinuityErrs();
pimpleControlHolder pimple(mesh);
Info<< "\nStarting time loop\n" << endl;
while (runTime->run())
{
bool adjustTimeStep; scalar maxCo; scalar maxDeltaT;
readTimeControls( runTime, adjustTimeStep, maxCo, maxDeltaT );
scalar coNum, meanCoNum;
compressibleCourantNo( runTime, mesh, phi, rho, coNum, meanCoNum );
setDeltaT( runTime, adjustTimeStep, maxCo, coNum, maxDeltaT );
(*runTime)++;
Info<< "Time = " << runTime->timeName() << nl << endl;
rhoEqn( rho, phi );
// --- Pressure-velocity PIMPLE corrector loop
for (pimple->start(); pimple->loop(); (*pimple)++)
{
if (pimple->nOuterCorr() != 1)
{
p->storePrevIter();
rho->storePrevIter();
}
fvVectorMatrixHolder UEqn = fun_Ueqn( pimple, rho, p, U, phi, turbulence, mrfZones, pZones );
fun_hEqn( pThermo, rho, p, h, phi, turbulence, DpDt );
// --- PISO loop
for (int corr=0; corr<pimple->nCorr(); corr++)
{
fun_pEqn( mesh, runTime, pimple, pThermo, rho, p, h, psi, U, phi, turbulence, UEqn,
mrfZones, DpDt, cumulativeContErr, corr, rhoMax, rhoMin );
}
if (pimple->turbCorr())
{
turbulence->correct();
}
}
runTime->write();
Info<< "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMesh( runTime );
IOdictionaryHolder transportProperties;
volScalarFieldHolder p;
volVectorFieldHolder U;
surfaceScalarFieldHolder phi;
label pRefCell = 0;
scalar pRefValue = 0.0;
dimensionedScalar nu = createFields( runTime, mesh, transportProperties, p, U, phi, pRefCell, pRefValue );
scalar cumulativeContErr = initContinuityErrs();
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime->loop())
{
Info<< "Time = " << runTime->timeName() << nl << endl;
dictionary pisoDict;
int nOuterCorr;
int nCorr;
int nNonOrthCorr;
bool momentumPredictor;
bool transonic;
readPISOControls( mesh, pisoDict, nOuterCorr, nCorr, nNonOrthCorr, momentumPredictor, transonic);
CourantNo( runTime, mesh, phi );
fvVectorMatrixHolder UEqn
(
fvm::ddt( U )
+ fvm::div( phi, U )
- fvm::laplacian( nu, U )
);
solve( UEqn == -fvc::grad( p ) );
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
volScalarFieldHolder rAU( 1.0 / volScalarFieldHolder( UEqn->A(), &UEqn ) );
U = rAU * volVectorFieldHolder( UEqn->H(), &UEqn );
phi = ( fvc::interpolate(U) & surfaceVectorFieldHolder( mesh->Sf(), &mesh ) ) + fvc::ddtPhiCorr(rAU, U, phi);
adjustPhi(phi, U, p);
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
fvScalarMatrixHolder pEqn
(
fvm::laplacian(rAU, p ) == fvc::div(phi)
);
pEqn->setReference(pRefCell, pRefValue);
pEqn->solve();
if (nonOrth == nNonOrthCorr)
{
phi -= pEqn->flux();
}
}
continuityErrors( runTime, mesh, phi, cumulativeContErr );
U -= rAU * fvc::grad(p);
U->correctBoundaryConditions();
}
runTime->write();
Info<< "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
bool FragmentationEncoderService::addAttributes(DataObjectRef originalDataObject, DataObjectRef fragmentDataObject,
string sequenceNumberListCsv) {
//copy attributes. though eventually will use rich metadata?
const Attributes* originalAttributes = originalDataObject->getAttributes();
for (Attributes::const_iterator it = originalAttributes->begin(); it != originalAttributes->end(); it++) {
const Attribute attr = (*it).second;
bool addAttribute = fragmentDataObject->addAttribute(attr);
if (!addAttribute) {
HAGGLE_ERR("unable to add attribute\n");
return false;
}
}
//add sequence number attribute
// char sequenceBuffer[33];
// memset(sequenceBuffer, 0, sizeof(sequenceBuffer));
// sprintf(sequenceBuffer, "%d", sequenceNumber);
// HAGGLE_DBG("stringSequenceNumber=%s\n", sequenceBuffer);
// bool addedSequenceNUmber = fragmentDataObject->addAttribute(
// HAGGLE_ATTR_FRAGMENTATION_SEQUENCE_NUMBER, sequenceBuffer, 0);
// if (!addedSequenceNUmber) {
// HAGGLE_ERR("unable to add addedSequenceNUmber attribute\n");
// return false;
// }
HAGGLE_DBG2("stringSequenceNumber=%s\n", sequenceNumberListCsv.c_str());
bool addedSequenceNumber = fragmentDataObject->addAttribute(HAGGLE_ATTR_FRAGMENTATION_SEQUENCE_NUMBER,
sequenceNumberListCsv, 0);
if (!addedSequenceNumber) {
HAGGLE_ERR("Unable to add sequence number attribute\n");
return false;
}
//add attribute to indicate data object is fragmentation block
bool addedIsFragmentationCodedAttribute = fragmentDataObject->addAttribute(HAGGLE_ATTR_FRAGMENTATION_NAME, "TRUE",
0);
if (!addedIsFragmentationCodedAttribute) {
HAGGLE_ERR("Unable to add fragmentation attribute\n");
return false;
}
//add original data len attribute
char lenBuffer[33];
memset(lenBuffer, 0, sizeof(lenBuffer));
int len = fragmentationDataObjectUtility->getFileLength(originalDataObject);
if(len == 0) {
HAGGLE_ERR("Orignal data len is zero - file already deleted\n");
return false;
}
sprintf(lenBuffer, "%d", len);
bool addedDataLenAttribute = fragmentDataObject->addAttribute(HAGGLE_ATTR_FRAGMENTATION_PARENT_ORIG_LEN, lenBuffer,
0);
if (!addedDataLenAttribute) {
HAGGLE_ERR("Unable to add original data len attribute\n");
return false;
}
//add dataobject id
const char* originalId = originalDataObject->getIdStr();
string originalStringId = originalId;
bool addedIdAttribute = fragmentDataObject->addAttribute(HAGGLE_ATTR_FRAGMENTATION_PARENT_DATAOBJECT_ID,
originalStringId, 0);
if (!addedIdAttribute) {
HAGGLE_ERR("Unable to add original data object id attribute\n");
return false;
}
//add dataobject name
string originalName = fragmentationDataObjectUtility->getFileName(originalDataObject);
HAGGLE_DBG2("Add original name %s as attribute\n", originalName.c_str());
bool addedNameAttribute = fragmentDataObject->addAttribute(HAGGLE_ATTR_FRAGMENTATION_PARENT_ORIG_NAME, originalName,
0);
if (!addedNameAttribute) {
HAGGLE_ERR("Unable to add original name attribute\n");
return false;
}
//add create time
string originalCreateTime = originalDataObject->getCreateTime().getAsString();
HAGGLE_DBG2("Add original create time %s as attribute\n", originalCreateTime.c_str());
bool addedCreatedTimeAttribute = fragmentDataObject->addAttribute(HAGGLE_ATTR_FRAGMENTATION_PARENT_CREATION_TIME,
originalCreateTime, 0);
if (!addedCreatedTimeAttribute) {
HAGGLE_ERR("Unable to add original create time attribute\n");
return false;
}
//set create time of fragment to same create time as parent so fragment data object ids can match up
Timeval createTime(originalCreateTime);
fragmentDataObject->setCreateTime(createTime);
if(originalDataObject->getSignature()) { // MOS
//add signee
string parentSignee = originalDataObject->getSignee();
HAGGLE_DBG2("Add original signee %s as attribute\n",parentSignee.c_str());
bool addedSigneeAttribute = fragmentDataObject->
addAttribute(HAGGLE_ATTR_FRAGMENTATION_PARENT_ORIG_SIGNEE,parentSignee,0);
if(!addedSigneeAttribute) {
HAGGLE_ERR("Unable to add original signee attribute\n");
return false;
}
//add signature
char *base64_signature = NULL;
if (base64_encode_alloc((char *)originalDataObject->getSignature(), originalDataObject->getSignatureLength(), &base64_signature) <= 0) {
HAGGLE_ERR("Unable to generate base64 encoded signature\n");
return false;
}
string parentSignature = base64_signature;
HAGGLE_DBG2("Add original signature %s as attribute\n",parentSignature.c_str());
bool addedSignatureAttribute = fragmentDataObject->
addAttribute(HAGGLE_ATTR_FRAGMENTATION_PARENT_ORIG_SIGNATURE,parentSignature,0);
if(!addedSignatureAttribute) {
HAGGLE_ERR("Unable to add original signature attribute\n");
return false;
}
if(base64_signature) {
free(base64_signature);
base64_signature = NULL;
}
}
return true;
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMeshNoClear( runTime );
singlePhaseTransportModelHolder fluid;
volScalarFieldHolder p;
volVectorFieldHolder U;
surfaceScalarFieldHolder phi;
label pRefCell = 0;
scalar pRefValue = 0.0;
createFields( runTime, mesh, fluid, p, U, phi, pRefCell, pRefValue );
scalar cumulativeContErr = initContinuityErrs();
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime->loop())
{
Info<< "Time = " << runTime->timeName() << nl << endl;
dictionary pisoDict; int nOuterCorr; int nCorr; int nNonOrthCorr;
bool momentumPredictor; bool transonic;
readPISOControls( mesh, pisoDict, nOuterCorr, nCorr, nNonOrthCorr, momentumPredictor, transonic);
scalar CoNum; scalar meanCoNum;
CourantNo( runTime, mesh, phi, CoNum, meanCoNum );
fluid->correct();
smart_tmp< fvVectorMatrix > UEqn( fvm::ddt( U() ) + fvm::div( phi(), U() ) - fvm::laplacian( fluid->nu(), U() ) );
solve( UEqn() == -fvc::grad( p() ));
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
smart_tmp< volScalarField > rAU( 1.0 / UEqn->A() );
U = rAU() * UEqn->H();
phi = ( fvc::interpolate( U() ) & mesh->Sf() ) + fvc::ddtPhiCorr( rAU(), U(), phi() );
adjustPhi(phi, U, p);
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
smart_tmp< fvScalarMatrix > pEqn( fvm::laplacian( rAU(), p() ) == fvc::div( phi() ) );
pEqn->setReference( pRefCell, pRefValue );
pEqn->solve();
if (nonOrth == nNonOrthCorr)
{
phi -= pEqn->flux();
}
}
continuityErrors( runTime, mesh, phi, cumulativeContErr );
U -= rAU() * fvc::grad( p() );
U->correctBoundaryConditions();
}
runTime->write();
Info << "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMesh( runTime );
uniformDimensionedVectorFieldHolder g = readGravitationalAcceleration( runTime, mesh );
volScalarFieldHolder T; volScalarFieldHolder p_rgh;
volVectorFieldHolder U; surfaceScalarFieldHolder phi;
singlePhaseTransportModelHolder laminarTransport;
incompressible::RASModelHolder turbulence;
volScalarFieldHolder rhok; volScalarFieldHolder kappat;
volScalarFieldHolder gh; surfaceScalarFieldHolder ghf;
volScalarFieldHolder p;
label pRefCell = 0;
scalar pRefValue = 0.0;
result_readTransportProperties result = createFields( runTime, mesh, g, T, p_rgh, U, phi, laminarTransport, turbulence, rhok,
kappat, gh, ghf, p, pRefCell, pRefValue );
dimensionedScalar& beta = result.m_beta;
dimensionedScalar& TRef = result.m_TRef;
dimensionedScalar& Pr = result.m_Pr;
dimensionedScalar& Prt = result.m_Prt;
scalar cumulativeContErr = initContinuityErrs();
simpleControlHolder simple(mesh);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (simple->loop())
{
Info<< "Time = " << runTime->timeName() << nl << endl;
p_rgh->storePrevIter();
// Pressure-velocity SIMPLE corrector
{
fvVectorMatrixHolder UEqn = fun_UEqn( mesh, simple, U, phi, turbulence, p, rhok, p_rgh, ghf );
fun_TEqn( phi, turbulence, kappat, T, rhok, beta, TRef, Prt, Pr );
fun_pEqn( mesh, runTime, simple, p, rhok, U, phi, turbulence, gh, ghf, p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr );
}
turbulence->correct();
runTime->write();
Info<< "ExecutionTime = " << runTime->elapsedCpuTime() << " s"
<< " ClockTime = " << runTime->elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
