A Linear Element class. More...

#include <TwoD_TVDLF_Elt.h>

Public Member Functions
	TwoD_TVDLF_Elt (double west, double east, double south, double north, TwoD_Hyperbolic_System *ptr, bool flag=false, std::set< int > faces=std::set< int >())
	Construct a linear rectangular element. More...

	~TwoD_TVDLF_Elt ()
	An empty destructor. More...

bool	face_is_external (const int &index) const
	Test to see if a face index of an element is external to the mesh. More...

bool	face_is_internal (const int &index) const
	Test to see if a face index of an element is internal to the mesh. More...

void	set_ptrs (const int &index, TwoD_TVDLF_Elt *ptr)
	Each element stores pointers to any adjacent elements in the four compass directions 0,1,2,3 for S,E,N,W. More...

TwoD_TVDLF_Elt *	get_ptrs (const int &index) const
	Return a pointer to an element in the given compass direction. More...

void	add_contribution (TwoD_TVDLF_Elt *ptr, const DenseVector< double > &sw, const DenseVector< double > &ne, std::set< int > indices)
	Add a contribution to this element from another element. More...

void	dump () const
	Dump the details of this element. More...

void	clear_contributions ()
	Reset the contributions to this element. More...

DenseVector< double >	contributed_Q () const
	Find the integral contributions to this black/red element from the corresponding contributing red/black element. More...

void	add_flux_contributions (const double &dt)
	Adds the contribution of each face's flux to the correction for this element unless it has already been added by a flux computation across the same face in an adjacent elt. More...

void	contributed_flux_in_west (const double &dt, DenseVector< double > &flux_in_west)
	Compute the flux into this element across the western face. More...

void	contributed_flux_in_south (const double &dt, DenseVector< double > &flux_in_south)
	Compute the flux into this element across the southern face. More...

void	contributed_flux_out_east (const double &dt, DenseVector< double > &flux_out_east)
	Compute the flux out of this element across the eastern face. More...

void	contributed_flux_out_north (const double &dt, DenseVector< double > &flux_out_north)
	Compute the flux out of this element across the northern face. More...

DenseVector< double >	get_s (const DenseVector< double > &x) const
	Get the local coordinate that corresponds to a given global coordinate. More...

DenseVector< double >	get_x (DenseVector< double > s) const
	Get the global position of a local coordinate in this element. More...

DenseVector< double >	get_x_mid () const
	Get the global position of a central node in this element. More...

DenseVector< double >	get_dx () const
	Get the size of the element as a vector (delta_x, delta_y). More...

double	get_dA () const
	Get the area of the element. More...

void	set_external_flag (bool flag)
	Set the external flag. More...

bool	get_external_flag () const
	Get the external flag. More...

std::set< int >	get_external_faces () const
	Get a set of indices of faces that are external. More...

DenseVector< double >	get_Q (const DenseVector< double > &s) const
	Get the value of the 'concentration' stored in this element. More...

DenseVector< double >	get_int_Q (const DenseVector< double > &sw, const DenseVector< double > &ne) const
	Get the integral of Q over a sub-element. More...

void	add_external_face (const int &i)
	Add an external face to the stored stl::set. More...

void	remove_external_face (const int &i)
	Remove an external face to the stored stl::set. More...

void	set_Q_mid (const DenseVector< double > &value)
	Set the value of the vector 'concentration' stored in this element. More...

DenseVector< double >	get_Q_mid () const
	Get the nodal concentration. More...

void	set_slope_x (const DenseVector< double > &value)
	Set the x-slope vector for this element. More...

void	set_slope_y (const DenseVector< double > &value)
	Set the y-slope vector for this element. More...

DenseVector< double >	get_slope_x () const
	The concentration is approximated by a linear function in each element. More...

DenseVector< double >	get_slope_y () const
	The concentration is approximated by a linear function in each element. More...

DenseVector< double >	get_Q_Taylor_series (const DenseVector< double > &s, const double &dt) const
	Get the Taylor series expansion of the concentration for a given time step and local coordinate for this element. More...

DenseVector< double >	get_source_contribution (const double &dt) const
	Evaluate the contribution to this element by the hyperbolic system's source function over a given time step using a mid-point in time evaluation. More...

double	get_max_dt () const
	Get the maximum allowable time step for this element by using information about the size of the element and the maximum wave speed set in the conservative system. More...

DenseVector< double >	get_flux_fn_x (const DenseVector< double > &s) const
	Get the flux function in the x direction evaluated for the concentration value stored in this elt. More...

DenseVector< double >	get_flux_fn_y (const DenseVector< double > &s) const
	Get the flux function in the y direction evaluated for the concentration value stored in this elt. More...

DenseMatrix< double >	get_Jac_flux_fn_x (const DenseVector< double > &s) const
	Get the Jacobian of the x flux function evaluated for the concentration value stored in this elt. More...

DenseMatrix< double >	get_Jac_flux_fn_y (const DenseVector< double > &s) const
	Get the Jacobian of the y flux function evaluated for the concentration value stored in this elt. More...

DenseVector< double >	get_source_fn (const DenseVector< double > &s) const
	Get the source function evaluated for the concentration value stored in this elt. More...

Public Attributes
TwoD_Hyperbolic_System *	p_system

Detailed Description

A Linear Element class.

Definition at line 19 of file TwoD_TVDLF_Elt.h.

Constructor & Destructor Documentation

◆ TwoD_TVDLF_Elt()

CppNoddy::TwoD_TVDLF_Elt::TwoD_TVDLF_Elt	(	double	west,
		double	east,
		double	south,
		double	north,
		TwoD_Hyperbolic_System *	ptr,
		bool	flag = `false`,
		std::set< int >	faces = `std::set<int>()`
	)

Construct a linear rectangular element.

Parameters

west	The western face location
east	The eastern face location
south	The western face location
north	The eastern face location
ptr	A pointer to the hyperbolic system
flag	A boolean indicator to specify an elt with an external face
faces	A set of indices of the external faces

Definition at line 17 of file TwoD_TVDLF_Elt.cpp.

                                                               {
#ifdef DEBUG
    std::cout << "DEBUG: Constructing a TwoD_TVDLF_Elt object over ["
              << west << ", " << east << "] X [" << south << ", " << north << "]\n";
#endif
    p_system = ptr;
    // south west corner
    this -> WEST = west;
    this -> SOUTH = south;
    // lengths of the element sides
    this -> DX = east - west;
    this -> DY = north - south;
    // is this an elt with an external face?
    EXTERNAL = flag;
    // which faces are external?
    EXTERNAL_FACES = faces;
    // pointers to the elements on the compass points
    p_ELTS = std::vector<TwoD_TVDLF_Elt*>(4, this);
    // linear reconstruction within the elt ... in 2 directions
    SLOPE_X = DenseVector<double>(p_system -> get_order(), 0.0);
    SLOPE_Y = DenseVector<double>(p_system -> get_order(), 0.0);
    // the concentrations in this elt
    Q = DenseVector<double>(p_system -> get_order(), 0.0);
    // the corrections to be added ... built up in parts
    DELTA_Q = DenseVector<double>(p_system -> get_order(), 0.0);
    // no fluxes have been added to this elt
    FLUX_FACE_DONE = std::vector<bool>(4, false);
  }

References p_system.

◆ ~TwoD_TVDLF_Elt()

CppNoddy::TwoD_TVDLF_Elt::~TwoD_TVDLF_Elt ( )

An empty destructor.

Definition at line 49 of file TwoD_TVDLF_Elt.cpp.

50 {}

Member Function Documentation

◆ add_contribution()

void CppNoddy::TwoD_TVDLF_Elt::add_contribution	(	TwoD_TVDLF_Elt *	ptr,
		const DenseVector< double > &	sw,
		const DenseVector< double > &	ne,
		std::set< int >	indices
	)

Add a contribution to this element from another element.

Parameters

ptr	A pointer to the element that contributes to this one
sw	The SW local coordinate in the contributory element
ne	The NE local coordinate in the contributory element
indices	A set of indices of faces that this element contributes to

Definition at line 99 of file TwoD_TVDLF_Elt.cpp.

                                                               {
    // if any face indices are external then we ignore them
    std::set< int > internal_indices;
    set_difference(indices.begin(), indices.end(),
                   EXTERNAL_FACES.begin(), EXTERNAL_FACES.end(),
                   inserter(internal_indices, internal_indices.begin()));
    // loop thru the contributions to see if it is already in there
    std::list< contribution >::iterator c = CONT_LIST.begin();
    bool found = false;
    while(c != CONT_LIST.end()) {
      if(c -> elt_ptr == ptr) {
        found = true;
        break;
      } else {
        ++c;
      }
    }
    if(found) {
      // just add face indices to the existing entry's set of faces
      c -> face_indices.insert(internal_indices.begin(), internal_indices.end());
    } else {
      // we need to make a new contribution entry
      contribution cont;
      cont.elt_ptr = ptr;
      cont.sw = sw;
      cont.ne = ne;
      cont.face_indices.insert(internal_indices.begin(), internal_indices.end());
      // push the contribution data into a list
      CONT_LIST.push_back(cont);
    }
  }

◆ add_external_face()

void CppNoddy::TwoD_TVDLF_Elt::add_external_face ( const int & i )

Add an external face to the stored stl::set.

Parameters

i	The index of the external face 0,1,2,3 for S,E,N,W.

Definition at line 460 of file TwoD_TVDLF_Elt.cpp.

                                                     {
    EXTERNAL_FACES.insert(i);
  }

◆ add_flux_contributions()

void CppNoddy::TwoD_TVDLF_Elt::add_flux_contributions ( const double & dt )

Adds the contribution of each face's flux to the correction for this element unless it has already been added by a flux computation across the same face in an adjacent elt.

Parameters

dt	The time step over which the flux is to be computed

Definition at line 72 of file TwoD_TVDLF_Elt.cpp.

                                                              {
    DenseVector<double> flux(p_system -> get_order(), 0.0);
    // work out the flux into the elt
    if(!FLUX_FACE_DONE[ 0 ]) {
      contributed_flux_in_south(dt, flux);
    }
    if(!FLUX_FACE_DONE[ 1 ]) {
      contributed_flux_out_east(dt, flux);
    }
    if(!FLUX_FACE_DONE[ 2 ]) {
      contributed_flux_out_north(dt, flux);
    }
    if(!FLUX_FACE_DONE[ 3 ]) {
      contributed_flux_in_west(dt, flux);
    }
    // evaluate the total integral over dt and divide by the area of the elt
    DELTA_Q *= dt / (DX * DY);
    // include the source contribution
    DELTA_Q += get_source_contribution(dt);
    // update the concentrations
    Q += DELTA_Q;
    // reset the correction to zero
    DELTA_Q = DenseVector<double>(p_system -> get_order(), 0.0);
    // reset the elt to having no fluxes added
    FLUX_FACE_DONE = std::vector<bool>(4, false);
  }

References contributed_flux_in_south(), contributed_flux_in_west(), contributed_flux_out_east(), contributed_flux_out_north(), get_source_contribution(), and p_system.

◆ clear_contributions()

void CppNoddy::TwoD_TVDLF_Elt::clear_contributions ( )

Reset the contributions to this element.

Definition at line 142 of file TwoD_TVDLF_Elt.cpp.

                                           {
    CONT_LIST.clear();
  }

◆ contributed_flux_in_south()

void CppNoddy::TwoD_TVDLF_Elt::contributed_flux_in_south	(	const double &	dt,
		DenseVector< double > &	flux_in_south
	)

