void ImportSTL:: doImport ( const std::string& name, mesh::Mesh& mesh ) { preciceTrace1("doImport()", name); assertion1(mesh.getDimensions() == 3, mesh.getDimensions()); // TODO }
double Physics::compute_mass(const mesh::Mesh& m, const_iterator u) { double total_mass = 0.; const double* source = reinterpret_cast<const double*>(&u[0]); vdPackI(m.nodes(), &source[0], 2, &h_vec[0]); process_volumes_psk( m ); for(int i=0; i<m.local_nodes(); i++) //total_mass += m.volume(i).vol()*u[i].M; total_mass += m.volume(i).vol()*theta_vec[i]*rho_vec[i]; return total_mass; }
double Physics::mass_flux_per_time(const mesh::Mesh& m){ double flux_per_time = 0.; for( int i=m.interior_cvfaces(); i<m.cvfaces(); i++ ) { const mesh::CVFace& cvf = m.cvface(i); int boundary_tag = cvf.boundary(); const BoundaryCondition& BC = boundary_condition_h( boundary_tag ); double t=0.; if( BC.type()==3 ) flux_per_time -= BC.value(t) * m.cvface(i).area(); } return flux_per_time*constants().rho_0(); }
void DriftRatchet:: createBodyWall ( mesh::Mesh& mesh, mesh::PropertyContainer* propertyContainer, mesh::Vertex* cutVertices[], mesh::Edge* cutEdges[] ) { int sectionCount = getCutsAlongXAxis ( _discretizationWidth ); double currentXInImage = 0.0; double currentXInPreImage = 0.0; double xStepInImage = _length / (double)sectionCount; double xStepInPreImage = (_pores * getCharacteristicLength(_maxRadius)) / (double)sectionCount; int dimensions = mesh.getDimensions(); utils::DynVector currentCenter ( dimensions, 0.0 ); currentXInImage += xStepInImage; currentXInPreImage += xStepInPreImage; for ( int i=0; i < sectionCount; i++ ) { currentCenter(0) = currentXInImage; double radius = getRadius ( currentXInPreImage ); createBodyWallSection ( mesh, propertyContainer, cutVertices, cutEdges, currentCenter, radius ); currentXInImage += xStepInImage; currentXInPreImage += xStepInPreImage; } }
void DriftRatchet:: createRightWall ( mesh::Mesh& mesh, mesh::PropertyContainer* propertyContainer, mesh::Vertex* cutVertices[], mesh::Edge* cutEdges[] ) { int dimensions = mesh.getDimensions(); if ( dimensions == 2 ){ utils::Vector2D center ( 0.0 ); center(0) += _length; mesh::Vertex& centerVertex = mesh.createVertex ( center ); if ( propertyContainer != NULL ) { centerVertex.addParent ( *propertyContainer ); } mesh::Edge& e0 = mesh.createEdge ( centerVertex, *cutVertices[0] ); mesh::Edge& e1 = mesh.createEdge ( *cutVertices[1], centerVertex ); if ( propertyContainer != NULL ) { e0.addParent ( *propertyContainer ); e1.addParent ( *propertyContainer ); } } else { assertion1 ( dimensions == 3, dimensions ); utils::Vector3D center ( 0.0 ); center(0) += _length; mesh::Vertex& centerVertex = mesh.createVertex ( center ); if ( propertyContainer != NULL ) { centerVertex.addParent ( *propertyContainer ); } int vertexCount = getNumberOfVerticesPerCut ( _discretizationWidth ); // Create edges and triangles mesh::Edge& firstCenterEdge = mesh.createEdge ( centerVertex, *cutVertices[0] ); if ( propertyContainer != NULL ) { firstCenterEdge.addParent ( *propertyContainer ); } mesh::Edge* oldCenterEdge = & firstCenterEdge; mesh::Edge* newCenterEdge = NULL; for ( int i=0; i < vertexCount - 1; i++ ) { newCenterEdge = & mesh.createEdge ( centerVertex, *cutVertices[i+1] ); mesh::Triangle& t = mesh.createTriangle ( *cutEdges[i], *oldCenterEdge, *newCenterEdge ); if ( propertyContainer != NULL ) { newCenterEdge->addParent ( *propertyContainer ); t.addParent ( *propertyContainer ); } oldCenterEdge = newCenterEdge; } mesh::Triangle& t = mesh.createTriangle ( *cutEdges[vertexCount-1], *oldCenterEdge, firstCenterEdge ); if ( propertyContainer != NULL ) { t.addParent ( *propertyContainer ); } } }
void ImportGeometry:: allocateDataValues ( mesh::Mesh& mesh ) { // Data values are already allocated during import when a checkpoint is read // and should not be overwritten by reallocating them. if ( not _importCheckpoint ){ mesh.allocateDataValues(); } }
void run () { Mesh::Mesh mesh; if (get_options ("blocky").size()) { auto input = Image<bool>::open (argument[0]); Mesh::vox2mesh (input, mesh); } else { auto input = Image<float>::open (argument[0]); float threshold = get_option_value ("threshold", Filter::estimate_optimal_threshold (input)); Mesh::vox2mesh_mc (input, threshold, mesh); } mesh.save (argument[1]); }
void run () { // Read in the mesh data Mesh::Mesh mesh (argument[0]); // If the .vtk files come from FIRST, they are defined in a native FSL space, and // therefore the source image must be known in order to transform to real space Options opt = get_options ("first"); if (opt.size()) { Image::Header H_first (opt[0][0]); mesh.transform_first_to_realspace (H_first); } // Get the template image Image::Header template_image (argument[1]); // Create the output image mesh.output_pve_image (template_image, argument[2]); }
void DriftRatchet:: specializedCreate ( mesh::Mesh& seed ) { using namespace mesh; std::string nameSubID ( seed.getName() + "-side-" ); PropertyContainer* leftWall = NULL; PropertyContainer* rightWall = NULL; if ( seed.getNameIDPairs().count(nameSubID + "0") ) { leftWall = & seed.getPropertyContainer ( nameSubID + "0" ); } if ( seed.getNameIDPairs().count(nameSubID + "1") ) { rightWall = & seed.getPropertyContainer ( nameSubID + "1" ); } int count = getNumberOfVerticesPerCut ( _discretizationWidth ); mesh::Vertex** cutVertices = new mesh::Vertex* [count]; count = getOffset().size() == 3 ? count : 0; // Only used in 3D mesh::Edge ** cutEdges = new mesh::Edge * [count]; createLeftWall ( seed, leftWall, cutVertices, cutEdges ); createBodyWall ( seed, NULL, cutVertices, cutEdges ); createRightWall ( seed, rightWall, cutVertices, cutEdges ); delete[] cutVertices; delete[] cutEdges; }
void Physics::preprocess_evaluation(double t, const mesh::Mesh& m, const_iterator u, const_iterator udash) { ++num_calls; for (int i = 0; i < m.nodes(); ++i) { assert(u[i].h == u[i].h && u[i].h != std::numeric_limits<double>::infinity() && u[i].h != -std::numeric_limits<double>::infinity() ); assert(u[i].M == u[i].M && u[i].M != std::numeric_limits<double>::infinity() && u[i].M != -std::numeric_limits<double>::infinity() ); } // Copy h from solution vector to h_vec and c_vec const double* source = reinterpret_cast<const double*>(&u[0]); vdPackI(m.nodes(), &source[0], 2, &h_vec[0]); // h and gradient at CV faces shape_matrix.matvec( h_vec, h_faces ); shape_gradient_matrixX.matvec( h_vec, grad_h_faces_.x() ); shape_gradient_matrixY.matvec( h_vec, grad_h_faces_.y() ); if (dimension == 3) shape_gradient_matrixZ.matvec( h_vec, grad_h_faces_.z() ); // determine the p-s-k values process_volumes_psk( m ); // density at faces using shape functions process_faces_shape( m ); // Compute psk values at faces using upwinding/limiting process_faces_lim( m ); // compute fluxes process_fluxes( t, m ); }
void CommunicateMesh:: receiveMesh ( mesh::Mesh& mesh, int rankSender ) { preciceTrace2 ( "receiveMesh()", mesh.getName(), rankSender ); using tarch::la::raw; int dim = mesh.getDimensions(); std::map<int, mesh::Vertex*> vertexMap; int vertexCount; _communication->startReceivePackage ( rankSender ); _communication->receive ( vertexCount, rankSender); utils::DynVector coords(dim); for ( int i=0; i < vertexCount; i++ ){ _communication->receive ( raw(coords), dim, rankSender ); mesh::Vertex& v = mesh.createVertex ( coords ); assertion1 ( v.getID() >= 0, v.getID() ); vertexMap[v.getID()] = &v; } std::map<int,mesh::Edge*> edgeMap; // only used in 3D int edgeCount; _communication->receive ( edgeCount, rankSender ); for ( int i=0; i < edgeCount; i++ ){ int vertexIndex1 = -1; int vertexIndex2 = -1; _communication->receive ( vertexIndex1, rankSender ); _communication->receive ( vertexIndex2, rankSender ); assertion ( vertexMap.find(vertexIndex1) != vertexMap.end() ); assertion ( vertexMap.find(vertexIndex2) != vertexMap.end() ); assertion1 ( vertexIndex1 != vertexIndex2, vertexIndex1 ); if ( dim == 2 ){ mesh.createEdge ( *vertexMap[vertexIndex1], *vertexMap[vertexIndex2] ); } else { assertion1 ( dim == 3, dim ); mesh::Edge & e = mesh.createEdge ( *vertexMap[vertexIndex1], *vertexMap[vertexIndex2] ); assertion1 ( e.getID() >= 0, e.getID() ); edgeMap[e.getID()] = &e; } } if ( dim == 3 ){ int triangleCount = 0; assertion ( (edgeMap.size() > 0) || (triangleCount == 0) ); _communication->receive ( triangleCount, rankSender ); for ( int i=0; i < triangleCount; i++ ) { int index1 = -1; int index2 = -1; int index3 = -1; _communication->receive ( index1, rankSender ); _communication->receive ( index2, rankSender ); _communication->receive ( index3, rankSender ); assertion ( edgeMap.find(index1) != edgeMap.end() ); assertion ( edgeMap.find(index2) != edgeMap.end() ); assertion ( edgeMap.find(index3) != edgeMap.end() ); assertion ( index1 != index2 ); assertion ( index2 != index3 ); assertion ( index3 != index1 ); mesh.createTriangle ( *edgeMap[index1], *edgeMap[index2], *edgeMap[index3] ); } } _communication->finishReceivePackage (); }
void DriftRatchet:: createBodyWallSection ( mesh::Mesh& mesh, mesh::PropertyContainer* propertyContainer, mesh::Vertex* cutVertices[], mesh::Edge* cutEdges[], const utils::DynVector& center, double radius ) { int dimensions = mesh.getDimensions(); if ( dimensions == 2 ){ utils::Vector2D upperPoint ( center[0], center[1] + radius ); utils::Vector2D lowerPoint ( center[0], center[1] - radius ); mesh::Vertex& upperVertex = mesh.createVertex ( upperPoint ); mesh::Vertex& lowerVertex = mesh.createVertex ( lowerPoint ); mesh::Edge& e0 = mesh.createEdge ( upperVertex, *cutVertices[0] ); mesh::Edge& e1 = mesh.createEdge ( *cutVertices[1], lowerVertex ); cutVertices[0] = & upperVertex; cutVertices[1] = & lowerVertex; if ( propertyContainer != NULL ) { e0.addParent ( *propertyContainer ); e1.addParent ( *propertyContainer ); cutVertices[0]->addParent ( *propertyContainer ); cutVertices[1]->addParent ( *propertyContainer ); } } else { assertion1 ( dimensions == 3, dimensions ); double currentAngle = 0.0; int vertexCount = getNumberOfVerticesPerCut ( _discretizationWidth ); double angle = 2.0 * tarch::la::PI / static_cast<double>(vertexCount); // Create vertices mesh::Vertex ** newCutVertices = new mesh::Vertex * [vertexCount]; for ( int i=0; i < vertexCount; i++ ) { utils::Vector3D currentCenter ( center ); double y = std::cos(currentAngle) * radius; currentCenter(1) += y; double z = std::sin(currentAngle) * radius; currentCenter(2) += z; currentAngle += angle; newCutVertices[i] = & mesh.createVertex ( currentCenter ); if ( propertyContainer != NULL ) { newCutVertices[i]->addParent ( *propertyContainer ); } } // Create edges and triangles mesh::Edge** newCutEdges = new mesh::Edge * [vertexCount]; mesh::Edge* initialEdge = & mesh.createEdge ( *cutVertices[0], *newCutVertices[0] ); if ( propertyContainer != NULL ) { initialEdge->addParent ( *propertyContainer ); } mesh::Edge* firstEdge = initialEdge; mesh::Edge* crossingEdge = NULL; mesh::Edge* secondEdge = NULL; for ( int i=0; i < vertexCount - 1; i++ ) { crossingEdge = & mesh.createEdge ( *cutVertices[i], *newCutVertices[i+1] ); newCutEdges[i] = & mesh.createEdge ( *newCutVertices[i], *newCutVertices[i+1] ); secondEdge = & mesh.createEdge ( *cutVertices[i+1], *newCutVertices[i+1] ); mesh::Triangle& t0 = mesh.createTriangle ( *firstEdge, *newCutEdges[i], *crossingEdge ); mesh::Triangle& t1 = mesh.createTriangle ( *crossingEdge, *secondEdge, *cutEdges[i] ); if ( propertyContainer != NULL ) { t0.addParent ( *propertyContainer ); t1.addParent ( *propertyContainer ); crossingEdge->addParent ( *propertyContainer ); secondEdge->addParent ( *propertyContainer ); } firstEdge = secondEdge; } crossingEdge = & mesh.createEdge ( *cutVertices[vertexCount - 1], *newCutVertices[0] ); newCutEdges[vertexCount - 1] = & mesh.createEdge ( *newCutVertices[vertexCount - 1], *newCutVertices[0] ); secondEdge = initialEdge; mesh::Triangle & t0 = mesh.createTriangle ( *firstEdge, *newCutEdges[vertexCount -1], *crossingEdge ); mesh::Triangle & t1 = mesh.createTriangle ( *crossingEdge, *secondEdge, *cutEdges[vertexCount - 1] ); if ( propertyContainer != NULL ) { crossingEdge->addParent ( *propertyContainer ); newCutEdges[vertexCount - 1]->addParent ( *propertyContainer ); t0.addParent ( *propertyContainer ); t1.addParent ( *propertyContainer ); } // Transfer cutting vertices and edges for ( int i=0; i < vertexCount; i++ ) { cutVertices[i] = newCutVertices[i]; cutEdges[i] = newCutEdges[i]; } delete[] newCutVertices; delete[] newCutEdges; } }
void DriftRatchet:: createLeftWall ( mesh::Mesh& mesh, mesh::PropertyContainer* propertyContainer, mesh::Vertex* cutVertices[], mesh::Edge* cutEdges[] ) { int dimensions = mesh.getDimensions(); if ( dimensions == 2 ){ using utils::Vector2D; double radius = getRadius ( 0.0 ); Vector2D center ( 0.0 ); mesh::Vertex& centerVertex = mesh.createVertex ( center ); if ( propertyContainer != NULL ) { centerVertex.addParent ( *propertyContainer ); } Vector2D upperPoint ( center(0), center(1) + radius ); cutVertices[0] = & mesh.createVertex ( upperPoint ); Vector2D lowerPoint ( center(0), center(1) - radius); cutVertices[1] = & mesh.createVertex ( lowerPoint ); mesh::Edge& e0 = mesh.createEdge ( *cutVertices[0], centerVertex); mesh::Edge& e1 = mesh.createEdge ( centerVertex, *cutVertices[1] ); if ( propertyContainer != NULL ) { e0.addParent ( *propertyContainer ); e1.addParent ( *propertyContainer ); } } else { assertion1 ( dimensions == 3, dimensions ); using utils::Vector3D; double currentAngle = 0.0; int vertexCount = getNumberOfVerticesPerCut ( _discretizationWidth ); double angle = 2.0 * tarch::la::PI / static_cast<double>(vertexCount); double radius = getRadius ( 0.0 ); Vector3D center(0.0); mesh::Vertex& centerVertex = mesh.createVertex ( center ); if ( propertyContainer != NULL ) { centerVertex.addParent ( *propertyContainer ); } // Create vertices for ( int i=0; i < vertexCount; i++ ) { Vector3D currentPoint ( center ); double y = std::cos(currentAngle) * radius; currentPoint(1) += y; double z = std::sin(currentAngle) * radius; currentPoint(2) += z; currentAngle += angle; cutVertices[i] = & mesh.createVertex ( currentPoint ); if ( propertyContainer != NULL ) { cutVertices[i]->addParent ( *propertyContainer ); } } // Create edges and triangles mesh::Edge & firstCenterEdge = mesh.createEdge ( centerVertex, *cutVertices[0] ); mesh::Edge * oldCenterEdge = & firstCenterEdge; mesh::Edge * newCenterEdge = NULL; for ( int i=0; i < vertexCount - 1; i++ ) { newCenterEdge = & mesh.createEdge ( centerVertex, *cutVertices[i+1] ); cutEdges[i] = & mesh.createEdge ( *cutVertices[i], *cutVertices[i+1] ); mesh::Triangle & t = mesh.createTriangle ( *oldCenterEdge, *cutEdges[i], *newCenterEdge ); if ( propertyContainer != NULL ) { cutEdges[i]->addParent ( *propertyContainer ); oldCenterEdge->addParent ( *propertyContainer ); t.addParent ( *propertyContainer ); } oldCenterEdge = newCenterEdge; } cutEdges[vertexCount-1] = & mesh.createEdge ( *cutVertices[vertexCount-1], *cutVertices[0] ); mesh::Triangle & t = mesh.createTriangle ( *oldCenterEdge, *cutEdges[vertexCount-1], firstCenterEdge ); if ( propertyContainer != NULL ) { cutEdges[vertexCount-1]->addParent ( *propertyContainer ); t.addParent ( *propertyContainer ); } } }
void Physics::initialise(double& t, const mesh::Mesh& m, iterator u, iterator udash, iterator temp, Callback compute_residual) { // allocate storage initialise_vectors( m ); // Set initial values set_initial_conditions(t, m); for( int i=0; i<m.local_nodes(); i++ ){ u[i].h = h_vec[i]; udash[i].M = 0; } // set M and C according to pressure and concentration process_volumes_psk( m ); // find theta for each volume for( int i=0; i<m.local_nodes(); i++ ){ u[i].M = rho_vec[i]*theta_vec[i]; //std::cout << u[i].M << " " << rho_vec[i] << " " << theta_vec[i] << std::endl; } // Compute residual compute_residual(temp, true); // determine the derivative coefficients process_derivative_coefficients( m ); // Set initial derivatives for( int f=0; f<m.interior_cvfaces(); f++ ){ int front_id = m.cvface(f).front().id(); double vol = m.volume(front_id).vol(); if (front_id < m.local_nodes()){ udash[front_id].M += M_flux_faces[f]/vol; } int back_id = m.cvface(f).back().id(); vol = m.volume(back_id).vol(); if (back_id < m.local_nodes()){ udash[back_id].M -= M_flux_faces[f]/vol; } } for( int f=m.interior_cvfaces(); f<m.cvfaces(); f++){ int back_id = m.cvface(f).back().id(); double vol = m.volume(back_id).vol(); if (back_id < m.local_nodes()){ udash[back_id].M -= M_flux_faces[f]/vol; } } /* for(int i=0; i<m.local_nodes(); i++){ if(fabs(udash[i].M)>1e-10) //std::cout << i << " " << u[i].h << " " << u[i].M << " " << udash[i].h << " " << udash[i].M << std::endl; } */ }