Transfer_base Class Reference

#include <Transfer_base.h>

Inheritance diagram for Transfer_base:

Collaboration diagram for Transfer_base:

Public Types
typedef Element_node_enumerator	ENE
typedef Field< Nodal_data, ENE >	Element_var
typedef Field< const Nodal_data_const, ENE >	Element_var_const
typedef Field< const Nodal_coor_const, ENE >	Element_coor_const
typedef Transfer_base	Self
typedef std::vector < RFC_Pane_transfer * > ::iterator	Pane_iterator
typedef std::vector < RFC_Pane_transfer * > ::const_iterator	Pane_iterator_const
typedef std::vector< const RFC_Pane_transfer * > ::const_iterator	Pane_const_iterator

Public Member Functions
	Transfer_base (RFC_Window_transfer *s, RFC_Window_transfer *t)
template<class _SDF >
void	transfer_2f (const _SDF &sDF, Facial_data &tDF, const Real alpha, int doa, bool verb)
	template function for transfering from nodes/faces to faces. More...
template<class _SDF >
void	transfer_2n (const _SDF &sDF, Nodal_data &tDF, const Real alpha, Real *tol, int *iter, int doa, bool verb)
	template function for transfering from nodes/faces to nodes. More...
template<class _SDF >
void	interpolate_fe (const _SDF &sDF, Nodal_data &tDF, bool verb)
	Perform finite-element interpolation (non-conservative), assuming source data has been replicated. More...
template<class _SDF >
void	loadtransfer (const _SDF &vS, Nodal_data &vT, const Real alpha, const int order, bool verb)
	Computes the load vector. More...
void	minmax (const RFC_Window_transfer &win, const Facial_data_const &sDF, Array_n &min_v, Array_n &max_v)
void	minmax (const RFC_Window_transfer &win, const Nodal_data_const &sDF, Array_n &min_v, Array_n &max_v)
void	integrate (const RFC_Window_transfer &win, const Nodal_data_const &sDF, Array_n &intergral, const int doa)
void	integrate (const RFC_Window_transfer &win, const Facial_data_const &sDF, Array_n &intergral, const int doa)
bool	isfinite (Real x)
template<class _Data >
RFC_BEGIN_NAME_SPACE void	integrate_subface (const RFC_Pane_transfer *p_src, RFC_Pane_transfer *p_trg, const _Data &data_s, ENE &ene_src, ENE &ene_trg, int sfid_src, int sfid_trg, const Real alpha, Facial_data &tDF, Facial_data &tBF, int doa)
template<class _SDF >
RFC_BEGIN_NAME_SPACE void	interpolate_fe (const _SDF &sDF, Nodal_data &tDF, bool verbose)

Protected Member Functions
template<class _SDF >
void	integrate_subface (const RFC_Pane_transfer *p_src, RFC_Pane_transfer *p_trg, const _SDF &sDF, ENE &ene_src, ENE &ene_trg, int sfid_src, int sfid_trg, const Real alpha, Facial_data &tDF, Facial_data &tBF, int doa)
template<class _SDF >
void	init_load_vector (const _SDF &vS, const Real alpha, Nodal_data &ld, Nodal_data &diag, int doa, bool lump)
	Initialize load vector and the diagonal of the mass matrix. More...
int	pcg (Nodal_data &x, Nodal_data &b, Nodal_data &p, Nodal_data &q, Nodal_data &r, Nodal_data &s, Nodal_data &z, Nodal_data &di, Real *tol, int *max_iter)
void	precondition_Jacobi (const Nodal_data_const &rhs, const Nodal_data_const &diag, Nodal_data &x)
	Diagonal (Jacobi) preconditioner. More...
void	multiply_mass_mat_and_x (const Nodal_data_const &x, Nodal_data &y)
Real	square (const Array_n_const &x) const
Real	norm2 (const Nodal_data_const &x) const
Real	dot (const Nodal_data_const &x, const Nodal_data_const &y) const
void	dot2 (const Nodal_data_const &x1, const Nodal_data_const &y1, const Nodal_data_const &x2, const Nodal_data_const &y2, Array_n prod) const
void	scale (const Real &a, Nodal_data &x)
void	invert (Nodal_data &x)
void	copy_vec (const Nodal_data_const &x, Nodal_data &y)
void	saxpy (const Real &a, const Nodal_data_const &x, const Real &b, Nodal_data &y)
template<class _SDF >
void	compute_load_vector_wra (const RFC_Pane_transfer *p_src, RFC_Pane_transfer *p_dst, const _SDF &sDF, ENE &ene_src, ENE &ene_trg, int sfid_src, int sfid_trg, const Real alpha, Nodal_data &rhs, Nodal_data &diag, int doa, bool lump)
	Computes the element-wise load vector, and also computes mass matrix if diag has a nonnegative ID. More...
template<class _Data , class _Points , class _Loads , class Tag >
void	element_load_vector (const _Data &data_s, const Generic_element &e_s, const Generic_element &e_t, const _Points &pnts_s, const _Points &pnts_t, const Point_2 *ncs_s, const Point_2 *ncs_t, const Real alpha, const int sne, const Tag &tag, _Loads loads, _Loads diag, Real *emm, int doa, bool lump)
	Computes the element-wise load vector, and also computes mass matrix if emm is not NULL. More...
template<class _Data >
void	compute_load_prime (const Generic_element &e_s, const _Data &data_s, const Vector_3 *grads_s, Vector_3 *load_prime, Tag_nodal)
template<class _Data >
void	compute_load_prime (const Generic_element &e_s, const _Data &data_s, const Vector_3 *grads_s, Vector_3 *load_prime, Tag_facial)

Protected Attributes
RFC_Window_transfer &	src
RFC_Window_transfer &	trg
int	sc

Private Member Functions
template<class _Value >
void	interpolate (const Generic_element &e, const Element_var_const values, const Generic_element::Nat_coor &nc, _Value &v)
template<class _Value >
void	interpolate (const Generic_element &e, const Array_n_const value, const Generic_element::Nat_coor &nc, _Value &v)
const RFC_Pane_transfer *	get_src_pane (int i)
RFC_Pane_transfer *	get_trg_pane (int i)
Element_var_const	make_field (const Nodal_data_const &d, const RFC_Pane_transfer *pn, const ENE &ene)
	Construct a element-wise accessor from nodal data and pointers. More...
Element_var	make_field (Nodal_data &d, RFC_Pane_transfer *pn, const ENE &ene)
Element_var_const	make_field (const Nodal_data_const &d, const RFC_Pane_transfer *pn, int)
const Array_n_const	make_field (const Facial_data_const &d, const RFC_Pane_transfer *pn, const ENE &ene)
const Array_n_const	make_field (const Facial_data_const &d, const RFC_Pane_transfer *pn, int i)
bool	is_nodal (Tag_nodal) const
bool	is_nodal (Tag_facial) const
bool	is_nodal (const Element_var_const &) const
bool	is_nodal (const Element_var &) const
bool	is_nodal (const Array_n_const &) const

Private Attributes
const RFC_Pane_transfer *	_src_pane
RFC_Pane_transfer *	_trg_pane
std::vector< const RFC_Pane_transfer * >	src_ps
std::vector< RFC_Pane_transfer * >	trg_ps

Detailed Description

Definition at line 45 of file Transfer_base.h.

Member Typedef Documentation

typedef Field< const Nodal_coor_const, ENE> Element_coor_const

Definition at line 51 of file Transfer_base.h.

typedef Field< Nodal_data, ENE> Element_var

Definition at line 49 of file Transfer_base.h.

typedef Field< const Nodal_data_const, ENE> Element_var_const

Definition at line 50 of file Transfer_base.h.

typedef Element_node_enumerator ENE

Definition at line 47 of file Transfer_base.h.

