1#ifndef _RHEOLEF_BASIS_ORDERING_ICC
2#define _RHEOLEF_BASIS_ORDERING_ICC
41#include "rheolef/reference_element.h"
53 reference_element hat_K,
54 const point_basic<size_t>& power_index)
56 size_t d = hat_K.dimension();
58 for (
size_t mu = 0; mu <
d; ++mu) {
59 switch (hat_K.variant()) {
67 if (mu != 2) deg_p += power_index[mu];
68 else deg_p = max(deg_p, power_index[mu]);
83 reference_element hat_K,
85 const std::vector<point_basic<size_t> >& power_index,
86 std::vector<size_t>& ideg2ipow)
88 ideg2ipow.resize (power_index.size());
89 std::vector<size_t> first_loc_ideg (degree+1);
90 first_loc_ideg [0] = 0;
91 for (
size_t k = 1; k <= degree; ++k) {
94 for (
size_t loc_ipow = 0, loc_npow = power_index.size(); loc_ipow < loc_npow; ++loc_ipow) {
95 size_t deg = get_degree (hat_K, power_index[loc_ipow]);
96 size_t ideg = first_loc_ideg[deg];
97 ideg2ipow[ideg] = loc_ipow;
98 first_loc_ideg[deg]++;
111 reference_element hat_K,
113 const std::vector<point_basic<size_t> >& power_index,
114 std::vector<size_t>& ipow2inod)
116 ipow2inod.resize (power_index.size());
117 for (
size_t ipow = 0, npow = power_index.size(); ipow < npow; ++ipow) {
118 ipow2inod[ipow] = ilat2loc_inod (hat_K, degree, power_index[ipow]);
124 const std::vector<size_t>& perm,
125 std::vector<size_t>& iperm)
127 iperm.resize (perm.size());
128 for (
size_t iloc = 0, nloc = perm.size(); iloc < nloc; ++iloc) {
129 iperm[perm[iloc]] = iloc;
140make_power_indexes_permuted (
141 reference_element hat_K,
143 std::vector<size_t> ilat2ipow,
144 std::vector<point_basic<size_t> >& power_index)
148 switch (hat_K.variant()) {
150 power_index[0] = point_basic<size_t>();
154 for (
size_type ilat = 0; ilat <= degree; ilat++) {
155 power_index[ilat2ipow[ilat]] = point_basic<size_t>(ilat);
161 for (
size_type j = 0; j <= degree; j++) {
162 for (
size_type i = 0; i+j <= degree; i++) {
163 power_index[ilat2ipow[ilat++]] = point_basic<size_t>(i,j);
169 for (
size_type j = 0; j <= degree; j++) {
170 for (
size_type i = 0; i <= degree; i++) {
171 power_index[ilat2ipow[ilat++]] = point_basic<size_t>(i,j);
176 for (
size_type k = 0, ilat = 0; k <= degree; k++) {
177 for (
size_type j = 0; j+k <= degree; j++) {
178 for (
size_type i = 0; i+j+k <= degree; i++, ilat++) {
179 power_index[ilat2ipow[ilat]] = point_basic<size_t>(i,j,k);
186 for (
size_type k = 0, ilat = 0; k <= degree; k++) {
187 for (
size_type j = 0; j <= degree; j++) {
188 for (
size_type i = 0; i+j <= degree; i++, ilat++) {
189 power_index[ilat2ipow[ilat]] = point_basic<size_t>(i,j,k);
196 for (
size_type k = 0, ilat = 0; k <= degree; k++) {
197 for (
size_type j = 0; j <= degree; j++) {
198 for (
size_type i = 0; i <= degree; i++, ilat++) {
199 power_index[ilat2ipow[ilat]] = point_basic<size_t>(i,j,k);
211 reference_element hat_K,
213 std::vector<point_basic<size_t> >& power_index)
217 std::vector<size_type> id (nloc);
218 for (
size_type iloc = 0; iloc < nloc; ++iloc) {
221 make_power_indexes_permuted (hat_K, degree,
id, power_index);
225make_power_indexes_sorted_by_degrees (
226 reference_element hat_K,
228 std::vector<point_basic<size_t> >& power_index)
232 make_power_indexes (hat_K, degree, power_index);
233 std::vector<size_type> perm (nloc);
234 sort_by_degrees (hat_K, degree, power_index, perm);
235 std::vector<size_type> iperm (nloc);
236 invert_permutation (perm, iperm);
237 make_power_indexes_permuted (hat_K, degree, iperm, power_index);
241make_power_indexes_sorted_by_inodes (
242 reference_element hat_K,
244 std::vector<point_basic<size_t> >& power_index)
248 make_power_indexes (hat_K, degree, power_index);
249 std::vector<size_type> perm (nloc);
250 sort_by_inodes (hat_K, degree, power_index, perm);
251 make_power_indexes_permuted (hat_K, degree, perm, power_index);
260 reference_element hat_K,
262 std::vector<size_t>& inod2ideg)
264 std::vector<point_basic<size_t> > power_index;
265 make_power_indexes (hat_K, degree, power_index);
266 std::vector<size_t> ideg2ilat;
267 std::vector<size_t> ilat2inod;
268 sort_by_inodes (hat_K, degree, power_index, ilat2inod);
269 sort_by_degrees (hat_K, degree, power_index, ideg2ilat);
270 std::vector<size_t> ilat2ideg;
271 std::vector<size_t> inod2ilat;
272 invert_permutation (ilat2inod, inod2ilat);
273 invert_permutation (ideg2ilat, ilat2ideg);
274 inod2ideg.resize (power_index.size());
275 for (
size_t iloc = 0, nloc = inod2ideg.size(); iloc < nloc; ++iloc) {
276 inod2ideg [iloc] = ilat2ideg [inod2ilat[iloc]];
field::size_type size_type
static const variant_type H
static const variant_type q
static const variant_type e
static const variant_type p
std::vector< int >::size_type size_type
static size_type n_node(variant_type variant, size_type order)
static const variant_type T
static const variant_type P
static const variant_type t
This file is part of Rheolef.