Compute the flux into this element across the southern face.

Parameters

dt	The time step over which the flux is to be computed
flux_in_south	A vector flux that is overwritten by this method and returned containing the appropriate flux values.

Definition at line 220 of file TwoD_TVDLF_Elt.cpp.

                                                                                                     {
    DenseVector<double> flux(p_system -> get_order(), 0.0);
    flux_in_south = DenseVector<double>(p_system -> get_order(), 0.0);
    std::list< contribution >::iterator c = CONT_LIST.begin();
    if(face_is_internal(0)) {
      // loop over all contributing elements
      while(c != CONT_LIST.end()) {
        // true if this makes a contribution to the South face
        if(c -> face_indices.find(0) != c -> face_indices.end()) {
          // get the local coords in the contributing elt, but has to
          // be at the mid-point for the x-integration
          DenseVector<double> s_half(2, 0.0);
          s_half[ 0 ] = (c -> sw[ 0 ] + c -> ne[ 0 ]) * 0.5;
          s_half[ 1 ] =  c -> sw[ 1 ];
          // current concentration value at the mid-time point
          DenseVector<double> q_half_step(c -> elt_ptr -> get_Q_Taylor_series(s_half, dt / 2));
          // evaluate the flux at this Q value
          c -> elt_ptr -> p_system -> flux_fn_y(c -> elt_ptr -> get_x(s_half), q_half_step, flux);
          // the length of the elements face that this computation is over (for the x-integral)
          const double sub_dx((c -> elt_ptr -> get_x(c -> ne) - c -> elt_ptr -> get_x(c -> sw))[0]);
          flux_in_south += flux * sub_dx;
        }
        ++c;
      }
      // flux_in_south of this elt = flux_out_north of the elt to the south
      p_ELTS[ 0 ] -> add_to_delta_Q(2, -flux_in_south);
    }
    // if we are computing the flux thru South face and it is external
    // then we should use the user specified edge values
    else {
      std::list< contribution >::iterator c = CONT_LIST.begin();
      // loop over all contributing elements
      while(c != CONT_LIST.end()) {
        // find any contributing elts to this external face
        if(c -> elt_ptr -> face_is_external(0)) {
          // get the local coords in the contributing elt, but has to
          // be at the mid-point for the x-integration
          DenseVector<double> s_half(2, 0.0);
          s_half[ 0 ] = (c -> sw[ 0 ] + c -> ne[ 0 ]) * 0.5;
          s_half[ 1 ] =  c -> sw[ 1 ];
          // global coordinate
          const DenseVector<double> x(c -> elt_ptr -> get_x(s_half));
          // get the concentration at the mid-time point
          DenseVector<double> q_half_step(c -> elt_ptr -> get_Q_Taylor_series(s_half, dt / 2));
          // at this point we have obtained the 'natural' boundary condition
          // but we now allow the user to overwrite this using the edge_values
          // not overwriting q_half_step means we keep the natural condition
          p_system -> edge_values(0, x, q_half_step);
          // evaluate the flux at this Q value
          c -> elt_ptr -> p_system -> flux_fn_y(x, q_half_step, flux);
          // the length of the elements face that this computation is over (for the x-integral)
          const double sub_dx((c -> elt_ptr -> get_x(c -> ne) - c -> elt_ptr -> get_x(c -> sw))[0]);
          flux_in_south += flux * sub_dx;
        }
        ++c;
      }
    }
    FLUX_FACE_DONE[ 0 ] = true;
    DELTA_Q += flux_in_south;
  }

References face_is_external(), face_is_internal(), get_Q_Taylor_series(), get_x(), and p_system.

Referenced by add_flux_contributions().

◆ contributed_flux_in_west()

void CppNoddy::TwoD_TVDLF_Elt::contributed_flux_in_west	(	const double &	dt,
		DenseVector< double > &	flux_in_west
	)

Compute the flux into this element across the western face.

Parameters

dt	The time step over which the flux is to be computed
flux_in_west	A vector flux that is overwritten by this method and returned containing the appropriate flux values.

Definition at line 159 of file TwoD_TVDLF_Elt.cpp.

                                                                                                   {
    DenseVector<double> flux(p_system -> get_order(), 0.0);
    flux_in_west = DenseVector<double>(p_system -> get_order(), 0.0);
    std::list< contribution >::iterator c = CONT_LIST.begin();
    if(face_is_internal(3)) {
      // loop over all contributing elements
      while(c != CONT_LIST.end()) {
        // true if this makes a contribution to the West face
        if(c -> face_indices.find(3) != c -> face_indices.end()) {
          // get the local coords in the contributing elt, but has to
          // be at the mid-point for the y-integration
          DenseVector<double> s_half(2, 0.0);
          s_half[ 0 ] = c -> sw[ 0 ];
          s_half[ 1 ] = (c -> sw[1] + c -> ne[1]) * 0.5;
          // current concentration value at the mid-time step
          DenseVector<double> q_half_step(c -> elt_ptr -> get_Q_Taylor_series(s_half, dt / 2));
          // evaluate the flux at this Q value
          c -> elt_ptr -> p_system -> flux_fn_x(c -> elt_ptr -> get_x(s_half), q_half_step, flux);
          // the length of the elements face that this computation is over (for the y-integral)
          const double sub_dy((c -> elt_ptr -> get_x(c -> ne) - c -> elt_ptr -> get_x(c -> sw))[1]);
          flux_in_west += flux * sub_dy;
        }
        ++c;
      }
      // flux_in_west of this elt = flux_out_east of the elt to the west
      p_ELTS[ 3 ] -> add_to_delta_Q(1, -flux_in_west);
    }
    // if we are computing the flux thru West face and it is external
    // then we should use the user specified edge values
    else {
      std::list< contribution >::iterator c = CONT_LIST.begin();
      // loop over all contributing elements
      while(c != CONT_LIST.end()) {
        // find any contributing elts to this external face
        if(c -> elt_ptr -> face_is_external(3)) {
          // get the local coords in the contributing elt, but has to
          // be at the mid-point for the y-integration
          DenseVector<double> s_half(2, 0.0);
          s_half[ 0 ] = c -> sw[ 0 ];
          s_half[ 1 ] = (c -> sw[1] + c -> ne[1]) * 0.5;
          // global coordinate
          const DenseVector<double> x(c -> elt_ptr -> get_x(s_half));
          // get the concentration at the mid-time point
          DenseVector<double> q_half_step(c -> elt_ptr -> get_Q_Taylor_series(s_half, dt / 2));
          // at this point we have obtained the 'natural' boundary condition
          // but we now allow the user to overwrite this using the edge_values
          // not overwriting q_half_step means we keep the natural condition
          p_system -> edge_values(3, x, q_half_step);
          // evaluate the flux at this Q value
          c -> elt_ptr -> p_system -> flux_fn_x(x, q_half_step, flux);
          // the length of the elements face that this computation is over (for the y-integral)
          const double sub_dy((c -> elt_ptr -> get_x(c -> ne) - c -> elt_ptr -> get_x(c -> sw))[1]);
          flux_in_west += flux * sub_dy;
        }
        ++c;
      }
    }
    FLUX_FACE_DONE[ 3 ] = true;
    DELTA_Q += flux_in_west;
  }