typedef std::vector<const RFC_Pane_transfer*>::const_iterator Pane_const_iterator

Definition at line 57 of file Transfer_base.h.

typedef std::vector<RFC_Pane_transfer*>::iterator Pane_iterator

Definition at line 54 of file Transfer_base.h.

typedef std::vector<RFC_Pane_transfer*>::const_iterator Pane_iterator_const

Definition at line 55 of file Transfer_base.h.

typedef Transfer_base Self

Definition at line 53 of file Transfer_base.h.

Constructor & Destructor Documentation

Transfer_base ( RFC_Window_transfer *  s, RFC_Window_transfer *  t  )

inline

Definition at line 59 of file Transfer_base.h.

References RFC_Window_derived< _Pane >::panes(), src, src_ps, trg, and trg_ps.

    : src( *s), trg( *t), sc( s->color()), _src_pane(NULL), _trg_pane(NULL)
  { src.panes( src_ps); trg.panes( trg_ps); }

Here is the call graph for this function:

Member Function Documentation

void compute_load_prime ( const Generic_element &  e_s, const _Data &  data_s, const Vector_3 *  grads_s, Vector_3 *  load_prime, Tag_nodal    )

inlineprotected

Definition at line 215 of file Transfer_base.h.

References j, k, and NULL_VECTOR.

Referenced by element_load_vector().

                                                             {
    Vector_3 NULL_VECTOR(0,0,0);
    for ( unsigned int k=0; k<data_s.dimension(); ++k) {
      load_prime[k] = NULL_VECTOR;
      for ( unsigned int j=0; j<e_s.size_of_nodes(); ++j) {
        load_prime[k] += data_s[j][k] * grads_s[j];
      }
    }
  }

Here is the caller graph for this function:

void compute_load_prime ( const Generic_element &  e_s, const _Data &  data_s, const Vector_3 *  grads_s, Vector_3 *  load_prime, Tag_facial    )

inlineprotected

Definition at line 228 of file Transfer_base.h.

References k, and NULL_VECTOR.

                                                              {
    Vector_3 NULL_VECTOR(0,0,0);
    for ( unsigned int k=0; k<data_s.dimension(); ++k) {
      load_prime[k] = NULL_VECTOR;
    }
  }

void compute_load_vector_wra ( const RFC_Pane_transfer *  p_src, RFC_Pane_transfer *  p_dst, const _SDF &  sDF, ENE &  ene_src, ENE &  ene_trg, int  sfid_src, int  sfid_trg, const Real  alpha, Nodal_data &  rhs, Nodal_data &  diag, int  doa, bool  lump  )

protected

Computes the element-wise load vector, and also computes mass matrix if diag has a nonnegative ID.

The mass matrix will be lumped if lump is true

Definition at line 292 of file Transfer_2n.C.

References RFC_Pane_transfer::coordinates(), RFC_Data_const< _Tag >::dimension(), element_load_vector(), RFC_Pane_transfer::get_emm(), RFC_Pane_base::get_nat_coor_in_element(), i, Element_node_enumerator::id(), make_field(), Element_node_enumerator::size_of_edges(), and Element_node_enumerator::size_of_nodes().

Referenced by init_load_vector().

{
  // Construct generic elements in parent source and target elements
  Generic_element e_src( ene_src.size_of_edges(), ene_src.size_of_nodes());
  Generic_element e_trg( ene_trg.size_of_edges(), ene_trg.size_of_nodes());

  // Obtain the local coordinates in source and target elements
  Point_2 ncs_src[3], ncs_trg[3];
  for ( int i=0; i<3; ++i) {
    p_src->get_nat_coor_in_element( sfid_src, i, ncs_src[i]);
    p_trg->get_nat_coor_in_element( sfid_trg, i, ncs_trg[i]);
  }

  // Construct enumerators for nodal vertices in source and target elements
  Nodal_coor_const nc;
  Element_coor_const pnts_s( nc, p_src->coordinates(), ene_src);
  Element_coor_const pnts_t( nc, p_trg->coordinates(), ene_trg);

  // Initialize pointer to element mass matrix. If a lumped mass matrix
  // is desired, then use a local buffer to store the element matrix.
  Real *pemm=NULL;

  bool needs_diag = diag.dimension()>0;
  // Compute the element mass matrix only needs_diag is true.
  if ( needs_diag)
    pemm = lump ? (Real*)NULL : p_trg->get_emm( ene_trg.id());
  
  // Invoke the implementation to compute load vector and mass matrix.
  element_load_vector( make_field( sDF, p_src, ene_src), 
                       e_src, e_trg, pnts_s, pnts_t, ncs_src, ncs_trg, 
                       alpha, 3, sDF.tag(),
                       make_field( rhs, p_trg, ene_trg), 
                       make_field( diag, p_trg, ene_trg),
                       pemm, doa, lump);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void copy_vec ( const Nodal_data_const &  x, Nodal_data &  y  )

protected

Definition at line 248 of file Transfer_base.C.

References RFC_Data_const< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), RFC_Data< _Tag >::set_value(), and trg_ps.

Referenced by pcg(), and precondition_Jacobi().

                                                                {
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    Real *px = (*pit)->pointer( x.id());
    Real *py = (*pit)->pointer( y.id());

    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_nodes(); i<=size; ++i)
      y.set_value( py, i, x.get_value( px, i));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Real dot ( const Nodal_data_const &  x, const Nodal_data_const &  y  ) const

protected

Definition at line 171 of file Transfer_base.C.

References RFC_Window_transfer::allreduce(), RFC_Data_const< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), MPI_SUM, trg, and trg_ps.

                                                     {
  Real prod(0);
  
  for ( Pane_iterator_const pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    const Real *px = (*pit)->pointer( x.id());
    const Real *py = (*pit)->pointer( y.id());
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_nodes(); i<=size; ++i)
      if ( (*pit)->is_primary_node( i))
        prod += x.get_value( px, i) * y.get_value( py, i);
  }
  
  trg.allreduce( &prod, MPI_SUM);
  return prod;
}

Here is the call graph for this function:

void dot2 ( const Nodal_data_const &  x1, const Nodal_data_const &  y1, const Nodal_data_const &  x2, const Nodal_data_const &  y2, Array_n  prod  ) const

protected

Definition at line 190 of file Transfer_base.C.

References RFC_Window_transfer::allreduce(), RFC_Data_const< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), MPI_SUM, trg, and trg_ps.

Referenced by pcg().

                                          {
  prods[0] = prods[1] = 0;
  for ( Pane_iterator_const pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    const Real *px1 = (*pit)->pointer( x1.id());
    const Real *py1 = (*pit)->pointer( y1.id());
    const Real *px2 = (*pit)->pointer( x2.id());
    const Real *py2 = (*pit)->pointer( y2.id());
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_nodes(); i<=size; ++i)
      if ( (*pit)->is_primary_node( i)) {
        prods[0] += x1.get_value( px1, i) * y1.get_value( py1, i);
        prods[1] += x2.get_value( px2, i) * y2.get_value( py2, i);
      }
  }
  
  trg.allreduce( prods, MPI_SUM);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void element_load_vector ( const _Data &  data_s, const Generic_element &  e_s, const Generic_element &  e_t, const _Points &  pnts_s, const _Points &  pnts_t, const Point_2 *  ncs_s, const Point_2 *  ncs_t, const Real  alpha, const int  sne, const Tag &  tag, _Loads  loads, _Loads  diag, Real *  emm, int  doa, bool  lump  )

protected

Computes the element-wise load vector, and also computes mass matrix if emm is not NULL.

Note that loads and mass matrix are added to the arrays.

Definition at line 139 of file Transfer_2n.C.

References compute_load_prime(), copy, Array_n::dimension(), i, interpolate(), is_nodal(), j, k, max(), min(), n, ni, NULL_VECTOR, and v.

Referenced by compute_load_vector_wra().

{
  const unsigned int n = e_t.size_of_nodes();

  Generic_element sub_e( sne);
  Vector_n vt(data_s.dimension(), 0); Array_n v( vt.begin(), vt.end());

  // Interpolate the coordinates.
  Point_3 ps_s[Generic_element::MAX_SIZE];
  Point_3 ps_t[Generic_element::MAX_SIZE];
  for ( int i=0; i<sne; ++i) e_t.interpolate( pnts_t, ncs_t[i], &ps_t[i]);
  if ( alpha!=1.)
    for ( int i=0; i<sne; ++i) e_s.interpolate( pnts_s, ncs_s[i], &ps_s[i]);

  // Set the default degree of accuracy for the quadrature rules.
  if ( is_nodal( data_s)) 
  { if ( doa == 0) doa = std::max(e_t.order(), e_s.order())==1? 2 : 4; }
  else doa=1;

  // Create a local buffer for element-mass-matrix. Note that only
  // lower triangle matrix is computed, as emm is symmetric.
  Real emm[Generic_element::MAX_SIZE*Generic_element::MAX_SIZE];
  bool compute_mass = diag.dimension()>0;
  if ( compute_mass) std::fill(emm, emm+n*n, 0.);

#ifdef SOBOLEV
  // Evaluate the gradient as well for Sobolev minimization
  std::vector<Real> esf(n*n,0.);
  std::vector<Vector_n> l_t(n,Vector_n(data_s.dimension(),0));
#endif

  Point_2 sub_nc, nc_s, nc_t;
  Real N[Generic_element::MAX_SIZE];
  // Loop through the quadrature points of the subelement
  for ( int i=0, ni=sub_e.get_num_gp(doa); i < ni; ++i) {
    sub_e.get_gp_nat_coor( i, sub_nc, doa);
    sub_e.interpolate( ncs_s, sub_nc, &nc_s);

    // Interploate to the quadrature point
    interpolate( e_s, data_s, nc_s, v);

    // Compute area of subelement in target element
    Real a_t=sub_e.get_gp_weight(i, doa), a_s=a_t;
    a_t *= sub_e.Jacobian_det( ps_t, sub_nc);

    // Compute area of subelement in source element. Use target area if alpha=1
    if ( alpha!=1.) a_s *= sub_e.Jacobian_det( ps_s, sub_nc);
    else a_s = a_t;

    v *= a_s;
    sub_e.interpolate( ncs_t, sub_nc, &nc_t);
    e_t.shape_func( nc_t, N);

#if SOBOLEV
    Vector_3 grads_t[Generic_element::MAX_SIZE];
    e_t.gradients( pnts_t, nc_t, grads_t);

    std::vector<Vector_3> load_prime( data_s.dimension(), NULL_VECTOR);

    Vector_3 grads_s[Generic_element::MAX_SIZE];
    if ( alpha!=1)
      e_s.gradients( pnts_s, nc_s, grads_s);
    else
      std::copy(grads_t,grads_t+n, grads_s);
    compute_load_prime( e_s, data_s, grads_s, &load_prime[0], tag);
#endif

    for ( unsigned int j=0; j<n; ++j) {
      loads[j] += N[j] * v;
      if ( compute_mass) {
        for ( unsigned int k=0; k<=j; ++k)
          emm[j*n+k] += N[j]*N[k]*a_t;
      }
#if SOBOLEV
      for ( unsigned int k=0; k<data_s.dimension(); ++k)
        l_t[j][k] += grads_t[j]*load_prime[k]*area;

      if ( !lump && compute_mass) {
        for ( unsigned int k=0; k<=j; ++k) { 
          // Weigh esf by the stretch ratio.
          esf[j*n+k] += grads_t[j]*grads_t[k]*area;
        }
      }
#endif
    }
  }

#if SOBOLEV
  Real mu=-1;
  if ( mu<0 && !lump && compute_mass) {
    Real t1=0, t2=0;
    // Evaluate mu
    for ( unsigned int j=0; j<n; ++j) {
      for ( unsigned int k=0; k<j; ++k) {
        t1 += emm[j*n+k]*esf[j*n+k]; t2 += esf[j*n+k]*esf[j*n+k];
      }
    }
    mu = -t1 / t2;
  }

  if ( mu > 0) {
    // Add the stiffness to the mass matrix.
    for ( unsigned int j=0; j<n; ++j) {
      loads[j] += mu * l_t[j];

      if ( emm_out) {
        for ( unsigned int k=0; k<=j; ++k) { 
          emm[j*n+k] += mu*esf[j*n+k];
        }
      }
    }
  }
#endif

  // Add emm onto emm_out and/or diag. Note that emm only saves lower triangle
  if ( compute_mass) {
    for ( unsigned int j=0; j<n; ++j) {
      // Update the diagonal 
      if ( lump) {
        // Lump the mass matrix 
        for ( unsigned int k=0; k<n; ++k) 
          diag[j][0] += emm[std::max(j,k)*n+std::min(j,k)]; 
      }
      else // Otherwise, add only the diagonal entries
        diag[j][0] += emm[j*n+j];
    }
    
    // Update the element mass matrix. Adding lower triangle to the 
    // diagonal and upper triangle as well.
    if ( emm_out) {
      for ( unsigned int j=0; j<n; ++j) 
        for ( unsigned int k=0; k<n; ++k)
          emm_out[j*n+k] += emm[std::max(j,k)*n+std::min(j,k)];
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const RFC_Pane_transfer* get_src_pane ( int  i )

inlineprivate

Definition at line 295 of file Transfer_base.h.

References _src_pane, RFC_Pane_base::id(), RFC_Window_transfer::pane(), and src.

Referenced by init_load_vector(), interpolate_fe(), and transfer_2f().

                                                {
    if ( !_src_pane || _src_pane->id()) 
      _src_pane = &src.pane(i);
    return _src_pane;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

RFC_Pane_transfer* get_trg_pane ( int  i )

inlineprivate

Definition at line 300 of file Transfer_base.h.

References _trg_pane, RFC_Pane_base::id(), RFC_Window_transfer::pane(), and trg.

                                           {
    if ( !_trg_pane || _trg_pane->id()) 
      _trg_pane = &trg.pane(i);
    return _trg_pane;
  }

Here is the call graph for this function:

void init_load_vector ( const _SDF &  vS, const Real  alpha, Nodal_data &  ld, Nodal_data &  diag, int  doa, bool  lump  )

protected

Initialize load vector and the diagonal of the mass matrix.

Parameters

vS	Souce data
alpha	Parameter to control interpolation of coordinates between input meshes
ld	Load vector
diag	Diagonal of corresponding mass matrix.
doa	Degree of accuracy for quadrature rule to be used
lump	Indicates whether to compute lump mass matrix for faster estimation of solution.

Definition at line 341 of file Transfer_2n.C.

References compute_load_vector_wra(), RFC_Data_const< _Tag >::dimension(), Face_ID::face_id, RFC_Pane_base::get_host_element_of_subface(), get_src_pane(), i, Element_node_enumerator::id(), RFC_Pane_base::id(), RFC_Data_const< _Tag >::id(), MPI_SUM, Face_ID::pane_id, RFC_Window_transfer::reduce_to_all(), trg, and trg_ps.

Referenced by loadtransfer(), and transfer_2n().

{
  bool needs_diag = diag.dimension()>0;

  // First, initialize the entries of the target mesh to zero.
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    Real *p = (*pit)->pointer( rhs.id());
    std::fill( p, p+(*pit)->size_of_nodes()*rhs.dimension(), Real(0));

    if ( needs_diag) {
      p = (*pit)->pointer( diag.id());
      std::fill( p, p+(*pit)->size_of_nodes()*diag.dimension(), Real(0));
    }
  }
                 
  // Second, compute the integral over the target meshes by looping through
  //         the subfaces of the target window
  ENE   ene_src, ene_trg; 
  const RFC_Pane_transfer *p_src = NULL;
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    // Loop through the subfaces of the target window
    for ( int i=1, size=(*pit)->size_of_subfaces(); i<=size; ++i) {
      (*pit)->get_host_element_of_subface( i, ene_trg);
      if ( !(*pit)->need_recv( ene_trg.id())) continue;

      const Face_ID &fid = (*pit)->get_subface_counterpart(i);
      if ( !p_src || p_src->id()!=fid.pane_id) 
        p_src = get_src_pane( fid.pane_id);
      p_src->get_host_element_of_subface( fid.face_id, ene_src);

      compute_load_vector_wra( p_src, *pit, sDF, ene_src, ene_trg, 
                               fid.face_id, i, alpha, rhs, diag, doa, lump);
    }
  }

  trg.reduce_to_all( rhs, MPI_SUM);
  if ( needs_diag) trg.reduce_to_all( diag, MPI_SUM);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void integrate	(	const RFC_Window_transfer &	win,
		const Nodal_data_const &	sDF,
		Array_n &	intergral,
		const int	doa
	)

Definition at line 372 of file Transfer_base.C.

References RFC_Window_transfer::allreduce(), RFC_Data_const< _Tag >::dimension(), i, interpolate(), make_field(), MPI_SUM, n, and RFC_Window_derived< _Pane >::panes().

                                         {
  integral = Vector_n( sDF.dimension(), 0);

  std::vector<const RFC_Pane_transfer*> ps;
  win.panes( ps);
  
  Vector_n vt(sDF.dimension(), 0); Array_n t( vt.begin(), vt.end());

  Point_2 nc; 
  for (std::vector<const RFC_Pane_transfer*>::iterator 
         pit=ps.begin(); pit!=ps.end(); ++pit) {
    ENE ene( (*pit)->base(), 1);
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_faces(); i<=size; ++i, ene.next()) {
      Generic_element e( ene.size_of_edges(), ene.size_of_nodes());

      Nodal_coor_const coors;
      Element_coor_const  pnts( coors, (*pit)->coordinates(), ene);

      for ( int i=0, n = e.get_num_gp(doa); i<n; ++i) {
        e.get_gp_nat_coor( i, nc, doa);
        
        interpolate( e, make_field( sDF, *pit, ene), nc, t);
        Real a=e.get_gp_weight(i, doa) * e.Jacobian_det( pnts, nc);
        t *= a;
        integral += t;
      }
    }
  }

  // Perform global reduction
  win.allreduce( integral, MPI_SUM);
}

Here is the call graph for this function:

void integrate	(	const RFC_Window_transfer &	win,
		const Facial_data_const &	sDF,
		Array_n &	intergral,
		const int	doa
	)

Definition at line 333 of file Transfer_base.C.

References RFC_Window_transfer::allreduce(), RFC_Data_const< _Tag >::dimension(), i, make_field(), MPI_SUM, n, and RFC_Window_derived< _Pane >::panes().

                                         {
  integral = Vector_n( sDF.dimension(), 0);

  std::vector<const RFC_Pane_transfer*> ps;
  win.panes( ps);
  
  Vector_n vt(sDF.dimension(), 0); Array_n t( vt.begin(), vt.end());

  Point_2 nc; 
  for (std::vector<const RFC_Pane_transfer*>::iterator 
         pit=ps.begin(); pit!=ps.end(); ++pit) {
    ENE ene( (*pit)->base(), 1);
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_faces(); i<=size; ++i, ene.next()) {
      Generic_element e( ene.size_of_edges(), ene.size_of_nodes());

      Nodal_coor_const coors;
      Element_coor_const  pnts( coors, (*pit)->coordinates(), ene);

      for ( int i=0, n = e.get_num_gp(doa); i<n; ++i) {
        e.get_gp_nat_coor( i, nc, doa);
        
        t = make_field( sDF, *pit, ene);
        Real a=e.get_gp_weight(i, doa) * e.Jacobian_det( pnts, nc);
        t *= a;
        integral += t;
      }
    }
  }

  // Perform global reduction
  win.allreduce( integral, MPI_SUM);
}

Here is the call graph for this function:

RFC_BEGIN_NAME_SPACE void integrate_subface	(	const RFC_Pane_transfer *	p_src,
		RFC_Pane_transfer *	p_trg,
		const _Data &	data_s,
		ENE &	ene_src,
		ENE &	ene_trg,
		int	sfid_src,
		int	sfid_trg,
		const Real	alpha,
		Facial_data &	tDF,
		Facial_data &	tBF,
		int	doa
	)

Definition at line 43 of file Transfer_2f.C.

References RFC_Pane_transfer::coordinates(), RFC_Pane_base::get_nat_coor_in_element(), RFC_Data< _Tag >::get_value(), i, Element_node_enumerator::id(), interpolate(), is_nodal(), n, Element_node_enumerator::pane(), QUIET_NAN, Element_node_enumerator::size_of_edges(), Element_node_enumerator::size_of_nodes(), and v.

{
  // Initialize natural cooredinates of the subnodes of the subface in its
  // parent source and target faces. Compute ncs_s only if alpha!=1. 
  Point_3 ps_s[Generic_element::MAX_SIZE], ps_t[Generic_element::MAX_SIZE];
  Point_2 ncs_s[Generic_element::MAX_SIZE], ncs_t[Generic_element::MAX_SIZE];

  Generic_element e_s(ene_src.pane()?ene_src.size_of_edges():3, 
                      ene_src.pane()?ene_src.size_of_nodes():3);

  // Initialize physical and natural coordinates for source element
  if ( is_nodal(data_s) || alpha!=1) {
    for ( int i=0; i<3; ++i)
      p_src->get_nat_coor_in_element( sfid_src, i, ncs_s[i]);

    if ( alpha!=1.) {
      Nodal_coor_const nc;
      Element_coor_const  pnts_s( nc, p_src->coordinates(), ene_src);
  
      for ( int i=0; i<3; ++i) e_s.interpolate( pnts_s, ncs_s[i], &ps_s[i]);
    }
  }
  else {
    std::fill_n( &ncs_s[0][0], 6, QUIET_NAN);
    std::fill_n( &ps_s[0][0], Generic_element::MAX_SIZE*3, QUIET_NAN);
  }

  {  // Initialize physical and natural coordinates for target element
    for ( int i=0; i<3; ++i)
      p_trg->get_nat_coor_in_element( sfid_trg, i, ncs_t[i]);

    Nodal_coor_const nc;
    Generic_element e_t( ene_trg.size_of_edges(), ene_trg.size_of_nodes());
    Element_coor_const  pnts_t( nc, p_trg->coordinates(), ene_trg);

    for ( int i=0; i<3; ++i) e_t.interpolate( pnts_t, ncs_t[i], &ps_t[i]);
  }

  // Loop throught the quadrature points of the subfacet.
  Vector_n vt(data_s.dimension(), 0); 
  Array_n  t( vt.begin(), vt.end()), v=tDF.get_value( p_trg, ene_trg.id());
  Real     &area = tBF.get_value( p_trg, ene_trg.id())[0];

  Generic_element sub_e( 3);
  Point_2 sub_nc, nc_s; 
  
  if ( is_nodal( data_s)) {
    if ( doa == 0) doa = 2; // Set the default degree of accuracy
  }
  else 
    doa=1;

  for ( int i=0, n = sub_e.get_num_gp(doa); i<n; ++i) {
    sub_e.get_gp_nat_coor( i, sub_nc, doa);

    if ( is_nodal( data_s)) 
      sub_e.interpolate( ncs_s, sub_nc, &nc_s);

    interpolate( e_s, data_s, nc_s, t);

    Real a=sub_e.get_gp_weight(i, doa);
    a *= sub_e.Jacobian_det( ps_s, ps_t, alpha, sub_nc);

    t *= a;
    v += t;
    area += a;
  }
}

Here is the call graph for this function:

void integrate_subface ( const RFC_Pane_transfer *  p_src, RFC_Pane_transfer *  p_trg, const _SDF &  sDF, ENE &  ene_src, ENE &  ene_trg, int  sfid_src, int  sfid_trg, const Real  alpha, Facial_data &  tDF, Facial_data &  tBF, int  doa  )

protected

Referenced by transfer_2f().

Here is the caller graph for this function:

void interpolate ( const Generic_element &  e, const Element_var_const  values, const Generic_element::Nat_coor &  nc, _Value &  v  )

inlineprivate

Definition at line 266 of file Transfer_base.h.

Referenced by element_load_vector(), integrate(), integrate_subface(), and interpolate_fe().

  { e.interpolate( values, nc, &v); }

Here is the caller graph for this function:

void interpolate ( const Generic_element &  e, const Array_n_const  value, const Generic_element::Nat_coor &  nc, _Value &  v  )

inlineprivate

Definition at line 274 of file Transfer_base.h.

  { v = value; }

RFC_BEGIN_NAME_SPACE void interpolate_fe	(	const _SDF &	sDF,
		Nodal_data &	tDF,
		bool	verbose
	)

Definition at line 39 of file Transfer_2n.C.

References RFC_Window_transfer::barrier(), RFC_Pane_base::base(), RFC_Data_const< _Tag >::dimension(), RFC_Pane_base::get_host_element_of_subnode(), RFC_Pane_base::get_parent_node(), get_src_pane(), RFC_Pane_base::get_subnode_counterpart(), RFC_Data< _Tag >::get_value(), get_wtime(), i, RFC_Pane_base::id(), RFC_Data_const< _Tag >::id(), interpolate(), is_nodal(), RFC_Pane_base::is_quadratic(), RFC_Window_transfer::is_root(), k, make_field(), n, RFC_Pane_transfer::need_recv(), Node_ID::node_id, Node_ID::pane_id, RFC_Pane_base::parent_type_of_subnode(), PARENT_VERTEX, RFC_Pane_transfer::pointer(), RFC_Window_transfer::reduce_maxabs_to_all(), Element_node_enumerator::size_of_edges(), RFC_Pane_base::size_of_faces(), RFC_Pane_base::size_of_isolated_nodes(), Element_node_enumerator::size_of_nodes(), RFC_Pane_base::size_of_nodes(), RFC_Pane_base::size_of_subnodes(), trg, trg_ps, and v.

{
  double t0=0.;
  if ( verbose) {
    trg.barrier(); t0=get_wtime();
  }

  std::vector<bool> flags;
  // Loop through all the panes of target window
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    RFC_Pane_transfer *p_trg = *pit;
    Real *p = p_trg->pointer( tDF.id());
    std::fill( p, p+p_trg->size_of_nodes()*tDF.dimension(), Real(0));
    flags.clear(); flags.resize(p_trg->size_of_nodes()+1, false);

    // Loop through the faces to mark the ones that expect values.
    ENE  ene( p_trg->base(),  1);
    for ( int k=1, size=p_trg->size_of_faces(); k<=size; ++k, ene.next()) {
      if ( !p_trg->need_recv(k)) continue;

      for ( int i=0, n=ene.size_of_nodes(); i<n; ++i) flags[ene[i]] = true;
    }

    ENE ene_src; 
    Point_2  nc; 
    const RFC_Pane_transfer *p_src = NULL;
    int count=0, nnodes=p_trg->size_of_nodes()-p_trg->size_of_isolated_nodes();

    // Loop through the subnodes of the target window
    for ( int i=1, size=p_trg->size_of_subnodes(); i<=size; ++i) {

      int svid_trg = i;
      if ( p_trg->parent_type_of_subnode( svid_trg) != PARENT_VERTEX) 
        { if ( count >= nnodes) break; else continue; }
      else ++count;

      int pvid_trg = p_trg->get_parent_node( svid_trg);
      if ( !flags[pvid_trg]) continue;
      
      const Node_ID  &SVID_src = p_trg->get_subnode_counterpart( svid_trg);
      if ( !p_src || p_src->id()!=SVID_src.pane_id) 
        p_src = get_src_pane( SVID_src.pane_id);
      
      int svid_src = SVID_src.node_id;
      p_src->get_host_element_of_subnode(svid_src, ene_src, nc);

      Array_n  v = tDF.get_value( p, pvid_trg);

      if ( is_nodal(sDF.tag())) {
        Generic_element  e( ene_src.size_of_edges(), ene_src.size_of_nodes());
        interpolate( e, make_field( sDF, p_src, ene_src), nc, v);
      }
      else {
        interpolate( Generic_element(3), 
                     make_field( sDF, p_src, ene_src), nc, v);
      }
    }

    // If linear, we are done with this pane
    if ( !p_trg->is_quadratic()) continue;

    // Otherwise, we must interpolate values to other nodes. 
    // We now loop through the faces of the pane.
    ene = ENE( p_trg->base(),  1);
    for ( int k=1, size=p_trg->size_of_faces(); k<=size; ++k, ene.next()) {
      if ( !p_trg->need_recv(k)) continue; // Skip the face if not receiving 
      Element_var  f( tDF, p_trg->pointer( tDF.id()), ene);
      
      switch ( ene.size_of_nodes()) {
      case 6:
        f[3] = 0.5*(f[0]+f[1]);
        f[4] = 0.5*(f[1]+f[2]);
        f[5] = 0.5*(f[2]+f[0]); 
        break;
      case 9:
        f[8] = 0.25*(f[0]+f[1]+f[2]+f[3]); // Then continue as 8-nodes
      case 8:
        f[4] = 0.5*(f[0]+f[1]);
        f[5] = 0.5*(f[1]+f[2]);
        f[6] = 0.5*(f[2]+f[3]); 
        f[7] = 0.5*(f[3]+f[0]); 
        break;
      }
    }
  }

  trg.reduce_maxabs_to_all( tDF);

  if ( verbose) {
    // Output timing information
    trg.barrier();
    if ( trg.is_root())
      std:: cout << "RFACE: Interpolation done in " 
                 << get_wtime()-t0 << " seconds." << std::endl;
  }
}

