Foam::DICPreconditioner::DICPreconditioner
(
const lduMatrix::solver& sol,
const dictionary&
)
:
lduMatrix::preconditioner(sol),
rD_(sol.matrix().diag())
{
calcReciprocalD(rD_, sol.matrix());
}
Foam::FDICPreconditioner::FDICPreconditioner
(
const lduMatrix::solver& sol,
const dictionary&
)
:
lduMatrix::preconditioner(sol),
rD_(sol.matrix().diag()),
rDuUpper_(sol.matrix().upper().size()),
rDlUpper_(sol.matrix().upper().size())
{
scalar* __restrict__ rDPtr = rD_.begin();
scalar* __restrict__ rDuUpperPtr = rDuUpper_.begin();
scalar* __restrict__ rDlUpperPtr = rDlUpper_.begin();
const label* const __restrict__ uPtr =
solver_.matrix().lduAddr().upperAddr().begin();
const label* const __restrict__ lPtr =
solver_.matrix().lduAddr().lowerAddr().begin();
const scalar* const __restrict__ upperPtr =
solver_.matrix().upper().begin();
label nCells = rD_.size();
label nFaces = solver_.matrix().upper().size();
for (label face=0; face<nFaces; face++)
{
rDPtr[uPtr[face]] -= sqr(upperPtr[face])/rDPtr[lPtr[face]];
}
// Generate reciprocal FDIC
for (label cell=0; cell<nCells; cell++)
{
rDPtr[cell] = 1.0/rDPtr[cell];
}
for (label face=0; face<nFaces; face++)
{
rDuUpperPtr[face] = rDPtr[uPtr[face]]*upperPtr[face];
rDlUpperPtr[face] = rDPtr[lPtr[face]]*upperPtr[face];
}
}
Foam::GAMGPreconditioner::GAMGPreconditioner
(
const lduMatrix::solver& sol,
const dictionary& solverControls
)
:
GAMGSolver
(
sol.fieldName(),
sol.matrix(),
sol.interfaceBouCoeffs(),
sol.interfaceIntCoeffs(),
sol.interfaces(),
solverControls
),
lduMatrix::preconditioner(sol),
nVcycles_(2)
{
readControls();
}
Foam::symGaussSeidelPrecon::symGaussSeidelPrecon
(
const lduMatrix::solver& sol,
const dictionary& solverControlsUnused
)
:
lduPreconditioner
(
sol
),
mBouCoeffs_(sol.interfaceBouCoeffs().size()),
bPrime_(sol.matrix().lduAddr().size())
{
forAll(mBouCoeffs_, i)
{
if (interfaces_.set(i))
{
mBouCoeffs_.set(i, -coupleBouCoeffs_[i]);
}
}
}
//add by xiaow:begin
Foam::amgPrecon::amgPrecon
(
const lduMatrix::solver& sol,
const dictionary& dict
):
lduPreconditioner
(
sol
),
cycle_(amgCycle::cycleNames_.read(dict.lookup("cycle"))),
nPreSweeps_(readLabel(dict.lookup("nPreSweeps"))),
nPostSweeps_(readLabel(dict.lookup("nPostSweeps"))),
nMaxLevels_(readLabel(dict.lookup("nMaxLevels"))),
scale_(dict.lookup("scale")),
amgPtr_
(
new amgCycle
(
autoPtr<amgLevel>
(
new fineAmgLevel
(
sol.matrix(),
sol.interfaceBouCoeffs(),
sol.interfaceIntCoeffs(),
sol.interfaces(),
dict,
dict.lookup("policy"),
readLabel(dict.lookup("groupSize")),
readLabel(dict.lookup("minCoarseEqns")),
dict.lookup("smoother")
)
)
)
),
xBuffer_(sol.matrix().lduAddr().size())
{
// Make coarse levels
amgPtr_->makeCoarseLevels(nMaxLevels_);
}
Foam::diagonalPreconditioner::diagonalPreconditioner
(
const lduMatrix::solver& sol,
const dictionary&
)
:
lduMatrix::preconditioner(sol),
rD(sol.matrix().diag().size())
{
const scalargpuField& Diag = solver_.matrix().diag();
thrust::transform
(
Diag.begin(),
Diag.end(),
rD.begin(),
divideOperatorSFFunctor<scalar,scalar,scalar>(1.0)
);
}
Foam::diagonalPreconditioner::diagonalPreconditioner
(
const lduMatrix::solver& sol,
const dictionary&
)
:
lduMatrix::preconditioner(sol),
rD(sol.matrix().diag().size())
{
scalar* __restrict__ rDPtr = rD.begin();
const scalar* __restrict__ DPtr = solver_.matrix().diag().begin();
register label nCells = rD.size();
// Generate reciprocal diagonal
for (register label cell=0; cell<nCells; cell++)
{
rDPtr[cell] = 1.0/DPtr[cell];
}
}