Interpolation on a set of points with known rst coordinates in elements local to this process. Similar to point_interpolator, but prioritizes performance Only works with arrays of coordinates Performs interpolation with the configured NEKO_BCKND.  
 More...
 | 
| procedure, pass(this)  | init (this, xh, r, s, t, n_points) | 
|   | Constructor.  
  | 
|   | 
| procedure, pass(this)  | free (this) | 
|   | Destructor.  
  | 
|   | 
| procedure, pass(this)  | evaluate (this, interp_values, el_list, field, nel) | 
|   | Interpolates the scalar field \( X \) on the specified coordinates.  
  | 
|   | 
| procedure, pass(this)  | compute_weights (this, r, s, t) | 
|   | COmputes weights based on rst coordinates.  
  | 
|   | 
 | 
| type(space_t), pointer  | xh => null() | 
|   | First space.  
  | 
|   | 
| integer  | n_points | 
|   | Number of points to interpolate on.  
  | 
|   | 
| real(kind=rp), dimension(:,:), allocatable  | weights_r | 
|   | Weights for local interpolation.  
  | 
|   | 
| real(kind=rp), dimension(:,:), allocatable  | weights_s | 
|   | 
| real(kind=rp), dimension(:,:), allocatable  | weights_t | 
|   | 
| type(c_ptr)  | weights_r_d = c_null_ptr | 
|   | 
| type(c_ptr)  | weights_s_d = c_null_ptr | 
|   | 
| type(c_ptr)  | weights_t_d = c_null_ptr | 
|   | 
Definition at line 55 of file local_interpolation.f90.
 
◆ compute_weights()
      
        
          | procedure, pass(this) local_interpolation::local_interpolator_t::compute_weights  | 
          ( | 
          class(local_interpolator_t), intent(inout)  | 
          this,  | 
        
        
           | 
           | 
          real(kind=rp), dimension(:), intent(in)  | 
          r,  | 
        
        
           | 
           | 
          real(kind=rp), dimension(:), intent(in)  | 
          s,  | 
        
        
           | 
           | 
          real(kind=rp), dimension(:), intent(in)  | 
          t  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
- Parameters
 - 
  
    | r | local r-coordinates.  | 
    | s | local s-coordinates.  | 
    | t | local t-coordinates.  | 
    | wr | Weights in the r-direction.  | 
    | ws | Weights in the s-direction.  | 
    | wt | Weights in the t-direction.  | 
  
   
- Note
 wr, ws and wt must be arrays of dimensions (lx, N) where N is the number of points (size of the r,s,t arrays). 
Definition at line 75 of file local_interpolation.f90.
 
 
◆ evaluate()
      
        
          | procedure, pass(this) local_interpolation::local_interpolator_t::evaluate  | 
          ( | 
          class(local_interpolator_t), intent(inout)  | 
          this,  | 
        
        
           | 
           | 
          real(kind=rp), dimension(this%n_points), intent(inout)  | 
          interp_values,  | 
        
        
           | 
           | 
          integer, dimension(this%n_points), intent(in)  | 
          el_list,  | 
        
        
           | 
           | 
          real(kind=rp), dimension(this%xh%lxyz, nel), intent(inout)  | 
          field,  | 
        
        
           | 
           | 
          integer, intent(in)  | 
          nel  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
- Parameters
 - 
  
    | rst | r,s,t coordinates.  | 
    | el_owners | Array of element ids that "own" a given point i.  | 
    | sampled_fields_list | A list of fields to interpolate.  | 
    | wr | Weights in the r-direction of shape (lx, N) where N is the number of points to interpolate.  | 
    | ws | Weights in the s-direction of shape (lx, N) where N is the number of points to interpolate.  | 
    | wt | Weights in the t-direction of shape (lx, N) where N is the number of points to interpolate.  | 
  
   
- Note
 - The weights can be generated with the subroutine 
compute_weights. Assumes weights have been computed for these points.  
Definition at line 73 of file local_interpolation.f90.
 
 
◆ free()
◆ init()
      
        
          | procedure, pass(this) local_interpolation::local_interpolator_t::init  | 
          ( | 
          class(local_interpolator_t), intent(inout), target  | 
          this,  | 
        
        
           | 
           | 
          type(space_t), intent(in), target  | 
          xh,  | 
        
        
           | 
           | 
          real(kind=rp), dimension(n_points)  | 
          r,  | 
        
        
           | 
           | 
          real(kind=rp), dimension(n_points)  | 
          s,  | 
        
        
           | 
           | 
          real(kind=rp), dimension(n_points)  | 
          t,  | 
        
        
           | 
           | 
          integer, intent(in)  | 
          n_points  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
 
◆ n_points
      
        
          | integer local_interpolation::local_interpolator_t::n_points | 
        
      
 
 
◆ weights_r
◆ weights_r_d
      
        
          | type(c_ptr) local_interpolation::local_interpolator_t::weights_r_d = c_null_ptr | 
        
      
 
 
◆ weights_s
◆ weights_s_d
      
        
          | type(c_ptr) local_interpolation::local_interpolator_t::weights_s_d = c_null_ptr | 
        
      
 
 
◆ weights_t
◆ weights_t_d
      
        
          | type(c_ptr) local_interpolation::local_interpolator_t::weights_t_d = c_null_ptr | 
        
      
 
 
◆ xh
The documentation for this type was generated from the following file: