compute_bounded_volumes.C File Reference

This file contains implementation for computing the volume bounded between two different locations of each face of the surface mesh of a given window. More...

#include "Rocsurf.h"
#include "roccom_devel.h"
#include "Element_accessors.h"
#include "Generic_element_2.h"
#include <math.h>
#include <vector>

Include dependency graph for compute_bounded_volumes.C:

Go to the source code of this file.

Functions
SURF_BEGIN_NAMESPACE void	arrange (Point_3< Real > ps_face[4], Point_3< Real > ps[8], int ind1, int ind2, int ind3, int ind4)
void	arrange (Point_3< Real > ps_face[3], Point_3< Real > ps[8], int ind1, int ind2, int ind3)
Real	get_face_volume (Point_3< Real > ps_face[], int ne)
void	normalize_coor (Point_3< Real > ps_face[], int n, int k)

Detailed Description

This file contains implementation for computing the volume bounded between two different locations of each face of the surface mesh of a given window.

Typically, the two locations of the surface correspond to the surface at two different snapshots of a simulation.

Definition in file compute_bounded_volumes.C.

Function Documentation

SURF_BEGIN_NAMESPACE void arrange	(	Point_3< Real >	ps_face[4],
		Point_3< Real >	ps[8],
		int	ind1,
		int	ind2,
		int	ind3,
		int	ind4
	)

Definition at line 44 of file compute_bounded_volumes.C.

Referenced by Rocsurf::compute_bounded_volumes(), and Rocsurf::compute_swept_volumes().

                                {
  ps_face[0] = ps[ind1];
  ps_face[1] = ps[ind2];
  ps_face[2] = ps[ind3];
  ps_face[3] = ps[ind4];
}

Here is the caller graph for this function:

void arrange	(	Point_3< Real >	ps_face[3],
		Point_3< Real >	ps[8],
		int	ind1,
		int	ind2,
		int	ind3
	)

Definition at line 56 of file compute_bounded_volumes.C.

                                {
  ps_face[0] = ps[ind1];
  ps_face[1] = ps[ind2];
  ps_face[2] = ps[ind3];
}

Real get_face_volume	(	Point_3< Real >	ps_face[],
		int	ne
	)

Definition at line 67 of file compute_bounded_volumes.C.

References Vector_3< Type >::cross_product(), Generic_element_2::get_gp_nat_coor(), Generic_element_2::get_gp_weight(), Generic_element_2::get_num_gp(), Generic_element_2::interpolate(), Generic_element_2::Jacobian(), k, n, volume(), and x.

Referenced by Rocsurf::compute_bounded_volumes(), Rocsurf::compute_signed_volumes(), and Rocsurf::compute_swept_volumes().

                                                       {

  Generic_element_2    e(ne);
  Vector_2<Real>       nc(0,0);
  Vector_3<Real>       J[2];
  int order = 1;

  int size = e.get_num_gp(order);
  Real volume = 0;
  for (int k = 0; k<size; k++){
    Real weight = e.get_gp_weight( k, order);
    e.get_gp_nat_coor(k, nc, order);

    Point_3<Real> x;
    e.interpolate(ps_face,nc,&x);

    e.Jacobian( ps_face,nc,J);
    // Get the normal to the face
    Vector_3<Real> n = Vector_3<Real>::cross_product(J[0],J[1]);

    Real t =  weight * (n*(Vector_3<Real>&)x);
    
    // compute the volume, and add to running total
    volume += t;
  }
  return volume;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void normalize_coor	(	Point_3< Real >	ps_face[],
		int	n,
		int	k
	)

Definition at line 95 of file compute_bounded_volumes.C.

References i, k, and n.

Referenced by Rocsurf::compute_bounded_volumes(), and Rocsurf::compute_swept_volumes().

                                                            {
  Vector_3<Real> c(0,0,0);

  for ( int i=0; i<n; ++i) {
    c += (Vector_3<Real>&)ps_face[i]; 
  }
  c /= k;
  
  for ( int i=0; i<n; ++i) {
    ps_face[i] -= c; 
  }
}

Here is the caller graph for this function: