void Foam::lduMatrix::operator=(const lduMatrix& A)
{
if (this == &A)
{
FatalError
<< "lduMatrix::operator=(const lduMatrix&) : "
<< "attempted assignment to self"
<< abort(FatalError);
}
if (A.lowerPtr_)
{
lower() = A.lower();
}
else if (lowerPtr_)
{
delete lowerPtr_;
lowerPtr_ = NULL;
}
if (A.upperPtr_)
{
upper() = A.upper();
}
else if (upperPtr_)
{
delete upperPtr_;
upperPtr_ = NULL;
}
if (A.diagPtr_)
{
diag() = A.diag();
}
}
void Foam::coupledGaussSeidelPrecon::reverseSweepTranspose
(
const lduMatrix& matrix,
scalarField& x,
scalarField& bPrime
) const
{
const scalarField& diag = matrix.diag();
const scalarField& lower = matrix.lower();
const scalarField& upper = matrix.upper();
const labelList& upperAddr = matrix.lduAddr().upperAddr();
const labelList& ownStartAddr = matrix.lduAddr().ownerStartAddr();
const label nRows = x.size();
label fStart, fEnd;
for (register label rowI = nRows - 1; rowI >= 0; rowI--)
{
// lRow is equal to rowI
scalar& curX = x[rowI];
// Grab the accumulated neighbour side
curX = bPrime[rowI];
// Start and end of this row
fStart = ownStartAddr[rowI];
fEnd = ownStartAddr[rowI + 1];
// Accumulate the owner product side
for (register label curCoeff = fStart; curCoeff < fEnd; curCoeff++)
{
// Transpose multiplication. HJ, 19/Jan/2009
curX -= lower[curCoeff]*x[upperAddr[curCoeff]];
}
// Finish current x
curX /= diag[rowI];
// Distribute the neighbour side using current x
for (register label curCoeff = fStart; curCoeff < fEnd; curCoeff++)
{
// Transpose multiplication. HJ, 19/Jan/2009
bPrime[upperAddr[curCoeff]] -= upper[curCoeff]*curX;
}
}
}
Foam::procLduMatrix::procLduMatrix
(
const lduMatrix& ldum,
const FieldField<Field, scalar>& interfaceCoeffs,
const lduInterfaceFieldPtrsList& interfaces
)
:
upperAddr_(ldum.lduAddr().upperAddr()),
lowerAddr_(ldum.lduAddr().lowerAddr()),
diag_(ldum.diag()),
upper_(ldum.upper()),
lower_(ldum.lower())
{
label nInterfaces = 0;
forAll(interfaces, i)
{
if (interfaces.set(i))
{
nInterfaces++;
}
}
interfaces_.setSize(nInterfaces);
nInterfaces = 0;
forAll(interfaces, i)
{
if (interfaces.set(i))
{
interfaces_.set
(
nInterfaces++,
new procLduInterface
(
interfaces[i],
interfaceCoeffs[i]
)
);
}
}
}
Foam::DILUPreconditioner::DILUPreconditioner
(
const lduMatrix& matrix,
const FieldField<Field, scalar>& coupleBouCoeffs,
const FieldField<Field, scalar>& coupleIntCoeffs,
const lduInterfaceFieldPtrsList& interfaces,
const dictionary&
)
:
lduPreconditioner
(
matrix,
coupleBouCoeffs,
coupleIntCoeffs,
interfaces
),
rD_(matrix.diag())
{
calcReciprocalD(rD_, matrix);
}
void Foam::lduMatrix::operator-=(const lduMatrix& A)
{
if (A.diagPtr_)
{
diag() -= A.diag();
}
if (symmetric() && A.symmetric())
{
upper() -= A.upper();
}
else if (symmetric() && A.asymmetric())
{
if (upperPtr_)
{
lower();
}
else
{
upper();
}
upper() -= A.upper();
lower() -= A.lower();
}
else if (asymmetric() && A.symmetric())
{
if (A.upperPtr_)
{
lower() -= A.upper();
upper() -= A.upper();
}
else
{
lower() -= A.lower();
upper() -= A.lower();
}
}
else if (asymmetric() && A.asymmetric())
{
lower() -= A.lower();
upper() -= A.upper();
}
else if (diagonal())
{
if (A.upperPtr_)
{
upper() = -A.upper();
}
if (A.lowerPtr_)
{
lower() = -A.lower();
}
}
else if (A.diagonal())
{
}
else
{
FatalErrorIn("lduMatrix::operator-=(const lduMatrix& A)")
<< "Unknown matrix type combination"
<< abort(FatalError);
}
}
void Foam::lduMatrix::operator-=(const lduMatrix& A)
{
if (A.diagPtr_)
{
diag() -= A.diag();
}
if (symmetric() && A.symmetric())
{
upper() -= A.upper();
}
else if (symmetric() && A.asymmetric())
{
if (upperPtr_)
{
lower();
}
else
{
upper();
}
upper() -= A.upper();
lower() -= A.lower();
}
else if (asymmetric() && A.symmetric())
{
if (A.upperPtr_)
{
lower() -= A.upper();
upper() -= A.upper();
}
else
{
lower() -= A.lower();
upper() -= A.lower();
}
}
else if (asymmetric() && A.asymmetric())
{
lower() -= A.lower();
upper() -= A.upper();
}
else if (diagonal())
{
if (A.upperPtr_)
{
upper() = -A.upper();
}
if (A.lowerPtr_)
{
lower() = -A.lower();
}
}
else if (A.diagonal())
{
}
else
{
if (debug > 1)
{
WarningIn("lduMatrix::operator-=(const lduMatrix& A)")
<< "Unknown matrix type combination" << nl
<< " this :"
<< " diagonal:" << diagonal()
<< " symmetric:" << symmetric()
<< " asymmetric:" << asymmetric() << nl
<< " A :"
<< " diagonal:" << A.diagonal()
<< " symmetric:" << A.symmetric()
<< " asymmetric:" << A.asymmetric()
<< endl;
}
}
}
void Foam::GaussSeidelSmoother::smooth
(
const word& fieldName_,
scalarField& psi,
const lduMatrix& matrix_,
const scalarField& source,
const FieldField<Field, scalar>& interfaceBouCoeffs_,
const lduInterfaceFieldPtrsList& interfaces_,
const direction cmpt,
const label nSweeps
)
{
register scalar* psiPtr = psi.begin();
register const label nCells = psi.size();
scalarField bPrime(nCells);
register scalar* bPrimePtr = bPrime.begin();
register const scalar* const diagPtr = matrix_.diag().begin();
register const scalar* const upperPtr =
matrix_.upper().begin();
register const scalar* const lowerPtr =
matrix_.lower().begin();
register const label* const uPtr =
matrix_.lduAddr().upperAddr().begin();
register const label* const ownStartPtr =
matrix_.lduAddr().ownerStartAddr().begin();
// Parallel boundary initialisation. The parallel boundary is treated
// as an effective jacobi interface in the boundary.
// Note: there is a change of sign in the coupled
// interface update. The reason for this is that the
// internal coefficients are all located at the l.h.s. of
// the matrix whereas the "implicit" coefficients on the
// coupled boundaries are all created as if the
// coefficient contribution is of a source-kind (i.e. they
// have a sign as if they are on the r.h.s. of the matrix.
// To compensate for this, it is necessary to turn the
// sign of the contribution.
FieldField<Field, scalar> mBouCoeffs(interfaceBouCoeffs_.size());
forAll(mBouCoeffs, patchi)
{
if (interfaces_.set(patchi))
{
mBouCoeffs.set(patchi, -interfaceBouCoeffs_[patchi]);
}
}
for (label sweep=0; sweep<nSweeps; sweep++)
{
bPrime = source;
matrix_.initMatrixInterfaces
(
mBouCoeffs,
interfaces_,
psi,
bPrime,
cmpt
);
matrix_.updateMatrixInterfaces
(
mBouCoeffs,
interfaces_,
psi,
bPrime,
cmpt
);
register scalar curPsi;
register label fStart;
register label fEnd = ownStartPtr[0];
for (register label cellI=0; cellI<nCells; cellI++)
{
// Start and end of this row
fStart = fEnd;
fEnd = ownStartPtr[cellI + 1];
// Get the accumulated neighbour side
curPsi = bPrimePtr[cellI];
// Accumulate the owner product side
for (register label curFace=fStart; curFace<fEnd; curFace++)
{
curPsi -= upperPtr[curFace]*psiPtr[uPtr[curFace]];
}
// Finish current psi
curPsi /= diagPtr[cellI];
// Distribute the neighbour side using current psi
for (register label curFace=fStart; curFace<fEnd; curFace++)
{
bPrimePtr[uPtr[curFace]] -= lowerPtr[curFace]*curPsi;
}
psiPtr[cellI] = curPsi;
}
}
}
void Foam::GAMGSolver::scale
(
scalargpuField& field,
scalargpuField& Acf,
const lduMatrix& A,
const FieldField<gpuField, scalar>& interfaceLevelBouCoeffs,
const lduInterfaceFieldPtrsList& interfaceLevel,
const scalargpuField& source,
const direction cmpt
) const
{
A.Amul
(
Acf,
field,
interfaceLevelBouCoeffs,
interfaceLevel,
cmpt
);
scalar scalingFactorNum = 0.0;
scalar scalingFactorDenom = 0.0;
scalingFactorNum =
thrust::reduce
(
thrust::make_transform_iterator
(
thrust::make_zip_iterator(thrust::make_tuple
(
source.begin(),
field.begin()
)),
multiplyTupleFunctor()
),
thrust::make_transform_iterator
(
thrust::make_zip_iterator(thrust::make_tuple
(
source.end(),
field.end()
)),
multiplyTupleFunctor()
),
0.0,
thrust::plus<scalar>()
);
scalingFactorDenom =
thrust::reduce
(
thrust::make_transform_iterator
(
thrust::make_zip_iterator(thrust::make_tuple
(
Acf.begin(),
field.begin()
)),
multiplyTupleFunctor()
),
thrust::make_transform_iterator
(
thrust::make_zip_iterator(thrust::make_tuple
(
Acf.end(),
field.end()
)),
multiplyTupleFunctor()
),
0.0,
thrust::plus<scalar>()
);
/*
forAll(field, i)
{
scalingFactorNum += source[i]*field[i];
scalingFactorDenom += Acf[i]*field[i];
}
*/
vector2D scalingVector(scalingFactorNum, scalingFactorDenom);
A.mesh().reduce(scalingVector, sumOp<vector2D>());
scalar sf = scalingVector.x()/stabilise(scalingVector.y(), VSMALL);
if (debug >= 2)
{
Pout<< sf << " ";
}
const scalargpuField& D = A.diag();
/*
forAll(field, i)
{
field[i] = sf*field[i] + (source[i] - sf*Acf[i])/D[i];
}
*/
thrust::transform
(
field.begin(),
field.end(),
thrust::make_zip_iterator(thrust::make_tuple
(
source.begin(),
Acf.begin(),
D.begin()
)),
field.begin(),
GAMGSolverScaleFunctor(sf)
);
}
void Foam::symGaussSeidelSmoother::smooth
(
const word& fieldName_,
scalarField& psi,
const lduMatrix& matrix_,
const scalarField& source,
const FieldField<Field, scalar>& interfaceBouCoeffs_,
const lduInterfaceFieldPtrsList& interfaces_,
const direction cmpt,
const label nSweeps
)
{
scalar* __restrict__ psiPtr = psi.begin();
const label nCells = psi.size();
scalarField bPrime(nCells);
scalar* __restrict__ bPrimePtr = bPrime.begin();
const scalar* const __restrict__ diagPtr = matrix_.diag().begin();
const scalar* const __restrict__ upperPtr =
matrix_.upper().begin();
const scalar* const __restrict__ lowerPtr =
matrix_.lower().begin();
const label* const __restrict__ uPtr =
matrix_.lduAddr().upperAddr().begin();
const label* const __restrict__ ownStartPtr =
matrix_.lduAddr().ownerStartAddr().begin();
// Parallel boundary initialisation. The parallel boundary is treated
// as an effective jacobi interface in the boundary.
// Note: there is a change of sign in the coupled
// interface update. The reason for this is that the
// internal coefficients are all located at the l.h.s. of
// the matrix whereas the "implicit" coefficients on the
// coupled boundaries are all created as if the
// coefficient contribution is of a source-kind (i.e. they
// have a sign as if they are on the r.h.s. of the matrix.
// To compensate for this, it is necessary to turn the
// sign of the contribution.
FieldField<Field, scalar>& mBouCoeffs =
const_cast<FieldField<Field, scalar>&>
(
interfaceBouCoeffs_
);
forAll(mBouCoeffs, patchi)
{
if (interfaces_.set(patchi))
{
mBouCoeffs[patchi].negate();
}
}
for (label sweep=0; sweep<nSweeps; sweep++)
{
bPrime = source;
matrix_.initMatrixInterfaces
(
mBouCoeffs,
interfaces_,
psi,
bPrime,
cmpt
);
matrix_.updateMatrixInterfaces
(
mBouCoeffs,
interfaces_,
psi,
bPrime,
cmpt
);
scalar psii;
label fStart;
label fEnd = ownStartPtr[0];
for (label celli=0; celli<nCells; celli++)
{
// Start and end of this row
fStart = fEnd;
fEnd = ownStartPtr[celli + 1];
// Get the accumulated neighbour side
psii = bPrimePtr[celli];
// Accumulate the owner product side
for (label facei=fStart; facei<fEnd; facei++)
{
psii -= upperPtr[facei]*psiPtr[uPtr[facei]];
}
// Finish current psi
psii /= diagPtr[celli];
// Distribute the neighbour side using current psi
for (label facei=fStart; facei<fEnd; facei++)
{
bPrimePtr[uPtr[facei]] -= lowerPtr[facei]*psii;
}
psiPtr[celli] = psii;
}
fStart = ownStartPtr[nCells];
for (label celli=nCells-1; celli>=0; celli--)
{
// Start and end of this row
fEnd = fStart;
fStart = ownStartPtr[celli];
// Get the accumulated neighbour side
psii = bPrimePtr[celli];
// Accumulate the owner product side
for (label facei=fStart; facei<fEnd; facei++)
{
psii -= upperPtr[facei]*psiPtr[uPtr[facei]];
}
// Finish psi for this cell
psii /= diagPtr[celli];
// Distribute the neighbour side using psi for this cell
for (label facei=fStart; facei<fEnd; facei++)
{
bPrimePtr[uPtr[facei]] -= lowerPtr[facei]*psii;
}
psiPtr[celli] = psii;
}
}
// Restore interfaceBouCoeffs_
forAll(mBouCoeffs, patchi)
{
if (interfaces_.set(patchi))
{
mBouCoeffs[patchi].negate();
}
}
}
Foam::FDICPreconditioner::FDICPreconditioner
(
const lduMatrix& matrix,
const FieldField<Field, scalar>& coupleBouCoeffs,
const FieldField<Field, scalar>& coupleIntCoeffs,
const lduInterfaceFieldPtrsList& interfaces,
const dictionary&
)
:
lduPreconditioner
(
matrix,
coupleBouCoeffs,
coupleIntCoeffs,
interfaces
),
rD_(matrix.diag()),
rDuUpper_(matrix.upper().size()),
rDlUpper_(matrix.upper().size())
{
scalar* __restrict__ rDPtr = rD_.begin();
scalar* __restrict__ rDuUpperPtr = rDuUpper_.begin();
scalar* __restrict__ rDlUpperPtr = rDlUpper_.begin();
const label* const __restrict__ uPtr =
matrix_.lduAddr().upperAddr().begin();
const label* const __restrict__ lPtr =
matrix_.lduAddr().lowerAddr().begin();
const scalar* const __restrict__ upperPtr = matrix_.upper().begin();
register label nCells = rD_.size();
register label nFaces = matrix_.upper().size();
for (register label face=0; face<nFaces; face++)
{
#ifdef ICC_IA64_PREFETCH
__builtin_prefetch (&uPtr[face+96],0,0);
__builtin_prefetch (&lPtr[face+96],0,0);
__builtin_prefetch (&upperPtr[face+96],0,1);
__builtin_prefetch (&rDPtr[lPtr[face+24]],0,1);
__builtin_prefetch (&rDPtr[uPtr[face+24]],1,1);
#endif
rDPtr[uPtr[face]] -= sqr(upperPtr[face])/rDPtr[lPtr[face]];
}
#ifdef ICC_IA64_PREFETCH
#pragma ivdep
#endif
// Generate reciprocal FDIC
for (register label cell=0; cell<nCells; cell++)
{
#ifdef ICC_IA64_PREFETCH
__builtin_prefetch (&rDPtr[cell+96],0,1);
#endif
rDPtr[cell] = 1.0/rDPtr[cell];
}
#ifdef ICC_IA64_PREFETCH
#pragma ivdep
#endif
for (register label face=0; face<nFaces; face++)
{
#ifdef ICC_IA64_PREFETCH
__builtin_prefetch (&uPtr[face+96],0,0);
__builtin_prefetch (&lPtr[face+96],0,0);
__builtin_prefetch (&upperPtr[face+96],0,0);
__builtin_prefetch (&rDuUpperPtr[face+96],0,0);
__builtin_prefetch (&rDlUpperPtr[face+96],0,0);
__builtin_prefetch (&rDPtr[uPtr[face+32]],0,1);
__builtin_prefetch (&rDPtr[lPtr[face+32]],0,1);
#endif
rDuUpperPtr[face] = rDPtr[uPtr[face]]*upperPtr[face];
rDlUpperPtr[face] = rDPtr[lPtr[face]]*upperPtr[face];
}
}
void Foam::lduMatrix::operator+=(const lduMatrix& A)
{
if (A.diagPtr_)
{
diag() += A.diag();
}
if (symmetric() && A.symmetric())
{
upper() += A.upper();
}
else if (symmetric() && A.asymmetric())
{
if (upperPtr_)
{
lower();
}
else
{
upper();
}
upper() += A.upper();
lower() += A.lower();
}
else if (asymmetric() && A.symmetric())
{
if (A.upperPtr_)
{
lower() += A.upper();
upper() += A.upper();
}
else
{
lower() += A.lower();
upper() += A.lower();
}
}
else if (asymmetric() && A.asymmetric())
{
lower() += A.lower();
upper() += A.upper();
}
else if (diagonal())
{
if (A.upperPtr_)
{
upper() = A.upper();
}
if (A.lowerPtr_)
{
lower() = A.lower();
}
}
else if (A.diagonal())
{
}
else
{
if (debug > 1)
{
WarningIn("lduMatrix::operator+=(const lduMatrix& A)")
<< "Unknown matrix type combination"
<< endl;
}
}
}