int main(int argc, char* argv[]) { // Check arguments if (argc < 2) { std::cerr << "Usage: " << argv[0] << " NODES_FILE TETS_FILE\n"; exit(1); } MeshType mesh; std::vector<typename MeshType::node_type> nodes; // Create a nodes_file from the first input argument std::ifstream nodes_file(argv[1]); // Interpret each line of the nodes_file as a 3D Point and add to the Mesh Point p; while (CS207::getline_parsed(nodes_file, p)) nodes.push_back(mesh.add_node(p)); // Create a trianges_file from the second input argument std::ifstream triangles_file(argv[2]); // Interpret each line of the tets_file as three ints which refer to nodes std::array<int,3> t; // add in the triangles while (CS207::getline_parsed(triangles_file, t)) for (unsigned i = 1; i < t.size(); ++i) for (unsigned j = 0; j < i; ++j) for (unsigned k = 0; k < j; ++k) { mesh.add_triangle(nodes[t[i]], nodes[t[j]], nodes[t[k]]); } // Set masses of nodes equal to 1/N where N is the number of nodes // and the initial velocities to 0. Also, get the indexes of // the nodes at positions (1,0,0) and (0,0,0) for(auto it=mesh.node_begin(); it != mesh.node_end(); ++ it) { (*it).value().mass = total_mass/mesh.num_nodes(); (*it).value().velocity = Point(0.0,0.0,0.0); } // Set spring constants for each node equal to spring_const variable // and set initial length values equal to lengths of edges prior to // running the symplectic Euler steps for(auto it=mesh.edge_begin(); it != mesh.edge_end(); ++ it) { (*it).value().spring_constant = spring_const; (*it).value().initial_length = (*it).length(); } // Set the triangle direction values so that we can determine which // way to point normal vectors. This part assumes a convex shape Point center = get_center(mesh); for(auto it=mesh.triangle_begin(); it != mesh.triangle_end(); ++ it) { //std::cout << (*it).index() << std::endl; set_normal_direction((*it),center); } // Print out the stats std::cout << mesh.num_nodes() << " " << mesh.num_edges() << std::endl; std::cout << "Center: " << get_center(mesh) << std::endl; // Launch the SDLViewer CS207::SDLViewer viewer; auto node_map = viewer.empty_node_map(mesh); viewer.launch(); viewer.add_nodes(mesh.node_begin(), mesh.node_end(), node_map); viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map); viewer.center_view(); // Begin the mass-spring simulation double dt = 0.0001; double t_start = 0; double t_end = 20.0; // Initialize constraints PlaneConstraint c1; //SelfCollisionConstraint c2; //auto combined_constraints = make_combined_constraints(c1,c2); for (double t = t_start; t < t_end; t += dt) { MassSpringForce ms_force; PressureForce p_force = PressureForce(0.0); DampingForce d_force = DampingForce(mesh.num_nodes()); GravityForce g_force; WindForce w_force; (void) d_force; // prevents compiler from throwing error for unused variable if (t >= t_addgas - dt) { p_force.set_pressure(gas_const/get_volume(mesh)); if (t < t_addgas) std::cout << "Adding gas to the ball now..." << std::endl; } auto combined_forces = make_combined_force(ms_force, p_force, w_force, g_force); symp_euler_step(mesh, t, dt, combined_forces, c1); // Update viewer with nodes' new positions viewer.add_nodes(mesh.node_begin(), mesh.node_end(), node_map); // update the viewer's label with the ball center's position on the z axis viewer.set_label(get_center(mesh).z); } return 0; }
int main(int argc, char** argv) { // Check arguments if (argc < 5) { std::cerr << "Usage: " << argv[0] << " NODES_FILE TETS_FILE\n"; exit(1); } // Construct the first mesh MeshType mesh; //construct the second mesh MeshType mesh2; std::vector<typename MeshType::node_type> mesh_node; // Read all Points and add them to the Mesh std::ifstream nodes_file(argv[1]); Point p; while (CS207::getline_parsed(nodes_file, p)) { mesh_node.push_back(mesh.add_node(p)); } // Read all mesh triangles and add them to the Mesh std::ifstream tris_file(argv[2]); std::array<int,3> t; while (CS207::getline_parsed(tris_file, t)) { mesh.add_triangle(mesh_node[t[0]], mesh_node[t[1]], mesh_node[t[2]]); } std::vector<typename MeshType::node_type> mesh_node2; // Read all Points and add them to the Mesh std::ifstream nodes_file2(argv[3]); while (CS207::getline_parsed(nodes_file2, p)) { mesh_node2.push_back(mesh2.add_node(p)); } // Read all mesh triangles and add them to the Mesh std::ifstream tris_file2(argv[4]); while (CS207::getline_parsed(tris_file2, t)) { mesh2.add_triangle(mesh_node2[t[0]], mesh_node2[t[1]], mesh_node2[t[2]]); } //move the second mesh to the specified position for(auto it = mesh2.node_begin();it!=mesh2.node_end();++it){ (*it).position().elem[1] +=4 ; (*it).position().elem[2] +=4 ; } // Print out the stats std::cout << mesh.num_nodes() << " " << mesh.num_edges() << " " << mesh.num_triangles() << std::endl; std::cout << mesh2.num_nodes() << " " << mesh2.num_edges() << " " << mesh2.num_triangles() << std::endl; //set the mass and velocity of each Node for the first mesh for (auto it = mesh.node_begin(); it != mesh.node_end(); ++it){ (*it).value().mass = float(1)/mesh.num_nodes(); (*it).value().velocity = Point(0, 10, 10); } //set the mass and velocity of each Node for the second mesh for (auto it = mesh2.node_begin(); it != mesh2.node_end(); ++it){ (*it).value().mass = float(1)/mesh.num_nodes(); (*it).value().velocity = Point(0, -10, -10); } //set K and L for each edge for (auto it = mesh.node_begin(); it != mesh.node_end(); ++it) { for (auto j = (*it).edge_begin(); j != (*it).edge_end(); ++j){ (*j).value().L = (*j).length(); (*j).value().K = 16000; } } for (auto it = mesh2.node_begin(); it != mesh2.node_end(); ++it) { for (auto j = (*it).edge_begin(); j != (*it).edge_end(); ++j){ (*j).value().L = (*j).length(); (*j).value().K = 16000; } } // Launch the SDLViewer CS207::SDLViewer viewer; auto node_map = viewer.empty_node_map(mesh); viewer.launch(); viewer.add_nodes(mesh.node_begin(), mesh.node_end(), node_map); viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map); viewer.add_nodes(mesh2.node_begin(), mesh2.node_end(), node_map); viewer.add_edges(mesh2.edge_begin(), mesh2.edge_end(), node_map); viewer.center_view(); //Begin the mass-spring simulation double dt = 0.0002; double t_start = 0.0; double t_end = 10.0; //three color parameter int color1 = 1; int color2 = 1; int color3 = 1; //Create listener Pause_listener* pause = new Pause_listener(dt); Speed_listener* speed = new Speed_listener(dt, dt); XYZ_listener<MeshType>* xyz = new XYZ_listener<MeshType>(&mesh); Color_listener* col = new Color_listener(&color1, &color2, &color3); //add listener viewer.add_listener(pause); viewer.add_listener(speed); viewer.add_listener(xyz); viewer.add_listener(col); //Initialize forces WindForce wind_force(Point(0,100,200)); PressureForce<typename MeshType::node_type, MeshType> pressure_force(1, 2500, &mesh); DampingForce damp_force(float(1)/mesh.num_nodes()); //auto force = make_combined_force(MassSpringForce(), GravityForce(), make_combined_force(pressure_force, damp_force, wind_force)); auto force = make_combined_force(MassSpringForce(), make_combined_force(pressure_force, damp_force, wind_force)); //Initialize constriants auto constraint = PlaneConstraint<MeshType>(-4); //simulation processing for (double t = t_start; t < t_end; t += dt) { constraint(mesh, 0); constraint(mesh2, 0); //define a collision constrain auto collision_constrain = CollisionConstraint<MeshType>(); //add the forces to the meshs at each dt symp_euler_step(mesh, t, dt, force); symp_euler_step(mesh2, t, dt, force); //detec the collision betweent the two meshes CollisionDetector<MeshType> c; c.add_object(mesh); c.add_object(mesh2); c.check_collisions(); std::vector<unsigned> collision; std::vector<unsigned> collision2; //find the corresponding mesh for each node for (auto it=c.begin(); it!= c.end(); ++it){ auto boom = *it; Node n = boom.n1; if (boom.mesh1 == &mesh) collision.push_back(n.index()); if (boom.mesh1 == &mesh2) collision2.push_back(n.index()); } //add the collision constrain to the meshes collision_constrain(mesh,mesh2,collision,collision2); viewer.set_label(t); //update with removed nodes //clear teh viewer's node viewer.clear(); node_map.clear(); //update viewer with new positions and new edges viewer.add_nodes(mesh.node_begin(), mesh.node_end(), color(color1, color2, color3), node_map); viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map); viewer.add_nodes(mesh2.node_begin(), mesh2.node_end(), color(color1, color2, color3), node_map); viewer.add_edges(mesh2.edge_begin(), mesh2.edge_end(), node_map); // These lines slow down the animation for small graphs if (mesh.num_nodes() < 100) CS207::sleep(0.001); } return 0; }
combined_force<combined_force<F1,F2>, combined_force<combined_force<F3,F4>, F5>> make_combined_force(F1& f1, F2& f2, F3& f3, F4& f4, F5& f5) { combined_force<F1,F2> two_combined = make_combined_force(f1,f2); auto three_combined = make_combined_force(f3,f4,f5); auto five_combined = make_combined_force(two_combined,three_combined); return five_combined; }
combined_force<combined_force<F1,F2>,combined_force<F3,F4>> make_combined_force(F1& f1, F2& f2, F3& f3, F4& f4) { combined_force<F1,F2> two_combined1 = make_combined_force(f1,f2); combined_force<F3,F4> two_combined2 = make_combined_force(f3,f4); auto four_combined = make_combined_force(two_combined1,two_combined2); return four_combined; }
combined_force<combined_force<F1,F2>,F3> make_combined_force(F1& f1, F2& f2, F3& f3) { combined_force<F1,F2> two_combined = make_combined_force(f1,f2); auto three_combined = make_combined_force(two_combined,f3); return three_combined; }
// ============================================================================= int main(int argc, char** argv) { // Check arguments if (argc < 3) { std::cerr << "Usage: " << argv[0] << " NODES_FILE TETS_FILE\n"; exit(1); } // Construct an empty graph GraphType graph; // Create a nodes_file from the first input argument std::ifstream nodes_file(argv[1]); // Interpret each line of the nodes_file as a 3D Point and add to the Graph Point p; std::vector<typename GraphType::node_type> nodes; while (CME212::getline_parsed(nodes_file, p)) nodes.push_back(graph.add_node(p)); // Create a tets_file from the second input argument std::ifstream tets_file(argv[2]); // Interpret each line of the tets_file as four ints which refer to nodes std::array<int,4> t; while (CME212::getline_parsed(tets_file, t)) { graph.add_edge(nodes[t[0]], nodes[t[1]]); graph.add_edge(nodes[t[0]], nodes[t[2]]); #if 1 // Diagonal edges graph.add_edge(nodes[t[0]], nodes[t[3]]); graph.add_edge(nodes[t[1]], nodes[t[2]]); #endif graph.add_edge(nodes[t[1]], nodes[t[3]]); graph.add_edge(nodes[t[2]], nodes[t[3]]); } // Set initial velocity and mass for (GraphType::NodeIterator it = graph.node_begin(); it != graph.node_end(); ++it) { Node n = *it; n.value().vel = Point(0,0,0); // Initial velocity == 0 n.value().mass = 1.0 / graph.num_nodes(); // graph has total mass == 1, constant density } // Set rest length for all of the Edges to their initial length for (GraphType::EdgeIterator ei = graph.edge_begin(); ei != graph.edge_end(); ++ei ) { (*ei).value().L = (*ei).length(); } // Print out the stats std::cout << graph.num_nodes() << " " << graph.num_edges() << std::endl; // Launch the SDLViewer CME212::SDLViewer viewer; auto node_map = viewer.empty_node_map(graph); viewer.launch(); viewer.add_nodes(graph.node_begin(), graph.node_end(), node_map); viewer.add_edges(graph.edge_begin(), graph.edge_end(), node_map); viewer.center_view(); // Begin the mass-spring simulation double dt = 0.001; double t_start = 0; double t_end = 5.0; for (double t = t_start; t < t_end; t += dt) { // P1 --------------------------------------------------------------------- // symp_euler_step(graph, t, dt, Problem1Force()); // P3 ---------------------------------------------------------------------- //symp_euler_step(graph, t, dt, cf); // Create individual forces GravityForce g(grav); MassSpringForce msf(100); DampingForce d(1.0 / graph.num_nodes()); // Combine the individual forces auto cf = make_combined_force(g, msf, d); // P4 ---------------------------------------------------------------------- // Create individual constraints HPlane hp(-0.75); Sphere sp(0.15, Point(0.5,0.5,-0.5)); SphereRemove sr(0.15, Point(0.5,0.5,-0.5)); // Combined individual constraints // P4.1 // auto c = make_combined_constraint(hp, FixedConstraint()); // P4.2 // auto c = make_combined_constraint(sp, FixedConstraint()); // P4.3 auto c = make_combined_constraint(sr, FixedConstraint()); // Mixed constraints // auto c = make_combined_constraint(hp, sr, FixedConstraint()); // auto c = make_combined_constraint(hp, sp, FixedConstraint()); symp_euler_step(graph, t, dt, cf, c); viewer.clear(); node_map.clear(); viewer.add_nodes(graph.node_begin(), graph.node_end(), node_map); viewer.add_edges(graph.edge_begin(), graph.edge_end(), node_map); // Update viewer with nodes' new positions viewer.add_nodes(graph.node_begin(), graph.node_end(), node_map); viewer.set_label(t); // These lines slow down the animation for small graphs, like grid0_*. // Feel free to remove them or tweak the constants. if (graph.size() < 100) CME212::sleep(0.0001); } return 0; }
int main(int argc, char* argv[]) { // Check arguments if (argc < 5) { std::cerr << "Usage: final_project NODES_FILE TRIS_FILE ball.nodes ball.tris \n"; exit(1); } MeshType mesh; std::vector<typename MeshType::node_type> mesh_node; // Read all water Points and add them to the Mesh std::ifstream nodes_file(argv[1]); Point p; uint water_nodes = 0; while (CS207::getline_parsed(nodes_file, p)) { mesh_node.push_back(mesh.add_node(p)); water_nodes++; } // Read all water mesh triangles and add them to the Mesh std::ifstream tris_file(argv[2]); std::array<int,3> t; int water_tris = 0; while (CS207::getline_parsed(tris_file, t)) { mesh.add_triangle(mesh_node[t[0]], mesh_node[t[1]], mesh_node[t[2]]); water_tris++; } uint water_edges = mesh.num_edges(); std::ifstream nodes_file2(argv[3]); double radius = 1 * scale; while (CS207::getline_parsed(nodes_file2, p)) { p *= scale; p.z += + start_height; mesh_node.push_back(mesh.add_node(p)); } // Read all ball mesh triangles and add them to the mesh std::ifstream tris_file2(argv[4]); while (CS207::getline_parsed(tris_file2, t)) { mesh.add_triangle(mesh_node[t[0]+water_nodes], mesh_node[t[1]+water_nodes], mesh_node[t[2]+water_nodes]); } // Print out the stats std::cout << mesh.num_nodes() << " " << mesh.num_edges() << " " << mesh.num_triangles() << std::endl; /* Set the initial conditions */ // Set the initial values of the nodes and get the maximum height double double max_h = 0; double dx = 0; double dy = 0; auto init_cond = Still(); auto b_init_cond = Cone(); // Find the maximum height and apply initial conditions to nodes for (auto it = mesh.node_begin(); it != mesh.node_end(); ++it) { auto n = *it; if (n.index() < water_nodes){ n.value().q = init_cond(n.position()); n.value().b = b_init_cond(n.position()); max_h = std::max(max_h, n.value().q.h); } else { n.value().q = QVar(n.position().z, 0, 0); n.value().mass = total_mass/(mesh.num_nodes() - water_nodes); n.value().velocity = Point(0.0,0.0,0.0); } } // Set the initial values of the triangles to the average of their nodes and finds S // Set the triangle direction values so that we can determine which // way to point normal vectors. This part assumes a convex shape Point center = get_center(mesh); for (auto it = mesh.triangle_begin(); it != mesh.triangle_end(); ++it) { auto t = *it; if (t.index() < water_tris){ t.value().q_bar = (t.node1().value().q + t.node2().value().q + t.node3().value().q) / 3.0; t.value().q_bar2 = t.value().q_bar; double b_avg = (t.node1().value().b + t.node2().value().b + t.node3().value().b) / 3.0; // finds the max dx and dy to calculate Source dx = std::max(dx, fabs(t.node1().position().x - t.node2().position().x)); dx = std::max(dx, fabs(t.node2().position().x - t.node3().position().x)); dx = std::max(dx, fabs(t.node3().position().x - t.node1().position().x)); dy = std::max(dy, fabs(t.node1().position().y - t.node2().position().y)); dy = std::max(dy, fabs(t.node2().position().y - t.node3().position().y)); dy = std::max(dy, fabs(t.node3().position().y - t.node1().position().y)); t.value().S = QVar(0, -grav * t.value().q_bar.h * b_avg / dx, -grav * t.value().q_bar.h * b_avg / dy); } else set_normal_direction((*it),center); } // Calculate the minimum edge length and set edge inital condititons double min_edge_length = std::numeric_limits<double>::max(); uint count = 0; for (auto it = mesh.edge_begin(); it != mesh.edge_end(); ++it, count++){ if (count < water_edges) min_edge_length = std::min(min_edge_length, (*it).length()); else { (*it).value().spring_constant = spring_const; (*it).value().initial_length = (*it).length(); } } // Launch the SDLViewer CS207::SDLViewer viewer; viewer.launch(); auto node_map = viewer.empty_node_map(mesh); viewer.add_nodes(mesh.node_begin(), mesh.node_end(), Color(water_nodes), NodePosition(), node_map); viewer.add_edges(mesh.edge_begin(), mesh.edge_end(), node_map); // adds solid color-slows down program significantly //viewer.add_triangles(mesh.triangle_begin(), mesh.triangle_end(), node_map); viewer.center_view(); // CFL stability condition requires dt <= dx / max|velocity| // For the shallow water equations with u = v = 0 initial conditions // we can compute the minimum edge length and maximum original water height // to set the time-step // Compute the minimum edge length and maximum water height for computing dt double dt = 0.25 * min_edge_length / (sqrt(grav * max_h)); double t_start = 0; double t_end = 10; Point ball_loc = Point(0,0,0); double dh = 0; // double pressure = gas_const/(4/3*M_PI*radius*radius*radius); // add listener my_listener* l = new my_listener(viewer,mesh,dt); viewer.add_listener(l); // Preconstruct a Flux functor EdgeFluxCalculator f; // defines the constraint PlaneConstraint c = PlaneConstraint(plane_const); // Begin the time stepping for (double t = t_start; t < t_end; t += dt) { // define forces on ball GravityForce g_force; BuoyantForce b_force = BuoyantForce(dh, ball_loc.z); WindForce w_force; MassSpringForce ms_force; // PressureForce p_force = PressureForce(pressure); // DampingForce d_force = DampingForce(mesh.num_nodes()); auto combined_forces = make_combined_force(g_force, b_force, w_force, ms_force); // Step forward in time with forward Euler hyperbolic_step(mesh, f, t, dt, ball_loc, water_tris); // Update node values with triangle-averaged values ball_loc = post_process(mesh, combined_forces, c, t, dt, water_nodes); // Update the viewer with new node positions viewer.add_nodes(mesh.node_begin(), mesh.node_end(), Color(water_nodes), NodePosition(), node_map); // viewer.add_triangles(mesh.triangle_begin(), mesh.triangle_end(), node_map); viewer.set_label(t); // find radius of cross sectional radius of ball submerged dh = ball_loc.z; if (dh > 2*radius) dh = 2 * radius; ball_loc.z = cross_radius(radius, dh); // These lines slow down the animation for small meshes. if (mesh.num_nodes() < 100) CS207::sleep(0.05); } return 0; }