32 #include "navier_stokes.h"
34 #include "constitutive.h"
35 #include "fluid_interface.h"
38 #include "meshes/triangle_mesh.h"
41 using namespace oomph;
52 public virtual PseudoSolidNodeUpdateElement<TCrouzeixRaviartElement<2>,
53 TPVDBubbleEnrichedElement<2,3> >
65 TPVDBubbleEnrichedElement<2,3> >()
76 std::string txt=
"VARIABLES=";
103 const unsigned &nplot)
110 Vector<double> s(el_dim);
113 Vector<double> dudt(el_dim);
116 Vector<double> mesh_veloc(el_dim,0.0);
119 outfile << tecplot_zone_string(nplot);
122 unsigned n_node = nnode();
126 DShape dpsifdx(n_node,el_dim);
129 unsigned num_plot_points=nplot_points(nplot);
130 for (
unsigned iplot=0;iplot<num_plot_points;iplot++)
134 get_s_plot(iplot,nplot,s);
137 dshape_eulerian(s,psif,dpsifdx);
140 Vector<double> mesh_veloc(el_dim);
141 Vector<double> dudt(el_dim);
142 Vector<double> dudt_ALE(el_dim);
143 DenseMatrix<double> interpolated_dudx(el_dim,el_dim);
146 for(
unsigned i=0;i<el_dim;i++)
151 for(
unsigned j=0;j<el_dim;j++)
153 interpolated_dudx(i,j) = 0.0;
160 for(
unsigned i=0;i<el_dim;i++)
163 unsigned u_nodal_index = u_index_nst(i);
165 for(
unsigned l=0;l<n_node;l++)
167 dudt[i]+=du_dt_nst(l,u_nodal_index)*psif[l];
168 mesh_veloc[i]+=dnodal_position_dt(l,i)*psif[l];
171 for(
unsigned j=0;j<el_dim;j++)
173 interpolated_dudx(i,j) += nodal_value(l,u_nodal_index)*
181 for(
unsigned i=0;i<el_dim;i++)
184 for (
unsigned k=0;k<el_dim;k++)
186 dudt_ALE[i]-=mesh_veloc[k]*interpolated_dudx(i,k);
192 for(
unsigned i=0;i<el_dim;i++)
194 outfile << interpolated_x(s,i) <<
" ";
198 for(
unsigned i=0;i<el_dim;i++)
200 outfile << interpolated_u_nst(s,i) <<
" ";
204 outfile << interpolated_p_nst(s) <<
" ";
207 for(
unsigned i=0;i<el_dim;i++)
209 outfile << dudt_ALE[i] <<
" ";
213 for(
unsigned i=0;i<el_dim;i++)
215 outfile << mesh_veloc[i] <<
" ";
219 unsigned n_prev=node_pt(0)->position_time_stepper_pt()->ntstorage();
220 for (
unsigned t=1;t<n_prev;t++)
222 for(
unsigned i=0;i<el_dim;i++)
224 outfile << interpolated_x(t,s,i) <<
" ";
229 n_prev=node_pt(0)->time_stepper_pt()->ntstorage();
230 for (
unsigned t=1;t<n_prev;t++)
232 for(
unsigned i=0;i<el_dim;i++)
234 outfile << interpolated_u_nst(t,s,i) <<
" ";
238 outfile << Error <<
" "
239 << size() << std::endl;
243 write_tecplot_zone_footer(outfile,nplot);
257 unsigned n_node = nnode();
260 unsigned u_nodal_index[el_dim];
261 for(
unsigned i=0;i<el_dim;i++) {u_nodal_index[i] = u_index_nst(i);}
265 DShape dpsidx(n_node,el_dim);
268 unsigned n_intpt = integral_pt()->nweight();
271 Vector<double> s(el_dim);
274 for(
unsigned ipt=0;ipt<n_intpt;ipt++)
277 for(
unsigned i=0;i<el_dim;i++) s[i] = integral_pt()->knot(ipt,i);
280 double w = integral_pt()->weight(ipt);
284 double J = this->dshape_eulerian_at_knot(ipt,psif,dpsidx);
290 Vector<double> interpolated_u(el_dim,0.0);
293 for(
unsigned l=0;l<n_node;l++)
296 for(
unsigned i=0;i<el_dim;i++)
299 double u_value = raw_nodal_value(l,u_nodal_index[i]);
300 interpolated_u[i] += u_value*psif[l];
305 for(
unsigned i=0;i<el_dim;i++)
307 sum+=interpolated_u[i]*interpolated_u[i]*W;
324 :
public virtual SolidTElement<1,3>
338 :
public virtual SolidPointElement
407 template<
class ELEMENT>
420 delete this->time_stepper_pt(0);
423 unsigned n=Outer_boundary_polyline_pt->npolyline();
424 for (
unsigned j=0;j<n;j++)
426 delete Outer_boundary_polyline_pt->polyline_pt(j);
428 delete Outer_boundary_polyline_pt;
431 unsigned n_drop = Drop_polygon_pt.size();
432 for(
unsigned idrop=0;idrop<n_drop;idrop++)
434 unsigned n=Drop_polygon_pt[idrop]->npolyline();
435 for (
unsigned j=0;j<n;j++)
437 delete Drop_polygon_pt[idrop]->polyline_pt(j);
439 delete Drop_polygon_pt[idrop];
443 delete_free_surface_elements();
444 delete Free_surface_mesh_pt;
445 delete_volume_constraint_elements();
446 delete Volume_constraint_mesh_pt;
449 delete Fluid_mesh_pt->spatial_error_estimator_pt();
452 delete Fluid_mesh_pt;
455 delete Drop_pressure_data_pt;
467 delete_free_surface_elements();
468 delete_volume_constraint_elements();
471 this->rebuild_global_mesh();
480 create_free_surface_elements();
481 create_volume_constraint_elements();
485 this->rebuild_global_mesh();
490 complete_problem_setup();
504 Fluid_mesh_pt->set_lagrangian_nodal_coordinates();
508 void complete_problem_setup();
511 void doc_solution(
const std::string& comment=
"");
514 void compute_error_estimate(
double& max_err,
522 Use_volume_constraint=
false;
525 Hijacked_element_pt->unhijack_all_data();
528 delete_volume_constraint_elements();
531 Drop_pressure_data_pt=0;
534 delete Volume_constraint_mesh_pt;
535 Volume_constraint_mesh_pt=0;
538 this->flush_sub_meshes();
541 this->add_sub_mesh(Fluid_mesh_pt);
544 this->add_sub_mesh(this->Free_surface_mesh_pt);
547 this->rebuild_global_mesh();
550 std::cout <<
"Removed volume constraint to obtain "
551 << this->assign_eqn_numbers() <<
" new equation numbers\n";
558 void create_free_surface_elements();
564 unsigned n_element = Free_surface_mesh_pt->nelement();
567 for(
unsigned e=0;e<n_element;e++)
570 delete Free_surface_mesh_pt->element_pt(e);
575 Free_surface_mesh_pt->flush_element_and_node_storage();
582 void create_volume_constraint_elements();
587 if (Volume_constraint_mesh_pt==0)
return;
590 if (Vol_constraint_el_pt!=0)
592 Initial_value_for_drop_pressure=Vol_constraint_el_pt->p_traded();
596 unsigned n_element = Volume_constraint_mesh_pt->nelement();
599 unsigned first_el_to_be_killed=0;
600 for(
unsigned e=first_el_to_be_killed;e<n_element;e++)
602 delete Volume_constraint_mesh_pt->element_pt(e);
606 Vol_constraint_el_pt=0;
609 Volume_constraint_mesh_pt->flush_element_and_node_storage();
646 Inflow_boundary_id=0,
647 Upper_wall_boundary_id=1,
648 Outflow_boundary_id=2,
649 Bottom_wall_boundary_id=3,
650 First_drop_boundary_id=4,
651 Second_drop_boundary_id=5
661 template<
class ELEMENT>
670 this->add_time_stepper_pt(
new BDF<2>);
678 Vector<TriangleMeshCurveSection*> boundary_polyline_pt(4);
682 Vector<Vector<double> > vertex_coord(2);
683 for(
unsigned i=0;i<2;i++)
685 vertex_coord[i].resize(2);
689 vertex_coord[0][0]=0.0;
690 vertex_coord[0][1]=0.0;
691 vertex_coord[1][0]=0.0;
692 vertex_coord[1][1]=1.0;
695 boundary_polyline_pt[0] =
new TriangleMeshPolyLine(vertex_coord,
699 vertex_coord[0][0]=0.0;
700 vertex_coord[0][1]=1.0;
702 vertex_coord[1][1]=1.0;
705 boundary_polyline_pt[1] =
new TriangleMeshPolyLine(vertex_coord,
706 Upper_wall_boundary_id);
710 vertex_coord[0][1]=1.0;
712 vertex_coord[1][1]=0.0;
715 boundary_polyline_pt[2] =
new TriangleMeshPolyLine(vertex_coord,
716 Outflow_boundary_id);
720 vertex_coord[0][1]=0.0;
721 vertex_coord[1][0]=0.0;
722 vertex_coord[1][1]=0.0;
725 boundary_polyline_pt[3] =
new TriangleMeshPolyLine(vertex_coord,
726 Bottom_wall_boundary_id);
729 Outer_boundary_polyline_pt =
new TriangleMeshPolygon(boundary_polyline_pt);
736 Drop_polygon_pt.resize(1);
740 double y_center = 0.5;
745 Vector<double> zeta(1);
748 Vector<double> coord(2);
751 unsigned npoints = 16;
752 double unit_zeta = MathematicalConstants::Pi/double(npoints-1);
756 Vector<TriangleMeshCurveSection*> drop_polyline_pt(2);
759 Vector<Vector<double> > drop_vertex(npoints);
762 for(
unsigned ipoint=0; ipoint<npoints;ipoint++)
765 drop_vertex[ipoint].resize(2);
768 zeta[0]=unit_zeta*double(ipoint);
769 drop_pt->position(zeta,coord);
772 drop_vertex[ipoint][0]=coord[0]+x_center;
773 drop_vertex[ipoint][1]=coord[1]+y_center;
777 drop_polyline_pt[0] =
new TriangleMeshPolyLine(drop_vertex,
778 First_drop_boundary_id);
781 for(
unsigned ipoint=0; ipoint<npoints;ipoint++)
784 drop_vertex[ipoint].resize(2);
787 zeta[0]=(unit_zeta*double(ipoint))+MathematicalConstants::Pi;
788 drop_pt->position(zeta,coord);
791 drop_vertex[ipoint][0]=coord[0]+x_center;
792 drop_vertex[ipoint][1]=coord[1]+y_center;
796 drop_polyline_pt[1] =
new TriangleMeshPolyLine(drop_vertex,
797 Second_drop_boundary_id);
800 Drop_polygon_pt[0] =
new TriangleMeshPolygon(
809 TriangleMeshClosedCurve* outer_closed_curve_pt=Outer_boundary_polyline_pt;
810 unsigned nb=Drop_polygon_pt.size();
811 Vector<TriangleMeshClosedCurve*> drop_closed_curve_pt(nb);
812 for (
unsigned i=0;i<nb;i++)
814 drop_closed_curve_pt[i]=Drop_polygon_pt[i];
818 double uniform_element_area=0.2;
821 Vector<double> drop_center(2);
822 drop_center[0]=x_center;
823 drop_center[1]=y_center;
827 TriangleMeshParameters triangle_mesh_parameters(
828 outer_closed_curve_pt);
831 triangle_mesh_parameters.internal_closed_curve_pt() =
832 drop_closed_curve_pt;
835 triangle_mesh_parameters.element_area() =
836 uniform_element_area;
839 triangle_mesh_parameters.add_region_coordinates(1, drop_center);
843 new RefineableSolidTriangleMesh<ELEMENT>(
844 triangle_mesh_parameters, this->time_stepper_pt());
847 Z2ErrorEstimator* error_estimator_pt=
new Z2ErrorEstimator;
848 Fluid_mesh_pt->spatial_error_estimator_pt()=error_estimator_pt;
851 Fluid_mesh_pt->max_permitted_error()=0.005;
852 Fluid_mesh_pt->min_permitted_error()=0.001;
853 Fluid_mesh_pt->max_element_size()=0.2;
854 Fluid_mesh_pt->min_element_size()=0.001;
857 if (CommandLineArgs::command_line_flag_has_been_set(
"--validation"))
859 Fluid_mesh_pt->min_element_size()=0.01;
863 this->Fluid_mesh_pt->output_boundaries(
"boundaries.dat");
864 this->Fluid_mesh_pt->output(
"mesh.dat");
871 complete_problem_setup();
874 Use_volume_constraint=
true;
875 Volume_constraint_mesh_pt =
new Mesh;
876 create_volume_constraint_elements();
879 Free_surface_mesh_pt=
new Mesh;
880 create_free_surface_elements();
886 this->add_sub_mesh(this->Volume_constraint_mesh_pt);
889 this->add_sub_mesh(Fluid_mesh_pt);
892 this->add_sub_mesh(this->Free_surface_mesh_pt);
895 this->build_global_mesh();
898 cout <<
"Number of equations: " << this->assign_eqn_numbers() << std::endl;
907 template<
class ELEMENT>
912 unsigned nb=Fluid_mesh_pt->nboundary();
913 for(
unsigned b=First_drop_boundary_id;b<nb;b++)
917 unsigned n_element = Fluid_mesh_pt->nboundary_element_in_region(b,0);
920 for(
unsigned e=0;e<n_element;e++)
924 ELEMENT* bulk_elem_pt =
dynamic_cast<ELEMENT*
>(
925 Fluid_mesh_pt->boundary_element_in_region_pt(b,0,e));
928 int face_index = Fluid_mesh_pt->face_index_at_boundary_in_region(b,0,e);
931 ElasticLineFluidInterfaceElement<ELEMENT>* el_pt =
932 new ElasticLineFluidInterfaceElement<ELEMENT>(
933 bulk_elem_pt,face_index);
936 Free_surface_mesh_pt->add_element_pt(el_pt);
939 el_pt->set_boundary_number_in_bulk_mesh(b);
955 template<
class ELEMENT>
960 if (!Use_volume_constraint)
return;
964 Hijacked_element_pt=
dynamic_cast<ELEMENT*
>(
965 Fluid_mesh_pt->region_element_pt(1,0));
969 unsigned index_of_traded_pressure=0;
970 Drop_pressure_data_pt=Hijacked_element_pt->
971 hijack_internal_value(0,index_of_traded_pressure);
974 Vol_constraint_el_pt=
976 Drop_pressure_data_pt,
977 index_of_traded_pressure);
980 Drop_pressure_data_pt->set_value(index_of_traded_pressure,
981 Initial_value_for_drop_pressure);
984 Volume_constraint_mesh_pt->add_element_pt(Vol_constraint_el_pt);
987 unsigned nb=Fluid_mesh_pt->nboundary();
988 for(
unsigned b=First_drop_boundary_id;b<nb;b++)
992 unsigned n_element = Fluid_mesh_pt->nboundary_element_in_region(b,0);
995 for(
unsigned e=0;e<n_element;e++)
999 ELEMENT* bulk_elem_pt =
dynamic_cast<ELEMENT*
>(
1000 Fluid_mesh_pt->boundary_element_in_region_pt(b,0,e));
1003 int face_index = Fluid_mesh_pt->face_index_at_boundary_in_region(b,0,e);
1006 ElasticLineVolumeConstraintBoundingElement<ELEMENT>* el_pt =
1007 new ElasticLineVolumeConstraintBoundingElement<ELEMENT>(
1008 bulk_elem_pt,face_index);
1011 el_pt->set_volume_constraint_element(Vol_constraint_el_pt);
1014 Volume_constraint_mesh_pt->add_element_pt(el_pt);
1024 template<
class ELEMENT>
1028 map<unsigned,bool> is_on_drop_bound;
1031 unsigned ndrop=Drop_polygon_pt.size();
1032 for(
unsigned idrop=0;idrop<ndrop;idrop++)
1036 Vector<unsigned> drop_bound_id=this->Drop_polygon_pt[idrop]->
1037 polygon_boundary_id();
1040 unsigned nbound=drop_bound_id.size();
1043 for(
unsigned ibound=0;ibound<nbound;ibound++)
1046 unsigned bound_id=drop_bound_id[ibound];
1049 is_on_drop_bound[bound_id]=
true;
1056 unsigned nbound=Fluid_mesh_pt->nboundary();
1057 for(
unsigned ibound=0;ibound<nbound;ibound++)
1059 unsigned num_nod=Fluid_mesh_pt->nboundary_node(ibound);
1060 for (
unsigned inod=0;inod<num_nod;inod++)
1063 Node* nod_pt=Fluid_mesh_pt->boundary_node_pt(ibound,inod);
1066 if((ibound==0) || (ibound==1) || (ibound==3))
1073 if(ibound==2) {nod_pt->pin(1);}
1077 SolidNode* solid_node_pt =
dynamic_cast<SolidNode*
>(nod_pt);
1078 if(is_on_drop_bound[ibound])
1080 solid_node_pt->unpin_position(0);
1081 solid_node_pt->unpin_position(1);
1085 solid_node_pt->pin_position(0);
1086 solid_node_pt->pin_position(1);
1096 unsigned n_element = Fluid_mesh_pt->nelement();
1097 for(
unsigned e=0;e<n_element;e++)
1100 ELEMENT* el_pt =
dynamic_cast<ELEMENT*
>(Fluid_mesh_pt->element_pt(e));
1114 n_element = Fluid_mesh_pt->nregion_element(1);
1115 for(
unsigned e=0;e<n_element;e++)
1119 dynamic_cast<ELEMENT*
>(Fluid_mesh_pt->region_element_pt(1,e));
1133 nbound=this->Fluid_mesh_pt->nboundary();
1134 for(
unsigned ibound=0;ibound<nbound;++ibound)
1136 if ((ibound==Upper_wall_boundary_id)||
1137 (ibound==Bottom_wall_boundary_id)||
1138 (ibound==Outflow_boundary_id) ||
1139 (ibound==Inflow_boundary_id))
1142 unsigned num_nod=this->Fluid_mesh_pt->nboundary_node(ibound);
1143 for (
unsigned inod=0;inod<num_nod;inod++)
1146 Node* nod_pt=this->Fluid_mesh_pt->boundary_node_pt(ibound,inod);
1149 unsigned n_prev=nod_pt->time_stepper_pt()->nprev_values();
1152 for (
unsigned t=0;t<=n_prev;t++)
1154 if (ibound!=Inflow_boundary_id)
1157 if (ibound!=Outflow_boundary_id)
1159 nod_pt->set_value(t,0,0.0);
1161 nod_pt->set_value(t,1,0.0);
1165 nod_pt->x(t,0)=nod_pt->x(0,0);
1166 nod_pt->x(t,1)=nod_pt->x(0,1);
1173 unsigned num_nod=this->Fluid_mesh_pt->nboundary_node(Inflow_boundary_id);
1174 for (
unsigned inod=0;inod<num_nod;inod++)
1177 Node* nod_pt=this->Fluid_mesh_pt->boundary_node_pt(Inflow_boundary_id,
1180 double y = nod_pt->x(1);
1190 template<
class ELEMENT>
1199 sprintf(filename,
"%s/soln%i.dat",
1210 compute_error_estimate(max_err,min_err);
1213 double square_of_l2_norm=0.0;
1214 unsigned nel=Fluid_mesh_pt->nelement();
1215 for (
unsigned e=0;e<nel;e++)
1218 dynamic_cast<ELEMENT*
>(this->Fluid_mesh_pt->element_pt(e))->
1219 square_of_l2_norm();
1224 some_file.open(filename);
1225 some_file << dynamic_cast<ELEMENT*>(this->Fluid_mesh_pt->element_pt(0))
1226 ->variable_identifier();
1227 this->Fluid_mesh_pt->output(some_file,npts);
1228 some_file <<
"TEXT X = 25, Y = 78, CS=FRAME T = \"Global Step "
1230 << comment <<
"\"\n";
1234 sprintf(filename,
"%s/boundaries%i.dat",
1237 some_file.open(filename);
1238 this->Fluid_mesh_pt->output_boundaries(some_file);
1245 Fluid_mesh_pt->max_and_min_element_size(max_area, min_area);
1249 << this->time_pt()->time() <<
" "
1250 << Fluid_mesh_pt->nelement() <<
" "
1255 << sqrt(square_of_l2_norm) <<
" "
1267 template<
class ELEMENT>
1272 ErrorEstimator* err_est_pt=Fluid_mesh_pt->spatial_error_estimator_pt();
1275 unsigned nel=Fluid_mesh_pt->nelement();
1276 Vector<double> elemental_error(nel);
1281 Mesh* fluid_mesh_pt=
dynamic_cast<Mesh*
>(Fluid_mesh_pt);
1282 err_est_pt->get_element_errors(fluid_mesh_pt,
1288 for (
unsigned e=0;e<nel;e++)
1291 set_error(elemental_error[e]);
1293 max_err=std::max(max_err,elemental_error[e]);
1294 min_err=std::min(min_err,elemental_error[e]);
1307 CommandLineArgs::setup(argc,argv);
1313 CommandLineArgs::specify_command_line_flag(
"--validation");
1316 CommandLineArgs::parse_and_assign();
1319 CommandLineArgs::doc_specified_flags();
1341 problem.steady_newton_solve(1);
1345 problem.steady_newton_solve();
1349 problem.doc_solution();
1352 problem.remove_volume_constraint();
1357 problem.initialise_dt(dt);
1360 problem.assign_initial_values_impulsive();
1363 problem.doc_solution();
1370 problem.complete_problem_setup();
1374 if (CommandLineArgs::command_line_flag_has_been_set(
"--validation"))
1377 oomph_info <<
"Remeshing after every second step during validation\n";
1379 for (
unsigned i=0;i<nstep;i++)
1382 problem.unsteady_newton_solve(dt);
1383 problem.doc_solution();
1389 unsigned ncycle=1000;
1390 if (CommandLineArgs::command_line_flag_has_been_set(
"--validation"))
1393 oomph_info <<
"Only doing one cycle during validation\n";
1398 for(
unsigned j=0;j<ncycle;j++)
1401 unsigned max_adapt=1;
1404 for (
unsigned i=0;i<nstep;i++)
1407 problem.unsteady_newton_solve(dt,max_adapt,
false);
1411 std::stringstream label;
1412 label <<
"Adaptation " <<j <<
" Step "<< i;
1413 problem.doc_solution(label.str());
int main(int argc, char **argv)
Driver code for moving block problem.
Problem class to simulate viscous drop propagating along 2D channel.
double Initial_value_for_drop_pressure
Backed up drop pressure between adaptations.
void actions_before_newton_solve()
Update the problem specs before solve.
RefineableSolidTriangleMesh< ELEMENT > * Fluid_mesh_pt
Pointer to Fluid_mesh.
void complete_problem_setup()
Set boundary conditions and complete the build of all elements.
void doc_solution(const std::string &comment="")
Doc the solution.
void delete_free_surface_elements()
Delete free surface elements.
void compute_error_estimate(double &max_err, double &min_err)
Compute the error estimates and assign to elements for plotting.
void actions_before_adapt()
Actions before adapt: Wipe the mesh of free surface elements.
void create_volume_constraint_elements()
Create elements that impose volume constraint on the drop.
Mesh * Free_surface_mesh_pt
Pointers to mesh of free surface elements.
void create_free_surface_elements()
Create free surface elements.
~DropInChannelProblem()
Destructor.
bool Use_volume_constraint
Bool to indicate if volume constraint is applied (only for steady run)
DropInChannelProblem()
Constructor.
void actions_after_newton_solve()
Update the after solve (empty)
void remove_volume_constraint()
Change the boundary conditions to remove the volume constraint.
Vector< TriangleMeshPolygon * > Drop_polygon_pt
Vector storing pointer to the drop polygons.
Mesh * Volume_constraint_mesh_pt
Pointer to mesh containing elements that impose volume constraint.
VolumeConstraintElement * Vol_constraint_el_pt
Pointer to element that imposes volume constraint for drop.
Data * Drop_pressure_data_pt
Pointer to a global drop pressure datum.
TriangleMeshPolygon * Outer_boundary_polyline_pt
Triangle mesh polygon for outer boundary.
void delete_volume_constraint_elements()
Delete volume constraint elements.
void actions_after_adapt()
Actions after adapt: Rebuild the mesh of free surface elements.
ELEMENT * Hijacked_element_pt
Pointer to hijacked element.
Overload CrouzeixRaviart element to modify output.
void set_error(const double &error)
Set error value for post-processing.
double square_of_l2_norm()
Get square of L2 norm of velocity.
MyCrouzeixRaviartElement()
Constructor initialise error.
double Error
Storage for elemental error estimate – used for post-processing.
void output(std::ostream &outfile, const unsigned &nplot)
Overload output function.
std::string variable_identifier()
Return variable identifier.
////////////////////////////////////////////////////////////// //////////////////////////////////////...
DocInfo Doc_info
Doc info object.
ofstream Norm_file
File to document the norm of the solution (for validation purposes – triangle doesn't give fully repr...
ofstream Trace_file
Trace file.
double Inflow_veloc_magnitude
Scaling factor for inflow velocity (allows it to be switched off to do hydrostatics)
double Length
Length of the channel.
ConstitutiveLaw * Constitutive_law_pt
Constitutive law used to determine the mesh deformation.
double Radius
Initial radius of bubble.
double Volume
Volume of the bubble (negative because it's outside the fluid!)
double Nu
Pseudo-solid Poisson ratio.
double Re
Reynolds number.
double Ca
Capillary number.
double Viscosity_ratio
Viscosity ratio of the droplet to the surrounding fluid.