Here is the call graph for this function:

void interpolate_fe	(	const _SDF &	sDF,
		Nodal_data &	tDF,
		bool	verb
	)

Perform finite-element interpolation (non-conservative), assuming source data has been replicated.

Parameters

sDF	Souce data
tDF	Target data
verb	Verbose level

Referenced by Interpolator::transfer(), and transfer_2n().

Here is the caller graph for this function:

void invert ( Nodal_data &  x )

protected

Definition at line 237 of file Transfer_base.C.

References RFC_Data< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), Array_n::invert(), and trg_ps.

                                    {
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    Real *px = (*pit)->pointer( x.id());
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_nodes(); i<=size; ++i)
      x.get_value( px, i).invert();
  }
}

Here is the call graph for this function:

bool is_nodal ( Tag_nodal  ) const

inlineprivate

Definition at line 342 of file Transfer_base.h.

Referenced by element_load_vector(), integrate_subface(), interpolate_fe(), and transfer_2f().

{ return true; }

Here is the caller graph for this function:

bool is_nodal ( Tag_facial  ) const

inlineprivate

Definition at line 343 of file Transfer_base.h.

{ return false; }

bool is_nodal ( const Element_var_const &  ) const

inlineprivate

Definition at line 344 of file Transfer_base.h.

{ return true; }

bool is_nodal ( const Element_var &  ) const

inlineprivate

Definition at line 345 of file Transfer_base.h.

{ return true; }

bool is_nodal ( const Array_n_const &  ) const

inlineprivate

Definition at line 346 of file Transfer_base.h.

{ return false; }

bool isfinite ( Real  x )

inline

Definition at line 260 of file Transfer_base.h.

Referenced by minmax().

{ return x>-HUGE_VAL && x<HUGE_VAL; }

Here is the caller graph for this function:

void loadtransfer	(	const _SDF &	vS,
		Nodal_data &	vT,
		const Real	alpha,
		const int	order,
		bool	verb
	)

Computes the load vector.

Arguments similar to transfer_2f.

See Also

transfer_2f, transfer_2n

Definition at line 493 of file Transfer_2n.C.

References RFC_Window_transfer::barrier(), RFC_Window_transfer::clear_replicated_data(), get_wtime(), init_load_vector(), RFC_Window_transfer::is_root(), RFC_Window_transfer::replicate_data(), src, and trg.

Referenced by Transfer_n2n::comp_loads(), and Transfer_f2n::comp_loads().

{
  double t0=0.;
  if ( verbose) {
    trg.barrier(); t0=get_wtime();
  }

  // Replicate the data of the source mesh (including coordinates if alpha!=1)
  bool needs_source_coor = alpha!=1.;
  src.replicate_data( sDF, needs_source_coor);

  Nodal_data dummy;
  init_load_vector( sDF, alpha, tDF, dummy, order, false);
  src.clear_replicated_data();

  if ( verbose) {
    // Output timing information
    trg.barrier();
    if ( trg.is_root())
      std:: cout << "RFACE: Load transfer done in " 
                 << get_wtime()-t0 << " seconds." << std::endl;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Element_var_const make_field ( const Nodal_data_const &  d, const RFC_Pane_transfer *  pn, const ENE &  ene  )

inlineprivate

Construct a element-wise accessor from nodal data and pointers.

Definition at line 308 of file Transfer_base.h.

References RFC_Data_const< _Tag >::id(), and RFC_Pane_transfer::pointer().

Referenced by compute_load_vector_wra(), integrate(), interpolate_fe(), and transfer_2f().

                              {
    return Element_var_const( d, pn->pointer(d.id()), ene);
  };

Here is the call graph for this function:

Here is the caller graph for this function:

Element_var make_field ( Nodal_data &  d, RFC_Pane_transfer *  pn, const ENE &  ene  )

inlineprivate

Definition at line 315 of file Transfer_base.h.

References RFC_Data_const< _Tag >::id(), and RFC_Pane_transfer::pointer().

                              {
    return Element_var( d, pn->pointer(d.id()), ene);
  };

Here is the call graph for this function:

Element_var_const make_field ( const Nodal_data_const &  d, const RFC_Pane_transfer *  pn, int    )

inlineprivate

Definition at line 322 of file Transfer_base.h.

References RFC_Data_const< _Tag >::id(), RFC_Pane_transfer::pointer(), and RFC_assertion_msg.

                                                {
    RFC_assertion_msg(false, "Should never reach here. Bug in the code?"); 
    return Element_var_const( d, pn->pointer(d.id()), ENE());
  };

Here is the call graph for this function:

const Array_n_const make_field ( const Facial_data_const &  d, const RFC_Pane_transfer *  pn, const ENE &  ene  )

inlineprivate

Definition at line 329 of file Transfer_base.h.

References RFC_Data_const< _Tag >::get_value(), Element_node_enumerator::id(), RFC_Data_const< _Tag >::id(), and RFC_Pane_transfer::pointer().

                            {
    return d.get_value( pn->pointer(d.id()), ene.id());
  };

Here is the call graph for this function:

const Array_n_const make_field ( const Facial_data_const &  d, const RFC_Pane_transfer *  pn, int  i  )

inlineprivate

Definition at line 336 of file Transfer_base.h.

References RFC_Data_const< _Tag >::get_value(), RFC_Data_const< _Tag >::id(), and RFC_Pane_transfer::pointer().

                   {
    return d.get_value( pn->pointer(d.id()), i);
  };

Here is the call graph for this function:

void minmax	(	const RFC_Window_transfer &	win,
		const Facial_data_const &	sDF,
		Array_n &	min_v,
		Array_n &	max_v
	)

Definition at line 297 of file Transfer_base.C.

References RFC_Window_transfer::allreduce(), Array_n_const::dimension(), RFC_Data_const< _Tag >::dimension(), RFC_Data_const< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), isfinite(), k, max(), min(), MPI_COMM_WORLD, MPI_MAX, MPI_MIN, RFC_Window_base::name(), RFC_Window_derived< _Pane >::panes(), and RFC_assertion.

                                       {
  min_v = Vector_n( sDF.dimension(), HUGE_VAL);
  max_v = Vector_n( sDF.dimension(), -HUGE_VAL);
  
  std::vector<const RFC_Pane_transfer*> ps;
  win.panes( ps);
  
  for (std::vector<const RFC_Pane_transfer*>::iterator 
         pit=ps.begin(); pit!=ps.end(); ++pit) {
    const Real *p = (*pit)->pointer( sDF.id());
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_faces(); i<=size; ++i) {
      Array_n_const t = sDF.get_value( p, i);
      for ( unsigned int k=0; k<t.dimension(); ++k) {
        if ( !isfinite(t[k])) {
          std::cerr << "ERROR: ****Invalid number " 
                    << t[k] << " in " << win.name() << "[" 
                    << i-1 << "][" << k << "] (C Convention). Aborting..." << std::endl;
          RFC_assertion( isfinite(t[k])); MPI_Abort( MPI_COMM_WORLD, -1);
        }
      }
      min_v = min( min_v, t);
      max_v = max( max_v, t);
    }
  }

  // Perform global reduction
  win.allreduce( min_v, MPI_MIN);
  win.allreduce( max_v, MPI_MAX);
}

Here is the call graph for this function:

void minmax	(	const RFC_Window_transfer &	win,
		const Nodal_data_const &	sDF,
		Array_n &	min_v,
		Array_n &	max_v
	)

Definition at line 261 of file Transfer_base.C.

References RFC_Window_transfer::allreduce(), Array_n_const::dimension(), RFC_Data_const< _Tag >::dimension(), RFC_Data_const< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), isfinite(), k, max(), min(), MPI_COMM_WORLD, MPI_MAX, MPI_MIN, RFC_Window_base::name(), RFC_Window_derived< _Pane >::panes(), and RFC_assertion.

                                       {

  min_v = Vector_n( sDF.dimension(), HUGE_VAL);
  max_v = Vector_n( sDF.dimension(), -HUGE_VAL);
  
  std::vector<const RFC_Pane_transfer*> ps;
  win.panes( ps);
  
  for (std::vector<const RFC_Pane_transfer*>::iterator 
         pit=ps.begin(); pit!=ps.end(); ++pit) {
    const Real *p = (*pit)->pointer( sDF.id());
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_nodes(); i<=size; ++i) {
      Array_n_const t = sDF.get_value( p, i);
      for ( unsigned int k=0; k<t.dimension(); ++k) {
        if ( !isfinite(t[k])) {
          std::cerr << "ERROR: ****Invalid number " 
                    << t[k] << " in " << win.name() << "[" 
                    << i-1 << "][" << k << "] (C Convention). Aborting..." << std::endl;
          RFC_assertion( isfinite(t[k])); MPI_Abort( MPI_COMM_WORLD, -1);
        }
      }
      min_v = min( min_v, t);
      max_v = max( max_v, t);
    }
  }

  // Perform global reduction
  win.allreduce( min_v, MPI_MIN);
  win.allreduce( max_v, MPI_MAX);
}

Here is the call graph for this function:

void multiply_mass_mat_and_x ( const Nodal_data_const &  x, Nodal_data &  y  )

protected

Definition at line 123 of file Transfer_base.C.

References RFC_Pane_base::base(), RFC_Data_const< _Tag >::dimension(), RFC_Pane_transfer::get_emm(), i, RFC_Data_const< _Tag >::id(), j, k, MPI_SUM, n, RFC_Pane_transfer::need_recv(), RFC_Pane_transfer::pointer(), RFC_Window_transfer::reduce_to_all(), RFC_Pane_base::size_of_faces(), trg, and trg_ps.

Referenced by pcg().

                                                       {
  // Loop through the elements of the target window to integrate
  //   \int_e N_iN_j de.
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    RFC_Pane_transfer *p_trg = *pit;
    Real *py = p_trg->pointer(y.id());
    const Real *px = p_trg->pointer(x.id());
    
    // Initialize y by setting all its entries to 0.
    Real *p = p_trg->pointer( y.id());
    std::fill( p, p+(*pit)->size_of_nodes()*y.dimension(), Real(0));

    // Loop through the faces of each pane.
    ENE ene( p_trg->base(),  1);
    for ( int k=1, size=p_trg->size_of_faces(); k<=size; ++k, ene.next()) {
      if ( !p_trg->need_recv(k)) continue;
      Real              *emm = p_trg->get_emm( k);
      Element_var        fy( y, py, ene);
      Element_var_const  fx( x, px, ene);

      // Add the submatrix onto the global matrix.
      for ( int i=0, n=ene.size_of_nodes(); i<n; ++i) {
        Array_n t = fy[i];
        for ( int j=0; j<n; ++j, ++emm) t += (*emm) * fx[j];
      }
    }
  }

  trg.reduce_to_all( y, MPI_SUM);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Real norm2 ( const Nodal_data_const &  x ) const

protected

Definition at line 156 of file Transfer_base.C.

References RFC_Window_transfer::allreduce(), RFC_Data_const< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), MPI_SUM, square(), trg, and trg_ps.

Referenced by pcg().

                                                     {
  Real nrm(0);
  
  for ( Pane_iterator_const pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    const Real *p = (*pit)->pointer( x.id());
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_nodes(); i<=size; ++i)
      if ( (*pit)->is_primary_node( i))
        nrm += square( x.get_value( p, i));
  }
  trg.allreduce( &nrm, MPI_SUM);
  return nrm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RFC_BEGIN_NAME_SPACE int pcg ( Nodal_data &  x, Nodal_data &  b, Nodal_data &  p, Nodal_data &  q, Nodal_data &  r, Nodal_data &  s, Nodal_data &  z, Nodal_data &  di, Real *  tol, int *  max_iter  )

protected

Definition at line 40 of file Transfer_base.C.

References copy_vec(), dot2(), i, multiply_mass_mat_and_x(), norm2(), precondition_Jacobi(), saxpy(), and sqrt().

Referenced by transfer_2n().

                                                                          {
  Real  resid, alpha, beta, rho, rho_1=0, sigma=0;

  Real normb = norm2(b);
  Real tol_sq = *tol * *tol;
  
  // r = b - A*x
  multiply_mass_mat_and_x(x, r);
  saxpy( Real(1), b, Real(-1), r);
  
  if (normb < 1.e-15) normb = Real(1);
  
  if ( (resid = norm2(r) / normb) <= tol_sq) {
    *tol = sqrt(resid);
    *iter = 0;
    return 0;
  }
  
  for (int i = 1; i <= *iter; i++) {
    precondition_Jacobi( r, di, z);
    multiply_mass_mat_and_x(z, s);
    
    // rho = dot(r, z); sigma = dot(z, s);
    Real gsums[2];

    dot2(r, z, z, s, Array_n(gsums,2));
    rho = gsums[0];

    if (i==1) {
      copy_vec( z, p);
      copy_vec( s, q);
      sigma = gsums[1];
    }
    else {
      beta = rho / rho_1;
      // p = z + beta * p;
      saxpy( Real(1), z, beta, p);
      
      // q = s + beta * q; i.e., q = A*p;
      saxpy( Real(1), s, beta, q);
      sigma = gsums[1] - beta * beta * sigma;
    }
    alpha = rho / sigma;
    
    // x += alpha * p;
    saxpy( alpha, p, Real(1), x);
    // r -= alpha * q;
    saxpy( -alpha, q, Real(1), r);
    
    if ( (resid = norm2(r) / normb) <= tol_sq) {
      *tol = sqrt(resid);
      *iter = i;
      return 0;     
    }
    
    rho_1 = rho;
  }
  
  *tol = sqrt(resid);
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void precondition_Jacobi ( const Nodal_data_const &  rhs, const Nodal_data_const &  diag, Nodal_data &  x  )

protected

Diagonal (Jacobi) preconditioner.

Parameters

rhs	is the right-hand side of the system
diag	is the diagonal of the mass matrix.
x	is the solution vector

Definition at line 105 of file Transfer_base.C.

References copy_vec(), RFC_Data_const< _Tag >::get_value(), RFC_Data< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), q, and trg_ps.

Referenced by pcg(), and transfer_2n().

                                                   {
  copy_vec( rhs, x); // Copy value from rhs to x

  // Divide x by diag.
  for (Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    Real *p = (*pit)->pointer( x.id());
    const Real *q = (*pit)->pointer( diag.id());

    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_nodes(); i<=size; ++i)
      x.get_value( p, i) /= diag.get_value( q, i)[0];
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void saxpy ( const Real &  a, const Nodal_data_const &  x, const Real &  b, Nodal_data &  y  )

protected

Definition at line 213 of file Transfer_base.C.

References RFC_Data_const< _Tag >::get_value(), RFC_Data< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), and trg_ps.

Referenced by pcg().

                                                    {
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    Real *px = (*pit)->pointer( x.id());
    Real *py = (*pit)->pointer( y.id());
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_nodes(); i<=size; ++i)
      (y.get_value( py, i)*=b) += a*x.get_value( px, i);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void scale ( const Real &  a, Nodal_data &  x  )

protected

Definition at line 226 of file Transfer_base.C.

References RFC_Data< _Tag >::get_value(), i, RFC_Data_const< _Tag >::id(), and trg_ps.