References face_is_external(), face_is_internal(), get_Q_Taylor_series(), get_x(), and p_system.

Referenced by add_flux_contributions().

◆ contributed_flux_out_east()

void CppNoddy::TwoD_TVDLF_Elt::contributed_flux_out_east	(	const double &	dt,
		DenseVector< double > &	flux_out_east
	)

Compute the flux out of this element across the eastern face.

Parameters

dt	The time step over which the flux is to be computed
flux_out_east	A vector flux that is overwritten by this method and returned containing the appropriate flux values.

Definition at line 281 of file TwoD_TVDLF_Elt.cpp.

                                                                                                     {
    DenseVector<double> flux(p_system -> get_order(), 0.0);
    flux_out_east = DenseVector<double>(p_system -> get_order(), 0.0);
    std::list< contribution >::iterator c = CONT_LIST.begin();
    if(face_is_internal(1)) {
      // loop over all contributing elements
      while(c != CONT_LIST.end()) {
        // true if this makes a contribution to the East face
        if(c -> face_indices.find(1) != c -> face_indices.end()) {
          // get the local coords in the contributing elt, but has to
          // be at the mid-point for the y-integration
          DenseVector<double> s_half(2, 0.0);
          s_half[ 0 ] = c -> ne[ 0 ];
          s_half[ 1 ] = (c -> sw[1] + c -> ne[1]) * 0.5;
          // current concentration value at the mid-time point
          DenseVector<double> q_half_step(c -> elt_ptr -> get_Q_Taylor_series(s_half, dt / 2));
          // evaluate the flux at this Q value
          c -> elt_ptr -> p_system -> flux_fn_x(c -> elt_ptr -> get_x(s_half), q_half_step, flux);
          // the length of the elements face that this computation is over (for the y-integral)
          const double sub_dy((c -> elt_ptr -> get_x(c -> ne) - c -> elt_ptr -> get_x(c -> sw))[1]);
          flux_out_east += flux * sub_dy;
        }
        ++c;
      }
      // flux_out_east of this elt = flux_in_west of the elt to the west
      p_ELTS[ 1 ] -> add_to_delta_Q(3, flux_out_east);
    }
    // if we are computing the flux thru East face and it is external
    // then we should use the user specified edge values
    else {
      std::list< contribution >::iterator c = CONT_LIST.begin();
      // loop over all contributing elements
      while(c != CONT_LIST.end()) {
        // find any contributing elts to this external face
        if(c -> elt_ptr -> face_is_external(1)) {
          // get the local coords in the contributing elt, but has to
          // be at the mid-point for the y-integration
          DenseVector<double> s_half(2, 0.0);
          s_half[ 0 ] = c -> ne[ 0 ];
          s_half[ 1 ] = (c -> sw[1] + c -> ne[1]) * 0.5;
          // global coordinate
          const DenseVector<double> x(c -> elt_ptr -> get_x(s_half));
          // get the concentration at this point mid-time point
          DenseVector<double> q_half_step(c -> elt_ptr -> get_Q_Taylor_series(s_half, dt / 2));
          // at this point we have obtained the 'natural' boundary condition
          // but we now allow the user to overwrite this using the edge_values
          // not overwriting q_half_step means we keep the natural condition
          p_system -> edge_values(1, x, q_half_step);
          // evaluate the flux at this Q value
          c -> elt_ptr -> p_system -> flux_fn_x(x, q_half_step, flux);
          // the length of the elements face that this computation is over (for the y-integral)
          const double sub_dy((c -> elt_ptr -> get_x(c -> ne) - c -> elt_ptr -> get_x(c -> sw))[1]);
          flux_out_east += flux * sub_dy;
        }
        ++c;
      }
    }
    FLUX_FACE_DONE[ 1 ] = true;
    DELTA_Q -= flux_out_east;
  }

References face_is_external(), face_is_internal(), get_Q_Taylor_series(), get_x(), and p_system.

Referenced by add_flux_contributions().

◆ contributed_flux_out_north()

void CppNoddy::TwoD_TVDLF_Elt::contributed_flux_out_north	(	const double &	dt,
		DenseVector< double > &	flux_out_north
	)

Compute the flux out of this element across the northern face.

Parameters

dt	The time step over which the flux is to be computed
flux_out_north	A vector flux that is overwritten by this method and returned containing the appropriate flux values.

