void DGFiniteElement<D>:: CalcGradientMatrix (FlatMatrix<> gmat) const { IntegrationRule ir (this->ElementType(), 2*order); Vector<> shape(ndof); MatrixFixWidth<D> dshape(ndof); Vector<> norms(ndof); gmat = 0.0; norms = 0.0; for (int i = 0; i < ir.Size(); i++) { this -> CalcShape (ir[i], shape); this -> CalcDShape (ir[i], dshape); for (int j = 0; j < ndof; j++) for (int k = 0; k < ndof; k++) for (int l = 0; l < D; l++) gmat(k*D+l, j) += ir[i].Weight() * dshape(j,l) * shape(k); for (int j = 0; j < norms.Size(); j++) norms(j) += ir[i].Weight() * sqr (shape(j)); } for (int j = 0; j < ndof; j++) gmat.Rows(D*j, D*(j+1)) /= norms(j); }
void DGFiniteElement<D>:: CalcTraceMatrix (int facet, FlatMatrix<> trace) const { ELEMENT_TYPE ftype = ElementTopology::GetFacetType (this->ElementType(), facet); Facet2ElementTrafo f2el(this->ElementType(), FlatArray<int> (8, const_cast<int*> (vnums)) ); const IntegrationRule & ir = SelectIntegrationRule (ftype, 2*order); ScalarFiniteElement<0> * facetfe0 = NULL; ScalarFiniteElement<1> * facetfe1 = NULL; ScalarFiniteElement<2> * facetfe2 = NULL; switch (ftype) { case ET_POINT : facetfe0 = new FE_Point; break; case ET_SEGM : facetfe1 = new L2HighOrderFE<ET_SEGM> (order); break; case ET_TRIG : facetfe2 = new L2HighOrderFE<ET_TRIG> (order); break; case ET_QUAD : facetfe2 = new L2HighOrderFE<ET_QUAD> (order); break; default: ; } int ndof_facet = trace.Height(); Vector<> shape(ndof); Vector<> fshape(ndof_facet); Vector<> norms(ndof_facet); trace = 0.0; norms = 0.0; for (int i = 0; i < ir.Size(); i++) { if (D == 1) facetfe0 -> CalcShape (ir[i], fshape); else if (D == 2) facetfe1 -> CalcShape (ir[i], fshape); else facetfe2 -> CalcShape (ir[i], fshape); this -> CalcShape (f2el (facet, ir[i]), shape); trace += ir[i].Weight() * fshape * Trans (shape); for (int j = 0; j < norms.Size(); j++) norms(j) += ir[i].Weight() * sqr (fshape(j)); } for (int j = 0; j < fshape.Size(); j++) trace.Row(j) /= norms(j); delete facetfe0; delete facetfe1; delete facetfe2; }
Wavefront::Wavefront(const LLVolumeFace* face, const LLXform* transform, const LLXform* transform_normals) : name("") { class v4adapt { private: LLStrider<LLVector4a> mV4aStrider; public: v4adapt(LLVector4a* vp){ mV4aStrider = vp; } inline LLVector3 operator[] (const unsigned int i) { return LLVector3((F32*)&mV4aStrider[i]); } }; v4adapt verts(face->mPositions); for (S32 i = 0; i < face->mNumVertices; ++i) { LLVector3 v = verts[i]; vertices.push_back(std::pair<LLVector3, LLVector2>(v, face->mTexCoords[i])); } if (transform) Transform(vertices, transform); v4adapt norms(face->mNormals); for (S32 i = 0; i < face->mNumVertices; ++i) normals.push_back(norms[i]); if (transform_normals) Transform(normals, transform_normals); for (S32 i = 0; i < face->mNumIndices/3; ++i) { triangles.push_back(tri(face->mIndices[i*3+0], face->mIndices[i*3+1], face->mIndices[i*3+2])); } }
void AdaptivityAction::act() { NonlinearSystemBase & system = _problem->getNonlinearSystemBase(); Adaptivity & adapt = _problem->adaptivity(); // we don't need to run mesh modifiers *again* after they ran already during the mesh // splitting process. Adaptivity::init must be called for any adaptivity to work, however, so we // can't just skip it for the useSplit case. if (_app.isUseSplit()) adapt.init(0, 0); else adapt.init(getParam<unsigned int>("steps"), getParam<unsigned int>("initial_adaptivity")); adapt.setErrorEstimator(getParam<MooseEnum>("error_estimator")); adapt.setParam("cycles_per_step", getParam<unsigned int>("cycles_per_step")); adapt.setParam("refine fraction", getParam<Real>("refine_fraction")); adapt.setParam("coarsen fraction", getParam<Real>("coarsen_fraction")); adapt.setParam("max h-level", getParam<unsigned int>("max_h_level")); adapt.setParam("recompute_markers_during_cycles", getParam<bool>("recompute_markers_during_cycles")); adapt.setPrintMeshChanged(getParam<bool>("print_changed_info")); const std::vector<std::string> & weight_names = getParam<std::vector<std::string>>("weight_names"); const std::vector<Real> & weight_values = getParam<std::vector<Real>>("weight_values"); int num_weight_names = weight_names.size(); int num_weight_values = weight_values.size(); if (num_weight_names) { if (num_weight_names != num_weight_values) mooseError("Number of weight_names must be equal to number of weight_values in " "Execution/Adaptivity"); // If weights have been specified then set the default weight to zero std::vector<Real> weights(system.nVariables(), 0); for (int i = 0; i < num_weight_names; i++) { std::string name = weight_names[i]; double value = weight_values[i]; weights[system.getVariable(0, name).number()] = value; } std::vector<FEMNormType> norms(system.nVariables(), H1_SEMINORM); SystemNorm sys_norm(norms, weights); adapt.setErrorNorm(sys_norm); } adapt.setTimeActive(getParam<Real>("start_time"), getParam<Real>("stop_time")); adapt.setInterval(getParam<unsigned int>("interval")); }
QModelIndex cast( NifModel * nif, const QModelIndex & index ) { QModelIndex iData = getShapeData( nif, index ); QVector<Vector3> verts = nif->getArray<Vector3>( iData, "Vertices" ); QVector<Triangle> triangles; QModelIndex iPoints = nif->getIndex( iData, "Points" ); if ( iPoints.isValid() ) { QList< QVector< quint16 > > strips; for ( int r = 0; r < nif->rowCount( iPoints ); r++ ) strips.append( nif->getArray<quint16>( iPoints.child( r, 0 ) ) ); triangles = triangulate( strips ); } else { triangles = nif->getArray<Triangle>( iData, "Triangles" ); } QVector<Vector3> norms( verts.count() ); foreach ( Triangle tri, triangles ) { Vector3 a = verts[ tri[0] ]; Vector3 b = verts[ tri[1] ]; Vector3 c = verts[ tri[2] ]; Vector3 fn = Vector3::crossproduct( b - a, c - a ); norms[ tri[0] ] += fn; norms[ tri[1] ] += fn; norms[ tri[2] ] += fn; }
//! Sets an integer indicating the current number of iterations, {\em //! currentNumIter} to \f$1\f$. Returns \f$0\f$ if successfull, an error message //! and \f$-1\f$ are returned if no LinearSOE object has been set. int XC::CTestRelativeNormUnbalance::start(void) { int retval= ConvergenceTestNorm::start(); // determine the initial norm .. the the norm of the initial unbalance calculatedNormB= getNormB(); if(currentIter <= maxNumIter) norms(0)= calculatedNormB; norm0= calculatedNormB; return retval; }
CompressedFormat Dataset::compute_sim() const { stack::fe_asserter dummy{}; index_t nnz_sim = 0; index_t *starts_sim = nullptr, *index_sim = nullptr; double *values_sim = nullptr; spmm(TRANS::N, TRANS::T, n_users, n_items, n_users, ratings.nnz(),ratings.values(),ratings.starts(),ratings.index(), ratings.nnz(),ratings.values(),ratings.starts(),ratings.index(), nnz_sim, values_sim, starts_sim, index_sim); #ifndef NDEBUG std::cerr << (nnz_sim * 100.0) / n_users / n_users << "% sparsity of sim" << std::endl; #endif std::function<double(index_t)> norm = [=](index_t row)->double { /* for normal cosine similarity */ // const double *begin = ratings.values() + ratings.starts()[row]; // const double *end = ratings.values() + ratings.starts()[row + 1]; // double x = 0; // must be executed serially ! // double x_c = 0; // std::for_each(begin, end, [&](double v){ kahan_accumulate(x, x_c, v * v); }); // return std::sqrt(x); /* for squared cosine similarity */ return nnz_row(row, ratings.starts()); }; // cache the norms std::vector<double> norms(n_users); for(int user = 0; user < n_users; user ++) norms[user] = norm(user); // divide for(int user = 0; user < n_users; user ++) { double *ptr = values_sim + starts_sim[user]; const double *end = values_sim + starts_sim[user + 1]; const index_t *index = index_sim + starts_sim[user]; while(ptr != end) { double divisor = norms[user] * norms[*index]; if(std::fpclassify(divisor) != FP_ZERO) *ptr = *ptr * *ptr / divisor; // *ptr /= divisor; // for normal cosine similarity index++; ptr++; } } return CompressedFormat(n_users, n_users, std::move(values_sim), nnz_sim, std::move(starts_sim), ratings.starts_len(), std::move(index_sim)); }
Base<F> Coherence( const ElementalMatrix<F>& A ) { DEBUG_ONLY(CSE cse("Coherence")) DistMatrix<F> B( A ); DistMatrix<Base<F>,MR,STAR> norms(B.Grid()); ColumnTwoNorms( B, norms ); DiagonalSolve( RIGHT, NORMAL, norms, B, true ); DistMatrix<F> C(B.Grid()); Identity( C, A.Width(), A.Width() ); Herk( UPPER, ADJOINT, Base<F>(-1), B, Base<F>(1), C ); return HermitianMaxNorm( UPPER, C ); }
void AdaptivityAction::act() { NonlinearSystem & system = _problem->getNonlinearSystem(); Adaptivity & adapt = _problem->adaptivity(); adapt.init(getParam<unsigned int>("steps"), getParam<unsigned int>("initial_adaptivity")); adapt.setErrorEstimator(getParam<MooseEnum>("error_estimator")); adapt.setParam("cycles_per_step", getParam<unsigned int>("cycles_per_step")); adapt.setParam("refine fraction", getParam<Real>("refine_fraction")); adapt.setParam("coarsen fraction", getParam<Real>("coarsen_fraction")); adapt.setParam("max h-level", getParam<unsigned int>("max_h_level")); adapt.setPrintMeshChanged(getParam<bool>("print_changed_info")); const std::vector<std::string> & weight_names = getParam<std::vector<std::string> >("weight_names"); const std::vector<Real> & weight_values = getParam<std::vector<Real> >("weight_values"); int num_weight_names = weight_names.size(); int num_weight_values = weight_values.size(); if (num_weight_names) { if (num_weight_names != num_weight_values) mooseError("Number of weight_names must be equal to number of weight_values in Execution/Adaptivity"); // If weights have been specified then set the default weight to zero std::vector<Real> weights(system.nVariables(),0); for(int i=0;i<num_weight_names;i++) { std::string name = weight_names[i]; double value = weight_values[i]; weights[system.getVariable(0, name).number()] = value; } std::vector<FEMNormType> norms(system.nVariables(), H1_SEMINORM); SystemNorm sys_norm(norms, weights); adapt.setErrorNorm(sys_norm); } adapt.setTimeActive(getParam<Real>("start_time"), getParam<Real>("stop_time")); }
StatusType checkStatus(Iteration<SC,MV,OP>* iSolver) { // Get residual std::vector<MagnitudeType> norms(1); Teuchos::RCP<const MV> res = iSolver->getNativeResiduals(&norms); MagnitudeType resNorm = norms[0]; if (curNorm_ == -STS::one()) { prevNorm_ = curNorm_ = resNorm; } else { prevNorm_ = curNorm_; curNorm_ = resNorm; } return Base::checkStatus(iSolver); }
void Mesh::computeNormals(void) { if (normals.size() == vertices.size()) { std::cout << "Normals already exist! : " << normals.size() << "\n"; return; } clock_t begin, end; double elapsed_secs; begin = clock(); std::cout << "Calculating normals begin\n"; std::vector<Vertex> norms(vertices.size()); for (auto &t : triangles) { Vertex pa, pb, pc; Vertex diff1, diff2; Vertex trinorm; pa = vertices[t.v1]; pb = vertices[t.v2]; pc = vertices[t.v3]; diff1 = pb - pa; diff2 = pc - pa; trinorm = diff1.Cross(diff2); trinorm = trinorm.Normalize(); trinormals.push_back(trinorm); float theta1 = (pb - pa).Angle(pc - pa); float theta2 = (pa - pb).Angle(pc - pb); float theta3 = (pb - pc).Angle(pa - pc); norms[t.v1] = norms[t.v1] + trinorm * t.Area(vertices) * theta1; norms[t.v2] = norms[t.v2] + trinorm * t.Area(vertices) * theta2; norms[t.v3] = norms[t.v3] + trinorm * t.Area(vertices) * theta3; } for (auto &n : norms) { Vertex v = n.Normalize(); normals.push_back(v); } end = clock(); elapsed_secs = double(end - begin) / CLOCKS_PER_SEC; std::cout << "Calculating normals end : elapsed time: " << elapsed_secs << "\n"; }
// SmootherBase test ST::magnitudeType testApply(const Matrix& A, const SmootherBase & smoother, MultiVector & X, const MultiVector & RHS, Teuchos::FancyOStream & out, bool & success) { Array<ST::magnitudeType> norms(1); RHS.norm2(norms); out << "||RHS|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << norms[0] << std::endl; Teuchos::Array<ST::magnitudeType> initialNorms(1); X.norm2(initialNorms); out << "||X_initial|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << initialNorms[0] << std::endl; smoother.Apply(X, RHS); // TODO: bool const &InitialGuessIsZero=false Teuchos::Array<ST::magnitudeType> finalNorms(1); X.norm2(finalNorms); out << "||X_final|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(25) << norms[0] << std::endl; Teuchos::Array<ST::magnitudeType> residualNorms = Utils::ResidualNorm(A, X, RHS); out << "||Residual|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(20) << residualNorms[0] << std::endl; return residualNorms[0]; }
void CModelSurface::UpdateNormals(){ vector<CVec3> norms( _vertices.size() ); for( vector<CTriangle>::iterator it=_triangles.begin();it!=_triangles.end();++it ){ const CTriangle &tri=*it; int i0=tri.vertices[0]; int i1=tri.vertices[1]; int i2=tri.vertices[2]; const CVec3 &v0=_vertices[i0].position; const CVec3 &v1=_vertices[i1].position; const CVec3 &v2=_vertices[i2].position; CVec3 normal=CPlane::TrianglePlane( v0,v1,v2 ).n; norms[i0]+=normal; norms[i1]+=normal; norms[i2]+=normal; } for( int i=0;i<_vertices.size();++i ){ _vertices[i].normal=norms[i].Normalize(); } }
bool BelosAdaptersTestResults(int numIters, RCP<MV> & X, Teuchos::FancyOStream & out, bool & success) { // Check numIters switch (TestHelpers::Parameters::getDefaultComm()->getSize()) { case 0: TEST_EQUALITY(numIters, 5); break; case 4: // Epetra TEST_EQUALITY(numIters, 6); // Tpetra TEST_EQUALITY(numIters, 7); break; default:; } // Compute norm of X (using MV traits) typedef Belos::MultiVecTraits<Scalar, MV> MVT; std::vector<Scalar> norms(1); MVT::MvNorm(*X, norms); // Test norm equality across the unit tests return MueLuTests::BelosAdaptersTestResultsNorm<Scalar>(norms[0]); }
// SmootherBase test ST::magnitudeType testApply_X0_RandomRHS(const Matrix& A, const SmootherBase & smoother, Teuchos::FancyOStream & out, bool & success) { RCP<MultiVector> X = MultiVectorFactory::Build(A.getDomainMap(),1); RCP<MultiVector> RHS = MultiVectorFactory::Build(A.getRangeMap(),1); // Random X X->setSeed(846930886); X->randomize(); // Normalize X Array<ST::magnitudeType> norms(1); X->norm2(norms); X->scale(1/norms[0]); // Compute RHS corresponding to X A.apply(*X,*RHS, Teuchos::NO_TRANS,(SC)1.0,(SC)0.0); // Reset X to 0 X->putScalar((SC) 0.0); return testApply(A, smoother, *X, *RHS, out, success); }
int CTestRelativeNormUnbalance::start(void) { if (theSOE == 0) { opserr << "WARNING: CTestRelativeNormUnbalance::test() - no SOE returning true\n"; return -1; } // set iteration count = 1 norms.Zero(); currentIter = 1; norm0 = 0.0; // determine the initial norm .. the the norm of the initial unbalance const Vector &x = theSOE->getB(); double norm = x.pNorm(nType); if (currentIter <= maxNumIter) norms(0) = norm; norm0 = norm; return 0; }
// The main program int main(int argc, char** argv) { // Initialize libMesh LibMeshInit init(argc, argv); // Parameters GetPot infile("fem_system_params.in"); const Real global_tolerance = infile("global_tolerance", 0.); const unsigned int nelem_target = infile("n_elements", 400); const bool transient = infile("transient", true); const Real deltat = infile("deltat", 0.005); unsigned int n_timesteps = infile("n_timesteps", 1); //const unsigned int coarsegridsize = infile("coarsegridsize", 1); const unsigned int coarserefinements = infile("coarserefinements", 0); const unsigned int max_adaptivesteps = infile("max_adaptivesteps", 10); //const unsigned int dim = 2; #ifdef LIBMESH_HAVE_EXODUS_API const unsigned int write_interval = infile("write_interval", 5); #endif // Create a mesh, with dimension to be overridden later, distributed // across the default MPI communicator. Mesh mesh(init.comm()); GetPot infileForMesh("convdiff_mprime.in"); std::string find_mesh_here = infileForMesh("mesh","psiLF_mesh.xda"); mesh.read(find_mesh_here); std::cout << "Read in mesh from: " << find_mesh_here << "\n\n"; // And an object to refine it MeshRefinement mesh_refinement(mesh); mesh_refinement.coarsen_by_parents() = true; mesh_refinement.absolute_global_tolerance() = global_tolerance; mesh_refinement.nelem_target() = nelem_target; mesh_refinement.refine_fraction() = 0.3; mesh_refinement.coarsen_fraction() = 0.3; mesh_refinement.coarsen_threshold() = 0.1; //mesh_refinement.uniformly_refine(coarserefinements); // Print information about the mesh to the screen. mesh.print_info(); // Create an equation systems object. EquationSystems equation_systems (mesh); // Name system ConvDiff_MprimeSys & system = equation_systems.add_system<ConvDiff_MprimeSys>("Diff_ConvDiff_MprimeSys"); // Steady-state problem system.time_solver = AutoPtr<TimeSolver>(new SteadySolver(system)); // Sanity check that we are indeed solving a steady problem libmesh_assert_equal_to (n_timesteps, 1); // Read in all the equation systems data from the LF solve (system, solutions, rhs, etc) std::string find_psiLF_here = infileForMesh("psiLF_file","psiLF.xda"); std::cout << "Looking for psiLF at: " << find_psiLF_here << "\n\n"; equation_systems.read(find_psiLF_here, READ, EquationSystems::READ_HEADER | EquationSystems::READ_DATA | EquationSystems::READ_ADDITIONAL_DATA); // Check that the norm of the solution read in is what we expect it to be Real readin_L2 = system.calculate_norm(*system.solution, 0, L2); std::cout << "Read in solution norm: "<< readin_L2 << std::endl << std::endl; //DEBUG //equation_systems.write("right_back_out.xda", WRITE, EquationSystems::WRITE_DATA | // EquationSystems::WRITE_ADDITIONAL_DATA); #ifdef LIBMESH_HAVE_GMV //GMVIO(equation_systems.get_mesh()).write_equation_systems(std::string("right_back_out.gmv"), equation_systems); #endif // Initialize the system //equation_systems.init (); //already initialized by read-in // And the nonlinear solver options NewtonSolver *solver = new NewtonSolver(system); system.time_solver->diff_solver() = AutoPtr<DiffSolver>(solver); solver->quiet = infile("solver_quiet", true); solver->verbose = !solver->quiet; solver->max_nonlinear_iterations = infile("max_nonlinear_iterations", 15); solver->relative_step_tolerance = infile("relative_step_tolerance", 1.e-3); solver->relative_residual_tolerance = infile("relative_residual_tolerance", 0.0); solver->absolute_residual_tolerance = infile("absolute_residual_tolerance", 0.0); // And the linear solver options solver->max_linear_iterations = infile("max_linear_iterations", 50000); solver->initial_linear_tolerance = infile("initial_linear_tolerance", 1.e-3); // Print information about the system to the screen. equation_systems.print_info(); // Now we begin the timestep loop to compute the time-accurate // solution of the equations...not that this is transient, but eh, why not... for (unsigned int t_step=0; t_step != n_timesteps; ++t_step) { // A pretty update message std::cout << "\n\nSolving time step " << t_step << ", time = " << system.time << std::endl; // Adaptively solve the timestep unsigned int a_step = 0; for (; a_step != max_adaptivesteps; ++a_step) { // VESTIGIAL for now ('vestigial' eh ? ;) ) std::cout << "\n\n I should be skipped what are you doing here lalalalalalala *!**!*!*!*!*!* \n\n"; system.solve(); system.postprocess(); ErrorVector error; AutoPtr<ErrorEstimator> error_estimator; // To solve to a tolerance in this problem we // need a better estimator than Kelly if (global_tolerance != 0.) { // We can't adapt to both a tolerance and a mesh // size at once libmesh_assert_equal_to (nelem_target, 0); UniformRefinementEstimator *u = new UniformRefinementEstimator; // The lid-driven cavity problem isn't in H1, so // lets estimate L2 error u->error_norm = L2; error_estimator.reset(u); } else { // If we aren't adapting to a tolerance we need a // target mesh size libmesh_assert_greater (nelem_target, 0); // Kelly is a lousy estimator to use for a problem // not in H1 - if we were doing more than a few // timesteps we'd need to turn off or limit the // maximum level of our adaptivity eventually error_estimator.reset(new KellyErrorEstimator); } // Calculate error std::vector<Real> weights(9,1.0); // based on u, v, p, c, their adjoints, and source parameter // Keep the same default norm type. std::vector<FEMNormType> norms(1, error_estimator->error_norm.type(0)); error_estimator->error_norm = SystemNorm(norms, weights); error_estimator->estimate_error(system, error); // Print out status at each adaptive step. Real global_error = error.l2_norm(); std::cout << "Adaptive step " << a_step << ": " << std::endl; if (global_tolerance != 0.) std::cout << "Global_error = " << global_error << std::endl; if (global_tolerance != 0.) std::cout << "Worst element error = " << error.maximum() << ", mean = " << error.mean() << std::endl; if (global_tolerance != 0.) { // If we've reached our desired tolerance, we // don't need any more adaptive steps if (global_error < global_tolerance) break; mesh_refinement.flag_elements_by_error_tolerance(error); } else { // If flag_elements_by_nelem_target returns true, this // should be our last adaptive step. if (mesh_refinement.flag_elements_by_nelem_target(error)) { mesh_refinement.refine_and_coarsen_elements(); equation_systems.reinit(); a_step = max_adaptivesteps; break; } } // Carry out the adaptive mesh refinement/coarsening mesh_refinement.refine_and_coarsen_elements(); equation_systems.reinit(); std::cout << "Refined mesh to " << mesh.n_active_elem() << " active elements and " << equation_systems.n_active_dofs() << " active dofs." << std::endl; } // End loop over adaptive steps // Do one last solve if necessary if (a_step == max_adaptivesteps) { QoISet qois; std::vector<unsigned int> qoi_indices; qoi_indices.push_back(0); qois.add_indices(qoi_indices); qois.set_weight(0, 1.0); system.assemble_qoi_sides = true; //QoI doesn't involve sides std::cout << "\n~*~*~*~*~*~*~*~*~ adjoint solve start ~*~*~*~*~*~*~*~*~\n" << std::endl; std::pair<unsigned int, Real> adjsolve = system.adjoint_solve(); std::cout << "number of iterations to solve adjoint: " << adjsolve.first << std::endl; std::cout << "final residual of adjoint solve: " << adjsolve.second << std::endl; std::cout << "\n~*~*~*~*~*~*~*~*~ adjoint solve end ~*~*~*~*~*~*~*~*~" << std::endl; NumericVector<Number> &dual_solution = system.get_adjoint_solution(0); NumericVector<Number> &primal_solution = *system.solution; primal_solution.swap(dual_solution); ExodusII_IO(mesh).write_timestep("super_adjoint.exo", equation_systems, 1, /* This number indicates how many time steps are being written to the file */ system.time); primal_solution.swap(dual_solution); system.assemble(); //overwrite residual read in from psiLF solve // The total error estimate system.postprocess(); //to compute M_HF(psiLF) and M_LF(psiLF) terms Real QoI_error_estimate = (-0.5*(system.rhs)->dot(dual_solution)) + system.get_MHF_psiLF() - system.get_MLF_psiLF(); std::cout << "\n\n 0.5*M'_HF(psiLF)(superadj): " << std::setprecision(17) << 0.5*(system.rhs)->dot(dual_solution) << "\n"; std::cout << " M_HF(psiLF): " << std::setprecision(17) << system.get_MHF_psiLF() << "\n"; std::cout << " M_LF(psiLF): " << std::setprecision(17) << system.get_MLF_psiLF() << "\n"; std::cout << "\n\n Residual L2 norm: " << system.calculate_norm(*system.rhs, L2) << "\n"; std::cout << " Residual discrete L2 norm: " << system.calculate_norm(*system.rhs, DISCRETE_L2) << "\n"; std::cout << " Super-adjoint L2 norm: " << system.calculate_norm(dual_solution, L2) << "\n"; std::cout << " Super-adjoint discrete L2 norm: " << system.calculate_norm(dual_solution, DISCRETE_L2) << "\n"; std::cout << "\n\n QoI error estimate: " << std::setprecision(17) << QoI_error_estimate << "\n\n"; //DEBUG std::cout << "\n------------ herp derp ------------" << std::endl; //libMesh::out.precision(16); //dual_solution.print(); //system.get_adjoint_rhs().print(); AutoPtr<NumericVector<Number> > adjresid = system.solution->clone(); (system.matrix)->vector_mult(*adjresid,system.get_adjoint_solution(0)); SparseMatrix<Number>& adjmat = *system.matrix; (system.matrix)->get_transpose(adjmat); adjmat.vector_mult(*adjresid,system.get_adjoint_solution(0)); //std::cout << "******************** matrix-superadj product (libmesh) ************************" << std::endl; //adjresid->print(); adjresid->add(-1.0, system.get_adjoint_rhs(0)); //std::cout << "******************** superadjoint system residual (libmesh) ***********************" << std::endl; //adjresid->print(); std::cout << "\n\nadjoint system residual (discrete L2): " << system.calculate_norm(*adjresid,DISCRETE_L2) << std::endl; std::cout << "adjoint system residual (L2, all): " << system.calculate_norm(*adjresid,L2) << std::endl; std::cout << "adjoint system residual (L2, 0): " << system.calculate_norm(*adjresid,0,L2) << std::endl; std::cout << "adjoint system residual (L2, 1): " << system.calculate_norm(*adjresid,1,L2) << std::endl; std::cout << "adjoint system residual (L2, 2): " << system.calculate_norm(*adjresid,2,L2) << std::endl; std::cout << "adjoint system residual (L2, 3): " << system.calculate_norm(*adjresid,3,L2) << std::endl; std::cout << "adjoint system residual (L2, 4): " << system.calculate_norm(*adjresid,4,L2) << std::endl; std::cout << "adjoint system residual (L2, 5): " << system.calculate_norm(*adjresid,5,L2) << std::endl; /* AutoPtr<NumericVector<Number> > sadj_matlab = system.solution->clone(); AutoPtr<NumericVector<Number> > adjresid_matlab = system.solution->clone(); if(FILE *fp=fopen("superadj_matlab.txt","r")){ Real value; int counter = 0; int flag = 1; while(flag != -1){ flag = fscanf(fp,"%lf",&value); if(flag != -1){ sadj_matlab->set(counter, value); counter += 1; } } fclose(fp); } (system.matrix)->vector_mult(*adjresid_matlab,*sadj_matlab); //std::cout << "******************** matrix-superadj product (matlab) ***********************" << std::endl; //adjresid_matlab->print(); adjresid_matlab->add(-1.0, system.get_adjoint_rhs(0)); //std::cout << "******************** superadjoint system residual (matlab) ***********************" << std::endl; //adjresid_matlab->print(); std::cout << "\n\nmatlab import adjoint system residual (discrete L2): " << system.calculate_norm(*adjresid_matlab,DISCRETE_L2) << "\n" << std::endl; */ /* AutoPtr<NumericVector<Number> > sadj_fwd_hack = system.solution->clone(); AutoPtr<NumericVector<Number> > adjresid_fwd_hack = system.solution->clone(); if(FILE *fp=fopen("superadj_forward_hack.txt","r")){ Real value; int counter = 0; int flag = 1; while(flag != -1){ flag = fscanf(fp,"%lf",&value); if(flag != -1){ sadj_fwd_hack->set(counter, value); counter += 1; } } fclose(fp); } (system.matrix)->vector_mult(*adjresid_fwd_hack,*sadj_fwd_hack); //std::cout << "******************** matrix-superadj product (fwd_hack) ***********************" << std::endl; //adjresid_fwd_hack->print(); adjresid_fwd_hack->add(-1.0, system.get_adjoint_rhs(0)); //std::cout << "******************** superadjoint system residual (fwd_hack) ***********************" << std::endl; //adjresid_fwd_hack->print(); std::cout << "\n\nfwd_hack import adjoint system residual (discrete L2): " << system.calculate_norm(*adjresid_fwd_hack,DISCRETE_L2) << "\n" << std::endl; std::cout << "fwd_hack adjoint system residual (L2, 0): " << system.calculate_norm(*adjresid_fwd_hack,0,L2) << std::endl; std::cout << "fwd_hack adjoint system residual (L2, 1): " << system.calculate_norm(*adjresid_fwd_hack,1,L2) << std::endl; std::cout << "fwd_hack adjoint system residual (L2, 2): " << system.calculate_norm(*adjresid_fwd_hack,2,L2) << std::endl; std::cout << "fwd_hack adjoint system residual (L2, 3): " << system.calculate_norm(*adjresid_fwd_hack,3,L2) << std::endl; std::cout << "fwd_hack adjoint system residual (L2, 4): " << system.calculate_norm(*adjresid_fwd_hack,4,L2) << std::endl; std::cout << "fwd_hack adjoint system residual (L2, 5): " << system.calculate_norm(*adjresid_fwd_hack,5,L2) << std::endl; */ //std::cout << "************************ system.matrix ***********************" << std::endl; //system.matrix->print(); std::cout << "\n------------ herp derp ------------" << std::endl; // The cell wise breakdown ErrorVector cell_wise_error; cell_wise_error.resize((system.rhs)->size()); for(unsigned int i = 0; i < (system.rhs)->size() ; i++) { if(i < system.get_mesh().n_elem()) cell_wise_error[i] = fabs(-0.5*((system.rhs)->el(i) * dual_solution(i)) + system.get_MHF_psiLF(i) - system.get_MLF_psiLF(i)); else cell_wise_error[i] = fabs(-0.5*((system.rhs)->el(i) * dual_solution(i))); /*csv from 'save data' from gmv output gives a few values at each node point (value for every element that shares that node), yet paraview display only seems to show one of them -> the value in an element is given at each of the nodes that it has, hence the repetition; what is displayed in paraview is each element's value; even though MHF_psiLF and MLF_psiLF are stored by element this seems to give elemental contributions that agree with if we had taken the superadj-residual dot product by integrating over elements*/ /*at higher mesh resolutions and lower k, weird-looking artifacts start to appear and it no longer agrees with output from manual integration of superadj-residual...*/ } // Plot it std::ostringstream error_gmv; error_gmv << "error.gmv"; cell_wise_error.plot_error(error_gmv.str(), equation_systems.get_mesh()); //alternate element-wise breakdown, outputed as values matched to element centroids; for matlab plotz primal_solution.swap(dual_solution); system.postprocess(1); primal_solution.swap(dual_solution); system.postprocess(2); std::cout << "\n\n -0.5*M'_HF(psiLF)(superadj): " << std::setprecision(17) << system.get_half_adj_weighted_resid() << "\n"; primal_solution.swap(dual_solution); std::string write_error_here = infileForMesh("error_est_output_file", "error_est_breakdown.dat"); std::ofstream output(write_error_here); for(unsigned int i = 0 ; i < system.get_mesh().n_elem(); i++) { Point elem_cent = system.get_mesh().elem(i)->centroid(); if(output.is_open()) { output << elem_cent(0) << " " << elem_cent(1) << " " << fabs(system.get_half_adj_weighted_resid(i) + system.get_MHF_psiLF(i) - system.get_MLF_psiLF(i)) << "\n"; } } output.close(); } // End if at max adaptive steps #ifdef LIBMESH_HAVE_EXODUS_API // Write out this timestep if we're requested to if ((t_step+1)%write_interval == 0) { std::ostringstream file_name; /* // We write the file in the ExodusII format. file_name << "out_" << std::setw(3) << std::setfill('0') << std::right << t_step+1 << ".e"; //this should write out the primal which should be the same as what's read in... ExodusII_IO(mesh).write_timestep(file_name.str(), equation_systems, 1, //number of time steps written to file system.time); */ } #endif // #ifdef LIBMESH_HAVE_EXODUS_API } // All done. return 0; } //end main
bool NFFParser::readFile() const{ ifstream input(fileLocation, ios::in); if (!input.good()){ std::cout << "Can't find my file!\n"; return false; } if (!input){ cout << "Unable to open file"; return false; } else{ std::string line; while (getline(input, line)){ std::vector<std::string> splitLine = split(line, ' '); std::string command = splitLine[0]; if (command == "s"){ Vec3f center = read3DVector(splitLine); float radius = static_cast<float>(atof(splitLine[4].c_str())); Sphere* s = new Sphere(center, radius); SceneObject* so = new SceneObject(scene->materialIndex, s); scene->octree->insertShape(so, scene->octree->root, 0); } else if (command == "c"){ float baseX = static_cast<float>(atof(splitLine[1].c_str())); float baseY = static_cast<float>(atof(splitLine[2].c_str())); float baseZ = static_cast<float>(atof(splitLine[3].c_str())); float baseRadius = static_cast<float>(atof(splitLine[4].c_str())); Vec3f base = Vec3f(baseX, baseY, baseZ); float apexX = static_cast<float>(atof(splitLine[5].c_str())); float apexY = static_cast<float>(atof(splitLine[6].c_str())); float apexZ = static_cast<float>(atof(splitLine[7].c_str())); float apexRadius = static_cast<float>(atof(splitLine[8].c_str())); Vec3f apex = Vec3f(apexX, apexY, apexZ); if (baseRadius == apexRadius){ Cylinder* c = new Cylinder(base, apex, baseRadius); SceneObject* so = new SceneObject(scene->materialIndex, static_cast<Primitive*>(c)); scene->octree->insertShape(so, scene->octree->root, 0); } else{ // @TODO cone code } } else if (command == "p"){ int numVerts = atoi(splitLine[1].c_str()); if (numVerts >= 3){ std::vector<Vec3f> verts(numVerts); for (int i = 0; i < numVerts; i++){ getline(input, line); std::vector<std::string> splitLine = split(line, ' '); verts[i] = read3DVector(splitLine); } Polygon* poly = new Polygon(verts); std::vector<Triangle*> triangles = poly->triangles; for (std::vector<int>::size_type itr = 0; itr != triangles.size(); itr++) { Triangle* t = triangles[itr]; SceneObject* so = new SceneObject(scene->materialIndex, static_cast<Primitive*>(t)); scene->octree->insertShape(so, scene->octree->root, 0); } } } else if (command == "pp"){ int numVerts = atoi(splitLine[1].c_str()); if (numVerts >= 3){ std::vector<Vec3f> verts(numVerts); std::vector<Vec3f> norms(numVerts); for (int i = 0; i < numVerts; i++){ getline(input, line); std::vector<std::string> splitLine = split(line, ' '); float x = static_cast<float>(atof(splitLine[0].c_str())); float y = static_cast<float>(atof(splitLine[1].c_str())); float z = static_cast<float>(atof(splitLine[2].c_str())); verts.push_back(Vec3f(x, y, z)); float nx = static_cast<float>(atof(splitLine[3].c_str())); float ny = static_cast<float>(atof(splitLine[4].c_str())); float nz = static_cast<float>(atof(splitLine[5].c_str())); norms.push_back(Vec3f(nx, ny, nz)); } Vec3f n = Vec3f(0.f, 0.f, 0.f); for (std::vector<int>::size_type itr = 0; itr != norms.size(); itr++) { n += norms[itr]; } n /= 3.f; Triangle* t = new Triangle(verts[0], verts[1], verts[2], n); SceneObject* so = new SceneObject(scene->materialIndex, static_cast<Primitive*>(t)); scene->octree->insertShape(so, scene->octree->root, 0); } } else if (command == "v"){ for (int i = 0; i < 6; i++){ getline(input, line); std::vector<std::string> splitLine = split(line, ' '); std::string command = splitLine[0]; if (command == "from"){ scene->from = read3DVector(splitLine); } else if (command == "at"){ scene->at = read3DVector(splitLine); } else if (command == "up"){ scene->up = read3DVector(splitLine); } else if (command == "angle"){ scene->fov =static_cast<float>(atof(splitLine[1].c_str())); } else if (command == "hither"){ scene->hither = static_cast<float>(atof(splitLine[1].c_str())); } else if (command == "resolution"){ scene->screenWidth = std::stoi(splitLine[1]); scene->screenHeight = std::stoi(splitLine[1]); } } } else if (command == "b"){ scene->bg = read3DVector(splitLine); } else if (command == "l"){ Light* const l = new Light(read3DVector(splitLine)); scene->lights.push_back(l); } else if (command == "f"){ float red = static_cast<float>(atof(splitLine[1].c_str())); float green = static_cast<float>(atof(splitLine[2].c_str())); float blue = static_cast<float>(atof(splitLine[3].c_str())); float kd = static_cast<float>(atof(splitLine[4].c_str())); float ks = static_cast<float>(atof(splitLine[5].c_str())); float shine = static_cast<float>(atof(splitLine[6].c_str())); float T = static_cast<float>(atof(splitLine[7].c_str())); float refraction = static_cast<float>(atof(splitLine[8].c_str())); Material* m = new Material(red, green, blue, kd, ks, shine, T, refraction); ++scene->materialIndex; // incrementation here on purpose scene->materials.push_back(m); } } printf("File reading done.\n"); input.close(); } return true; }
int CTestNormUnbalance::test(void) { // check to ensure the SOE has been set - this should not happen if the // return from start() is checked if (theSOE == 0) return -2; // check to ensure the algo does invoke start() - this is needed otherwise // may never get convergence later on in analysis! if (currentIter == 0) { opserr << "WARNING: CTestNormUnbalance::test() - start() was never invoked.\n"; return -2; } // get the B vector & determine it's norm & save the value in norms vector const Vector &x = theSOE->getB(); double norm = x.pNorm(nType); if (currentIter <= maxNumIter) norms(currentIter-1) = norm; if(currentIter > 1) { if(norms(currentIter-2) < norm) { numIncr++; } } // print the data if required if (printFlag == 1) { opserr << "CTestNormUnbalance::test() - iteration: " << currentIter; opserr << " current Norm: " << norm << " (max: " << tol; opserr << ", Norm deltaX: " << theSOE->getX().pNorm(nType) << ")\n"; } if (printFlag == 4) { opserr << "CTestNormUnbalance::test() - iteration: " << currentIter; opserr << " current Norm: " << norm << " (max: " << tol << ")\n"; opserr << "\tNorm deltaX: " << theSOE->getX().pNorm(nType) << ", Norm deltaR: " << norm << endln; opserr << "\tdeltaX: " << theSOE->getX() << "\tdeltaR: " << x; } // // check if the algorithm converged // // if converged - print & return ok if (norm <= tol) { // do some printing first if (printFlag != 0) { if (printFlag == 1 || printFlag == 4) opserr << endln; else if (printFlag == 2 || printFlag == 6) { opserr << "CTestNormUnbalance::test() - iteration: " << currentIter; opserr << " current Norm: " << norm << " (max: " << tol; opserr << ", Norm deltaX: " << theSOE->getX().pNorm(nType) << ")\n"; } } // return the number of times test has been called return currentIter; } // algo failed to converged after specified number of iterations - but RETURN OK else if ((printFlag == 5 || printFlag == 6) && (currentIter >= maxNumIter||numIncr>=maxIncr)) { opserr << "WARNING: CTestNormUnbalance::test() - failed to converge but going on -"; opserr << " current Norm: " << norm << " (max: " << tol; opserr << ", Norm deltaX: " << theSOE->getX().pNorm(nType) << ")\n"; return currentIter; } // algo failed to converged after specified number of iterations - return FAILURE -2 else if (currentIter >= maxNumIter || numIncr >= maxIncr || norm > maxTol) { // the algorithm failed to converge opserr << "WARNING: CTestNormUnbalance::test() - failed to converge \n"; opserr << "after: " << currentIter << " iterations\n"; currentIter++; // we increment in case analysis does not check for convergence return -2; } // algorithm not yet converged - increment counter and return -1 else { currentIter++; return -1; } }
// Tests two sweeps of ILUT in Ifpack2 TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(Ifpack2Smoother, ILU_TwoSweeps, Scalar, LocalOrdinal, GlobalOrdinal, Node) { # include <MueLu_UseShortNames.hpp> MUELU_TESTING_SET_OSTREAM; MUELU_TESTING_LIMIT_EPETRA_SCOPE(Scalar,GlobalOrdinal,Node); typedef typename Teuchos::ScalarTraits<SC>::magnitudeType magnitude_type; MUELU_TEST_ONLY_FOR(Xpetra::UseTpetra) { //FIXME this will probably fail in parallel b/c it becomes block Jacobi Teuchos::ParameterList paramList; Ifpack2Smoother smoother("ILUT",paramList); //I don't use the testApply infrastructure because it has no provision for an initial guess. Teuchos::RCP<Matrix> A = TestHelpers::TestFactory<SC, LO, GO, NO>::Build1DPoisson(125); Level level; TestHelpers::TestFactory<SC,LO,GO,NO>::createSingleLevelHierarchy(level); level.Set("A", A); smoother.Setup(level); RCP<MultiVector> X = MultiVectorFactory::Build(A->getDomainMap(),1); RCP<MultiVector> RHS = MultiVectorFactory::Build(A->getRangeMap(),1); // Random X X->setSeed(846930886); X->randomize(); // Normalize X Array<magnitude_type> norms(1); X->norm2(norms); X->scale(1/norms[0]); // Compute RHS corresponding to X A->apply(*X,*RHS, Teuchos::NO_TRANS,(SC)1.0,(SC)0.0); // Reset X to 0 X->putScalar((SC) 0.0); RHS->norm2(norms); out << "||RHS|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << norms[0] << std::endl; out << "solve with zero initial guess" << std::endl; Teuchos::Array<magnitude_type> initialNorms(1); X->norm2(initialNorms); out << " ||X_initial|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << initialNorms[0] << std::endl; smoother.Apply(*X, *RHS, true); //zero initial guess Teuchos::Array<magnitude_type> finalNorms(1); X->norm2(finalNorms); Teuchos::Array<magnitude_type> residualNorm1 = Utilities::ResidualNorm(*A, *X, *RHS); out << " ||Residual_final|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(20) << residualNorm1[0] << std::endl; out << " ||X_final|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << finalNorms[0] << std::endl; out << "solve with random initial guess" << std::endl; X->randomize(); X->norm2(initialNorms); out << " ||X_initial|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << initialNorms[0] << std::endl; smoother.Apply(*X, *RHS, false); //nonzero initial guess X->norm2(finalNorms); Teuchos::Array<magnitude_type> residualNorm2 = Utilities::ResidualNorm(*A, *X, *RHS); out << " ||Residual_final|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(20) << residualNorm2[0] << std::endl; out << " ||X_final|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << finalNorms[0] << std::endl; RCP<const Teuchos::Comm<int> > comm = TestHelpers::Parameters::getDefaultComm(); if (comm->getSize() == 1) { //TEST_EQUALITY(residualNorms < 1e-10, true); TEST_EQUALITY(residualNorm1[0] != residualNorm2[0], true); } else { out << "Pass/Fail is only checked in serial." << std::endl; } } } // ILU
int main(int argc, char **argv) { #ifdef QUESO_HAVE_LIBMESH unsigned int i, j; QUESO::EnvOptionsValues opts; opts.m_seed = -1; #ifdef QUESO_HAS_MPI MPI_Init(&argc, &argv); QUESO::FullEnvironment env(MPI_COMM_WORLD, "", "", &opts); #else QUESO::FullEnvironment env("", "", &opts); #endif #ifdef LIBMESH_DEFAULT_SINGLE_PRECISION // SLEPc currently gives us a nasty crash with Real==float libmesh_example_assert(false, "--disable-singleprecision"); #endif // Need an artificial block here because libmesh needs to // call PetscFinalize before we call MPI_Finalize #ifdef LIBMESH_HAVE_SLEPC { libMesh::LibMeshInit init(argc, argv); libMesh::Mesh mesh(init.comm()); libMesh::MeshTools::Generation::build_square(mesh, 20, 20, 0.0, 1.0, 0.0, 1.0, libMeshEnums::QUAD4); QUESO::FunctionOperatorBuilder builder; builder.order = "FIRST"; builder.family = "LAGRANGE"; builder.num_req_eigenpairs = 10; QUESO::LibMeshNegativeLaplacianOperator precision(builder, mesh); libMesh::EquationSystems & es = precision.get_equation_systems(); libMesh::CondensedEigenSystem & eig_sys = es.get_system<libMesh::CondensedEigenSystem>( "Eigensystem"); // Check all eigenfunctions have unit L2 norm std::vector<double> norms(builder.num_req_eigenpairs, 0); for (i = 0; i < builder.num_req_eigenpairs; i++) { eig_sys.get_eigenpair(i); norms[i] = eig_sys.calculate_norm(*eig_sys.solution, libMesh::SystemNorm(libMeshEnums::L2)); if (abs(norms[i] - 1.0) > TEST_TOL) { return 1; } } const unsigned int dim = mesh.mesh_dimension(); const libMesh::DofMap & dof_map = eig_sys.get_dof_map(); libMesh::FEType fe_type = dof_map.variable_type(0); libMesh::AutoPtr<libMesh::FEBase> fe(libMesh::FEBase::build(dim, fe_type)); libMesh::QGauss qrule(dim, libMeshEnums::FIFTH); fe->attach_quadrature_rule(&qrule); const std::vector<libMesh::Real> & JxW = fe->get_JxW(); const std::vector<std::vector<libMesh::Real> >& phi = fe->get_phi(); libMesh::AutoPtr<libMesh::NumericVector<libMesh::Real> > u, v; double ui = 0.0; double vj = 0.0; double ip = 0.0; for (i = 0; i < builder.num_req_eigenpairs - 1; i++) { eig_sys.get_eigenpair(i); u = eig_sys.solution->clone(); for (j = i + 1; j < builder.num_req_eigenpairs; j++) { libMesh::MeshBase::const_element_iterator el = mesh.active_local_elements_begin(); libMesh::MeshBase::const_element_iterator end_el = mesh.active_local_elements_end(); eig_sys.get_eigenpair(j); v = eig_sys.solution->clone(); for ( ; el != end_el; ++el) { const libMesh::Elem * elem = *el; fe->reinit(elem); for (unsigned int qp = 0; qp < qrule.n_points(); qp++) { for (unsigned int dof = 0; dof < phi.size(); dof++) { ui += (*u)(dof) * phi[dof][qp]; vj += (*v)(dof) * phi[dof][qp]; } ip += ui * vj * JxW[qp]; ui = 0.0; vj = 0.0; } } std::cerr << "INTEGRAL of " << i << " against " << j << " is: " << ip << std::endl; if (abs(ip) > INTEGRATE_TOL) { return 1; } ip = 0.0; } } } #endif // LIBMESH_HAVE_SLEPC #ifdef QUESO_HAS_MPI MPI_Finalize(); #endif return 0; #else return 77; #endif }
TEUCHOS_UNIT_TEST(GenericRFactory, SymmetricProblem) { out << "version: " << MueLu::Version() << std::endl; RCP<const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm(); // generate problem LO maxLevels = 3; LO nEle = 63; const RCP<const Map> map = MapFactory::Build(TestHelpers::Parameters::getLib(), nEle, 0, comm); Teuchos::ParameterList matrixParameters; matrixParameters.set("nx",nEle); RCP<Galeri::Xpetra::Problem<Map,CrsMatrixWrap,MultiVector> > Pr = Galeri::Xpetra::BuildProblem<SC, LO, GO, Map, CrsMatrixWrap, MultiVector>("Laplace1D", map, matrixParameters); RCP<Matrix> Op = Pr->BuildMatrix(); // build nullspace RCP<MultiVector> nullSpace = MultiVectorFactory::Build(map,1); nullSpace->putScalar( (SC) 1.0); Teuchos::Array<Teuchos::ScalarTraits<SC>::magnitudeType> norms(1); nullSpace->norm1(norms); if (comm->getRank() == 0) out << "||NS|| = " << norms[0] << std::endl; // fill hierarchy RCP<Hierarchy> H = rcp( new Hierarchy() ); H->setDefaultVerbLevel(Teuchos::VERB_HIGH); RCP<Level> Finest = H->GetLevel(); Finest->setDefaultVerbLevel(Teuchos::VERB_HIGH); Finest->Set("A",Op); // set fine level matrix Finest->Set("Nullspace",nullSpace); // set null space information for finest level // define transfer operators RCP<CoupledAggregationFactory> CoupledAggFact = rcp(new CoupledAggregationFactory()); CoupledAggFact->SetMinNodesPerAggregate(3); CoupledAggFact->SetMaxNeighAlreadySelected(0); CoupledAggFact->SetOrdering("natural"); CoupledAggFact->SetPhase3AggCreation(0.5); RCP<SaPFactory> Pfact = rcp( new SaPFactory()); RCP<Factory> Rfact = rcp( new GenericRFactory() ); H->SetMaxCoarseSize(1); // setup smoothers Teuchos::ParameterList smootherParamList; smootherParamList.set("relaxation: type", "Symmetric Gauss-Seidel"); smootherParamList.set("relaxation: sweeps", (LO) 1); smootherParamList.set("relaxation: damping factor", (SC) 1.0); RCP<SmootherPrototype> smooProto = rcp( new TrilinosSmoother("RELAXATION", smootherParamList) ); RCP<SmootherFactory> SmooFact = rcp( new SmootherFactory(smooProto) ); //Acfact->setVerbLevel(Teuchos::VERB_HIGH); RCP<SmootherFactory> coarseSolveFact = rcp(new SmootherFactory(smooProto, Teuchos::null)); FactoryManager M; M.SetFactory("P", Pfact); M.SetFactory("R", Rfact); M.SetFactory("Aggregates", CoupledAggFact); M.SetFactory("Smoother", SmooFact); M.SetFactory("CoarseSolver", coarseSolveFact); H->Setup(M, 0, maxLevels); RCP<Level> coarseLevel = H->GetLevel(1); RCP<Matrix> P1 = coarseLevel->Get< RCP<Matrix> >("P"); RCP<Matrix> R1 = coarseLevel->Get< RCP<Matrix> >("R"); RCP<Level> coarseLevel2 = H->GetLevel(2); RCP<Matrix> P2 = coarseLevel2->Get< RCP<Matrix> >("P"); RCP<Matrix> R2 = coarseLevel2->Get< RCP<Matrix> >("R"); TEST_EQUALITY(Finest->IsAvailable("PreSmoother"), true); TEST_EQUALITY(Finest->IsAvailable("PostSmoother"), true); TEST_EQUALITY(coarseLevel->IsAvailable("PreSmoother"), true); TEST_EQUALITY(coarseLevel->IsAvailable("PostSmoother"), true); TEST_EQUALITY(coarseLevel2->IsAvailable("PreSmoother"), true); TEST_EQUALITY(coarseLevel2->IsAvailable("PostSmoother"), false); // test some basic multgrid data TEST_EQUALITY(P1->getGlobalNumEntries(), R1->getGlobalNumEntries()); TEST_EQUALITY(P1->getGlobalNumRows(), R1->getGlobalNumCols()); TEST_EQUALITY(P1->getGlobalNumCols(), R1->getGlobalNumRows()); TEST_EQUALITY(P2->getGlobalNumEntries(), R2->getGlobalNumEntries()); TEST_EQUALITY(P2->getGlobalNumRows(), R2->getGlobalNumCols()); TEST_EQUALITY(P2->getGlobalNumCols(), R2->getGlobalNumRows()); //RCP<Teuchos::FancyOStream> fos = getFancyOStream(Teuchos::rcpFromRef(cout)); // since A is chosen symmetric, it is P^T = R // check P^T * P = R * P // note: the Epetra matrix-matrix multiplication using implicit transpose is buggy in parallel case // (for multiplication of a square matrix with a rectangular matrix) // however it seems to work for two rectangular matrices Teuchos::RCP<Xpetra::Matrix<Scalar,LO,GO,Node> > RP = Xpetra::MatrixMatrix<Scalar,LO,GO,Node>::Multiply(*R1,false,*P1,false,out); Teuchos::RCP<Xpetra::Matrix<Scalar,LO,GO,Node> > PtP = Xpetra::MatrixMatrix<Scalar,LO,GO,Node>::Multiply(*P1,true,*P1,false,out); RCP<Vector> x = VectorFactory::Build(RP->getDomainMap()); RCP<Vector> bRP = VectorFactory::Build(RP->getRangeMap()); RCP<Vector> bPtP = VectorFactory::Build(PtP->getRangeMap()); x->randomize(); RP->apply(*x,*bRP); PtP->apply(*x,*bPtP); TEST_EQUALITY(bRP->norm1() - bPtP->norm1() < 1e-12, true); Teuchos::RCP<Xpetra::Matrix<Scalar,LO,GO,Node> > RP2 = Xpetra::MatrixMatrix<Scalar,LO,GO,Node>::Multiply(*R2,false,*P2,false,out); Teuchos::RCP<Xpetra::Matrix<Scalar,LO,GO,Node> > PtP2 = Xpetra::MatrixMatrix<Scalar,LO,GO,Node>::Multiply(*P2,true,*P2,false,out); x = VectorFactory::Build(RP2->getDomainMap()); bRP = VectorFactory::Build(RP2->getRangeMap()); bPtP = VectorFactory::Build(PtP2->getRangeMap()); x->randomize(); RP2->apply(*x,*bRP); PtP2->apply(*x,*bPtP); TEST_EQUALITY(bRP->norm1() - bPtP->norm1() < 1e-12, true); //R1->describe(*fos,Teuchos::VERB_EXTREME); }
// check Hierarchy::Setup routine with GenericRFactory as restriction factory TEUCHOS_UNIT_TEST(GenericRFactory, GenericRSetup) { out << "version: " << MueLu::Version() << std::endl; for (int i=1; i<5; i++) { // generate problem RCP<const Teuchos::Comm<int> > comm = TestHelpers::Parameters::getDefaultComm(); RCP<Matrix> A = TestHelpers::TestFactory<SC, LO, GO, NO>::Build1DPoisson(50*i*comm->getSize()); // Multigrid Hierarchy Hierarchy H(A); H.setVerbLevel(Teuchos::VERB_HIGH); // build nullspace RCP<MultiVector> nullSpace = MultiVectorFactory::Build(A->getRowMap(),1); nullSpace->putScalar( (SC) 1.0); Teuchos::Array<Teuchos::ScalarTraits<SC>::magnitudeType> norms(1); nullSpace->norm1(norms); if (comm->getRank() == 0) out << "||NS|| = " << norms[0] << std::endl; RCP<PgPFactory> Pfact = rcp( new PgPFactory()); RCP<Factory> Rfact = rcp( new GenericRFactory() ); RCP<RAPFactory> Acfact = rcp( new RAPFactory() ); // setup smoothers Teuchos::ParameterList smootherParamList; smootherParamList.set("relaxation: type", "Symmetric Gauss-Seidel"); smootherParamList.set("relaxation: sweeps", (LO) 1); smootherParamList.set("relaxation: damping factor", (SC) 1.0); RCP<SmootherPrototype> smooProto = rcp( new TrilinosSmoother("RELAXATION", smootherParamList) ); RCP<SmootherFactory> SmooFact = rcp( new SmootherFactory(smooProto) ); Acfact->setVerbLevel(Teuchos::VERB_HIGH); // Multigrid setup phase (using default parameters) FactoryManager M0; // how to build aggregates and smoother of the first level M0.SetFactory("A", Acfact); M0.SetFactory("P", Pfact); M0.SetFactory("R", Rfact); M0.SetFactory("Smoother", SmooFact); M0.SetFactory("CoarseSolver", SmooFact); FactoryManager M1; // first coarse level (Plain aggregation) M1.SetFactory("A", Acfact); M1.SetFactory("P", Pfact); M1.SetFactory("R", Rfact); M1.SetFactory("Smoother", SmooFact); M1.SetFactory("CoarseSolver", SmooFact); FactoryManager M2; // last level (SA) M2.SetFactory("A", Acfact); M2.SetFactory("P", Pfact); M2.SetFactory("R", Rfact); M2.SetFactory("Smoother", SmooFact); M2.SetFactory("CoarseSolver", SmooFact); bool bIsLastLevel = false; if(!bIsLastLevel) bIsLastLevel = H.Setup(0, Teuchos::null, rcpFromRef(M0), rcpFromRef(M1)); if(!bIsLastLevel) bIsLastLevel = H.Setup(1, rcpFromRef(M0), rcpFromRef(M1), rcpFromRef(M2)); if(!bIsLastLevel) bIsLastLevel = H.Setup(2, rcpFromRef(M1), rcpFromRef(M2), Teuchos::null ); RCP<Level> l0 = H.GetLevel(0); RCP<Level> l1; RCP<Level> l2; std::cout << "i = " << i << std::endl; if (H.GetNumLevels() > 1) l1 = H.GetLevel(1); if (H.GetNumLevels() > 2) l2 = H.GetLevel(2); /*RCP<Teuchos::FancyOStream> stdout = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout)); l0->print(*stdout,Teuchos::VERB_EXTREME); if(l1 != Teuchos::null) l1->print(*stdout,Teuchos::VERB_EXTREME); if(l2 != Teuchos::null) l2->print(*stdout,Teuchos::VERB_EXTREME);*/ TEST_EQUALITY(l0->IsAvailable("PreSmoother", MueLu::NoFactory::get()), true); TEST_EQUALITY(l0->IsAvailable("PostSmoother", MueLu::NoFactory::get()), (H.GetNumLevels() > 1 ? true : false)); TEST_EQUALITY(l0->IsAvailable("R", MueLu::NoFactory::get()), false); TEST_EQUALITY(l0->IsAvailable("A", MueLu::NoFactory::get()), true); TEST_EQUALITY(l0->IsAvailable("P", MueLu::NoFactory::get()), false); TEST_EQUALITY(l0->GetKeepFlag("PreSmoother", MueLu::NoFactory::get()), MueLu::Final); if (H.GetNumLevels() > 1) TEST_EQUALITY(l0->GetKeepFlag("PostSmoother", MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(l0->IsRequested("R", MueLu::NoFactory::get()), false); TEST_EQUALITY(l0->GetKeepFlag("A", MueLu::NoFactory::get()), MueLu::UserData); TEST_EQUALITY(l0->IsRequested("P", MueLu::NoFactory::get()), false); if (l1 != Teuchos::null) { TEST_EQUALITY(l1->IsAvailable("PreSmoother", MueLu::NoFactory::get()), true); TEST_EQUALITY(l1->IsAvailable("PostSmoother", MueLu::NoFactory::get()), (H.GetNumLevels() > 2 ? true : false)); TEST_EQUALITY(l1->IsAvailable("R", MueLu::NoFactory::get()), true); TEST_EQUALITY(l1->IsAvailable("A", MueLu::NoFactory::get()), true); TEST_EQUALITY(l1->IsAvailable("P", MueLu::NoFactory::get()), true); TEST_EQUALITY(l1->GetKeepFlag("A", MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(l1->GetKeepFlag("P", MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(l1->GetKeepFlag("R", MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(l1->GetKeepFlag("PreSmoother", MueLu::NoFactory::get()), MueLu::Final); if (H.GetNumLevels() > 2) TEST_EQUALITY(l1->GetKeepFlag("PostSmoother", MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(l1->IsRequested("Graph", MueLu::NoFactory::get()), false); TEST_EQUALITY(l1->IsRequested("Aggregates", MueLu::NoFactory::get()), false); TEST_EQUALITY(l1->IsRequested("Nullspace", MueLu::NoFactory::get()), false); } if (l2 != Teuchos::null) { TEST_EQUALITY(l2->IsAvailable("PreSmoother", MueLu::NoFactory::get()), true); TEST_EQUALITY(l2->IsAvailable("PostSmoother", MueLu::NoFactory::get()), (H.GetNumLevels() > 3 ? true : false)); TEST_EQUALITY(l2->IsAvailable("P", MueLu::NoFactory::get()), true); TEST_EQUALITY(l2->IsAvailable("R", MueLu::NoFactory::get()), true); TEST_EQUALITY(l2->IsAvailable("A", MueLu::NoFactory::get()), true); TEST_EQUALITY(l2->GetKeepFlag("A", MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(l2->GetKeepFlag("P", MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(l2->GetKeepFlag("R", MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(l2->GetKeepFlag("PreSmoother", MueLu::NoFactory::get()), MueLu::Final); if (H.GetNumLevels() > 3) TEST_EQUALITY(l2->GetKeepFlag("PostSmoother", MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(l2->IsRequested("Graph", MueLu::NoFactory::get()), false); TEST_EQUALITY(l2->IsRequested("Aggregates", MueLu::NoFactory::get()), false); TEST_EQUALITY(l2->IsRequested("Nullspace", MueLu::NoFactory::get()), false); } } // end for i=1..5 }
int CTestRelativeEnergyIncr::test(void) { // check to ensure the SOE has been set - this should not happen if the // return from start() is checked if (theSOE == 0) return -2; // check to ensure the algo does invoke start() - this is needed otherwise // may never get convergence later on in analysis! if (currentIter == 0) { opserr << "WARNING: CTestRelativeEnergyIncr::test() - start() was never invoked.\n"; return -2; } // determine the energy & save value in norms vector const Vector &b = theSOE->getB(); const Vector &x = theSOE->getX(); double product = x ^ b; if (product < 0.0) product *= -0.5; else product *= 0.5; if (currentIter <= maxNumIter) norms(currentIter-1) = product; // if first pass through .. set norm0 if (currentIter == 1) { norm0 = product; } // get ratio if (norm0 != 0.0) product /= norm0; // print the data if required if (printFlag == 1) { opserr << "CTestRelativeEnergyIncr::test() - iteration: " << currentIter; opserr << " current Ratio (dX*dR/dX1*dR1): " << product << " (max: " << tol << ")\n"; } if (printFlag == 4) { opserr << "CTestRelativeEnergyIncr::test() - iteration: " << currentIter; opserr << " current Ratio (dX*dR/dX1*dR1): " << product << " (max: " << tol << ")\n"; opserr << "\tNorm deltaX: " << x.pNorm(nType) << ", Norm deltaR: " << b.pNorm(nType) << endln; opserr << "\tdeltaX: " << x << "\tdeltaR: " << b; } // // check if the algorithm converged // // if converged - print & return ok if (product <= tol) { // do some printing first if (printFlag != 0) { if (printFlag == 1 || printFlag == 4) opserr << endln; else if (printFlag == 2 || printFlag == 6) { opserr << "CTestRelativeEnergyIncr::test() - iteration: " << currentIter; opserr << " last Ratio (dX*dR/dX1*dR1): " << product << " (max: " << tol << ")\n"; } } // return the number of times test has been called - SUCCESSFULL return currentIter; } // algo failed to converged after specified number of iterations - but RETURN OK else if ((printFlag == 5 || printFlag == 6) && currentIter >= maxNumIter) { opserr << "WARNING: CTestRelativeEnergyIncr::test() - failed to converge but goin on -"; opserr << " current Ratio (dX*dR/dX1*dR1): " << product << " (max: " << tol << ")\n"; opserr << "\tNorm deltaX: " << x.pNorm(nType) << ", Norm deltaR: " << b.pNorm(nType) << endln; return currentIter; } // algo failed to converged after specified number of iterations - return FAILURE -2 else if (currentIter >= maxNumIter) { // >= in case algorithm does not check opserr << "WARNING: CTestRelativeEnergyIncr::test() - failed to converge \n"; opserr << "after: " << currentIter << " iterations\n"; currentIter++; return -2; } // algorithm not yet converged - increment counter and return -1 else { currentIter++; return -1; } }
//! @brief Comprueba si se ha producido la convergencia. int XC::CTestRelativeNormUnbalance::test(void) { // check to ensure the SOE has been set - this should not happen if the // return from start() is checked if(!hasLinearSOE()) return -2; // check to ensure the algo does invoke start() - this is needed otherwise // may never get convergence later on in analysis! if(currentIter == 0) { std::cerr << getClassName() << "::" << __FUNCTION__ << "; WARNING: start() was never invoked.\n"; return -2; } // get the B vector & determine it's norm & save the value in norms vector calculatedNormX= getNormX(); calculatedNormB = getNormB(); lastRatio= calculatedNormB; if(currentIter <= maxNumIter) norms(currentIter)= calculatedNormB; // determine the ratio if(norm0 != 0.0) lastRatio/= norm0; // print the data if required if(printFlag) std::clog << getStatusMsg(printFlag); // // check if the algorithm converged // // if converged - print & return ok if(lastRatio <= tol) { // the algorithm converged // do some printing first if(printFlag != 0) { if(printFlag == 1 || printFlag == 4) std::cerr << std::endl; else if(printFlag == 2 || printFlag == 6) { std::cerr << getTestIterationMessage(); std::cerr << getRatioMessage("(|dR|/|dR0|)"); } } // return the number of times test has been called return currentIter; } // algo failed to converged after specified number of iterations - but RETURN OK else if((printFlag == 5 || printFlag == 6) && currentIter >= maxNumIter) { std::cerr << getClassName() << "::" << __FUNCTION__ << "; WARNING: failed to converge but going on -" << getRatioMessage("(dR/dR0)"); return currentIter; } // algo failed to converged after specified number of iterations - return FAILURE -2 else if(currentIter >= maxNumIter) { // the algorithm failed to converge std::cerr << getFailedToConvergeMessage(); currentIter++; // we increment in case analysis does not check for convergence return -2; } // algorithm not yet converged - increment counter and return -1 else { currentIter++; return -1; } }
int main (int argc, char* argv[]) { Teuchos::GlobalMPISession mpisess(&argc, &argv); bool success = true; Teuchos::RCP<Teuchos::FancyOStream> out = Teuchos::VerboseObjectBase::getDefaultOStream(); try { Teuchos::Time timer("total"); timer.start(); Tpetra::DefaultPlatform::DefaultPlatformType& platform = Tpetra::DefaultPlatform::getDefaultPlatform(); Teuchos::RCP<const Teuchos::Comm<int> > comm = platform.getComm(); typedef double Scalar; typedef Tpetra::Map<>::local_ordinal_type LO; typedef Tpetra::Map<>::global_ordinal_type GO; typedef Tpetra::DefaultPlatform::DefaultPlatformType::NodeType Node; typedef Tpetra::MultiVector<Scalar,LO,GO,Node> TMV; typedef Tpetra::Operator<Scalar,LO,GO,Node> TOP; typedef Belos::LinearProblem<Scalar,TMV,TOP> BLinProb; typedef Belos::SolverManager<Scalar,TMV,TOP> BSolverMgr; //Just get one parameter from the command-line: the name of an xml file //to get parameters from. std::string xml_file("calore1_mm.xml"); { bool printedHelp = false; process_command_line (printedHelp, xml_file, argc, argv); if (printedHelp) { return EXIT_SUCCESS; } } //Read the contents of the xml file into a ParameterList. That parameter list //should specify a matrix-file and optionally which Belos solver to use, and //which Ifpack2 preconditioner to use, etc. If there are sublists of parameters //for Belos and Ifpack2, those will be passed to the respective destinations //from within the build_problem and build_solver functions. *out << "Every proc reading parameters from xml_file: " << xml_file << std::endl; Teuchos::ParameterList test_params = Teuchos::ParameterXMLFileReader(xml_file).getParameters(); //The build_problem function is located in build_problem.hpp. //Note that build_problem calls build_precond and sets a preconditioner on the //linear-problem, if a preconditioner is specified. Teuchos::RCP<BLinProb> problem = build_problem<Scalar,LO,GO,Node>(test_params, comm); //The build_solver function is located in build_solver.hpp: Teuchos::RCP<BSolverMgr> solver = build_solver<Scalar,TMV,TOP>(test_params, problem); Belos::ReturnType ret = solver->solve(); *out << "Converged in " << solver->getNumIters() << " iterations." << std::endl; Teuchos::RCP<TMV> R = Teuchos::rcp(new TMV(*problem->getRHS())); problem->computeCurrResVec(&*R, &*problem->getLHS(), &*problem->getRHS()); Teuchos::Array<Teuchos::ScalarTraits<Scalar>::magnitudeType> norms(R->getNumVectors()); R->norm2(norms); if (norms.size() < 1) { throw std::runtime_error("ERROR: norms.size()==0 indicates R->getNumVectors()==0."); } *out << "2-Norm of 0th residual vec: " << norms[0] << std::endl; //If the xml file specified a number of iterations to expect, then we will //use that as a test pass/fail criteria. if (test_params.isParameter("expectNumIters")) { int expected_iters = 0; Ifpack2::getParameter(test_params, "expectNumIters", expected_iters); int actual_iters = solver->getNumIters(); if (ret == Belos::Converged && actual_iters <= expected_iters && norms[0] < 1.e-7) { } else { success = false; *out << "Actual iters("<<actual_iters <<") > expected number of iterations (" <<expected_iters<<"), or resid-norm(" << norms[0] << ") >= 1.e-7"<<std::endl; } } timer.stop(); *out << "proc 0 total program time: " << timer.totalElapsedTime() << std::endl; } TEUCHOS_STANDARD_CATCH_STATEMENTS(true, std::cerr, success) if (success) { *out << "End Result: TEST PASSED\n"; } else { *out << "End Result: TEST FAILED\n"; } return ( success ? 0 : 1 ); }
TEUCHOS_UNIT_TEST(SaPFactory_kokkos, EpetraVsTpetra) { # include "MueLu_UseShortNames.hpp" MueLu::VerboseObject::SetDefaultOStream(Teuchos::rcpFromRef(out)); out << "version: " << MueLu::Version() << std::endl; out << "Compare results of Epetra and Tpetra" << std::endl; out << "for 3 level AMG solver using smoothed aggregation with" << std::endl; out << "one SGS sweep on each multigrid level as pre- and postsmoother" << std::endl; RCP<const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm(); typedef Teuchos::ScalarTraits<SC> STS; SC zero = STS::zero(), one = STS::one(); Array<STS::magnitudeType> results(2); // run test only on 1 proc if(comm->getSize() == 1) { Xpetra::UnderlyingLib lib = Xpetra::UseEpetra; // run Epetra and Tpetra test for (int run = 0; run < 2; run++) { //TODO: create a subfunction instead or Tuple of UnderlyingLib if (run == 0) lib = Xpetra::UseEpetra; else lib = Xpetra::UseTpetra; // generate problem LO maxLevels = 3; LO its = 10; GO nEle = 63; const RCP<const Map> map = MapFactory::Build(lib, nEle, 0, comm); Teuchos::ParameterList matrixParameters; matrixParameters.set("nx", nEle); RCP<Galeri::Xpetra::Problem<Map,CrsMatrixWrap,MultiVector> > Pr = Galeri::Xpetra::BuildProblem<SC,LO,GO,Map,CrsMatrixWrap,MultiVector>("Laplace1D", map, matrixParameters); RCP<Matrix> Op = Pr->BuildMatrix(); // build nullspace RCP<MultiVector> nullSpace = MultiVectorFactory::Build(map,1); nullSpace->putScalar(one); Array<STS::magnitudeType> norms(1); nullSpace->norm1(norms); if (comm->getRank() == 0) out << "||NS|| = " << norms[0] << std::endl; // fill hierarchy RCP<Hierarchy> H = rcp( new Hierarchy() ); H->setDefaultVerbLevel(Teuchos::VERB_HIGH); RCP<Level> Finest = H->GetLevel(); Finest->setDefaultVerbLevel(Teuchos::VERB_HIGH); Finest->Set("A",Op); // set fine level matrix Finest->Set("Nullspace",nullSpace); // set null space information for finest level // define transfer operators RCP<CoupledAggregationFactory> CoupledAggFact = rcp(new CoupledAggregationFactory()); CoupledAggFact->SetMinNodesPerAggregate(3); CoupledAggFact->SetMaxNeighAlreadySelected(0); CoupledAggFact->SetOrdering("natural"); CoupledAggFact->SetPhase3AggCreation(0.5); RCP<TentativePFactory> Ptentfact = rcp(new TentativePFactory()); RCP<SaPFactory> Pfact = rcp( new SaPFactory()); RCP<Factory> Rfact = rcp( new TransPFactory() ); RCP<RAPFactory> Acfact = rcp( new RAPFactory() ); H->SetMaxCoarseSize(1); // setup smoothers Teuchos::ParameterList smootherParamList; smootherParamList.set("relaxation: type", "Symmetric Gauss-Seidel"); smootherParamList.set("relaxation: sweeps", (LO) 1); smootherParamList.set("relaxation: damping factor", (SC) 1.0); RCP<SmootherPrototype> smooProto = rcp( new TrilinosSmoother("RELAXATION", smootherParamList) ); RCP<SmootherFactory> SmooFact = rcp( new SmootherFactory(smooProto) ); Acfact->setVerbLevel(Teuchos::VERB_HIGH); RCP<SmootherFactory> coarseSolveFact = rcp(new SmootherFactory(smooProto, Teuchos::null)); FactoryManager M; M.SetFactory("P", Pfact); M.SetFactory("R", Rfact); M.SetFactory("A", Acfact); M.SetFactory("Ptent", Ptentfact); M.SetFactory("Aggregates", CoupledAggFact); M.SetFactory("Smoother", SmooFact); M.SetFactory("CoarseSolver", coarseSolveFact); H->Setup(M, 0, maxLevels); // test some basic multigrid data RCP<Level> coarseLevel = H->GetLevel(1); TEST_EQUALITY(coarseLevel->IsRequested("A",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel->IsRequested("P",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel->IsRequested("PreSmoother",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel->IsRequested("PostSmoother",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel->IsRequested("R",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel->IsAvailable("A",MueLu::NoFactory::get()), true); TEST_EQUALITY(coarseLevel->IsAvailable("P",MueLu::NoFactory::get()), true); TEST_EQUALITY(coarseLevel->IsAvailable("PreSmoother",MueLu::NoFactory::get()), true); TEST_EQUALITY(coarseLevel->IsAvailable("PostSmoother",MueLu::NoFactory::get()), true); TEST_EQUALITY(coarseLevel->IsAvailable("R",MueLu::NoFactory::get()), true); TEST_EQUALITY(coarseLevel->GetKeepFlag("A",MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(coarseLevel->GetKeepFlag("P",MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(coarseLevel->GetKeepFlag("PreSmoother",MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(coarseLevel->GetKeepFlag("PostSmoother",MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(coarseLevel->GetKeepFlag("R",MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(coarseLevel->IsRequested("P",Pfact.get()), false); TEST_EQUALITY(coarseLevel->IsRequested("P",Ptentfact.get()), false); TEST_EQUALITY(coarseLevel->IsRequested("PreSmoother",SmooFact.get()), false); TEST_EQUALITY(coarseLevel->IsRequested("PostSmoother",SmooFact.get()), false); TEST_EQUALITY(coarseLevel->IsRequested("R",Rfact.get()), false); TEST_EQUALITY(coarseLevel->IsRequested("A",Acfact.get()), false); TEST_EQUALITY(coarseLevel->IsAvailable("P",Pfact.get()), false); TEST_EQUALITY(coarseLevel->IsAvailable("P",Ptentfact.get()), false); TEST_EQUALITY(coarseLevel->IsAvailable("PreSmoother",SmooFact.get()), false); TEST_EQUALITY(coarseLevel->IsAvailable("PostSmoother",SmooFact.get()), false); TEST_EQUALITY(coarseLevel->IsAvailable("R",Rfact.get()), false); TEST_EQUALITY(coarseLevel->IsAvailable("A",Acfact.get()), false); TEST_EQUALITY(coarseLevel->GetKeepFlag("P",Pfact.get()), 0); TEST_EQUALITY(coarseLevel->GetKeepFlag("P",Ptentfact.get()), 0); TEST_EQUALITY(coarseLevel->GetKeepFlag("PreSmoother",SmooFact.get()), 0); TEST_EQUALITY(coarseLevel->GetKeepFlag("PostSmoother",SmooFact.get()), 0); TEST_EQUALITY(coarseLevel->GetKeepFlag("R",Rfact.get()), 0); TEST_EQUALITY(coarseLevel->GetKeepFlag("A",Acfact.get()), 0); RCP<Matrix> P1 = coarseLevel->Get< RCP<Matrix> >("P"); RCP<Matrix> R1 = coarseLevel->Get< RCP<Matrix> >("R"); TEST_EQUALITY(P1->getGlobalNumRows(), 63); TEST_EQUALITY(P1->getGlobalNumCols(), 21); TEST_EQUALITY(R1->getGlobalNumRows(), 21); TEST_EQUALITY(R1->getGlobalNumCols(), 63); RCP<Level> coarseLevel2 = H->GetLevel(2); TEST_EQUALITY(coarseLevel2->IsRequested("A",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel2->IsRequested("P",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel2->IsRequested("R",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel2->IsRequested("PreSmoother",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel2->IsRequested("PostSmoother",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel2->IsAvailable("A",MueLu::NoFactory::get()), true); TEST_EQUALITY(coarseLevel2->IsAvailable("P",MueLu::NoFactory::get()), true); TEST_EQUALITY(coarseLevel2->IsAvailable("PreSmoother",MueLu::NoFactory::get()), true); TEST_EQUALITY(coarseLevel2->IsAvailable("PostSmoother",MueLu::NoFactory::get()), false); TEST_EQUALITY(coarseLevel2->IsAvailable("R",MueLu::NoFactory::get()), true); TEST_EQUALITY(coarseLevel2->GetKeepFlag("A",MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(coarseLevel2->GetKeepFlag("P",MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(coarseLevel2->GetKeepFlag("PreSmoother",MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(coarseLevel2->GetKeepFlag("PostSmoother",MueLu::NoFactory::get()), 0); TEST_EQUALITY(coarseLevel2->GetKeepFlag("R",MueLu::NoFactory::get()), MueLu::Final); TEST_EQUALITY(coarseLevel2->IsRequested("P",Pfact.get()), false); TEST_EQUALITY(coarseLevel2->IsRequested("P",Ptentfact.get()), false); TEST_EQUALITY(coarseLevel2->IsRequested("R",Rfact.get()), false); TEST_EQUALITY(coarseLevel2->IsAvailable("P",Pfact.get()), false); TEST_EQUALITY(coarseLevel2->IsAvailable("P",Ptentfact.get()), false); TEST_EQUALITY(coarseLevel2->IsAvailable("PreSmoother",SmooFact.get()), false); TEST_EQUALITY(coarseLevel2->IsAvailable("PostSmoother",SmooFact.get()), false); TEST_EQUALITY(coarseLevel2->IsAvailable("R",Rfact.get()), false); TEST_EQUALITY(coarseLevel2->GetKeepFlag("P",Pfact.get()), 0); TEST_EQUALITY(coarseLevel2->GetKeepFlag("P",Ptentfact.get()), 0); TEST_EQUALITY(coarseLevel2->GetKeepFlag("PreSmoother",SmooFact.get()), 0); TEST_EQUALITY(coarseLevel2->GetKeepFlag("PostSmoother",SmooFact.get()), 0); TEST_EQUALITY(coarseLevel2->GetKeepFlag("R",Rfact.get()), 0); RCP<Matrix> P2 = coarseLevel2->Get< RCP<Matrix> >("P"); RCP<Matrix> R2 = coarseLevel2->Get< RCP<Matrix> >("R"); TEST_EQUALITY(P2->getGlobalNumRows(), 21); TEST_EQUALITY(P2->getGlobalNumCols(), 7); TEST_EQUALITY(R2->getGlobalNumRows(), 7); TEST_EQUALITY(R2->getGlobalNumCols(), 21); Teuchos::RCP<Xpetra::Matrix<Scalar,LO,GO> > PtentTPtent = Xpetra::MatrixMatrix<Scalar,LO,GO>::Multiply(*P1,true,*P1,false,out); TEST_EQUALITY(PtentTPtent->getGlobalMaxNumRowEntries()-3<1e-12, true); TEST_EQUALITY(P1->getGlobalMaxNumRowEntries()-2<1e-12, true); TEST_EQUALITY(P2->getGlobalMaxNumRowEntries()-2<1e-12, true); // Define RHS RCP<MultiVector> X = MultiVectorFactory::Build(map,1); RCP<MultiVector> RHS = MultiVectorFactory::Build(map,1); X->putScalar(1.0); X->norm2(norms); if (comm->getRank() == 0) out << "||X_true|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << norms[0] << std::endl; Op->apply(*X,*RHS,Teuchos::NO_TRANS,(SC)1.0,(SC)0.0); // Use AMG directly as an iterative method { X->putScalar( (SC) 0.0); H->Iterate(*RHS,*X,its); X->norm2(norms); if (comm->getRank() == 0) out << "||X_" << std::setprecision(2) << its << "|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << norms[0] << std::endl; results[run] = norms[0]; } } TEST_EQUALITY(results[0] - results[1] < 1e-10, true); // check results of EPETRA vs TPETRA } // comm->getSize == 1 } //SaPFactory_EpetraVsTpetra
bool mask_out_artifacts(const QString& timeseries_path, const QString& timeseries_out_path, double threshold, int interval_size) { if ((!threshold) || (!interval_size)) { printf("Problem with input parameters. Either threshold or interval_size is zero.\n"); return false; } QTime status_timer; status_timer.start(); DiskReadMda X(timeseries_path); int M = X.N1(); int N = X.N2(); //compute norms of chunks Mda norms(M, N / interval_size); for (int i = 0; i < N / interval_size; i++) { int timepoint = i * interval_size; if (status_timer.elapsed() > 5000) { printf("mask_out_artifacts compute_norms: %d/%d (%d%%)\n", timepoint, N, (int)(timepoint * 100.0 / N)); status_timer.restart(); } Mda chunk; X.readChunk(chunk, 0, timepoint, M, interval_size); for (int m = 0; m < M; m++) { double sumsqr = 0; for (int aa = 0; aa < interval_size; aa++) { sumsqr += chunk.value(m, aa) * chunk.value(m, aa); } norms.set(sqrt(sumsqr), m, i); } } //determine which chunks to use QVector<int> use_it(N / interval_size + 1); for (int i = 0; i < use_it.count(); i++) use_it[i] = 1; for (int m = 0; m < M; m++) { QVector<double> vals; for (int i = 0; i < norms.N2(); i++) { vals << norms.get(m, i); } double sigma0 = MLCompute::stdev(vals); double mean0 = MLCompute::mean(vals); printf("For channel %d: mean=%g, stdev=%g, interval size = %d\n", m, mean0, sigma0, interval_size); for (int i = 0; i < norms.N2(); i++) { if (norms.value(m, i) > mean0 + sigma0 * threshold) { use_it[i - 1] = 0; //don't use the neighbor chunks either use_it[i] = 0; //don't use the neighbor chunks either use_it[i + 1] = 0; //don't use the neighbor chunks either } } } //write the data int num_timepoints_used = 0; int num_timepoints_not_used = 0; DiskWriteMda Y; Y.open(MDAIO_TYPE_FLOAT32, timeseries_out_path, M, N); for (int i = 0; i < N / interval_size; i++) { int timepoint = i * interval_size; if (status_timer.elapsed() > 5000) { printf("mask_out_artifacts write data: %d/%d (%d%%)\n", timepoint, N, (int)(timepoint * 100.0 / N)); status_timer.restart(); } Mda chunk; X.readChunk(chunk, 0, timepoint, M, interval_size); if (use_it[i]) { num_timepoints_used += interval_size; Y.writeChunk(chunk, 0, timepoint); } else { num_timepoints_not_used += interval_size; } } Y.close(); printf("Using %.2f%% of all timepoints\n", num_timepoints_used * 100.0 / (num_timepoints_used + num_timepoints_not_used)); return true; }
TEUCHOS_UNIT_TEST_TEMPLATE_4_DECL(SaPFactory_kokkos, Build, Scalar, LocalOrdinal, GlobalOrdinal, Node) { # include "MueLu_UseShortNames.hpp" MUELU_TESTING_SET_OSTREAM; MUELU_TESTING_LIMIT_SCOPE(Scalar,GlobalOrdinal,Node); out << "version: " << MueLu::Version() << std::endl; RCP<const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm(); // construct two levels Level fineLevel, coarseLevel; TestHelpers_kokkos::TestFactory<SC, LO, GO, NO>::createTwoLevelHierarchy(fineLevel, coarseLevel); // construct matrices const SC lambdaMax = 5; RCP<Matrix> A = TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::Build2DPoisson(27*comm->getSize()); A->SetMaxEigenvalueEstimate(lambdaMax); RCP<Matrix> Ptent = TestHelpers_kokkos::TestFactory<SC,LO,GO,NO>::Build2DPoisson(27*comm->getSize()); // set level matrices fineLevel .Set("A", A); coarseLevel.Set("P", Ptent); // construct the factory to be tested const double dampingFactor = 0.5; RCP<SaPFactory_kokkos> sapFactory = rcp(new SaPFactory_kokkos); ParameterList Pparams; Pparams.set("sa: damping factor", dampingFactor); sapFactory->SetParameterList(Pparams); sapFactory->SetFactory("A", MueLu::NoFactory::getRCP()); sapFactory->SetFactory("P", MueLu::NoFactory::getRCP()); // build the data coarseLevel.Request("P", sapFactory.get()); sapFactory->Build(fineLevel, coarseLevel); // fetch the data RCP<Matrix> Pfact = coarseLevel.Get<RCP<Matrix>>("P", sapFactory.get()); // construct the data to compare SC omega = dampingFactor / lambdaMax; RCP<Vector> invDiag = Utilities_kokkos::GetMatrixDiagonalInverse(*A); RCP<ParameterList> APparams = rcp(new ParameterList); RCP<Matrix> Ptest = Xpetra::IteratorOps<SC,LO,GO,NO>::Jacobi(omega, *invDiag, *A, *Ptent, Teuchos::null, out, "label", APparams); // compare matrices by multiplying them by a random vector RCP<MultiVector> X = MultiVectorFactory::Build(A->getDomainMap(), 1); X->setSeed(846930886); X->randomize(); RCP<MultiVector> Bfact = MultiVectorFactory::Build(A->getRangeMap(), 1); RCP<MultiVector> Btest = MultiVectorFactory::Build(A->getRangeMap(), 1); typedef Teuchos::ScalarTraits<SC> STS; SC zero = STS::zero(), one = STS::one(); Pfact->apply(*X, *Bfact, Teuchos::NO_TRANS, one, zero); Ptest->apply(*X, *Btest, Teuchos::NO_TRANS, one, zero); Btest->update(-one, *Bfact, one); Array<typename STS::magnitudeType> norms(1); Btest->norm2(norms); out << "|| B_factory - B_test || = " << norms[0] << std::endl; TEST_EQUALITY(norms[0] < 1e-12, true); }
void POVPainter::drawColorMesh(const Mesh & mesh, int mode) { // Now we draw the given mesh to the OpenGL widget switch (mode) { case 0: // Filled triangles break; case 1: // Lines break; case 2: // Points break; } // Render the triangles of the mesh std::vector<Eigen::Vector3f> v = mesh.vertices(); std::vector<Eigen::Vector3f> n = mesh.normals(); std::vector<Color3f> c = mesh.colors(); // If there are no triangles then don't bother doing anything if (v.size() == 0 || v.size() != c.size()) return; QString vertsStr, ivertsStr, normsStr, texturesStr; QTextStream verts(&vertsStr); verts << "vertex_vectors{" << v.size() << ",\n"; QTextStream iverts(&ivertsStr); iverts << "face_indices{" << v.size() / 3 << ",\n"; QTextStream norms(&normsStr); norms << "normal_vectors{" << n.size() << ",\n"; QTextStream textures(&texturesStr); textures << "texture_list{" << c.size() << ",\n"; for(unsigned int i = 0; i < v.size(); ++i) { verts << "<" << v[i].x() << "," << v[i].y() << "," << v[i].z() << ">"; norms << "<" << n[i].x() << "," << n[i].y() << "," << n[i].z() << ">"; textures << "texture{pigment{rgbt<" << c[i].red() << "," << c[i].green() << "," << c[i].blue() << "," << 1.0 - d->color.alpha() << ">}}"; if (i != v.size()-1) { verts << ", "; norms << ", "; textures << ",\n"; } if (i != 0 && i%3 == 0) { verts << '\n'; norms << '\n'; } } // Now to write out the indices for (unsigned int i = 0; i < v.size(); i += 3) { iverts << "<" << i << "," << i+1 << "," << i+2 << ">"; iverts << "," << i << "," << i+1 << "," << i+2; if (i != v.size()-3) iverts << ", "; if (i != 0 && ((i+1)/3)%3 == 0) iverts << '\n'; } // Now to close off all the arrays verts << "\n}"; norms << "\n}"; iverts << "\n}"; textures << "\n}"; // Now to write out the full mesh - could be pretty big... *(d->output) << "mesh2 {\n" << vertsStr << '\n' << normsStr << '\n' << texturesStr << '\n' << ivertsStr << '\n' << "}\n\n"; }