Beispiel #1
0
  KOKKOS_INLINE_FUNCTION
  void operator()( const unsigned ielem ) const
  {
    // Gather nodal coordinates and solution vector:

    double x[ FunctionCount ] ;
    double y[ FunctionCount ] ;
    double z[ FunctionCount ] ;
    double val[ FunctionCount ] ;

    for ( unsigned i = 0 ; i < ElementNodeCount ; ++i ) {
      const unsigned node_index = elem_node_ids( ielem , i );

      x[i] = node_coords( node_index , 0 );
      y[i] = node_coords( node_index , 1 );
      z[i] = node_coords( node_index , 2 );

      val[i] = nodal_values( node_index );
    }

    double elem_vec[ FunctionCount ] ;
    double elem_mat[ FunctionCount ][ FunctionCount ] ;

    for( unsigned i = 0; i < FunctionCount ; i++ ) {
      elem_vec[i] = 0 ;
      for( unsigned j = 0; j < FunctionCount ; j++){
        elem_mat[i][j] = 0 ;
      }
    }

    for ( unsigned i = 0 ; i < IntegrationCount ; ++i ) {
      float dpsidx[ FunctionCount ] ;
      float dpsidy[ FunctionCount ] ;
      float dpsidz[ FunctionCount ] ;

      const float detJ =
        transform_gradients( elem_data.gradients[i] , x , y , z ,
                             dpsidx , dpsidy , dpsidz );

      contributeResidualJacobian( coeff_K ,
                                  val , dpsidx , dpsidy , dpsidz ,
                                  detJ ,
                                  elem_data.weights[i] ,
                                  elem_data.values[i] ,
                                  elem_vec , elem_mat );
    }

    for( unsigned i = 0; i < FunctionCount ; i++){
      element_vectors(ielem, i) = elem_vec[i] ;
      for( unsigned j = 0; j < FunctionCount ; j++){
        element_matrices(ielem, i, j) = elem_mat[i][j] ;
      }
    }
  }
  __device__ inline
  void operator()(void) const
  {
    extern __shared__ WorkSpace work_data[] ;

    for ( unsigned ielem = blockIdx.x ; ielem < elem_count ; ielem += gridDim.x ) {

      evaluateFunctions( ielem );

      contributeResidualJacobian( ielem );
    }
  }