Definition at line 342 of file TwoD_TVDLF_Elt.cpp.

                                                                                                       {
    DenseVector<double> flux(p_system -> get_order(), 0.0);
    flux_out_north = DenseVector<double>(p_system -> get_order(), 0.0);
    std::list< contribution >::iterator c = CONT_LIST.begin();
    if(face_is_internal(2)) {
      // loop over all contributing elements
      while(c != CONT_LIST.end()) {
        // true if this makes a contribution to the North face
        if(c -> face_indices.find(2) != c -> face_indices.end()) {
          // get the local coords in the contributing elt, but has to
          // be at the mid-point for the y-integration
          DenseVector<double> s_half(2, 0.0);
          s_half[ 0 ] = (c -> sw[ 0 ] + c -> ne[ 0 ]) * 0.5;
          s_half[ 1 ] =  c -> ne[ 1 ];
          // current concentration value at the mid-time point
          DenseVector<double> q_half_step(c -> elt_ptr -> get_Q_Taylor_series(s_half, dt / 2));
          // evaluate the flux at this Q value
          c -> elt_ptr -> p_system -> flux_fn_y(c -> elt_ptr -> get_x(s_half), q_half_step, flux);
          // the length of the elements face that this computation is over (for the y-integral)
          const double sub_dx((c -> elt_ptr -> get_x(c -> ne) - c -> elt_ptr -> get_x(c -> sw))[0]);
          flux_out_north += flux * sub_dx;
        }
        ++c;
      }
      // flux_out_north of this elt = flux_in_south of the elt to the north
      p_ELTS[ 2 ] -> add_to_delta_Q(0, flux_out_north);
    }
    // if we are computing the flux thru North face and it is external
    // then we should use the user specified edge values
    else {
      std::list< contribution >::iterator c = CONT_LIST.begin();
      // loop over all contributing elements
      while(c != CONT_LIST.end()) {
        // find any contributing elts to this external face
        if(c -> elt_ptr -> face_is_external(2)) {
          // get the local coords in the contributing elt, but has to
          // be at the mid-point for the x-integration
          DenseVector<double> s_half(2, 0.0);
          s_half[ 0 ] = (c -> sw[ 0 ] + c -> ne[ 0 ]) * 0.5;
          s_half[ 1 ] =  c -> ne[ 1 ];
          // global coordinate
          const DenseVector<double> x(c -> elt_ptr -> get_x(s_half));
          // get the concentration at this mid-time point
          DenseVector<double> q_half_step(c -> elt_ptr -> get_Q_Taylor_series(s_half, dt / 2));
          // at this point we have obtained the 'natural' boundary condition
          // but we now allow the user to overwrite this using the edge_values
          // not overwriting q_half_step means we keep the natural condition
          p_system -> edge_values(2, x, q_half_step);
          // evaluate the flux at this Q value
          c -> elt_ptr -> p_system -> flux_fn_y(x, q_half_step, flux);
          // the length of the elements face that this computation is over (for the x-integral)
          const double sub_dx((c -> elt_ptr -> get_x(c -> ne) - c -> elt_ptr -> get_x(c -> sw))[0]);
          flux_out_north += flux * sub_dx;
        }
        ++c;
      }
    }
    FLUX_FACE_DONE[ 2 ] = true;
    DELTA_Q -= flux_out_north;
  }

References face_is_external(), face_is_internal(), get_Q_Taylor_series(), get_x(), and p_system.

Referenced by add_flux_contributions().

◆ contributed_Q()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::contributed_Q ( ) const

Find the integral contributions to this black/red element from the corresponding contributing red/black element.

Returns: The integrated value of all components

Definition at line 146 of file TwoD_TVDLF_Elt.cpp.

                                                          {
    std::list< contribution >::const_iterator c = CONT_LIST.begin();
    // start with zero
    DenseVector<double> sum(p_system -> get_order(), 0.0);
    // loop over contributions
    while(c != CONT_LIST.end()) {
      // get integral of each
      sum += c -> elt_ptr -> get_int_Q(c -> sw, c -> ne);
      ++c;
    }
    return sum;
  }

References get_int_Q(), and p_system.

◆ dump()

void CppNoddy::TwoD_TVDLF_Elt::dump ( ) const

Dump the details of this element.

Definition at line 134 of file TwoD_TVDLF_Elt.cpp.

                                  {
    DenseVector<double> s(2, 0.0);
    std::cout << WEST + DX / 2 << " " << SOUTH + DY / 2 << " " << get_Q(s)[0] << "\n";
    if(EXTERNAL_FACES.find(1) != EXTERNAL_FACES.end()) {
      std::cout << "\n";
    }
  }

References get_Q().

◆ face_is_external()

bool CppNoddy::TwoD_TVDLF_Elt::face_is_external ( const int & index ) const

Test to see if a face index of an element is external to the mesh.

Parameters

index The face index to test (0,1,2,3) for (S,E,N,W)

Returns: True if the face is external to the mesh.

Definition at line 52 of file TwoD_TVDLF_Elt.cpp.

                                                              {
    bool found(true);
    if(EXTERNAL_FACES.find(index) == EXTERNAL_FACES.end()) {
      found = false;
    }
    return found;
  }

Referenced by contributed_flux_in_south(), contributed_flux_in_west(), contributed_flux_out_east(), contributed_flux_out_north(), and face_is_internal().

◆ face_is_internal()

bool CppNoddy::TwoD_TVDLF_Elt::face_is_internal ( const int & index ) const

Test to see if a face index of an element is internal to the mesh.

Parameters

index The face index to test (0,1,2,3) for (S,E,N,W)

Returns: True if the face is internal to the mesh.

Definition at line 60 of file TwoD_TVDLF_Elt.cpp.

                                                              {
    return !face_is_external(index);
  }

References face_is_external().

Referenced by contributed_flux_in_south(), contributed_flux_in_west(), contributed_flux_out_east(), and contributed_flux_out_north().