Referenced by read_frac(), scale_mesh(), tred1(), tred2(), write_output(), and write_output_2().

                                                  {
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    Real *px = (*pit)->pointer( x.id());
    // Loop through the nodes of each pane.
    for ( int i=1, size=(*pit)->size_of_nodes(); i<=size; ++i)
      x.get_value( px, i) *= a;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Real square ( const Array_n_const &  x ) const

inlineprotected

Definition at line 158 of file Transfer_base.h.

References x.

Referenced by norm2().

{ return x*x; }

Here is the caller graph for this function:

void transfer_2f	(	const _SDF &	sDF,
		Facial_data &	tDF,
		const Real	alpha,
		int	doa,
		bool	verb
	)

template function for transfering from nodes/faces to faces.

Parameters

sDF	Souce data
tDF	Target data
alpha	Parameter to control interpolation of coordinates between the input meshes
doa	Degree of accuracy for quadrature rule to be used
verb	Verbose level

Definition at line 124 of file Transfer_2f.C.

References RFC_Window_transfer::barrier(), RFC_Window_transfer::clear_replicated_data(), RFC_Window_transfer::delete_facial_buffers(), RFC_Data_const< _Tag >::dimension(), Face_ID::face_id, RFC_Window_transfer::facial_buffer(), RFC_Pane_base::get_host_element_of_subface(), RFC_Pane_base::get_parent_face(), get_src_pane(), RFC_Data< _Tag >::get_value(), get_wtime(), i, Element_node_enumerator::id(), RFC_Pane_base::id(), RFC_Data_const< _Tag >::id(), RFC_Window_transfer::init_facial_buffers(), integrate_subface(), is_nodal(), RFC_Window_transfer::is_root(), make_field(), Face_ID::pane_id, RFC_Window_transfer::replicate_data(), src, trg, and trg_ps.

Referenced by Transfer_n2f::transfer(), and Transfer_f2f::transfer().

{
  double t0=0.;
  if ( verbose) {
    trg.barrier(); t0=get_wtime();
  }

  src.replicate_data( sDF, alpha!=1);
  // First, create buffer space for the target window and initialize
  //        the entries of the target mesh to zero.
  trg.init_facial_buffers( tDF, 1);
  Facial_data tBF ( trg.facial_buffer( 0));

  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    Real *trg_data = (*pit)->pointer( tDF.id());
    Real *trg_buf  = (*pit)->pointer( tBF.id());
    
    std::fill( trg_data, trg_data+(*pit)->size_of_faces()*tDF.dimension(), 0);
    std::fill( trg_buf, trg_buf+(*pit)->size_of_faces(), 0);
  }

  // Second, compute the integral over the target meshes by looping through
  //         the subfaces of the target window
  ENE   ene_src, ene_trg; 
  const RFC_Pane_transfer *p_src = NULL;
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    // Loop through the subfaces of the target window
    for ( int i=1, size=(*pit)->size_of_subfaces(); i<=size; ++i) {
      (*pit)->get_host_element_of_subface( i, ene_trg);
      if ( !(*pit)->need_recv( ene_trg.id())) continue;

      const Face_ID &fid = (*pit)->get_subface_counterpart(i);
      if ( !p_src || p_src->id()!=fid.pane_id) 
        p_src = get_src_pane( fid.pane_id);
      if ( alpha!=1 || is_nodal( sDF.tag()) )
        p_src->get_host_element_of_subface( fid.face_id, ene_src);

      if ( is_nodal( sDF.tag()))
        integrate_subface( p_src, *pit, 
                           make_field(sDF, p_src, ene_src),
                           ene_src, ene_trg, fid.face_id, i, alpha, tDF, tBF, doa);
      else {
        int id = p_src->get_parent_face( fid.face_id);
        integrate_subface( p_src, *pit,
                           make_field(sDF, p_src, id),
                           ene_src, ene_trg, fid.face_id, i, alpha, tDF, tBF, doa);
      }
    }
  }

  // Loop through the panes of the target mesh
  for ( Pane_iterator pit=trg_ps.begin(); pit!=trg_ps.end(); ++pit) {
    Real *trg_data = (*pit)->pointer( tDF.id());
    Real *trg_buf  = (*pit)->pointer( tBF.id());

    for ( int i=1, size=(*pit)->size_of_faces(); i<=size; ++i) {
      if ( !(*pit)->need_recv(i)) continue;
      tDF.get_value( trg_data, i) /= tBF.get_value( trg_buf, i)[0];
    }
  }

  // Clean up the transfer buffers
  trg.delete_facial_buffers();
  src.clear_replicated_data();

  if ( verbose) {
    trg.barrier();
    if ( trg.is_root()) {
      std::cout << "RFACE: Transfer to faces done in " 
                << get_wtime()-t0 << " seconds." << std::endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void transfer_2n	(	const _SDF &	sDF,
		Nodal_data &	tDF,
		const Real	alpha,
		Real *	tol,
		int *	iter,
		int	doa,
		bool	verb
	)

template function for transfering from nodes/faces to nodes.

Parameters

sDF	Souce data
tDF	Target data
alpha	Parameter to control interpolation of coordinates between the input meshes
tol	Tolerance of iterative solver
iter	Number of iterations of iterative solver.
doa	Degree of accuracy for quadrature rule to be used
verb	Verbose level

Definition at line 387 of file Transfer_2n.C.

References RFC_Window_transfer::barrier(), RFC_Window_transfer::clear_replicated_data(), RFC_Window_transfer::delete_nodal_buffers(), get_wtime(), init_load_vector(), RFC_Window_transfer::init_nodal_buffers(), interpolate_fe(), RFC_Window_transfer::is_root(), RFC_Window_transfer::nodal_buffer(), pcg(), precondition_Jacobi(), q, RFC_Window_transfer::reduce_maxabs_to_all(), RFC_Window_transfer::replicate_data(), s, src, trg, and z.

Referenced by Transfer_n2n::transfer(), and Transfer_f2n::transfer().

{
  double t0(0);

  if ( verbose) {
    trg.barrier(); t0 = get_wtime();
  }

  // Allocate buffers
  trg.init_nodal_buffers( tDF, (*iter>0)?7:3, (*iter>0));
  Nodal_data b( trg.nodal_buffer(0));
  Nodal_data z( trg.nodal_buffer(1));
  Nodal_data diag( trg.nodal_buffer(2));

  bool needs_source_coor = alpha!=1.;
  // Replicate the data of the source mesh (including coordinates if alpha!=1)
  src.replicate_data( sDF, needs_source_coor);

  bool lump = *iter<=0; // whether to lump mass matrix

  // Initialize the load vector and the diagonal vector. 
  init_load_vector( sDF, alpha, b, diag, doa, lump);

  // Obtaining an initial guess by interpolation.
  if ( !lump) interpolate_fe( sDF, tDF, false);

  // Clear up replicated data after obtaining the load vector and interpolation
  src.clear_replicated_data();

  if ( *iter>0) {
    Nodal_data p( trg.nodal_buffer(3));
    Nodal_data q( trg.nodal_buffer(4));
    Nodal_data r( trg.nodal_buffer(5));
    Nodal_data s( trg.nodal_buffer(6));

    int ierr=pcg( tDF, b, p, q, r, s, z, diag, tol, iter);
    
    if (ierr) {
      std::cerr << "***RFACE: WARNING: PCG did not converge after " 
                << *iter << " iterations and relative error is "
                << *tol << std::endl;
    }
  }
  else {
    precondition_Jacobi( b, diag, tDF);
  }
  
  trg.reduce_maxabs_to_all( tDF);

  // Delete buffer spaces
  trg.delete_nodal_buffers();

  if ( verbose) {
    trg.barrier();
    if ( trg.is_root()) {
      std:: cout << "RFACE: Transfer to nodes done in " 
                 << get_wtime()-t0 << " seconds";
      if ( *iter > 0)
        std:: cout << " with relative error " 
                   << *tol << " after " << *iter << " iterators"
                   << std::endl;
      else
        std:: cout << "." << std::endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const RFC_Pane_transfer* _src_pane

private

Definition at line 288 of file Transfer_base.h.

Referenced by get_src_pane().

RFC_Pane_transfer* _trg_pane

private

Definition at line 289 of file Transfer_base.h.

Referenced by get_trg_pane().

int sc

protected

Definition at line 284 of file Transfer_base.h.

RFC_Window_transfer& src

protected

Definition at line 282 of file Transfer_base.h.

Referenced by get_src_pane(), loadtransfer(), Interpolator::transfer(), transfer_2f(), transfer_2n(), and Transfer_base().

std::vector<const RFC_Pane_transfer*> src_ps

private

Definition at line 291 of file Transfer_base.h.

Referenced by Transfer_base().

RFC_Window_transfer& trg

protected

Definition at line 283 of file Transfer_base.h.

Referenced by dot(), dot2(), get_trg_pane(), init_load_vector(), interpolate_fe(), loadtransfer(), multiply_mass_mat_and_x(), norm2(), Interpolator::transfer(), transfer_2f(), transfer_2n(), and Transfer_base().

std::vector<RFC_Pane_transfer*> trg_ps

private

Definition at line 292 of file Transfer_base.h.

Referenced by copy_vec(), dot(), dot2(), init_load_vector(), interpolate_fe(), invert(), multiply_mass_mat_and_x(), norm2(), precondition_Jacobi(), saxpy(), scale(), transfer_2f(), and Transfer_base().

---

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

• Transfer_base.h
• Transfer_2f.C
• Transfer_2n.C
• Transfer_base.C