virtual size32_t getTransformResult(ARowBuilder & rowBuilder)
{
SqLite3RowBuilder sqliteRowBuilder(stmt);
const RtlTypeInfo *typeInfo = rowBuilder.queryAllocator()->queryOutputMeta()->queryTypeInfo();
assertex(typeInfo);
RtlFieldStrInfo dummyField("<row>", NULL, typeInfo);
return typeInfo->build(rowBuilder, 0, &dummyField, sqliteRowBuilder);
}
virtual byte * getRowResult(IEngineRowAllocator * _resultAllocator)
{
RtlDynamicRowBuilder rowBuilder(_resultAllocator);
SqLite3RowBuilder sqliteRowBuilder(stmt);
const RtlTypeInfo *typeInfo = _resultAllocator->queryOutputMeta()->queryTypeInfo();
assertex(typeInfo);
RtlFieldStrInfo dummyField("<row>", NULL, typeInfo);
size32_t len = typeInfo->build(rowBuilder, 0, &dummyField, sqliteRowBuilder);
return (byte *) rowBuilder.finalizeRowClear(len);
}
size32_t CouchbaseEmbedFunctionContext::getTransformResult(ARowBuilder & rowBuilder)
{
execute();
auto resultrow = nextResultRowTree();
if (!resultrow)
fail("Failed to read row");
if (resultrow->getCount("./*") != 1)
typeError("row", "");
CouchbaseRowBuilder couchbaseRowBuilder(resultrow);
const RtlTypeInfo *typeInfo = rowBuilder.queryAllocator()->queryOutputMeta()->queryTypeInfo();
assertex(typeInfo);
RtlFieldStrInfo dummyField("<row>", NULL, typeInfo);
return typeInfo->build(rowBuilder, 0, &dummyField, couchbaseRowBuilder);
}
virtual const void *nextRow()
{
if (!stmt)
return NULL;
int rc = sqlite3_step(stmt);
if (rc != SQLITE_ROW)
{
stmt.clear();
return NULL;
}
RtlDynamicRowBuilder rowBuilder(resultAllocator);
SqLite3RowBuilder sqliteRowBuilder(stmt);
const RtlTypeInfo *typeInfo = resultAllocator->queryOutputMeta()->queryTypeInfo();
assertex(typeInfo);
RtlFieldStrInfo dummyField("<row>", NULL, typeInfo);
size32_t len = typeInfo->build(rowBuilder, 0, &dummyField, sqliteRowBuilder);
return rowBuilder.finalizeRowClear(len);
}
const void * CouchbaseRowStream::nextRow()
{
const void * result = NULL;
if (m_shouldRead && m_currentRow < m_Rows.length())
{
auto json = m_Rows.item(m_currentRow++);
Owned<IPropertyTree> contentTree = createPTreeFromJSONString(json,ipt_caseInsensitive);
if (contentTree)
{
CouchbaseRowBuilder * cbRowBuilder = new CouchbaseRowBuilder(contentTree);
RtlDynamicRowBuilder rowBuilder(m_resultAllocator);
const RtlTypeInfo *typeInfo = m_resultAllocator->queryOutputMeta()->queryTypeInfo();
assertex(typeInfo);
RtlFieldStrInfo dummyField("<row>", NULL, typeInfo);
size32_t len = typeInfo->build(rowBuilder, 0, &dummyField, *cbRowBuilder);
return rowBuilder.finalizeRowClear(len);
}
else
failx("Error processing result row");
}
return result;
}
void Foam::GAMGSolver::Vcycle
(
const PtrList<lduMatrix::smoother>& smoothers,
scalargpuField& psi,
const scalargpuField& source,
scalargpuField& Apsi,
scalargpuField& finestCorrection,
scalargpuField& finestResidual,
scalargpuField& scratch1,
scalargpuField& scratch2,
PtrList<scalargpuField>& coarseCorrFields,
PtrList<scalargpuField>& coarseSources,
const direction cmpt
) const
{
//debug = 2;
const label coarsestLevel = matrixLevels_.size() - 1;
// Restrict finest grid residual for the next level up.
agglomeration_.restrictField(coarseSources[0], finestResidual, 0);
if (debug >= 2 && nPreSweeps_)
{
Pout<< "Pre-smoothing scaling factors: ";
}
// Residual restriction (going to coarser levels)
for (label leveli = 0; leveli < coarsestLevel; leveli++)
{
if (coarseSources.set(leveli + 1))
{
// If the optional pre-smoothing sweeps are selected
// smooth the coarse-grid field for the restriced source
if (nPreSweeps_)
{
coarseCorrFields[leveli] = 0.0;
smoothers[leveli + 1].smooth
(
coarseCorrFields[leveli],
coarseSources[leveli],
cmpt,
min
(
nPreSweeps_ + preSweepsLevelMultiplier_*leveli,
maxPreSweeps_
)
);
scalargpuField ACf
(
const_cast<const scalargpuField&>(scratch1),
coarseCorrFields[leveli].size()
);
// Scale coarse-grid correction field
// but not on the coarsest level because it evaluates to 1
if (scaleCorrection_ && leveli < coarsestLevel - 1)
{
scale
(
coarseCorrFields[leveli],
const_cast<scalargpuField&>(ACf),
matrixLevels_[leveli],
interfaceLevelsBouCoeffs_[leveli],
interfaceLevels_[leveli],
coarseSources[leveli],
cmpt
);
}
// Correct the residual with the new solution
matrixLevels_[leveli].Amul
(
ACf,
coarseCorrFields[leveli],
interfaceLevelsBouCoeffs_[leveli],
interfaceLevels_[leveli],
cmpt
);
coarseSources[leveli] -= ACf;
}
// Residual is equal to source
agglomeration_.restrictField
(
coarseSources[leveli + 1],
coarseSources[leveli],
leveli + 1
);
}
}
if (debug >= 2 && nPreSweeps_)
{
Pout<< endl;
}
// Solve Coarsest level with either an iterative or direct solver
if (coarseCorrFields.set(coarsestLevel))
{
solveCoarsestLevel
(
coarseCorrFields[coarsestLevel],
coarseSources[coarsestLevel]
);
}
if (debug >= 2)
{
Pout<< "Post-smoothing scaling factors: ";
}
// Smoothing and prolongation of the coarse correction fields
// (going to finer levels)
scalargpuField dummyField(0);
for (label leveli = coarsestLevel - 1; leveli >= 0; leveli--)
{
if (coarseCorrFields.set(leveli))
{
// Create a field for the pre-smoothed correction field
// as a sub-field of the finestCorrection which is not
// currently being used
scalargpuField preSmoothedCoarseCorrField
(
const_cast<const scalargpuField&>(scratch2),
coarseCorrFields[leveli].size()
);
// Only store the preSmoothedCoarseCorrField if pre-smoothing is
// used
if (nPreSweeps_)
{
preSmoothedCoarseCorrField = coarseCorrFields[leveli];
}
agglomeration_.prolongField
(
coarseCorrFields[leveli],
(
coarseCorrFields.set(leveli + 1)
? coarseCorrFields[leveli + 1]
: dummyField // dummy value
),
leveli + 1
);
// Create A.psi for this coarse level as a sub-field of Apsi
scalargpuField ACf
(
const_cast<const scalargpuField&>(scratch1),
coarseCorrFields[leveli].size()
);
scalargpuField& ACfRef = ACf;
if (interpolateCorrection_) //&& leveli < coarsestLevel - 2)
{
if (coarseCorrFields.set(leveli+1))
{
interpolate
(
coarseCorrFields[leveli],
ACfRef,
matrixLevels_[leveli],
interfaceLevelsBouCoeffs_[leveli],
interfaceLevels_[leveli],
agglomeration_.restrictSortAddressing(leveli + 1),
agglomeration_.restrictTargetAddressing(leveli + 1),
agglomeration_.restrictTargetStartAddressing(leveli + 1),
coarseCorrFields[leveli + 1],
cmpt
);
}
else
{
interpolate
(
coarseCorrFields[leveli],
ACfRef,
matrixLevels_[leveli],
interfaceLevelsBouCoeffs_[leveli],
interfaceLevels_[leveli],
cmpt
);
}
}
// Scale coarse-grid correction field
// but not on the coarsest level because it evaluates to 1
if
(
scaleCorrection_
&& (interpolateCorrection_ || leveli < coarsestLevel - 1)
)
{
scale
(
coarseCorrFields[leveli],
ACfRef,
matrixLevels_[leveli],
interfaceLevelsBouCoeffs_[leveli],
interfaceLevels_[leveli],
coarseSources[leveli],
cmpt
);
}
// Only add the preSmoothedCoarseCorrField if pre-smoothing is
// used
if (nPreSweeps_)
{
coarseCorrFields[leveli] += preSmoothedCoarseCorrField;
}
smoothers[leveli + 1].smooth
(
coarseCorrFields[leveli],
coarseSources[leveli],
cmpt,
min
(
nPostSweeps_ + postSweepsLevelMultiplier_*leveli,
maxPostSweeps_
)
);
}
}
// Prolong the finest level correction
agglomeration_.prolongField
(
finestCorrection,
coarseCorrFields[0],
0
);
if (interpolateCorrection_)
{
interpolate
(
finestCorrection,
Apsi,
matrix_,
interfaceBouCoeffs_,
interfaces_,
agglomeration_.restrictSortAddressing(0),
agglomeration_.restrictTargetAddressing(0),
agglomeration_.restrictTargetStartAddressing(0),
coarseCorrFields[0],
cmpt
);
}
if (scaleCorrection_)
{
// Scale the finest level correction
scale
(
finestCorrection,
Apsi,
matrix_,
interfaceBouCoeffs_,
interfaces_,
finestResidual,
cmpt
);
}
thrust::transform
(
psi.begin(),
psi.end(),
finestCorrection.begin(),
psi.begin(),
thrust::plus<scalar>()
);
smoothers[0].smooth
(
psi,
source,
cmpt,
nFinestSweeps_
);
}