◆ get_dA()

double CppNoddy::TwoD_TVDLF_Elt::get_dA ( ) const

Get the area of the element.

Returns: The area of the element

Definition at line 444 of file TwoD_TVDLF_Elt.cpp.

                                      {
    return DX * DY;
  }

◆ get_dx()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_dx ( ) const

Get the size of the element as a vector (delta_x, delta_y).

Returns: The separation of the rectangles faces (delta_x, delta_y)

Definition at line 437 of file TwoD_TVDLF_Elt.cpp.

                                                   {
    DenseVector<double> delta(2, 0.0);
    delta[ 0 ] = DX;
    delta[ 1 ] = DY;
    return delta;
  }

◆ get_external_faces()

std::set< int > CppNoddy::TwoD_TVDLF_Elt::get_external_faces ( ) const

Get a set of indices of faces that are external.

Returns: A set of integers (0,1,2,3 for south, east, north, west) indicating which faces are external.

Definition at line 456 of file TwoD_TVDLF_Elt.cpp.

                                                       {
    return EXTERNAL_FACES;
  }

◆ get_external_flag()

bool CppNoddy::TwoD_TVDLF_Elt::get_external_flag ( ) const

Get the external flag.

Returns: The value of the flag (true if this is an elt with an external face)

Definition at line 452 of file TwoD_TVDLF_Elt.cpp.

                                               {
    return EXTERNAL;
  }

◆ get_flux_fn_x()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_flux_fn_x ( const DenseVector< double > & s ) const

inline

Get the flux function in the x direction evaluated for the concentration value stored in this elt.

Parameters

s	The local vector coordinate at which to evaluate

Returns: The flux function vector

Definition at line 233 of file TwoD_TVDLF_Elt.h.

                                                                          {
      DenseVector<double> f(p_system -> get_order(), 0.0);
      p_system -> flux_fn_x(get_x(s), get_Q(s), f);
      return f;
    }

References f, get_Q(), get_x(), and p_system.

◆ get_flux_fn_y()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_flux_fn_y ( const DenseVector< double > & s ) const

inline

Get the flux function in the y direction evaluated for the concentration value stored in this elt.

Parameters

s	The local vector coordinate at which to evaluate

Returns: The flux function vector

Definition at line 243 of file TwoD_TVDLF_Elt.h.

                                                                          {
      DenseVector<double> g(p_system -> get_order(), 0.0);
      p_system -> flux_fn_y(get_x(s), get_Q(s), g);
      return g;
    }

References get_Q(), get_x(), and p_system.

◆ get_int_Q()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_int_Q	(	const DenseVector< double > &	sw,
		const DenseVector< double > &	ne
	)		const

inline

Get the integral of Q over a sub-element.

Parameters

sw	A vector containing the SW local coordinates
ne	A vector containing the NE local coordinates

Returns: The integral of the concentration over the local range

Definition at line 348 of file TwoD_TVDLF_Elt.h.

                                                                                                                             {
    const double sub_dx(DX * (s_ne[ 0 ] - s_sw[ 0 ]) / 2);
    const double sub_dy(DY * (s_ne[ 1 ] - s_sw[ 1 ]) / 2);
    return get_Q((s_ne + s_sw) / 2) * sub_dx * sub_dy;
  }

References get_Q().

Referenced by contributed_Q().

◆ get_Jac_flux_fn_x()

DenseMatrix< double > CppNoddy::TwoD_TVDLF_Elt::get_Jac_flux_fn_x ( const DenseVector< double > & s ) const

inline

Get the Jacobian of the x flux function evaluated for the concentration value stored in this elt.

Parameters

s	The local coordinate at which to evaluate

Returns: The Jacobian matrix

Definition at line 253 of file TwoD_TVDLF_Elt.h.

                                                                              {
      DenseMatrix<double> J(p_system -> get_order(), p_system -> get_order(), 0.0);
      p_system -> Jac_flux_fn_x(get_x(s), get_Q(s), J);
      return J;
    }

References get_Q(), get_x(), and p_system.

◆ get_Jac_flux_fn_y()

DenseMatrix< double > CppNoddy::TwoD_TVDLF_Elt::get_Jac_flux_fn_y ( const DenseVector< double > & s ) const

inline

Get the Jacobian of the y flux function evaluated for the concentration value stored in this elt.

Parameters

s	The local coordinate at which to evaluate

Returns: The Jacobian matrix

Definition at line 263 of file TwoD_TVDLF_Elt.h.

                                                                              {
      DenseMatrix<double> J(p_system -> get_order(), p_system -> get_order(), 0.0);
      p_system -> Jac_flux_fn_y(get_x(s), get_Q(s), J);
      return J;
    }

References get_Q(), get_x(), and p_system.

◆ get_max_dt()

double CppNoddy::TwoD_TVDLF_Elt::get_max_dt ( ) const

inline

Get the maximum allowable time step for this element by using information about the size of the element and the maximum wave speed set in the conservative system.

The time step is guranteed to satisfy the CFL < 0.5 constraint in the two principle directions.

Returns: The maximum time step for this element

Definition at line 354 of file TwoD_TVDLF_Elt.h.

                                                 {
    DenseVector<double> c(2, 0.0);
    DenseVector<double> s(2, 0.0);
    p_system -> max_charac_speed(get_x(s), get_Q_mid(), c);
    return std::min(DX / c[ 0 ], DY / c[ 1 ]);
  }

References get_Q_mid(), get_x(), and p_system.

◆ get_ptrs()

TwoD_TVDLF_Elt * CppNoddy::TwoD_TVDLF_Elt::get_ptrs ( const int & index ) const

Return a pointer to an element in the given compass direction.

Parameters

index The appropriate index of the direction 0,1,2,3 for S,E,N,W

Returns: The pointer to the element

