//---------------------------------------------------------
DMat& qr(DMat& A, bool in_place)
//---------------------------------------------------------
{
// Form orthogonal QR factorization of A(m,n).
// The result Q is represented as a product of
// min(m, n) elementary reflectors.
int M=A.num_rows(), N=A.num_cols(), LDA=A.num_rows();
int min_mn = A.min_mn(), info=0; DVec tau(min_mn);
if (in_place)
{
// factorize arg
GEQRF(M, N, A.data(), LDA, tau.data(), info);
if (info) { umERROR("qr(A)", "dgeqrf reports: info = %d", info); }
//A.set_qrtau(tau); // H(i) = I - tau * v * v'
A.set_factmode(FACT_QR); // indicate factored state
return A;
}
else
{
// factorize copy of arg
DMat* tmp = new DMat(A, OBJ_temp, "qr(A)");
GEQRF (M, N, tmp->data(), LDA, tau.data(), info);
if (info) { umERROR("qr(A)", "dgeqrf reports: info = %d", info); }
//tmp->set_qrtau(tau); // H(i) = I - tau * v * v'
tmp->set_factmode(FACT_QR); // indicate factored state
return (*tmp);
}
}
//---------------------------------------------------------
DMat& lu(DMat& A, bool in_place)
//---------------------------------------------------------
{
// Given square matrix A, return its lu-factorization
// for use later in solving (multiple) linear systems.
if (!A.is_square()) { umERROR("lu(A)", "matrix is not square."); }
int rows=A.num_rows(); int N=rows, LDA=rows, info=0;
int* ipiv = umIVector(rows);
if (in_place)
{
// factorize arg
GETRF(N, N, A.data(), LDA, ipiv, info);
if (info) { umERROR("lu(A)", "dgetrf reports: info = %d", info); }
A.set_pivots(ipiv); // store pivots
A.set_factmode(FACT_LUP); // indicate factored state
return A;
}
else
{
// factorize copy of arg
DMat* tmp = new DMat(A, OBJ_temp, "lu(A)");
GETRF(N, N, tmp->data(), LDA, ipiv, info);
if (info) { umERROR("lu(A)", "dgetrf reports: info = %d", info); }
tmp->set_pivots(ipiv); // store pivots
tmp->set_factmode(FACT_LUP); // indicate factored state
return (*tmp);
}
}
//---------------------------------------------------------
DMat& chol(DMat& A, bool in_place)
//---------------------------------------------------------
{
// Given symmetric positive-definite matrix A,
// return its Cholesky-factorization for use
// later in solving (multiple) linear systems.
int M=A.num_rows(), LDA=A.num_rows(), info=0;
char uplo = 'U';
if (in_place)
{
// factorize arg
POTRF (uplo, M, A.data(), LDA, info);
if (info) { umERROR("chol(A)", "dpotrf reports: info = %d", info); }
A.zero_below_diag();
A.set_factmode(FACT_CHOL); // indicate factored state
return A;
}
else
{
// factorize copy of arg
DMat* tmp = new DMat(A, OBJ_temp, "chol(A)");
POTRF (uplo, M, tmp->data(), LDA, info);
if (info) { umERROR("chol(A)", "dpotrf reports: info = %d", info); }
tmp->zero_below_diag();
tmp->set_factmode(FACT_CHOL); // indicate factored state
#if (0)
// compare with Matlab
tmp->print(g_MSGFile, "chol", "lf", 4, 8);
#endif
return (*tmp);
}
}
//---------------------------------------------------------
DMat& NDG2D::CurvedDGJump2D
(
const DMat& gU, // [in]
const IVec& gmapD, // [in]
const DVec& bcU // [in]
)
//---------------------------------------------------------
{
// function [jumpU] = CurvedDGJump2D(gU, gmapD, bcU)
// purpose: compute discontinuous Galerkin jump applied
// to a field given at cubature and Gauss nodes
DMat mmCHOL; DVec gUM,gUP,fx;
DMat *tmp = new DMat("jumpU", OBJ_temp);
DMat &jumpU(*tmp);
// shorthand references
Cub2D& cub = this->m_cub; Gauss2D& gauss = this->m_gauss;
// surface traces at Gauss nodes
gUM = gU(gauss.mapM);
gUP = gU(gauss.mapP);
if (gmapD.size()>0) { gUP(gmapD) = bcU(gmapD); }
// compute jump term and lift to triangle interiors
fx = gUM - gUP;
jumpU = -gauss.interpT*(gauss.W.dm(fx));
// multiply straight sided triangles by inverse mass matrix
jumpU(All,straight) = VVT * dd(jumpU(All,straight), J(All,straight));
// multiply by custom inverse mass matrix for each curvilinear triangle
int Ncurved = curved.size(), k=0;
for (int m=1; m<=Ncurved; ++m) {
k = curved(m);
mmCHOL.borrow(Np,Np, cub.mmCHOL.pCol(k));
mmCHOL.set_factmode(FACT_CHOL); // indicate factored state
jumpU(All,k) = chol_solve(mmCHOL, jumpU(All,k));
}
// these parameters may be OBJ_temp (allocated on the fly)
if (OBJ_temp == gU.get_mode()) { delete (&gU); }
if (OBJ_temp == bcU.get_mode()) { delete (&bcU); }
return jumpU;
}
