Foam::autoPtr<Foam::lduMatrix::solver> Foam::lduMatrix::solver::New
(
const word& fieldName,
const lduMatrix& matrix,
const FieldField<Field, scalar>& interfaceBouCoeffs,
const FieldField<Field, scalar>& interfaceIntCoeffs,
const lduInterfaceFieldPtrsList& interfaces,
const dictionary& solverControls
)
{
const word name(solverControls.lookup("solver"));
if (matrix.diagonal())
{
return autoPtr<lduMatrix::solver>
(
new diagonalSolver
(
fieldName,
matrix,
interfaceBouCoeffs,
interfaceIntCoeffs,
interfaces,
solverControls
)
);
}
else if (matrix.symmetric())
{
symMatrixConstructorTable::iterator constructorIter =
symMatrixConstructorTablePtr_->find(name);
if (constructorIter == symMatrixConstructorTablePtr_->end())
{
FatalIOErrorIn
(
"lduMatrix::solver::New", solverControls
) << "Unknown symmetric matrix solver " << name << nl << nl
<< "Valid symmetric matrix solvers are :" << endl
<< symMatrixConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<lduMatrix::solver>
(
constructorIter()
(
fieldName,
matrix,
interfaceBouCoeffs,
interfaceIntCoeffs,
interfaces,
solverControls
)
);
}
else if (matrix.asymmetric())
{
asymMatrixConstructorTable::iterator constructorIter =
asymMatrixConstructorTablePtr_->find(name);
if (constructorIter == asymMatrixConstructorTablePtr_->end())
{
FatalIOErrorIn
(
"lduMatrix::solver::New", solverControls
) << "Unknown asymmetric matrix solver " << name << nl << nl
<< "Valid asymmetric matrix solvers are :" << endl
<< asymMatrixConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<lduMatrix::solver>
(
constructorIter()
(
fieldName,
matrix,
interfaceBouCoeffs,
interfaceIntCoeffs,
interfaces,
solverControls
)
);
}
else
{
FatalIOErrorIn
(
"lduMatrix::solver::New", solverControls
) << "cannot solve incomplete matrix, "
"no diagonal or off-diagonal coefficient"
<< exit(FatalIOError);
return autoPtr<lduMatrix::solver>(NULL);
}
}
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::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"
<< endl;
}
}
}