Definition at line 68 of file TwoD_TVDLF_Elt.cpp.

                                                                 {
    return p_ELTS[ index ];
  }

◆ get_Q()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_Q ( const DenseVector< double > & s ) const

inline

Get the value of the 'concentration' stored in this element.

Parameters

s	The local coordinate in the elt at which Q is requested

Returns: The concentration value of the elt for each component

Definition at line 319 of file TwoD_TVDLF_Elt.h.

                                                                                     {
    return Q + (SLOPE_X * s[ 0 ] * DX
                + SLOPE_Y * s[ 1 ] * DY) / 2;
  }

Referenced by dump(), get_flux_fn_x(), get_flux_fn_y(), get_int_Q(), get_Jac_flux_fn_x(), get_Jac_flux_fn_y(), get_Q_Taylor_series(), and get_source_fn().

◆ get_Q_mid()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_Q_mid ( ) const

inline

Get the nodal concentration.

Returns: The concentration at the central node

Definition at line 328 of file TwoD_TVDLF_Elt.h.

                                                             {
    return Q;
  }

Referenced by get_max_dt().

◆ get_Q_Taylor_series()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_Q_Taylor_series	(	const DenseVector< double > &	s,
		const double &	dt
	)		const

Get the Taylor series expansion of the concentration for a given time step and local coordinate for this element.

Parameters

s	The local coordinate
dt	The time step

Definition at line 468 of file TwoD_TVDLF_Elt.cpp.

                                                                                                              {
    const DenseVector<double> x(get_x(s));
    // value of Q at the current time point
    DenseVector<double> q(get_Q(s));
    // evaluate the 2nd order Taylor series expansion of Q at the
    // time step of size dt
    //
    // get the RHS from the eqn
    DenseVector<double> r(p_system -> get_order(), 0.0);
    p_system -> source_fn(x, q, r);
    // get the Jacobian of the x-flux fn
    DenseMatrix<double> jac(p_system -> get_order(), p_system -> get_order(), 0.0);
    p_system -> Jac_flux_fn_x(x, q, jac);
    r -= jac.multiply(SLOPE_X);
    // get the Jacobian of the y-flux fn
    p_system -> Jac_flux_fn_y(x, q, jac);
    r -= jac.multiply(SLOPE_Y);
    // add the correction
    q += r * dt;
    // the above should be equivalent to the expression below, but
    // minimises instantiation of Jacobian matrix
    // q += ( get_source_fn( s )
    //   - get_Jac_flux_fn_x( s ).multiply( slope_x )
    //   - get_Jac_flux_fn_y( s ).multiply( slope_y ) ) * dt;
    return q;
  }

References get_Q(), get_x(), CppNoddy::DenseMatrix< _Type >::multiply(), and p_system.

Referenced by contributed_flux_in_south(), contributed_flux_in_west(), contributed_flux_out_east(), contributed_flux_out_north(), and get_source_contribution().

◆ get_s()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_s ( const DenseVector< double > & x ) const

Get the local coordinate that corresponds to a given global coordinate.

If the global coordinate is outside this element, an exception is thrown.

Parameters

x	The global coordinate

Returns: The local coordinate

Definition at line 408 of file TwoD_TVDLF_Elt.cpp.

                                                                              {
#ifdef PARANOID
    if((x[0] < WEST) || (x[0] > WEST + DX) || (x[1] > SOUTH + DY) || (x[1] < SOUTH)) {
      std::string problem;
      problem = " The TwoD_TVDLF_Elt::get_s method has been called for an element \n";
      problem += " whose range does not bracket the given global coordinate.\n";
      throw ExceptionRuntime(problem);
    }
#endif
    DenseVector<double> s(2, 0.0);
    s[0] = -1 + 2 * (x[0] - WEST) / DX;
    s[1] = -1 + 2 * (x[1] - SOUTH) / DY;
    return s;
  }

◆ get_slope_x()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_slope_x ( ) const

inline

The concentration is approximated by a linear function in each element.

The slope of this function in the x-direction is found through this method.

Returns: The value of the 'slope_x' member data

Definition at line 340 of file TwoD_TVDLF_Elt.h.

                                                               {
    return SLOPE_X;
  }

◆ get_slope_y()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_slope_y ( ) const

inline

The concentration is approximated by a linear function in each element.

The slope of this function in the y-direction is found through this method.

Returns: The value of the 'slope_x' member data

Definition at line 344 of file TwoD_TVDLF_Elt.h.

                                                               {
    return SLOPE_Y;
  }

◆ get_source_contribution()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_source_contribution ( const double & dt ) const

Evaluate the contribution to this element by the hyperbolic system's source function over a given time step using a mid-point in time evaluation.

Parameters

dt	The time step over which source function is to be integrated

Returns: The total contribution

Definition at line 495 of file TwoD_TVDLF_Elt.cpp.

                                                                                    {
    const DenseVector<double> s_mid(2, 0.0);
    // evaluate the Taylor series expansion of the unknowns at the
    // mid time displacement point dt/2
    DenseVector<double> q(get_Q_Taylor_series(s_mid, dt / 2));
    DenseVector<double> R(p_system -> get_order(), 0.0);
    // work out the source function for this mid-point in time q value
    p_system -> source_fn(get_x(s_mid), q, R);
    // return the contribution
    return R * dt;
  }

References get_Q_Taylor_series(), get_x(), and p_system.

Referenced by add_flux_contributions().

◆ get_source_fn()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_source_fn ( const DenseVector< double > & s ) const

inline

Get the source function evaluated for the concentration value stored in this elt.

Parameters

s	The local coordinate at which to evaluate

Returns: The source function value

Definition at line 274 of file TwoD_TVDLF_Elt.h.

                                                                          {
      DenseVector<double> r(p_system -> get_order(), 0.0);
      p_system -> source_fn(get_x(s), get_Q(s), r);
      return r;
    }

