/** * @param x coordinates of point to be tested * @param t coordinates of apex point of cone * @param b coordinates of center of basement circle * @param aperture in radians Code copied from http://stackoverflow.com/questions/10768142/verify-if-point-is-inside-a-cone-in-3d-space credit to: furikuretsu altered to suit this purpose */ static bool isLyingInCone(float x[], float t[], float b[], float radius, float height) { float aperture = 2.f * atan(radius/height); // This is for our convenience float halfAperture = aperture/2.f; // Vector pointing to X point from apex float apexToXVect[] = {t[0]-x[0],t[1]-x[1],t[2]-x[2]}; // Vector pointing from apex to circle-center point. float axisVect[] = {t[0]-b[0],t[1]-b[1],t[2]-b[2]}; // X is lying in cone only if it's lying in // infinite version of its cone -- that is, // not limited by "round basement". // We'll use dotProd() to // determine angle between apexToXVect and axis. bool isInInfiniteCone = dotProd(apexToXVect,axisVect)/magn(apexToXVect)/magn(axisVect) > cos(halfAperture); // We can safely compare cos() of angles // between vectors instead of bare angles. return isInInfiniteCone; }
void NonlinSystem::assemble(bool rhsonly) { // sanity checks int ndof = this->get_num_dofs(); if (rhsonly) error("Parameter rhsonly = true has no meaning in NonlinSystem."); if (this->have_spaces == false) error("Before assemble(), you need to initialize spaces."); if (this->spaces == NULL) error("spaces = NULL in LinSystem::assemble()."); // assemble J(Y_n) and store in A, assemble F(Y_n) and store in RHS LinSystem::assemble(); // calculate norms of the residual F(Y_n) res_l2 = res_l1 = res_max = 0.0; for (int i = 0; i < ndof; i++) { res_l2 += sqr(this->RHS[i]); res_l1 += magn(this->RHS[i]); if (magn(this->RHS[i]) > res_max) res_max = magn(this->RHS[i]); } res_l2 = sqrt(res_l2); // multiply RHS by -alpha for (int i = 0; i < ndof; i++) this->RHS[i] *= -this->alpha; }
const BigInt operator /(const BigInt& amount1, const BigInt& amount2) { // magn = magnificent; BigInt quotient, magn(amount2), dividend(amount1), divisor(amount2); dividend.sign = divisor.sign = 0; if(dividend < divisor) return BigInt(0); if(dividend > divisor) magn = magn.leftShift(dividend.length - divisor.length); //if(dividend < magn) // magn = magn.rightShift(); // magn = magn/10; if(dividend >= magn) quotient.length = amount1.length - amount2.length + 1; else{ quotient.length = amount1.length - amount2.length; magn = magn.rightShift(); // magn = magn/10; } quotient.digit = new int[quotient.length]; for(int i = 0 ; i < quotient.length ; i++) quotient.digit[i] = 0; int index(0); while(dividend >= divisor){ while(dividend >= magn) { quotient.digit[index]++; dividend = dividend - magn; } magn = magn.rightShift(); index++; } if(amount1.getSign() == amount2.getSign()) return BigInt( quotient.digit , quotient.length, quotient.sign); else return BigInt( quotient.digit , quotient.length, !quotient.sign); }
//"рисует" одну линию поля из начальной точки PointB //с помощью функций работающих с Z-буфером void LineField(HDC hdc,POINT3 PointB,COLORREF rgb, double force) { VECTORS vect; vect.x = PointB.x; vect.y = PointB.y; vect.z = PointB.z; //видовые координаты проецируемой точки double xe, ye, ze1, ze2; //координаты пикселов int x1,y1,x2,y2; double dt = force > 0 ? 0.1 : -0.1; //длина шага на линии поля double x, y, z, Hx, Hy, Hz, Ha; int k = 0; VECMAG mag; int step = 0; double xt1,yt1,zt1,xt2,yt2,zt2; do { step++; x = vect.x; y = vect.y; z = vect.z; mag = magn(x,y,z); Hx = mag.hx; Hy = mag.hy; Hz = mag.hz; Ha = sqrt(Hx*Hx + Hy*Hy + Hz*Hz); vect.dx = Hx/Ha; vect.dy = Hy/Ha; vect.dz = Hz/Ha; xt1 = vect.x; yt1 = vect.y; zt1 = vect.z; xt2 = xt1 + vect.dx*dt; yt2 = yt1 + vect.dy*dt; zt2 = zt1 + vect.dz*dt; xe = Xe(xt1, yt1, zt1); ye=Ye(xt1,yt1,zt1); ze1=Ze(xt1,yt1,zt1); x1=xn(xe); y1=ym(ye); xe = Xe(xt2, yt2, zt1); ye=Ye(xt2,yt2,zt2); ze2=Ze(xt2,yt2,zt2); x2=xn(xe); y2=ym(ye); //"рисуем" отрезок линии поля ZbufLineWidth(hdc,x1,y1,x2,y2,ze1,ze2,3,rgb); vect.x = xt2; vect.y = yt2; vect.z = zt2; //после 10-и шагов на лини поля "рисуем" стрелку k++; if(k == 10) { arrowVector(hdc,x1,y1,x2,y2,ze2,RGB(0,0,255)); k = 0; } //прекращаем рисовать линию поля на границе куба } while (step < 1000 && (x>-xmax) && (x<xmax) && (y>-ymax) && (y<ymax) && (z>-zmax) && (z<zmax)); }
int main(int argc, char* argv[]) { // Load the mesh. Mesh mesh; MeshReaderH2D mloader; if (ALIGN_MESH) mloader.load("oven_load_circle.mesh", &mesh); else mloader.load("oven_load_square.mesh", &mesh); // Perform initial mesh refinemets. for (int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements(); // Initialize boundary conditions DefaultEssentialBCConst<std::complex<double> > bc_essential(BDY_PERFECT_CONDUCTOR, std::complex<double>(0.0, 0.0)); EssentialBCs<std::complex<double> > bcs(&bc_essential); // Create an Hcurl space with default shapeset. HcurlSpace<std::complex<double> > space(&mesh, &bcs, P_INIT); int ndof = space.get_num_dofs(); Hermes::Mixins::Loggable::Static::info("ndof = %d", ndof); // Initialize the weak formulation. CustomWeakForm wf(e_0, mu_0, mu_r, kappa, omega, J, ALIGN_MESH, &mesh, BDY_CURRENT); // Initialize coarse and reference mesh solution. Solution<std::complex<double> > sln, ref_sln; // Initialize refinements selector. HcurlProjBasedSelector<std::complex<double> > selector(CAND_LIST, CONV_EXP, H2DRS_DEFAULT_ORDER); // Initialize views. ScalarView eview("Electric field", new WinGeom(0, 0, 580, 400)); OrderView oview("Polynomial orders", new WinGeom(590, 0, 550, 400)); // DOF and CPU convergence graphs initialization. SimpleGraph graph_dof, graph_cpu; // Time measurement. Hermes::Mixins::TimeMeasurable cpu_time; cpu_time.tick(); // Adaptivity loop: int as = 1; bool done = false; do { Hermes::Mixins::Loggable::Static::info("---- Adaptivity step %d:", as); // Construct globally refined reference mesh and setup reference space. Mesh::ReferenceMeshCreator refMeshCreator(&mesh); Mesh* ref_mesh = refMeshCreator.create_ref_mesh(); Space<std::complex<double> >::ReferenceSpaceCreator refSpaceCreator(&space, ref_mesh); Space<std::complex<double> >* ref_space = refSpaceCreator.create_ref_space(); int ndof_ref = Space<std::complex<double> >::get_num_dofs(ref_space); // Initialize reference problem. Hermes::Mixins::Loggable::Static::info("Solving on reference mesh."); DiscreteProblem<std::complex<double> > dp(&wf, ref_space); // Time measurement. cpu_time.tick(); // Perform Newton's iteration. Hermes::Hermes2D::NewtonSolver<std::complex<double> > newton(&dp); try { newton.set_newton_max_iter(NEWTON_MAX_ITER); newton.set_newton_tol(NEWTON_TOL); newton.solve(); } catch(Hermes::Exceptions::Exception e) { e.print_msg(); throw Hermes::Exceptions::Exception("Newton's iteration failed."); }; // Translate the resulting coefficient vector into the Solution<std::complex<double> > sln. Hermes::Hermes2D::Solution<std::complex<double> >::vector_to_solution(newton.get_sln_vector(), ref_space, &ref_sln); // Project the fine mesh solution onto the coarse mesh. Hermes::Mixins::Loggable::Static::info("Projecting reference solution on coarse mesh."); OGProjection<std::complex<double> > ogProjection; ogProjection.project_global(&space, &ref_sln, &sln); // View the coarse mesh solution and polynomial orders. RealFilter real(&sln); MagFilter<double> magn(&real); ValFilter limited_magn(&magn, 0.0, 4e3); char title[100]; sprintf(title, "Electric field, adaptivity step %d", as); eview.set_title(title); //eview.set_min_max_range(0.0, 4e3); eview.show(&limited_magn); sprintf(title, "Polynomial orders, adaptivity step %d", as); oview.set_title(title); oview.show(&space); // Calculate element errors and total error estimate. Hermes::Mixins::Loggable::Static::info("Calculating error estimate."); Adapt<std::complex<double> >* adaptivity = new Adapt<std::complex<double> >(&space); // Set custom error form and calculate error estimate. CustomErrorForm cef(kappa); adaptivity->set_error_form(0, 0, &cef); double err_est_rel = adaptivity->calc_err_est(&sln, &ref_sln) * 100; // Report results. Hermes::Mixins::Loggable::Static::info("ndof_coarse: %d, ndof_fine: %d, err_est_rel: %g%%", Space<std::complex<double> >::get_num_dofs(&space), Space<std::complex<double> >::get_num_dofs(ref_space), err_est_rel); // Time measurement. cpu_time.tick(); // Add entry to DOF and CPU convergence graphs. graph_dof.add_values(Space<std::complex<double> >::get_num_dofs(&space), err_est_rel); graph_dof.save("conv_dof_est.dat"); graph_cpu.add_values(cpu_time.accumulated(), err_est_rel); graph_cpu.save("conv_cpu_est.dat"); // If err_est too large, adapt the mesh. if (err_est_rel < ERR_STOP) done = true; else { Hermes::Mixins::Loggable::Static::info("Adapting coarse mesh."); done = adaptivity->adapt(&selector, THRESHOLD, STRATEGY, MESH_REGULARITY); } if (space.get_num_dofs() >= NDOF_STOP) done = true; delete adaptivity; if(!done) { delete ref_space->get_mesh(); delete ref_space; } // Increase counter. as++; } while (done == false); Hermes::Mixins::Loggable::Static::info("Total running time: %g s", cpu_time.accumulated()); RealFilter ref_real(&sln); MagFilter<double> ref_magn(&ref_real); ValFilter ref_limited_magn(&ref_magn, 0.0, 4e3); eview.set_title("Fine mesh solution - magnitude"); eview.show(&ref_limited_magn); // Output solution in VTK format. Linearizer lin; bool mode_3D = true; lin.save_solution_vtk(&ref_limited_magn, "sln.vtk", "Magnitude of E", mode_3D); Hermes::Mixins::Loggable::Static::info("Solution in VTK format saved to file %s.", "sln.vtk"); // Wait for all views to be closed. View::wait(); return 0; }