int main() { // creating an algorithm for reading a mesh from a file viennamesh::algorithm_handle reader( new viennamesh::io::mesh_reader() ); // Setting the filename for the reader and writer reader->set_input( "filename", "../data/big_and_small_cube.poly" ); // start the algorithm reader->run(); // creating an algorithm using the Tetgen meshing library for meshing a hull viennamesh::algorithm_handle mesher( new viennamesh::tetgen::make_mesh() ); viennagrid::segmented_mesh<viennagrid::tetrahedral_3d_mesh, viennagrid::tetrahedral_3d_segmentation> mesh; // linking the output from the reader to the mesher mesher->set_default_source(reader); // setting the mesher paramters mesher->set_input( "cell_size", 1.0 ); // maximum cell size mesher->set_input( "max_radius_edge_ratio", 1.5 ); // maximum radius edge ratio mesher->set_input( "min_dihedral_angle", 0.17 ); // minimum dihedral angle in radiant, 0.17 are about 10 degrees mesher->set_output( "mesh", mesh ); // start the algorithm mesher->run(); viennagrid::io::vtk_writer<viennagrid::tetrahedral_3d_mesh> writer; writer(mesh.mesh, mesh.segmentation, "test"); }
int main() { CDT cdt; Vertex_handle va = cdt.insert(Point(-2,0,1)); Vertex_handle vb = cdt.insert(Point(0,-2,1)); Vertex_handle vc = cdt.insert(Point(2,0,1)); Vertex_handle vd = cdt.insert(Point(0,1,1)); cdt.insert(Point(2, 0.6,1)); cdt.insert_constraint(va, vb); cdt.insert_constraint(vb, vc); cdt.insert_constraint(vc, vd); cdt.insert_constraint(vd, va); std::cout << "Number of vertices: " << cdt.number_of_vertices() << std::endl; std::cout << "Meshing..." << std::endl; Mesher mesher(cdt); mesher.set_criteria(Criteria(0.125, 0.05)); mesher.refine_mesh(); std::cout << "Number of vertices: " << cdt.number_of_vertices() << std::endl; std::cout << "Run Lloyd optimization..."; CGAL::lloyd_optimize_mesh_2(cdt, CGAL::parameters::max_iteration_number = 10); std::cout << " done." << std::endl; std::cout << "Number of vertices: " << cdt.number_of_vertices() << std::endl; }
int main() { CDT cdt; Vertex_handle va = cdt.insert(Point(-4,0)); Vertex_handle vb = cdt.insert(Point(0,-1)); Vertex_handle vc = cdt.insert(Point(4,0)); Vertex_handle vd = cdt.insert(Point(0,1)); cdt.insert(Point(2, 0.6)); cdt.insert_constraint(va, vb); cdt.insert_constraint(vb, vc); cdt.insert_constraint(vc, vd); cdt.insert_constraint(vd, va); std::cout << "Number of vertices: " << cdt.number_of_vertices() << std::endl; std::cout << "Meshing the triangulation with default criterias..." << std::endl; Mesher mesher(cdt); mesher.refine_mesh(); std::cout << "Number of vertices: " << cdt.number_of_vertices() << std::endl; std::cout << "Meshing with new criterias..." << std::endl; // 0.125 is the default shape bound. It corresponds to abound 20.6 degree. // 0.5 is the upper bound on the length of the longuest edge. // See reference manual for Delaunay_mesh_size_traits_2<K>. mesher.set_criteria(Criteria(0.125, 0.5)); mesher.refine_mesh(); std::cout << "Number of vertices: " << cdt.number_of_vertices() << std::endl; }
int main() { // creating an algorithm for reading a mesh from a file viennamesh::algorithm_handle reader( new viennamesh::io::mesh_reader() ); // creating a meshing algorithm viennamesh::algorithm_handle mesher( new viennamesh::tetgen::make_mesh() ); // creating a hull extraction algorithm viennamesh::algorithm_handle extract_hull( new viennamesh::extract_boundary() ); // creating an algorithm for writing a mesh to a file viennamesh::algorithm_handle writer( new viennamesh::io::mesh_writer() ); // Setting the filename for the reader reader->set_input( "filename", "../data/cubeception.poly" ); // using the reader algorithm as default source for the mesher mesher->set_default_source(reader); // using the mesher algorithm as default source for the extract hull extract_hull->set_default_source(mesher); // using the extract hull algorithm as default source for the writer writer->set_default_source(extract_hull); // Setting the filename for the writer writer->set_input( "filename", "half-trigate_hull.vtu" ); // start the algorithms reader->run(); mesher->run(); extract_hull->run(); writer->run(); }
int main() { double K=100, sig=.1, r=.1,b=.02, S=110; //option parameters AmericanOptions call(K,sig,r,b); AmericanOptions put(K,sig,r,b); cout<<"SOLUTION TO PART a) AND b) "<<endl; cout<<"Perpetual Americal Call option value :"<<call.PerpetualCall(S)<<endl; cout<<"Perpetual Americal Put option value :"<<call.PerpetualPut(S)<<endl; cout<<endl<<"SOLUTION TO PART c) "<<endl; cout<<"***Call and Put variation as function of underlying equity***"<<endl; vector<double> equity; // equity mesh vector<double> AmericanCall; // call option data vector<double> AmericanPut; // put option data equity=mesher(50,150,10); // creating equity mesh cout<<"Equity variation :"<<endl; print(equity); cout<<endl; //calling call and put pricers with equity mesh as argument and returning results as a vector. AmericanCall=call.PerpetualCall(equity); AmericanPut=put.PerpetualPut(equity); cout<<setprecision(4); cout<<"Call values :"<<endl; print(AmericanCall); //printing call option values cout<<endl; cout<<"Put values :"<<endl; print(AmericanPut); //printing put option values cout<<endl; return 0; }
void AdaptiveLinearStatic :: updateYourself(TimeStep *tStep) { LinearStatic :: updateYourself(tStep); // perform error evaluation // evaluate error of the reached solution this->defaultErrEstimator->estimateError(temporaryEM, tStep); // this->defaultErrEstimator->estimateError (equilibratedEM, this->giveCurrentStep()); RemeshingStrategy strategy = this->defaultErrEstimator->giveRemeshingCrit()->giveRemeshingStrategy(tStep); if ( strategy == NoRemeshing_RS ) { return; } else { // do remeshing std :: unique_ptr< MesherInterface >mesher( classFactory.createMesherInterface( meshPackage, this->giveDomain(1) ) ); Domain *newDomain; MesherInterface :: returnCode result = mesher->createMesh(tStep, 1, this->giveDomain(1)->giveSerialNumber() + 1, & newDomain); if ( result == MesherInterface :: MI_OK ) { } else if ( result == MesherInterface :: MI_NEEDS_EXTERNAL_ACTION ) { // terminate step //this->terminate( tStep ); //this->terminateAnalysis(); //exit(1); } else { OOFEM_ERROR("createMesh failed"); } } }
void VoronoiCgal_Patch::Compute() { m_CgalPatchs = MakePatchs(m_ImageSpline); for (int i = 0; i < m_CgalPatchs.size(); ++i) { m_Delaunay = Delaunay(); insert_polygon(m_Delaunay, m_ImageSpline, i); insert_polygonInter(m_Delaunay, m_ImageSpline, i); Mesher mesher(m_Delaunay); Criteria criteria(0, 100); mesher.set_criteria(criteria); mesher.refine_mesh(); mark_domains(m_Delaunay); LineSegs lineSegs; for (auto e = m_Delaunay.finite_edges_begin(); e != m_Delaunay.finite_edges_end(); ++e) { Delaunay::Face_handle fn = e->first->neighbor(e->second); //CGAL::Object o = m_Delaunay.dual(e); if (!fn->is_in_domain() || !fn->info().in_domain()) { continue; } if (!m_Delaunay.is_constrained(*e) && (!m_Delaunay.is_infinite(e->first)) && (!m_Delaunay.is_infinite(e->first->neighbor(e->second)))) { Delaunay::Segment s = m_Delaunay.geom_traits().construct_segment_2_object() (m_Delaunay.circumcenter(e->first), m_Delaunay.circumcenter(e->first->neighbor(e->second))); const CgalInexactKernel::Segment_2* seg = &s; CgalPoint p1(seg->source().hx(), seg->source().hy()); CgalPoint p2(seg->target().hx(), seg->target().hy()); Vector2 pp1(p1.hx(), p1.hy()); Vector2 pp2(p2.hx(), p2.hy()); if (pp1 == pp2) { continue; } lineSegs.push_back(LineSeg(pp1, pp2)); } } for (auto it = lineSegs.begin(); it != lineSegs.end(); ++it) { //m_PositionGraph.AddNewLine(it->beg, it->end, ); } } m_PositionGraph.ComputeJoints(); //printf("joints: %d\n", m_PositionGraph.m_Joints.size()); //MakeLines(); MakeGraphLines(); }
TetMesh* createMeshFromVolume(const Volume *volume, bool verbose) { CleaverMesher mesher(volume); mesher.createTetMesh(verbose); return mesher.getTetMesh(); }
void generate_1d_device(DeviceT& device) { typedef viennagrid::brep_1d_mesh GeometryMeshType; typedef viennagrid::result_of::segmentation<GeometryMeshType>::type GeometrySegmentationType; typedef viennagrid::result_of::segment_handle<GeometrySegmentationType>::type GeometrySegmentHandleType; typedef viennagrid::segmented_mesh<GeometryMeshType, GeometrySegmentationType> SegmentedGeometryMeshType; // Typedefing vertex handle and point type for geometry creation typedef viennagrid::result_of::point<GeometryMeshType>::type PointType; typedef viennagrid::result_of::vertex_handle<GeometryMeshType>::type GeometryVertexHandle; // creating the geometry mesh viennamesh::result_of::parameter_handle< SegmentedGeometryMeshType >::type geometry_handle = viennamesh::make_parameter<SegmentedGeometryMeshType>(); GeometryMeshType & geometry = geometry_handle().mesh; GeometrySegmentationType & segmentation = geometry_handle().segmentation; GeometryVertexHandle c11 = viennagrid::make_vertex( geometry, PointType(-0.5) ); GeometryVertexHandle c1 = viennagrid::make_vertex( geometry, PointType(0.0) ); GeometryVertexHandle i1 = viennagrid::make_vertex( geometry, PointType(1.0) ); GeometryVertexHandle i2 = viennagrid::make_vertex( geometry, PointType(2.0) ); GeometryVertexHandle c2 = viennagrid::make_vertex( geometry, PointType(3.0) ); GeometryVertexHandle c21 = viennagrid::make_vertex( geometry, PointType(3.5) ); GeometrySegmentHandleType segment1 = segmentation.make_segment(); viennagrid::add( segment1, c11 ); viennagrid::add( segment1, c1 ); GeometrySegmentHandleType segment2 = segmentation.make_segment(); viennagrid::add( segment2, c1 ); viennagrid::add( segment2, i1 ); GeometrySegmentHandleType segment3 = segmentation.make_segment(); viennagrid::add( segment3, i1 ); viennagrid::add( segment3, i2 ); GeometrySegmentHandleType segment4 = segmentation.make_segment(); viennagrid::add( segment4, i2 ); viennagrid::add( segment4, c2 ); GeometrySegmentHandleType segment5 = segmentation.make_segment(); viennagrid::add( segment5, c2 ); viennagrid::add( segment5, c21 ); viennamesh::algorithm_handle mesher( new viennamesh::make_line_mesh() ); mesher->set_input( "mesh", geometry_handle ); mesher->set_input( "cell_size", 0.005 ); mesher->set_input( "make_segmented_mesh", true ); mesher->set_input( "absolute_min_geometry_point_distance", 1e-10 ); mesher->set_input( "relative_min_geometry_point_distance", 1e-10 ); device.make_line1d(); mesher->set_output( "mesh", device.get_segmesh_line_1d() ); mesher->run(); }
int makeLayoutPart(DisjointBoxLayout& a_dbl, const Box& a_domainCoarsest) { // Vector<int> vecRefRat(2, 2); ParmParse pp; int eekflag= 0; int blockFactor, bufferSize, maxSize; Real fillRat; pp.get("block_factor", blockFactor); pp.get("buffer_size", bufferSize); pp.get("maxboxsize", maxSize); pp.get("fill_ratio", fillRat); int nlevels = 2; Vector<int> vecRefRat(nlevels); pp.getarr("ref_ratio", vecRefRat,0,nlevels); BRMeshRefine mesher(a_domainCoarsest, vecRefRat, fillRat, blockFactor, bufferSize, maxSize); int topLevel = 0; int baseLevel = 0; //tags at base level IntVectSet tags; eekflag = makeTags(tags, a_domainCoarsest); if (eekflag < 0) return eekflag; Vector<Vector<Box> > oldMeshes(nlevels); oldMeshes[0] = Vector<Box>(1, a_domainCoarsest); Box finerDomain = a_domainCoarsest; for (int ilev = 1; ilev < nlevels; ilev++) { finerDomain.refine(vecRefRat[ilev]); oldMeshes[ilev] = Vector<Box>(1, finerDomain); } Vector<Vector<Box> > newMeshes; mesher.regrid(newMeshes, tags, baseLevel, topLevel, oldMeshes); Vector<int> procAssign; eekflag = LoadBalance(procAssign, newMeshes[1]); if (eekflag != 0) return eekflag; a_dbl.define(newMeshes[1], procAssign); int iverbose; pp.get("verbose", iverbose); if (iverbose == 1) { pout() << "the grids coarser domain= " << a_domainCoarsest << " = " << a_dbl << endl; } return eekflag; }
TetMesh* cleaveMeshToVolume(const Volume *volume, TetMesh *bgMesh, bool verbose) { CleaverMesher mesher(volume); mesher.setBackgroundMesh(bgMesh); mesher.buildAdjacency(); mesher.sampleVolume(); mesher.computeAlphas(); mesher.computeInterfaces(); mesher.generalizeTets(); mesher.snapsAndWarp(); mesher.stencilTets(); return mesher.getTetMesh(); }
bool Filler3D::treat_region(GRegion *gr) { BGMManager::set_use_cross_field(true); bool use_vectorial_smoothness; bool use_fifo; std::string algo; // readValue("param.dat","SMOOTHNESSALGO",algo); algo.assign("SCALAR"); if(!algo.compare("SCALAR")) { use_vectorial_smoothness = false; use_fifo = false; } else if(!algo.compare("FIFO")) { use_vectorial_smoothness = false; use_fifo = true; } else { std::cout << "unknown SMOOTHNESSALGO !" << std::endl; throw; } const bool debug = false; const bool export_stuff = true; double a; std::cout << "ENTERING POINTINSERTION3D" << std::endl; // acquire background mesh std::cout << "pointInsertion3D: recover BGM" << std::endl; a = Cpu(); frameFieldBackgroundMesh3D *bgm = dynamic_cast<frameFieldBackgroundMesh3D *>(BGMManager::get(gr)); time_smoothing += (Cpu() - a); if(!bgm) { std::cout << "pointInsertion3D:: BGM dynamic cast failed ! " << std::endl; throw; } // export BGM fields if(export_stuff) { std::cout << "pointInsertion3D: export size field " << std::endl; std::stringstream ss; ss << "bg3D_sizefield_" << gr->tag() << ".pos"; bgm->exportSizeField(ss.str()); std::cout << "pointInsertion3D : export crossfield " << std::endl; std::stringstream sscf; sscf << "bg3D_crossfield_" << gr->tag() << ".pos"; bgm->exportCrossField(sscf.str()); std::cout << "pointInsertion3D : export smoothness " << std::endl; std::stringstream sss; sss << "bg3D_smoothness_" << gr->tag() << ".pos"; bgm->exportSmoothness(sss.str()); if(use_vectorial_smoothness) { std::cout << "pointInsertion3D : export vectorial smoothness " << std::endl; std::stringstream ssvs; ssvs << "bg3D_vectorial_smoothness_" << gr->tag() << ".pos"; bgm->exportVectorialSmoothness(ssvs.str()); } } // ---------------- START FILLING NEW POINTS ---------------- std::cout << "pointInsertion3D : inserting points in region " << gr->tag() << std::endl; // ProfilerStart("/home/bernard/profile"); a = Cpu(); // ----- initialize fifo list ----- RTree<MVertex *, double, 3, double> rtree; listOfPoints *fifo; if(use_fifo) fifo = new listOfPointsFifo(); else if(use_vectorial_smoothness) fifo = new listOfPointsVectorialSmoothness(); else fifo = new listOfPointsScalarSmoothness(); std::set<MVertex *> temp; std::vector<MVertex *> boundary_vertices; std::map<MVertex *, int> vert_priority; std::map<MVertex *, double> smoothness_forplot; MElement *element; MVertex *vertex; std::vector<GFace *> faces = gr->faces(); for(std::vector<GFace *>::iterator it = faces.begin(); it != faces.end(); it++) { GFace *gf = *it; // int limit = code_kesskessai(gf->tag()); for(unsigned int i = 0; i < gf->getNumMeshElements(); i++) { element = gf->getMeshElement(i); for(std::size_t j = 0; j < element->getNumVertices(); j++) { // for all vertices vertex = element->getVertex(j); temp.insert(vertex); // limits.insert(make_pair(vertex,limit)); } } } int geodim; for(std::set<MVertex *>::iterator it = temp.begin(); it != temp.end(); it++) { geodim = (*it)->onWhat()->dim(); if((geodim == 0) || (geodim == 1) || (geodim == 2)) boundary_vertices.push_back(*it); } double min[3], max[3], x, y, z, h; for(unsigned int i = 0; i < boundary_vertices.size(); i++) { x = boundary_vertices[i]->x(); y = boundary_vertices[i]->y(); z = boundary_vertices[i]->z(); // "on boundary since working on boundary_vertices ... MVertex *closest = bgm->get_nearest_neighbor_on_boundary(boundary_vertices[i]); h = bgm->size(closest); // get approximate size, closest vertex, faster ?! fill_min_max(x, y, z, h, min, max); rtree.Insert(min, max, boundary_vertices[i]); if(!use_vectorial_smoothness) { smoothness_vertex_pair *svp = new smoothness_vertex_pair(); svp->v = boundary_vertices[i]; svp->rank = bgm->get_smoothness(x, y, z); svp->dir = 0; svp->layer = 0; svp->size = h; bgm->eval_approximate_crossfield(closest, svp->cf); fifo->insert(svp); if(debug) { smoothness_forplot[svp->v] = svp->rank; } } else { STensor3 temp; bgm->eval_approximate_crossfield(closest, temp); for(int idir = 0; idir < 3; idir++) { smoothness_vertex_pair *svp = new smoothness_vertex_pair(); svp->v = boundary_vertices[i]; svp->rank = bgm->get_vectorial_smoothness(idir, x, y, z); svp->dir = idir; svp->layer = 0; svp->size = h; svp->cf = temp; for(int k = 0; k < 3; k++) svp->direction(k) = temp(k, idir); // std::cout << "fifo size=" << fifo->size() << " inserting " ; fifo->insert(svp); // std::cout << " -> fifo size=" << fifo->size() << std::endl; } } } // TODO: si fifo était list of *PTR -> pas de copies, gain temps ? Wrapper3D wrapper; wrapper.set_bgm(bgm); MVertex *parent, *individual; new_vertices.clear(); bool spawn_created; int priority_counter = 0; STensor3 crossfield; int parent_layer; while(!fifo->empty()) { parent = fifo->get_first_vertex(); // parent_limit = fifo->get_first_limit(); parent_layer = fifo->get_first_layer(); // if(parent_limit!=-1 && parent_layer>=parent_limit()){ // continue; // } std::vector<MVertex *> spawns; if(!use_vectorial_smoothness) { spawns.resize(6); computeSixNeighbors(bgm, parent, spawns, fifo->get_first_crossfield(), fifo->get_first_size()); } else { spawns.resize(2); computeTwoNeighbors(bgm, parent, spawns, fifo->get_first_direction(), fifo->get_first_size()); } fifo->erase_first(); // std::cout << "while, fifo->size()=" << fifo->size() << " parent=(" << // parent->x() << "," << parent->y() << "," << parent->z() << ")" << // std::endl; for(unsigned int i = 0; i < spawns.size(); i++) { spawn_created = false; individual = spawns[i]; x = individual->x(); y = individual->y(); z = individual->z(); // std::cout << " working on candidate " << "(" << individual->x() << // "," // << individual->y() << "," << individual->z() << ")" << std::endl; if(bgm->inDomain(x, y, z)) { // std::cout << " spawn " << i << " in domain" << std::endl; MVertex *closest = bgm->get_nearest_neighbor(individual); h = bgm->size(closest); // get approximate size, closest vertex, faster ?! if(far_from_boundary_3D(bgm, individual, h)) { // std::cout << " spawn " << i << " far from bnd" << // std::endl; bgm->eval_approximate_crossfield(closest, crossfield); wrapper.set_ok(true); wrapper.set_individual(individual); wrapper.set_parent(parent); wrapper.set_size(&h); wrapper.set_crossfield(&crossfield); fill_min_max(x, y, z, h, min, max); rtree.Search(min, max, rtree_callback_3D, &wrapper); if(wrapper.get_ok()) { // std::cout << " spawn " << i << " wrapper OK" << // std::endl; if(!use_vectorial_smoothness) { smoothness_vertex_pair *svp = new smoothness_vertex_pair(); svp->v = individual; svp->rank = bgm->get_smoothness(individual->x(), individual->y(), individual->z()); svp->dir = 0; svp->layer = parent_layer + 1; svp->size = h; svp->cf = crossfield; fifo->insert(svp); if(debug) { smoothness_forplot[svp->v] = svp->rank; vert_priority[individual] = priority_counter++; } } else { if(debug) vert_priority[individual] = priority_counter++; for(int idir = 0; idir < 3; idir++) { smoothness_vertex_pair *svp = new smoothness_vertex_pair(); svp->v = individual; svp->rank = bgm->get_vectorial_smoothness(idir, x, y, z); svp->dir = idir; svp->layer = parent_layer + 1; svp->size = h; for(int k = 0; k < 3; k++) svp->direction(k) = crossfield(k, idir); svp->cf = crossfield; fifo->insert(svp); } } rtree.Insert(min, max, individual); new_vertices.push_back(individual); spawn_created = true; } } } if(!spawn_created) { delete individual; } } // end loop on spawns } // ProfilerStop(); time_insert_points += (Cpu() - a); // --- output --- if(debug) { std::stringstream ss; ss << "priority_3D_" << gr->tag() << ".pos"; print_nodal_info(ss.str().c_str(), vert_priority); ss.clear(); std::stringstream sss; sss << "smoothness_3D_" << gr->tag() << ".pos"; print_nodal_info(sss.str().c_str(), smoothness_forplot); sss.clear(); } // ------- meshing using new points std::cout << "tets in gr before= " << gr->tetrahedra.size() << std::endl; std::cout << "nb new vertices= " << new_vertices.size() << std::endl; a = Cpu(); int option = CTX::instance()->mesh.algo3d; CTX::instance()->mesh.algo3d = ALGO_3D_DELAUNAY; deMeshGRegion deleter; deleter(gr); std::vector<GRegion *> regions; regions.push_back(gr); meshGRegion mesher(regions); //? mesher(gr); //? MeshDelaunayVolume(regions); time_meshing += (Cpu() - a); std::cout << "tets in gr after= " << gr->tetrahedra.size() << std::endl; std::cout << "gr tag=" << gr->tag() << std::endl; CTX::instance()->mesh.algo3d = option; delete fifo; for(unsigned int i = 0; i < new_vertices.size(); i++) delete new_vertices[i]; new_vertices.clear(); rtree.RemoveAll(); return true; }
void FdBlackScholesRebateEngine::calculate() const { // 1. Layout std::vector<Size> dim; dim.push_back(xGrid_); const boost::shared_ptr<FdmLinearOpLayout> layout( new FdmLinearOpLayout(dim)); // 2. Mesher const boost::shared_ptr<StrikedTypePayoff> payoff = boost::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff); const Time maturity = process_->time(arguments_.exercise->lastDate()); Real xMin=Null<Real>(); Real xMax=Null<Real>(); if ( arguments_.barrierType == Barrier::DownIn || arguments_.barrierType == Barrier::DownOut) { xMin = std::log(arguments_.barrier); } if ( arguments_.barrierType == Barrier::UpIn || arguments_.barrierType == Barrier::UpOut) { xMax = std::log(arguments_.barrier); } const boost::shared_ptr<Fdm1dMesher> equityMesher( new FdmBlackScholesMesher(xGrid_, process_, maturity, payoff->strike(), xMin, xMax)); std::vector<boost::shared_ptr<Fdm1dMesher> > meshers; meshers.push_back(equityMesher); boost::shared_ptr<FdmMesher> mesher ( new FdmMesherComposite(layout, meshers)); // 3. Calculator boost::shared_ptr<StrikedTypePayoff> rebatePayoff( new CashOrNothingPayoff(Option::Call, 0.0, arguments_.rebate)); boost::shared_ptr<FdmInnerValueCalculator> calculator( new FdmLogInnerValue(rebatePayoff, mesher, 0)); // 4. Step conditions std::list<boost::shared_ptr<StepCondition<Array> > > stepConditions; std::list<std::vector<Time> > stoppingTimes; // 4.1 Step condition if discrete dividends boost::shared_ptr<FdmDividendHandler> dividendCondition( new FdmDividendHandler(arguments_.cashFlow, mesher, process_->riskFreeRate()->referenceDate(), process_->riskFreeRate()->dayCounter(), 0)); if(!arguments_.cashFlow.empty()) { stepConditions.push_back(dividendCondition); stoppingTimes.push_back(dividendCondition->dividendTimes()); } QL_REQUIRE(arguments_.exercise->type() == Exercise::European, "only european style option are supported"); boost::shared_ptr<FdmStepConditionComposite> conditions( new FdmStepConditionComposite(stoppingTimes, stepConditions)); // 5. Boundary conditions std::vector<boost::shared_ptr<FdmDirichletBoundary> > boundaries; if ( arguments_.barrierType == Barrier::DownIn || arguments_.barrierType == Barrier::DownOut) { boundaries.push_back(boost::shared_ptr<FdmDirichletBoundary>( new FdmDirichletBoundary(layout, arguments_.rebate, 0, FdmDirichletBoundary::Lower))); } if ( arguments_.barrierType == Barrier::UpIn || arguments_.barrierType == Barrier::UpOut) { boundaries.push_back(boost::shared_ptr<FdmDirichletBoundary>( new FdmDirichletBoundary(layout, arguments_.rebate, 0, FdmDirichletBoundary::Upper))); } // 6. Solver boost::shared_ptr<FdmBlackScholesSolver> solver( new FdmBlackScholesSolver( Handle<GeneralizedBlackScholesProcess>(process_), mesher, boundaries, conditions, calculator, payoff->strike(), maturity, tGrid_, dampingSteps_, theta_, localVol_, illegalLocalVolOverwrite_)); const Real spot = process_->x0(); results_.value = solver->valueAt(spot); results_.delta = solver->deltaAt(spot); results_.gamma = solver->gammaAt(spot); results_.theta = solver->thetaAt(spot); }
void Filler::treat_region(GRegion* gr){ int NumSmooth = CTX::instance()->mesh.smoothCrossField; std::cout << "NumSmooth = " << NumSmooth << std::endl ; if(NumSmooth && (gr->dim() == 3)){ double scale = gr->bounds().diag()*1e-2; Frame_field::initRegion(gr,NumSmooth); Frame_field::saveCrossField("cross0.pos",scale); Frame_field::smoothRegion(gr,NumSmooth); Frame_field::saveCrossField("cross1.pos",scale); } #if defined(HAVE_RTREE) unsigned int i; int j; int count; int limit; bool ok2; double x,y,z; SPoint3 point; Node *node,*individual,*parent; MVertex* vertex; MElement* element; MElementOctree* octree; deMeshGRegion deleter; Wrapper wrapper; GFace* gf; std::queue<Node*> fifo; std::vector<Node*> spawns; std::vector<Node*> garbage; std::vector<MVertex*> boundary_vertices; std::set<MVertex*> temp; std::list<GFace*> faces; std::map<MVertex*,int> limits; std::set<MVertex*>::iterator it; std::list<GFace*>::iterator it2; std::map<MVertex*,int>::iterator it3; RTree<Node*,double,3,double> rtree; Frame_field::init_region(gr); Size_field::init_region(gr); Size_field::solve(gr); octree = new MElementOctree(gr->model()); garbage.clear(); boundary_vertices.clear(); temp.clear(); new_vertices.clear(); faces.clear(); limits.clear(); faces = gr->faces(); for(it2=faces.begin();it2!=faces.end();it2++){ gf = *it2; limit = code(gf->tag()); for(i=0;i<gf->getNumMeshElements();i++){ element = gf->getMeshElement(i); for(j=0;j<element->getNumVertices();j++){ vertex = element->getVertex(j); temp.insert(vertex); limits.insert(std::pair<MVertex*,int>(vertex,limit)); } } } /*for(i=0;i<gr->getNumMeshElements();i++){ element = gr->getMeshElement(i); for(j=0;j<element->getNumVertices();j++){ vertex = element->getVertex(j); temp.insert(vertex); } }*/ for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()==0){ boundary_vertices.push_back(*it); } } for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()==1){ boundary_vertices.push_back(*it); } } for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()==2){ boundary_vertices.push_back(*it); } } /*for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()<3){ boundary_vertices.push_back(*it); } }*/ //std::ofstream file("nodes.pos"); //file << "View \"test\" {\n"; for(i=0;i<boundary_vertices.size();i++){ x = boundary_vertices[i]->x(); y = boundary_vertices[i]->y(); z = boundary_vertices[i]->z(); node = new Node(SPoint3(x,y,z)); compute_parameters(node,gr); node->set_layer(0); it3 = limits.find(boundary_vertices[i]); node->set_limit(it3->second); rtree.Insert(node->min,node->max,node); fifo.push(node); //print_node(node,file); } count = 1; while(!fifo.empty()){ parent = fifo.front(); fifo.pop(); garbage.push_back(parent); if(parent->get_limit()!=-1 && parent->get_layer()>=parent->get_limit()){ continue; } spawns.clear(); spawns.resize(6); for(i=0;i<6;i++){ spawns[i] = new Node(); } create_spawns(gr,octree,parent,spawns); for(i=0;i<6;i++){ ok2 = 0; individual = spawns[i]; point = individual->get_point(); x = point.x(); y = point.y(); z = point.z(); if(inside_domain(octree,x,y,z)){ compute_parameters(individual,gr); individual->set_layer(parent->get_layer()+1); individual->set_limit(parent->get_limit()); if(far_from_boundary(octree,individual)){ wrapper.set_ok(1); wrapper.set_individual(individual); wrapper.set_parent(parent); rtree.Search(individual->min,individual->max,rtree_callback,&wrapper); if(wrapper.get_ok()){ fifo.push(individual); rtree.Insert(individual->min,individual->max,individual); vertex = new MVertex(x,y,z,gr,0); new_vertices.push_back(vertex); ok2 = 1; //print_segment(individual->get_point(),parent->get_point(),file); } } } if(!ok2) delete individual; } if(count%100==0){ printf("%d\n",count); } count++; } //file << "};\n"; int option = CTX::instance()->mesh.algo3d; CTX::instance()->mesh.algo3d = ALGO_3D_DELAUNAY; deleter(gr); std::vector<GRegion*> regions; regions.push_back(gr); meshGRegion mesher(regions); //? mesher(gr); //? MeshDelaunayVolume(regions); CTX::instance()->mesh.algo3d = option; for(i=0;i<garbage.size();i++) delete garbage[i]; for(i=0;i<new_vertices.size();i++) delete new_vertices[i]; new_vertices.clear(); delete octree; rtree.RemoveAll(); Size_field::clear(); Frame_field::clear(); #endif }
int main() { typedef viennagrid::plc_3d_mesh GeometryMeshType; typedef viennagrid::result_of::point<GeometryMeshType>::type PointType; typedef viennagrid::result_of::vertex_handle<GeometryMeshType>::type GeometryVertexHandle; typedef viennagrid::result_of::line_handle<GeometryMeshType>::type GeometryLineHandle; // creating the geometry mesh viennamesh::result_of::parameter_handle< GeometryMeshType >::type geometry_handle = viennamesh::make_parameter<GeometryMeshType>(); GeometryMeshType & geometry = geometry_handle(); double s = 10.0; GeometryVertexHandle vtx[8]; GeometryLineHandle lines[12]; vtx[0] = viennagrid::make_vertex( geometry, PointType(0, 0, 0) ); vtx[1] = viennagrid::make_vertex( geometry, PointType(0, s, 0) ); vtx[2] = viennagrid::make_vertex( geometry, PointType(s, 0, 0) ); vtx[3] = viennagrid::make_vertex( geometry, PointType(s, s, 0) ); vtx[4] = viennagrid::make_vertex( geometry, PointType(0, 0, s) ); vtx[5] = viennagrid::make_vertex( geometry, PointType(0, s, s) ); vtx[6] = viennagrid::make_vertex( geometry, PointType(s, 0, s) ); vtx[7] = viennagrid::make_vertex( geometry, PointType(s, s, s) ); // bottom 4 lines lines[0] = viennagrid::make_line( geometry, vtx[0], vtx[1] ); lines[1] = viennagrid::make_line( geometry, vtx[1], vtx[3] ); lines[2] = viennagrid::make_line( geometry, vtx[3], vtx[2] ); lines[3] = viennagrid::make_line( geometry, vtx[2], vtx[0] ); // top 4 lines lines[4] = viennagrid::make_line( geometry, vtx[4], vtx[5] ); lines[5] = viennagrid::make_line( geometry, vtx[5], vtx[7] ); lines[6] = viennagrid::make_line( geometry, vtx[7], vtx[6] ); lines[7] = viennagrid::make_line( geometry, vtx[6], vtx[4] ); // columns lines[8] = viennagrid::make_line( geometry, vtx[0], vtx[4] ); lines[9] = viennagrid::make_line( geometry, vtx[1], vtx[5] ); lines[10] = viennagrid::make_line( geometry, vtx[2], vtx[6] ); lines[11] = viennagrid::make_line( geometry, vtx[3], vtx[7] ); viennagrid::make_plc( geometry, lines+0, lines+4 ); viennagrid::make_plc( geometry, lines+4, lines+8 ); { GeometryLineHandle cur_lines[4]; cur_lines[0] = lines[0]; cur_lines[1] = lines[9]; cur_lines[2] = lines[4]; cur_lines[3] = lines[8]; viennagrid::make_plc( geometry, cur_lines+0, cur_lines+4 ); } { GeometryLineHandle cur_lines[4]; cur_lines[0] = lines[2]; cur_lines[1] = lines[11]; cur_lines[2] = lines[6]; cur_lines[3] = lines[10]; viennagrid::make_plc( geometry, cur_lines+0, cur_lines+4 ); } { GeometryLineHandle cur_lines[4]; cur_lines[0] = lines[3]; cur_lines[1] = lines[10]; cur_lines[2] = lines[7]; cur_lines[3] = lines[8]; viennagrid::make_plc( geometry, cur_lines+0, cur_lines+4 ); } { GeometryLineHandle cur_lines[4]; cur_lines[0] = lines[1]; cur_lines[1] = lines[11]; cur_lines[2] = lines[5]; cur_lines[3] = lines[9]; viennagrid::make_plc( geometry, cur_lines+0, cur_lines+4 ); } // creating the seed point locator algorithm viennamesh::algorithm_handle mesher( new viennamesh::tetgen::algorithm() ); viennamesh::algorithm_handle extract_seed_points( new viennamesh::extract_seed_points::algorithm() ); mesher->set_input( "default", geometry_handle ); extract_seed_points->link_input( "default", mesher, "default" ); mesher->run(); extract_seed_points->run(); typedef viennamesh::result_of::seed_point_container<PointType>::type PointContainerType; viennamesh::result_of::parameter_handle<PointContainerType>::type point_container = extract_seed_points->get_output<PointContainerType>( "default" ); if (point_container) { std::cout << "Number of extracted seed points: " << point_container().size() << std::endl; for (PointContainerType::iterator it = point_container().begin(); it != point_container().end(); ++it) std::cout << " " << it->first << " " << it->second << std::endl; } }
int main() { // creating an algorithm using the Tetgen meshing library for meshing a hull viennamesh::algorithm_handle mesher( new viennamesh::cgal::algorithm() ); // creating an algorithm for writing a mesh to a file viennamesh::algorithm_handle writer( new viennamesh::io::mesh_writer() ); // Typedefing the mesh type representing the 3D geometry; using triangles typedef viennagrid::triangular_3d_mesh GeometryMeshType; // Typedefing vertex handle, line handle and point type for geometry creation typedef viennagrid::result_of::point<GeometryMeshType>::type PointType; typedef viennagrid::result_of::vertex_handle<GeometryMeshType>::type GeometryVertexHandle; // creating the geometry mesh and segmentation viennamesh::result_of::parameter_handle< GeometryMeshType >::type geometry_handle = viennamesh::make_parameter<GeometryMeshType>(); GeometryMeshType & geometry = geometry_handle(); double s = 10.0; GeometryVertexHandle vtx[8]; vtx[0] = viennagrid::make_vertex( geometry, PointType(0, 0, 0) ); vtx[1] = viennagrid::make_vertex( geometry, PointType(0, s, 0) ); vtx[2] = viennagrid::make_vertex( geometry, PointType(s, 0, 0) ); vtx[3] = viennagrid::make_vertex( geometry, PointType(s, s, 0) ); vtx[4] = viennagrid::make_vertex( geometry, PointType(0, 0, s) ); vtx[5] = viennagrid::make_vertex( geometry, PointType(0, s, s) ); vtx[6] = viennagrid::make_vertex( geometry, PointType(s, 0, s) ); vtx[7] = viennagrid::make_vertex( geometry, PointType(s, s, s) ); viennagrid::make_triangle( geometry, vtx[0], vtx[1], vtx[2] ); viennagrid::make_triangle( geometry, vtx[2], vtx[1], vtx[3] ); viennagrid::make_triangle( geometry, vtx[4], vtx[6], vtx[5] ); viennagrid::make_triangle( geometry, vtx[6], vtx[7], vtx[5] ); viennagrid::make_triangle( geometry, vtx[0], vtx[2], vtx[4] ); viennagrid::make_triangle( geometry, vtx[2], vtx[6], vtx[4] ); viennagrid::make_triangle( geometry, vtx[1], vtx[5], vtx[3] ); viennagrid::make_triangle( geometry, vtx[3], vtx[5], vtx[7] ); viennagrid::make_triangle( geometry, vtx[0], vtx[4], vtx[1] ); viennagrid::make_triangle( geometry, vtx[1], vtx[4], vtx[5] ); viennagrid::make_triangle( geometry, vtx[2], vtx[3], vtx[6] ); viennagrid::make_triangle( geometry, vtx[3], vtx[7], vtx[6] ); // linking the output from the reader to the mesher mesher->set_input( "default", geometry_handle ); // setting the mesher paramters mesher->set_input( "cell_size", 0.3 ); // maximum cell size mesher->set_input( "max_radius_edge_ratio", 3.0); // maximum radius edge ratio mesher->set_input( "min_facet_angle", 0.52 ); // maximum radius edge ratio // linking the output from the mesher to the writer writer->link_input( "default", mesher, "default" ); // Setting the filename for the reader and writer writer->set_input( "filename", "meshed_cube.vtu" ); // start the algorithms mesher->run(); writer->run(); }
int main() { // Typedefing the mesh type representing the 2D geometry; using just lines, segments are represented using seed points typedef viennagrid::line_2d_mesh GeometryMeshType; // Typedefing vertex handle and point type for geometry creation typedef viennagrid::result_of::point<GeometryMeshType>::type PointType; typedef viennagrid::result_of::vertex_handle<GeometryMeshType>::type GeometryVertexHandle; // creating the geometry mesh viennamesh::result_of::parameter_handle< GeometryMeshType >::type geometry_handle = viennamesh::make_parameter<GeometryMeshType>(); GeometryMeshType & geometry = geometry_handle(); double s = 10.0; GeometryVertexHandle vtx[10]; vtx[0] = viennagrid::make_vertex( geometry, PointType(0, 0) ); vtx[1] = viennagrid::make_vertex( geometry, PointType(0, s) ); vtx[2] = viennagrid::make_vertex( geometry, PointType(s, 0) ); vtx[3] = viennagrid::make_vertex( geometry, PointType(s, s) ); vtx[4] = viennagrid::make_vertex( geometry, PointType(2*s, 0) ); vtx[5] = viennagrid::make_vertex( geometry, PointType(2*s, s) ); vtx[6] = viennagrid::make_vertex( geometry, PointType(s/3, s/3) ); vtx[7] = viennagrid::make_vertex( geometry, PointType(s/3, 2*s/3) ); vtx[8] = viennagrid::make_vertex( geometry, PointType(2*s/3, s/3) ); vtx[9] = viennagrid::make_vertex( geometry, PointType(2*s/3, 2*s/3) ); viennagrid::make_line( geometry, vtx[0], vtx[1] ); viennagrid::make_line( geometry, vtx[0], vtx[2] ); viennagrid::make_line( geometry, vtx[1], vtx[3] ); viennagrid::make_line( geometry, vtx[2], vtx[3] ); viennagrid::make_line( geometry, vtx[2], vtx[4] ); viennagrid::make_line( geometry, vtx[3], vtx[5] ); viennagrid::make_line( geometry, vtx[4], vtx[5] ); viennagrid::make_line( geometry, vtx[6], vtx[7] ); viennagrid::make_line( geometry, vtx[6], vtx[8] ); viennagrid::make_line( geometry, vtx[7], vtx[9] ); viennagrid::make_line( geometry, vtx[8], vtx[9] ); // creating an algorithm using the Tetgen meshing library for meshing a hull viennamesh::algorithm_handle mesher( new viennamesh::triangle::make_mesh() ); // setting the created line geometry as input for the mesher mesher->set_input( "mesh", geometry ); // creating the seed points and set it as input for the mesher viennamesh::seed_point_2d_container seed_points; seed_points.push_back( std::make_pair(PointType(s/4, s/2), 0) ); seed_points.push_back( std::make_pair(PointType(s+s/2, s/2), 1) ); mesher->set_input( "seed_points", seed_points ); // creating the hole points and set it as input for the mesher viennamesh::point_2d_container hole_points; hole_points.push_back( PointType(s/2, s/2) ); mesher->set_input( "hole_points", hole_points ); // setting the mesher paramters mesher->set_input( "cell_size", 1.0 ); // maximum cell size mesher->set_input( "min_angle", 0.35 ); // minimum angle in radiant, 0.35 are about 20 degrees mesher->set_input( "delaunay", true ); // we want a Delaunay triangulation mesher->set_input( "algorithm_type", "incremental_delaunay" ); // incremental Delaunay algorithm is used // start the algorithm mesher->run(); // creating an algorithm for writing a mesh to a file viennamesh::algorithm_handle writer( new viennamesh::io::mesh_writer() ); // linking the output from the mesher to the writer writer->set_default_source(mesher); // Setting the filename for the reader and writer writer->set_input( "filename", "meshed_quads.vtu" ); // start the algorithm writer->run(); }
void FdBlackScholesVanillaEngine::calculate() const { // 1. Layout std::vector<Size> dim; dim.push_back(xGrid_); const boost::shared_ptr<FdmLinearOpLayout> layout( new FdmLinearOpLayout(dim)); const boost::shared_ptr<StrikedTypePayoff> payoff = boost::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff); // 2. Mesher const Time maturity = process_->time(arguments_.exercise->lastDate()); const boost::shared_ptr<Fdm1dMesher> equityMesher( new FdmBlackScholesMesher( xGrid_, process_, maturity, payoff->strike(), Null<Real>(), Null<Real>(), 0.0001, 1.5, std::pair<Real, Real>(payoff->strike(), 0.1))); std::vector<boost::shared_ptr<Fdm1dMesher> > meshers; meshers.push_back(equityMesher); boost::shared_ptr<FdmMesher> mesher ( new FdmMesherComposite(layout, meshers)); // 3. Calculator boost::shared_ptr<FdmInnerValueCalculator> calculator( new FdmLogInnerValue(payoff, mesher, 0)); // 4. Step conditions std::list<boost::shared_ptr<StepCondition<Array> > > stepConditions; std::list<std::vector<Time> > stoppingTimes; // 4.1 Step condition if discrete dividends if(!arguments_.cashFlow.empty()) { boost::shared_ptr<FdmDividendHandler> dividendCondition( new FdmDividendHandler(arguments_.cashFlow, mesher, process_->riskFreeRate()->referenceDate(), process_->riskFreeRate()->dayCounter(), 0)); stepConditions.push_back(dividendCondition); stoppingTimes.push_back(dividendCondition->dividendTimes()); } // 4.2 Step condition if american or bermudan exercise QL_REQUIRE( arguments_.exercise->type() == Exercise::American || arguments_.exercise->type() == Exercise::European || arguments_.exercise->type() == Exercise::Bermudan, "exercise type is not supported"); if (arguments_.exercise->type() == Exercise::American) { stepConditions.push_back(boost::shared_ptr<StepCondition<Array> >( new FdmAmericanStepCondition(mesher,calculator))); } else if (arguments_.exercise->type() == Exercise::Bermudan) { boost::shared_ptr<FdmBermudanStepCondition> bermudanCondition( new FdmBermudanStepCondition( arguments_.exercise->dates(), process_->riskFreeRate()->referenceDate(), process_->riskFreeRate()->dayCounter(), mesher, calculator)); stepConditions.push_back(bermudanCondition); stoppingTimes.push_back(bermudanCondition->exerciseTimes()); } boost::shared_ptr<FdmStepConditionComposite> conditions( new FdmStepConditionComposite(stoppingTimes, stepConditions)); // 5. Boundary conditions std::vector<boost::shared_ptr<FdmDirichletBoundary> > boundaries; // 6. Solver boost::shared_ptr<FdmBlackScholesSolver> solver( new FdmBlackScholesSolver( Handle<GeneralizedBlackScholesProcess>(process_), mesher, boundaries, conditions, calculator, payoff->strike(), maturity, tGrid_, dampingSteps_, schemeDesc_, localVol_, illegalLocalVolOverwrite_)); const Real spot = process_->x0(); results_.value = solver->valueAt(spot); results_.delta = solver->deltaAt(spot); results_.gamma = solver->gammaAt(spot); results_.theta = solver->thetaAt(spot); }
// Entry Point int main(int argc, char* argv[]) { bool verbose = false; bool have_sizing_field = false; std::vector<std::string> material_fields; std::string output_path = kDefaultOutputName; double alpha = kDefaultAlpha; double alpha_long = kDefaultAlphaLong; double alpha_short = kDefaultAlphaShort; std::string sizing_field; enum cleaver::MeshType mesh_mode = cleaver::Structured; double background_time = 0; //------------------------------- // Parse Command Line Params //------------------------------- try{ po::options_description description("Command line flags"); description.add_options() ("help,h", "display help message") ("verbose,v", "enable verbose output") ("version,V", "display version information") ("material_fields,i", po::value<std::vector<std::string> >()->multitoken(), "material field paths") ("alpha,a", po::value<double>(), "initial alpha value") ("alpha_short,s", po::value<double>(), "alpha short value for regular mesh_mode") ("alpha_long,l", po::value<double>(), "alpha long value for regular mesh_mode") ("mesh_mode,m", po::value<std::string>(), "background mesh mode (structured [default], regular)") ("sizing_field,z", po::value<std::string>(), "sizing field path") ("output", po::value<std::string>()->default_value(kDefaultOutputName, "bgmesh"), "output path") ; boost::program_options::variables_map variables_map; boost::program_options::store(boost::program_options::parse_command_line(argc, argv, description), variables_map); boost::program_options::notify(variables_map); // print version info if (variables_map.count("version")) { std::cout << cleaver::Version << std::endl; return 0; } // print help else if (variables_map.count("help") || (argc ==1)) { std::cout << description << std::endl; return 0; } // enable verbose mode if (variables_map.count("verbose")) { verbose = true; } //alphas if (variables_map.count("alpha")) { alpha = variables_map["alpha"].as<double>(); } if (variables_map.count("alpha_short")) { alpha_short = variables_map["alpha_short"].as<double>(); } if (variables_map.count("alpha_long")) { alpha_long = variables_map["alpha_long"].as<double>(); } // parse the background mesh mode if (variables_map.count("mesh_mode")) { std::string mesh_mode_string = variables_map["mesh_mode"].as<std::string>(); if(mesh_mode_string.compare("regular") == 0) { mesh_mode = cleaver::Regular; } else if(mesh_mode_string.compare("structured") == 0) { mesh_mode = cleaver::Structured; } else { std::cerr << "Error: invalid background mesh mode: " << mesh_mode_string << std::endl; std::cerr << "Valid Modes: [regular] [structured] " << std::endl; return 6; } } // parse the material field input file names if (variables_map.count("material_fields")) { material_fields = variables_map["material_fields"].as<std::vector<std::string> >(); int file_count = material_fields.size(); } else{ std::cout << "Error: At least one material field file must be specified." << std::endl; return 0; } //----------------------------------------- // parse the sizing field input file name // and NOT check for conflicting parameters //---------------------------------------- if (variables_map.count("sizing_field")) { have_sizing_field = true; sizing_field = variables_map["sizing_field"].as<std::string>(); } // set output path if (variables_map.count("output")) { output_path = variables_map["output"].as<std::string>(); } } catch (std::exception& e) { std::cerr << "Error: " << e.what() << std::endl; return 0; } catch(...) { std::cerr << "Unhandled exception caught. Terminating." << std::endl; return 0; } //----------------------------------- // Load Data & Construct Volume //----------------------------------- std::cout << " Loading input fields:" << std::endl; for (size_t i=0; i < material_fields.size(); i++) { std::cout << " - " << material_fields[i] << std::endl; } std::vector<cleaver::AbstractScalarField*> fields = loadNRRDFiles(material_fields, verbose); if(fields.empty()){ std::cerr << "Failed to load image data. Terminating." << std::endl; return 0; } else if(fields.size() == 1) { fields.push_back(new cleaver::InverseScalarField(fields[0])); } cleaver::Volume *volume = new cleaver::Volume(fields); cleaver::CleaverMesher mesher(volume); mesher.setAlphaInit(alpha); //------------------------------------------------------------ // Load Sizing Field //------------------------------------------------------------ cleaver::AbstractScalarField *sizingField = NULL; if (have_sizing_field) { std::cout << "Loading sizing field: " << sizing_field << std::endl; sizingField = loadNRRDFile(sizing_field, verbose); } else { std::cerr << "Sizing Field file required !" << '\n'; return 2; } //------------------------------------------------------------ // Set Sizing Field on Volume //------------------------------------------------------------ volume->setSizingField(sizingField); //----------------------------------------------------------- // Construct Background Mesh //----------------------------------------------------------- cleaver::Timer background_timer; background_timer.start(); cleaver::TetMesh *bgMesh = NULL; if(verbose) std::cout << "Creating Octree Mesh..." << std::endl; switch(mesh_mode) { case cleaver::Regular: mesher.setAlphas(alpha_long,alpha_short); mesher.setRegular(true); bgMesh = mesher.createBackgroundMesh(verbose); break; default: case cleaver::Structured: mesher.setRegular(false); bgMesh = mesher.createBackgroundMesh(verbose); break; } background_timer.stop(); background_time = background_timer.time(); mesher.setBackgroundTime(background_time); //----------------------------------------------------------- // Write Background Mesh //----------------------------------------------------------- if (bgMesh ) { bgMesh->writeNodeEle(output_path, false, false, false); } //----------------------------------------------------------- // THE END //----------------------------------------------------------- std::cout << " Done." << std::endl; return 0; }
void FdSimpleBSSwingEngine::calculate() const { QL_REQUIRE(arguments_.exercise->type() == Exercise::Bermudan, "Bermudan exercise supported only"); // 1. Layout std::vector<Size> dim; dim.push_back(xGrid_); dim.push_back(arguments_.maxExerciseRights+1); const boost::shared_ptr<FdmLinearOpLayout> layout( new FdmLinearOpLayout(dim)); // 2. Mesher const boost::shared_ptr<StrikedTypePayoff> payoff = boost::dynamic_pointer_cast<StrikedTypePayoff>(arguments_.payoff); const Time maturity = process_->time(arguments_.exercise->lastDate()); const boost::shared_ptr<Fdm1dMesher> equityMesher( new FdmBlackScholesMesher(xGrid_, process_, maturity, payoff->strike())); const boost::shared_ptr<Fdm1dMesher> exerciseMesher( new Uniform1dMesher(0, arguments_.maxExerciseRights, arguments_.maxExerciseRights+1)); std::vector<boost::shared_ptr<Fdm1dMesher> > meshers; meshers.push_back(equityMesher); meshers.push_back(exerciseMesher); boost::shared_ptr<FdmMesher> mesher ( new FdmMesherComposite(layout, meshers)); // 3. Calculator boost::shared_ptr<FdmInnerValueCalculator> calculator( new FdmZeroInnerValue()); // 4. Step conditions std::list<boost::shared_ptr<StepCondition<Array> > > stepConditions; std::list<std::vector<Time> > stoppingTimes; // 4.1 Bermudan step conditions std::vector<Time> exerciseTimes; for (Size i=0; i<arguments_.exercise->dates().size(); ++i) { Time t = process_->time(arguments_.exercise->dates()[i]); QL_REQUIRE(t >= 0, "exercise dates must not contain past date"); exerciseTimes.push_back(t); } stoppingTimes.push_back(exerciseTimes); boost::shared_ptr<FdmInnerValueCalculator> exerciseCalculator( new FdmLogInnerValue(payoff, mesher, 0)); stepConditions.push_back(boost::shared_ptr<StepCondition<Array> >( new FdmSimpleSwingCondition(exerciseTimes, mesher, exerciseCalculator, 1))); boost::shared_ptr<FdmStepConditionComposite> conditions( new FdmStepConditionComposite(stoppingTimes, stepConditions)); // 5. Boundary conditions std::vector<boost::shared_ptr<FdmDirichletBoundary> > boundaries; // 6. Solver FdmSolverDesc solverDesc = { mesher, boundaries, conditions, calculator, maturity, tGrid_, 0 }; boost::shared_ptr<FdmSimple2dBSSolver> solver( new FdmSimple2dBSSolver( Handle<GeneralizedBlackScholesProcess>(process_), payoff->strike(), solverDesc, schemeDesc_)); const Real spot = process_->x0(); std::vector< std::pair<Real, Real> > exerciseValues; for (Size i=arguments_.minExerciseRights; i <= arguments_.maxExerciseRights; ++i) { const Real y = std::exp(Real(i)); exerciseValues.push_back( std::pair<Real, Real>(solver->valueAt(spot, y), y)); } const Real y = std::max_element(exerciseValues.begin(), exerciseValues.end())->second; results_.value = solver->valueAt(spot, y); results_.delta = solver->deltaAt(spot, y, spot*0.01); results_.gamma = solver->gammaAt(spot, y, spot*0.01); results_.theta = solver->thetaAt(spot, y); }
static PyObject * meshFromShape(PyObject *self, PyObject *args, PyObject* kwds) { try { PyObject *shape; static char* kwds_maxLength[] = {"Shape", "MaxLength",NULL}; PyErr_Clear(); double maxLength=0; if (PyArg_ParseTupleAndKeywords(args, kwds, "O!d", kwds_maxLength, &(Part::TopoShapePy::Type), &shape, &maxLength)) { MeshPart::Mesher mesher(static_cast<Part::TopoShapePy*>(shape)->getTopoShapePtr()->_Shape); mesher.setMethod(MeshPart::Mesher::Mefisto); mesher.setMaxLength(maxLength); mesher.setRegular(true); return new Mesh::MeshPy(mesher.createMesh()); } static char* kwds_maxArea[] = {"Shape", "MaxArea",NULL}; PyErr_Clear(); double maxArea=0; if (PyArg_ParseTupleAndKeywords(args, kwds, "O!d", kwds_maxArea, &(Part::TopoShapePy::Type), &shape, &maxArea)) { MeshPart::Mesher mesher(static_cast<Part::TopoShapePy*>(shape)->getTopoShapePtr()->_Shape); mesher.setMethod(MeshPart::Mesher::Mefisto); mesher.setMaxArea(maxArea); mesher.setRegular(true); return new Mesh::MeshPy(mesher.createMesh()); } static char* kwds_localLen[] = {"Shape", "LocalLength",NULL}; PyErr_Clear(); double localLen=0; if (PyArg_ParseTupleAndKeywords(args, kwds, "O!d", kwds_localLen, &(Part::TopoShapePy::Type), &shape, &localLen)) { MeshPart::Mesher mesher(static_cast<Part::TopoShapePy*>(shape)->getTopoShapePtr()->_Shape); mesher.setMethod(MeshPart::Mesher::Mefisto); mesher.setLocalLength(localLen); mesher.setRegular(true); return new Mesh::MeshPy(mesher.createMesh()); } static char* kwds_deflection[] = {"Shape", "Deflection",NULL}; PyErr_Clear(); double deflection=0; if (PyArg_ParseTupleAndKeywords(args, kwds, "O!d", kwds_deflection, &(Part::TopoShapePy::Type), &shape, &deflection)) { MeshPart::Mesher mesher(static_cast<Part::TopoShapePy*>(shape)->getTopoShapePtr()->_Shape); mesher.setMethod(MeshPart::Mesher::Mefisto); mesher.setDeflection(deflection); mesher.setRegular(true); return new Mesh::MeshPy(mesher.createMesh()); } static char* kwds_minmaxLen[] = {"Shape", "MinLength","MaxLength",NULL}; PyErr_Clear(); double minLen=0, maxLen=0; if (PyArg_ParseTupleAndKeywords(args, kwds, "O!dd", kwds_minmaxLen, &(Part::TopoShapePy::Type), &shape, &minLen, &maxLen)) { MeshPart::Mesher mesher(static_cast<Part::TopoShapePy*>(shape)->getTopoShapePtr()->_Shape); mesher.setMethod(MeshPart::Mesher::Mefisto); mesher.setMinMaxLengths(minLen, maxLen); mesher.setRegular(true); return new Mesh::MeshPy(mesher.createMesh()); } #if defined (HAVE_NETGEN) static char* kwds_fineness[] = {"Shape", "Fineness", "SecondOrder", "Optimize", "AllowQuad",NULL}; PyErr_Clear(); int fineness=0, secondOrder=0, optimize=1, allowquad=0; if (PyArg_ParseTupleAndKeywords(args, kwds, "O!i|iii", kwds_fineness, &(Part::TopoShapePy::Type), &shape, &fineness, &secondOrder, &optimize, &allowquad)) { MeshPart::Mesher mesher(static_cast<Part::TopoShapePy*>(shape)->getTopoShapePtr()->_Shape); mesher.setMethod(MeshPart::Mesher::Netgen); mesher.setFineness(fineness); mesher.setSecondOrder(secondOrder > 0); mesher.setOptimize(optimize > 0); mesher.setQuadAllowed(allowquad > 0); return new Mesh::MeshPy(mesher.createMesh()); } static char* kwds_user[] = {"Shape", "GrowthRate", "SegPerEdge", "SegPerRadius", "SecondOrder", "Optimize", "AllowQuad",NULL}; PyErr_Clear(); double growthRate=0, nbSegPerEdge=0, nbSegPerRadius=0; if (PyArg_ParseTupleAndKeywords(args, kwds, "O!|dddiii", kwds_user, &(Part::TopoShapePy::Type), &shape, &growthRate, &nbSegPerEdge, &nbSegPerRadius, &secondOrder, &optimize, &allowquad)) { MeshPart::Mesher mesher(static_cast<Part::TopoShapePy*>(shape)->getTopoShapePtr()->_Shape); mesher.setMethod(MeshPart::Mesher::Netgen); mesher.setGrowthRate(growthRate); mesher.setNbSegPerEdge(nbSegPerEdge); mesher.setNbSegPerRadius(nbSegPerRadius); mesher.setSecondOrder(secondOrder > 0); mesher.setOptimize(optimize > 0); mesher.setQuadAllowed(allowquad > 0); return new Mesh::MeshPy(mesher.createMesh()); } #endif PyErr_Clear(); if (PyArg_ParseTuple(args, "O!", &(Part::TopoShapePy::Type), &shape)) { MeshPart::Mesher mesher(static_cast<Part::TopoShapePy*>(shape)->getTopoShapePtr()->_Shape); #if defined (HAVE_NETGEN) mesher.setMethod(MeshPart::Mesher::Netgen); #else mesher.setMethod(MeshPart::Mesher::Mefisto); mesher.setRegular(true); #endif return new Mesh::MeshPy(mesher.createMesh()); } } catch (const Base::Exception& e) { PyErr_SetString(Base::BaseExceptionFreeCADError, e.what()); return 0; } PyErr_SetString(Base::BaseExceptionFreeCADError,"Wrong arguments"); return 0; }
void generic_benchmark( double size, times_t & times, memory_t & memory ) { viennautils::Timer timer; viennautils::memory_capture memory_capture(benchmarking_memory); double s = 10.0; // creating an algorithm using the Tetgen meshing library for meshing a hull viennamesh::algorithm_handle mesher( new viennamesh::cgal::algorithm() ); // Typedefing the mesh type representing the 3D geometry; using triangles typedef viennagrid::triangular_3d_mesh GeometryMeshType; // Typedefing vertex handle, line handle and point type for geometry creation typedef viennagrid::result_of::point<GeometryMeshType>::type PointType; typedef viennagrid::result_of::vertex_handle<GeometryMeshType>::type GeometryVertexHandle; // creating the geometry mesh and segmentation viennamesh::result_of::parameter_handle< GeometryMeshType >::type geometry_handle = viennamesh::make_parameter<GeometryMeshType>(); GeometryMeshType & geometry = geometry_handle(); // setting the created line geometry as input for the mesher mesher->set_input( "default", geometry_handle ); // setting the mesher paramters mesher->set_input( "cell_size", size ); // maximum cell size mesher->set_input( "max_radius_edge_ratio", 3.0 ); mesher->set_input( "min_facet_angle", 0.3 ); int64_t memory_before_geometry = memory_capture.allocated_memory(); GeometryVertexHandle vtx[8]; vtx[0] = viennagrid::make_vertex( geometry, PointType(0, 0, 0) ); vtx[1] = viennagrid::make_vertex( geometry, PointType(0, s, 0) ); vtx[2] = viennagrid::make_vertex( geometry, PointType(s, 0, 0) ); vtx[3] = viennagrid::make_vertex( geometry, PointType(s, s, 0) ); vtx[4] = viennagrid::make_vertex( geometry, PointType(0, 0, s) ); vtx[5] = viennagrid::make_vertex( geometry, PointType(0, s, s) ); vtx[6] = viennagrid::make_vertex( geometry, PointType(s, 0, s) ); vtx[7] = viennagrid::make_vertex( geometry, PointType(s, s, s) ); viennagrid::make_triangle( geometry, vtx[0], vtx[1], vtx[2] ); viennagrid::make_triangle( geometry, vtx[2], vtx[1], vtx[3] ); viennagrid::make_triangle( geometry, vtx[4], vtx[6], vtx[5] ); viennagrid::make_triangle( geometry, vtx[6], vtx[7], vtx[5] ); viennagrid::make_triangle( geometry, vtx[0], vtx[2], vtx[4] ); viennagrid::make_triangle( geometry, vtx[2], vtx[6], vtx[4] ); viennagrid::make_triangle( geometry, vtx[1], vtx[5], vtx[3] ); viennagrid::make_triangle( geometry, vtx[3], vtx[5], vtx[7] ); viennagrid::make_triangle( geometry, vtx[0], vtx[4], vtx[1] ); viennagrid::make_triangle( geometry, vtx[1], vtx[4], vtx[5] ); viennagrid::make_triangle( geometry, vtx[2], vtx[3], vtx[6] ); viennagrid::make_triangle( geometry, vtx[3], vtx[7], vtx[6] ); int64_t memory_after_geometry_creation = memory_capture.allocated_memory(); if (benchmarking_memory) memory.viennagrid_geometry_size += (memory_after_geometry_creation - memory_before_geometry); timer.start(); viennamesh::parameter_handle converted_geometry = geometry_handle->get_converted< viennamesh::cgal::input_mesh >(); if (!benchmarking_memory) times.convert_geometry_to_cgal_time += timer.get(); int64_t memory_after_convert_to_triangle = memory_capture.allocated_memory(); if (benchmarking_memory) memory.cgal_geometry_size += (memory_after_convert_to_triangle-memory_after_geometry_creation); // start the algorithms timer.start(); mesher->run(); if (!benchmarking_memory) times.meshing_time += timer.get(); int64_t memory_after_meshing = memory_capture.allocated_memory(); if (benchmarking_memory) memory.cgal_mesh_size += (memory_after_meshing-memory_after_convert_to_triangle); // typedef viennagrid::thin_tetrahedral_3d_mesh MeshType; typedef viennagrid::tetrahedral_3d_mesh MeshType; timer.start(); viennamesh::result_of::parameter_handle<MeshType>::type converted_mesh = mesher->get_output("default")->get_converted< MeshType >(); if (!benchmarking_memory) times.convert_mesh_to_viennagrid_time += timer.get(); viennagrid::detail::create_coboundary_information<viennagrid::vertex_tag, viennagrid::line_tag>( converted_mesh() ); viennagrid::detail::create_coboundary_information<viennagrid::vertex_tag, viennagrid::triangle_tag>( converted_mesh() ); viennagrid::detail::create_coboundary_information<viennagrid::vertex_tag, viennagrid::tetrahedron_tag>( converted_mesh() ); viennagrid::detail::create_coboundary_information<viennagrid::line_tag, viennagrid::triangle_tag>( converted_mesh() ); viennagrid::detail::create_coboundary_information<viennagrid::line_tag, viennagrid::tetrahedron_tag>( converted_mesh() ); viennagrid::detail::create_coboundary_information<viennagrid::triangle_tag, viennagrid::tetrahedron_tag>( converted_mesh() ); int64_t memory_after_convert = memory_capture.allocated_memory(); if (benchmarking_memory) memory.viennagrid_mesh_size += (memory_after_convert-memory_after_meshing); if (benchmarking_memory) { memory.num_vertices += viennagrid::vertices(converted_mesh()).size(); memory.num_cells += viennagrid::cells(converted_mesh()).size(); } }
int main() { typedef viennagrid::plc_3d_mesh GeometryMeshType; typedef viennagrid::result_of::point<GeometryMeshType>::type PointType; typedef viennagrid::result_of::vertex_handle<GeometryMeshType>::type GeometryVertexHandle; typedef viennagrid::result_of::line_handle<GeometryMeshType>::type GeometryLineHandle; // creating the geometry mesh viennamesh::result_of::parameter_handle< GeometryMeshType >::type geometry_handle = viennamesh::make_parameter<GeometryMeshType>(); GeometryMeshType & geometry = geometry_handle(); double s = 10.0; GeometryVertexHandle vtx[8]; GeometryLineHandle lines[12]; vtx[0] = viennagrid::make_vertex( geometry, PointType(0, 0, 0) ); vtx[1] = viennagrid::make_vertex( geometry, PointType(0, s, 0) ); vtx[2] = viennagrid::make_vertex( geometry, PointType(s, 0, 0) ); vtx[3] = viennagrid::make_vertex( geometry, PointType(s, s, 0) ); vtx[4] = viennagrid::make_vertex( geometry, PointType(0, 0, s) ); vtx[5] = viennagrid::make_vertex( geometry, PointType(0, s, s) ); vtx[6] = viennagrid::make_vertex( geometry, PointType(s, 0, s) ); vtx[7] = viennagrid::make_vertex( geometry, PointType(s, s, s) ); // bottom 4 lines lines[0] = viennagrid::make_line( geometry, vtx[0], vtx[1] ); lines[1] = viennagrid::make_line( geometry, vtx[1], vtx[3] ); lines[2] = viennagrid::make_line( geometry, vtx[3], vtx[2] ); lines[3] = viennagrid::make_line( geometry, vtx[2], vtx[0] ); // top 4 lines lines[4] = viennagrid::make_line( geometry, vtx[4], vtx[5] ); lines[5] = viennagrid::make_line( geometry, vtx[5], vtx[7] ); lines[6] = viennagrid::make_line( geometry, vtx[7], vtx[6] ); lines[7] = viennagrid::make_line( geometry, vtx[6], vtx[4] ); // columns lines[8] = viennagrid::make_line( geometry, vtx[0], vtx[4] ); lines[9] = viennagrid::make_line( geometry, vtx[1], vtx[5] ); lines[10] = viennagrid::make_line( geometry, vtx[2], vtx[6] ); lines[11] = viennagrid::make_line( geometry, vtx[3], vtx[7] ); viennagrid::make_plc( geometry, lines+0, lines+4 ); viennagrid::make_plc( geometry, lines+4, lines+8 ); { GeometryLineHandle cur_lines[4]; cur_lines[0] = lines[0]; cur_lines[1] = lines[9]; cur_lines[2] = lines[4]; cur_lines[3] = lines[8]; viennagrid::make_plc( geometry, cur_lines+0, cur_lines+4 ); } { GeometryLineHandle cur_lines[4]; cur_lines[0] = lines[2]; cur_lines[1] = lines[11]; cur_lines[2] = lines[6]; cur_lines[3] = lines[10]; viennagrid::make_plc( geometry, cur_lines+0, cur_lines+4 ); } { GeometryLineHandle cur_lines[4]; cur_lines[0] = lines[3]; cur_lines[1] = lines[10]; cur_lines[2] = lines[7]; cur_lines[3] = lines[8]; viennagrid::make_plc( geometry, cur_lines+0, cur_lines+4 ); } { GeometryLineHandle cur_lines[4]; cur_lines[0] = lines[1]; cur_lines[1] = lines[11]; cur_lines[2] = lines[5]; cur_lines[3] = lines[9]; viennagrid::make_plc( geometry, cur_lines+0, cur_lines+4 ); } // creating an algorithm using the Tetgen meshing library for meshing a hull viennamesh::algorithm_handle mesher( new viennamesh::tetgen::make_mesh() ); // set the input geometry and seed points mesher->set_input( "mesh", geometry_handle ); viennamesh::seed_point_3d_container seed_points; seed_points.push_back( std::make_pair( PointType(s/2, s/2, s/2), 0 ) ); mesher->set_input( "seed_points", seed_points ); // setting the mesher paramters mesher->set_input( "cell_size", 1.0 ); // maximum cell size mesher->set_input( "max_radius_edge_ratio", 1.5 ); // maximum radius edge ratio mesher->set_input( "min_dihedral_angle", 0.17 ); // minimum dihedral angle in radiant, 0.17 are about 10 degrees // start the algorithm mesher->run(); // creating an algorithm for writing a mesh to a file viennamesh::algorithm_handle writer( new viennamesh::io::mesh_writer() ); // linking the output from the mesher to the writer writer->set_default_source(mesher); // Setting the filename for the reader and writer writer->set_input( "filename", "one_cube.vtu" ); // start the algorithm writer->run(); }
void Fd2dBlackScholesVanillaEngine::calculate() const { // 1. Layout std::vector<Size> dim; dim.push_back(xGrid_); dim.push_back(yGrid_); const boost::shared_ptr<FdmLinearOpLayout> layout( new FdmLinearOpLayout(dim)); const boost::shared_ptr<BasketPayoff> payoff = boost::dynamic_pointer_cast<BasketPayoff>(arguments_.payoff); // 2. Mesher const Time maturity = p1_->time(arguments_.exercise->lastDate()); const boost::shared_ptr<Fdm1dMesher> em1( new FdmBlackScholesMesher( xGrid_, p1_, maturity, p1_->x0(), Null<Real>(), Null<Real>(), 0.0001, 1.5, std::pair<Real, Real>(p1_->x0(), 0.1))); const boost::shared_ptr<Fdm1dMesher> em2( new FdmBlackScholesMesher( xGrid_, p2_, maturity, p2_->x0(), Null<Real>(), Null<Real>(), 0.0001, 1.5, std::pair<Real, Real>(p2_->x0(), 0.1))); std::vector<boost::shared_ptr<Fdm1dMesher> > meshers; meshers.push_back(em1); meshers.push_back(em2); boost::shared_ptr<FdmMesher> mesher ( new FdmMesherComposite(layout, meshers)); // 3. Calculator boost::shared_ptr<FdmInnerValueCalculator> calculator( new FdmLogBasketInnerValue(payoff, mesher)); // 4. Step conditions std::list<boost::shared_ptr<StepCondition<Array> > > stepConditions; std::list<std::vector<Time> > stoppingTimes; // 4.2 Step condition if american or bermudan exercise QL_REQUIRE( arguments_.exercise->type() == Exercise::American || arguments_.exercise->type() == Exercise::European || arguments_.exercise->type() == Exercise::Bermudan, "exercise type is not supported"); if (arguments_.exercise->type() == Exercise::American) { stepConditions.push_back(boost::shared_ptr<StepCondition<Array> >( new FdmAmericanStepCondition(mesher,calculator))); } else if (arguments_.exercise->type() == Exercise::Bermudan) { boost::shared_ptr<FdmBermudanStepCondition> bermudanCondition( new FdmBermudanStepCondition( arguments_.exercise->dates(), p1_->riskFreeRate()->referenceDate(), p1_->riskFreeRate()->dayCounter(), mesher, calculator)); stepConditions.push_back(bermudanCondition); stoppingTimes.push_back(bermudanCondition->exerciseTimes()); } boost::shared_ptr<FdmStepConditionComposite> conditions( new FdmStepConditionComposite(stoppingTimes, stepConditions)); // 5. Boundary conditions std::vector<boost::shared_ptr<FdmDirichletBoundary> > boundaries; // 6. Solver boost::shared_ptr<Fdm2dBlackScholesSolver> solver( new Fdm2dBlackScholesSolver( Handle<GeneralizedBlackScholesProcess>(p1_), Handle<GeneralizedBlackScholesProcess>(p2_), correlation_, mesher, boundaries, conditions, calculator, maturity, tGrid_, dampingSteps_, schemeDesc_)); const Real x = p1_->x0(); const Real y = p2_->x0(); results_.value = solver->valueAt(x, y); results_.theta = solver->thetaAt(x, y); }