//=============================================================================
int Epetra_SerialSpdDenseSolver::Factor(void) {
if (Factored()) return(0); // Already factored
if (Inverted()) EPETRA_CHK_ERR(-100); // Cannot factor inverted matrix
int ierr = 0;
ANORM_ = SymMatrix_->OneNorm();
// If we want to refine the solution, then the factor must
// be stored separatedly from the original matrix
if (A_ == AF_)
if (RefineSolution_ ) {
SymFactor_ = new Epetra_SerialSymDenseMatrix(*SymMatrix_);
Factor_ = SymFactor_;
AF_ = SymFactor_->A();
LDAF_ = SymFactor_->LDA();
}
if (Equilibrate_) ierr = EquilibrateMatrix();
if (ierr!=0) EPETRA_CHK_ERR(ierr-2);
POTRF (SymMatrix_->UPLO(), N_, AF_, LDAF_, &INFO_);
Factored_ = true;
double DN = N_;
UpdateFlops((DN*DN*DN)/3.0);
EPETRA_CHK_ERR(INFO_);
return(0);
}
void Render(double time)
{
static const ModelMatrixf reflection =
ModelMatrixf::Translation(0.0f, -1.0f, 0.0f) *
ModelMatrixf::Reflection(false, true, false);
auto camera = CamMatrixf::Orbiting(
Vec3f(),
4.5,
FullCircles(time / 10.0),
Degrees(45.0 - SineWave(time / 7.0)*35.0)
);
shape_prog.Use();
shape.Bind();
gl.FrontFace(make_shape.FaceWinding());
shape_model_matrix =
ModelMatrixf::Translation(0.0f, 1.1f, 0.0f) *
ModelMatrixf::RotationX(FullCircles(time / 12.0));
// render into the off-screen framebuffer
fbo.Bind(Framebuffer::Target::Draw);
gl.Viewport(width/tex_size_div, height/tex_size_div);
gl.Clear().ColorBuffer().DepthBuffer();
shape_camera_matrix = camera * reflection;
gl.FrontFace(Inverted(make_shape.FaceWinding()));
shape_instr.Draw(shape_indices);
// render into the on-screen framebuffer
dfb.Bind(Framebuffer::Target::Draw);
gl.Viewport(width, height);
gl.Clear().ColorBuffer().DepthBuffer();
shape_camera_matrix = camera;
gl.FrontFace(make_shape.FaceWinding());
shape_instr.Draw(shape_indices);
// Render the plane
plane_prog.Use();
plane.Bind();
gl.FrontFace(make_plane.FaceWinding());
plane_camera_matrix = camera;
plane_model_matrix = ModelMatrixf::Translation(0.0f, -0.5f, 0.0f);
plane_instr.Draw(plane_indices);
}
//=============================================================================
int Epetra_SerialDenseSVD::Solve(void) {
//FOR NOW, ONLY ALLOW SOLVES IF INVERTED!!!!
//NO REFINEMENT!!!
//NO EQUILIBRATION!!!
// We will call one of four routines depending on what services the user wants and
// whether or not the matrix has been inverted or factored already.
//
// If the matrix has been inverted, use DGEMM to compute solution.
// Otherwise, if the user want the matrix to be equilibrated or wants a refined solution, we will
// call the X interface.
// Otherwise, if the matrix is already factored we will call the TRS interface.
// Otherwise, if the matrix is unfactored we will call the SV interface.
/*
if (Equilibrate_) {
ierr = EquilibrateRHS();
B_Equilibrated_ = true;
}
EPETRA_CHK_ERR(ierr);
if (A_Equilibrated_ && !B_Equilibrated_) EPETRA_CHK_ERR(-1); // Matrix and vectors must be similarly scaled
if (!A_Equilibrated_ && B_Equilibrated_) EPETRA_CHK_ERR(-2);
if (B_==0) EPETRA_CHK_ERR(-3); // No B
if (X_==0) EPETRA_CHK_ERR(-4); // No B
if (ShouldEquilibrate() && !A_Equilibrated_) ierr = 1; // Warn that the system should be equilibrated.
*/
double DN = N_;
double DNRHS = NRHS_;
if (Inverted()) {
if (B_==X_) EPETRA_CHK_ERR(-100); // B and X must be different for this case
GEMM(TRANS_, 'N', N_, NRHS_, N_, 1.0, AI_, LDAI_, B_, LDB_, 0.0, X_, LDX_);
if (INFO_!=0) EPETRA_CHK_ERR(INFO_);
UpdateFlops(2.0*DN*DN*DNRHS);
Solved_ = true;
}
else EPETRA_CHK_ERR(-101); //Currently, for solve must have inverse
/*
else {
if (!Factored()) Factor(); // Matrix must be factored
if (B_!=X_) *LHS_ = *RHS_; // Copy B to X if needed
GETRS(TRANS_, N_, NRHS_, AF_, LDAF_, IPIV_, X_, LDX_, &INFO_);
if (INFO_!=0) EPETRA_CHK_ERR(INFO_);
UpdateFlops(2.0*DN*DN*DNRHS);
Solved_ = true;
}
int ierr1=0;
if (RefineSolution_ && !Inverted()) ierr1 = ApplyRefinement();
if (ierr1!=0) EPETRA_CHK_ERR(ierr1)
else
EPETRA_CHK_ERR(ierr);
if (Equilibrate_) ierr1 = UnequilibrateLHS();
EPETRA_CHK_ERR(ierr1);
*/
return(0);
}
//=============================================================================
int Epetra_SerialSpdDenseSolver::Solve(void) {
int ierr = 0;
// We will call one of four routines depending on what services the user wants and
// whether or not the matrix has been inverted or factored already.
//
// If the matrix has been inverted, use DGEMM to compute solution.
// Otherwise, if the user want the matrix to be equilibrated or wants a refined solution, we will
// call the X interface.
// Otherwise, if the matrix is already factored we will call the TRS interface.
// Otherwise, if the matrix is unfactored we will call the SV interface.
if (Equilibrate_) {
ierr = Epetra_SerialDenseSolver::EquilibrateRHS();
B_Equilibrated_ = true;
}
EPETRA_CHK_ERR(ierr);
if (A_Equilibrated_ && !B_Equilibrated_) EPETRA_CHK_ERR(-1); // Matrix and vectors must be similarly scaled
if (!A_Equilibrated_ && B_Equilibrated_) EPETRA_CHK_ERR(-2);
if (B_==0) EPETRA_CHK_ERR(-3); // No B
if (X_==0) EPETRA_CHK_ERR(-4); // No B
if (ShouldEquilibrate() && !A_Equilibrated_) ierr = 1; // Warn that the system should be equilibrated.
double DN = N_;
double DNRHS = NRHS_;
if (Inverted()) {
if (B_==X_) EPETRA_CHK_ERR(-100); // B and X must be different for this case
GEMM('N', 'N', N_, NRHS_, N_, 1.0, AF_, LDAF_,
B_, LDB_, 0.0, X_, LDX_);
if (INFO_!=0) EPETRA_CHK_ERR(INFO_);
UpdateFlops(2.0*DN*DN*DNRHS);
Solved_ = true;
}
else {
if (!Factored()) Factor(); // Matrix must be factored
if (B_!=X_) {
*LHS_ = *RHS_; // Copy B to X if needed
X_ = LHS_->A(); LDX_ = LHS_->LDA();
}
POTRS(SymMatrix_->UPLO(), N_, NRHS_, AF_, LDAF_, X_, LDX_, &INFO_);
if (INFO_!=0) EPETRA_CHK_ERR(INFO_);
UpdateFlops(2.0*DN*DN*DNRHS);
Solved_ = true;
}
int ierr1=0;
if (RefineSolution_) ierr1 = ApplyRefinement();
if (ierr1!=0) {
EPETRA_CHK_ERR(ierr1);
}
else {
EPETRA_CHK_ERR(ierr);
}
if (Equilibrate_) ierr1 = Epetra_SerialDenseSolver::UnequilibrateLHS();
EPETRA_CHK_ERR(ierr1);
return(0);
}