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);
}