References get_Q(), get_x(), and p_system.

◆ get_x()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_x ( DenseVector< double > s ) const

Get the global position of a local coordinate in this element.

Parameters

s	The local coordinate

Returns: The global position

Definition at line 423 of file TwoD_TVDLF_Elt.cpp.

                                                                       {
    DenseVector<double> x(2, 0.0);
    x[ 0 ] = WEST + (s[ 0 ] + 1) * DX / 2;
    x[ 1 ] = SOUTH + (s[ 1 ] + 1) * DY / 2;
    return x;
  }

Referenced by contributed_flux_in_south(), contributed_flux_in_west(), contributed_flux_out_east(), contributed_flux_out_north(), get_flux_fn_x(), get_flux_fn_y(), get_Jac_flux_fn_x(), get_Jac_flux_fn_y(), get_max_dt(), get_Q_Taylor_series(), get_source_contribution(), and get_source_fn().

◆ get_x_mid()

DenseVector< double > CppNoddy::TwoD_TVDLF_Elt::get_x_mid ( ) const

Get the global position of a central node in this element.

Returns: The global position of the central node

Definition at line 430 of file TwoD_TVDLF_Elt.cpp.

                                                      {
    DenseVector<double> x(2, 0.0);
    x[ 0 ] = WEST + DX / 2;
    x[ 1 ] = SOUTH + DY / 2;
    return x;
  }

◆ remove_external_face()

void CppNoddy::TwoD_TVDLF_Elt::remove_external_face ( const int & i )

Remove an external face to the stored stl::set.

Parameters

i	The index of the external face 0,1,2,3 for S,E,N,W.

Definition at line 464 of file TwoD_TVDLF_Elt.cpp.

                                                        {
    EXTERNAL_FACES.erase(i);
  }

◆ set_external_flag()

void CppNoddy::TwoD_TVDLF_Elt::set_external_flag ( bool flag )

Set the external flag.

Parameters

flag	is the value to set

Definition at line 448 of file TwoD_TVDLF_Elt.cpp.

                                                  {
    EXTERNAL = flag;
  }

◆ set_ptrs()

void CppNoddy::TwoD_TVDLF_Elt::set_ptrs	(	const int &	index,
		TwoD_TVDLF_Elt *	ptr
	)

Each element stores pointers to any adjacent elements in the four compass directions 0,1,2,3 for S,E,N,W.

Parameters

index	The index of the direction to set the pointer for
ptr	A pointer to the element in the chosen direction

Definition at line 64 of file TwoD_TVDLF_Elt.cpp.

                                                                     {
    p_ELTS[ index ] = ptr;
  }

◆ set_Q_mid()

void CppNoddy::TwoD_TVDLF_Elt::set_Q_mid ( const DenseVector< double > & value )

inline

Set the value of the vector 'concentration' stored in this element.

To second order, this is the value of the concentration at the mid-point of the element.

Parameters

value The vector value to be assigned to the concentration member data Q

Definition at line 324 of file TwoD_TVDLF_Elt.h.

                                                                        {
    Q = value;
  }

◆ set_slope_x()

void CppNoddy::TwoD_TVDLF_Elt::set_slope_x ( const DenseVector< double > & value )

inline

Set the x-slope vector for this element.

Parameters

value The slope vector to be set

Definition at line 332 of file TwoD_TVDLF_Elt.h.

                                                                          {
    SLOPE_X = value;
  }

◆ set_slope_y()

void CppNoddy::TwoD_TVDLF_Elt::set_slope_y ( const DenseVector< double > & value )

inline

Set the y-slope vector for this element.

Parameters

value The slope vector to be set

Definition at line 336 of file TwoD_TVDLF_Elt.h.

                                                                          {
    SLOPE_Y = value;
  }

Member Data Documentation

◆ p_system

TwoD_Hyperbolic_System* CppNoddy::TwoD_TVDLF_Elt::p_system

Definition at line 281 of file TwoD_TVDLF_Elt.h.

Referenced by add_flux_contributions(), contributed_flux_in_south(), contributed_flux_in_west(), contributed_flux_out_east(), contributed_flux_out_north(), contributed_Q(), get_flux_fn_x(), get_flux_fn_y(), get_Jac_flux_fn_x(), get_Jac_flux_fn_y(), get_max_dt(), get_Q_Taylor_series(), get_source_contribution(), get_source_fn(), and TwoD_TVDLF_Elt().

The documentation for this class was generated from the following files:

include/TwoD_TVDLF_Elt.h
src/TwoD_TVDLF_Elt.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TwoD_TVDLF_Elt()

◆ ~TwoD_TVDLF_Elt()

Member Function Documentation

◆ add_contribution()

◆ add_external_face()

◆ add_flux_contributions()

◆ clear_contributions()

◆ contributed_flux_in_south()

◆ contributed_flux_in_west()

◆ contributed_flux_out_east()

◆ contributed_flux_out_north()

◆ contributed_Q()

◆ dump()

◆ face_is_external()

◆ face_is_internal()

◆ get_dA()

◆ get_dx()

◆ get_external_faces()

◆ get_external_flag()

◆ get_flux_fn_x()

◆ get_flux_fn_y()

◆ get_int_Q()

◆ get_Jac_flux_fn_x()

◆ get_Jac_flux_fn_y()

◆ get_max_dt()

◆ get_ptrs()

◆ get_Q()

◆ get_Q_mid()

◆ get_Q_Taylor_series()

◆ get_s()

◆ get_slope_x()

◆ get_slope_y()

◆ get_source_contribution()

◆ get_source_fn()

◆ get_x()

◆ get_x_mid()

◆ remove_external_face()

◆ set_external_flag()

◆ set_ptrs()

◆ set_Q_mid()

◆ set_slope_x()

◆ set_slope_y()

Member Data Documentation

◆ p_system