| 1 |
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root |
| 2 |
// SPDX-License-Identifier: LGPL-2.1-or-later |
| 3 |
/*! \file evm.h |
| 4 |
* \ingroup gm |
| 5 |
*/ |
| 6 |
|
| 7 |
/****************************************************************************/ |
| 8 |
/* */ |
| 9 |
/* File: evm.h */ |
| 10 |
/* */ |
| 11 |
/* Purpose: elementary vector manipulations, header for evm.c */ |
| 12 |
/* */ |
| 13 |
/* Author: Klaus Johannsen */ |
| 14 |
/* Institut fuer Computeranwendungen */ |
| 15 |
/* Universitaet Stuttgart */ |
| 16 |
/* Pfaffenwaldring 27 */ |
| 17 |
/* 70569 Stuttgart */ |
| 18 |
/* internet: [email protected] */ |
| 19 |
/* */ |
| 20 |
/* History: 8.12.94 begin, ug3-version */ |
| 21 |
/* */ |
| 22 |
/* Remarks: */ |
| 23 |
/* */ |
| 24 |
/****************************************************************************/ |
| 25 |
|
| 26 |
|
| 27 |
/****************************************************************************/ |
| 28 |
/* */ |
| 29 |
/* auto include mechanism and other include files */ |
| 30 |
/* */ |
| 31 |
/****************************************************************************/ |
| 32 |
|
| 33 |
#ifndef __EVM__ |
| 34 |
#define __EVM__ |
| 35 |
|
| 36 |
#include <cmath> |
| 37 |
|
| 38 |
#include <dune/uggrid/low/architecture.h> |
| 39 |
#include <dune/uggrid/low/debug.h> |
| 40 |
#include <dune/uggrid/low/namespace.h> |
| 41 |
#include <dune/uggrid/low/ugtypes.h> |
| 42 |
|
| 43 |
#include "gm.h" |
| 44 |
|
| 45 |
START_UGDIM_NAMESPACE |
| 46 |
|
| 47 |
/****************************************************************************/ |
| 48 |
/* */ |
| 49 |
/* defines in the following order */ |
| 50 |
/* */ |
| 51 |
/* compile time constants defining static data size (i.e. arrays) */ |
| 52 |
/* other constants */ |
| 53 |
/* macros */ |
| 54 |
/* */ |
| 55 |
/****************************************************************************/ |
| 56 |
|
| 57 |
/****************************************************************************/ |
| 58 |
/* */ |
| 59 |
/* macros */ |
| 60 |
/* */ |
| 61 |
/****************************************************************************/ |
| 62 |
|
| 63 |
|
| 64 |
/* macros for 2D vector operations */ |
| 65 |
#define V2_LINCOMB(a,A,b,B,C) {(C)[0] = (a)*(A)[0] + (b)*(B)[0];\ |
| 66 |
(C)[1] = (a)*(A)[1] + (b)*(B)[1];} |
| 67 |
#define V2_COPY(A,C) {(C)[0] = (A)[0];\ |
| 68 |
(C)[1] = (A)[1];} |
| 69 |
#define V2_SUBTRACT(A,B,C) {(C)[0] = (A)[0] - (B)[0];\ |
| 70 |
(C)[1] = (A)[1] - (B)[1];} |
| 71 |
#define V2_ADD(A,B,C) {(C)[0] = (A)[0] + (B)[0];\ |
| 72 |
(C)[1] = (A)[1] + (B)[1];} |
| 73 |
#define V2_SCALE(c,C) {(C)[0] = (c)*(C)[0];\ |
| 74 |
(C)[1] = (c)*(C)[1];} |
| 75 |
#define V2_VECTOR_PRODUCT(A,B,c) (c) = (A)[0]*(B)[1] - (A)[1]*(B)[0]; |
| 76 |
#define V2_ISEQUAL(A,B) ((std::abs((A)[0]-(B)[0])<SMALL_C)&&(std::abs((A)[1]-(B)[1])<SMALL_C)) |
| 77 |
#define V2_EUKLIDNORM(A,b) (b) = sqrt((double)((A)[0]*(A)[0]+(A)[1]*(A)[1])); |
| 78 |
#define V2_EUKLIDNORM_OF_DIFF(A,B,b) (b) = sqrt((double)(((A)[0]-(B)[0])*((A)[0]-(B)[0])+((A)[1]-(B)[1])*((A)[1]-(B)[1]))); |
| 79 |
#define V2_CLEAR(A) {(A)[0] = 0.0; (A)[1]= 0.0;} |
| 80 |
#define V2_SCALAR_PRODUCT(A,B,c) (c) = (A)[0]*(B)[0]+(A)[1]*(B)[1]; |
| 81 |
#define V2_SCAL_PROD(A,B) ((A)[0]*(B)[0]+(A)[1]*(B)[1]) |
| 82 |
|
| 83 |
|
| 84 |
/* macros for 2D matrix-vector operations */ |
| 85 |
#define M2_TIMES_V2(M,A,B) {(B)[0] = (M)[0]*(A)[0] + (M)[2]*(A)[1];\ |
| 86 |
(B)[1] = (M)[1]*(A)[0] + (M)[3]*(A)[1];} |
| 87 |
#define MM2_TIMES_V2(M,A,B) {(B)[0] = (M)[0][0]*(A)[0] + (M)[0][1]*(A)[1];\ |
| 88 |
(B)[1] = (M)[1][0]*(A)[0] + (M)[1][1]*(A)[1];} |
| 89 |
|
| 90 |
#define MT2_TIMES_V2(M,A,B) {(B)[0] = (M)[0][0]*(A)[0] + (M)[1][0]*(A)[1];\ |
| 91 |
(B)[1] = (M)[0][1]*(A)[0] + (M)[1][1]*(A)[1];} |
| 92 |
|
| 93 |
#define MD2_TIMES_V2(M,A,B) {(B)[0] = (M)[0]*(A)[0];\ |
| 94 |
(B)[1] = (M)[1]*(A)[1];} |
| 95 |
|
| 96 |
/* macros for matrix operations */ |
| 97 |
#define M2_DET(M) ((M)[0]*(M)[3] - (M)[1]*(M)[2]) |
| 98 |
|
| 99 |
#define M2_INVERT(M,IM,det) \ |
| 100 |
{ DOUBLE invdet; \ |
| 101 |
det = (M)[0][0]*(M)[1][1]-(M)[1][0]*(M)[0][1]; \ |
| 102 |
if (std::abs((det))<SMALL_D*SMALL_D) det= 0.; \ |
| 103 |
else { \ |
| 104 |
invdet = 1.0 / (det); \ |
| 105 |
(IM)[0][0] = (M)[1][1]*invdet; \ |
| 106 |
(IM)[1][0] = -(M)[1][0]*invdet; \ |
| 107 |
(IM)[0][1] = -(M)[0][1]*invdet; \ |
| 108 |
(IM)[1][1] = (M)[0][0]*invdet;}} |
| 109 |
|
| 110 |
/* macros for vector operations */ |
| 111 |
#define V3_LINCOMB(a,A,b,B,C) {(C)[0] = (a)*(A)[0] + (b)*(B)[0];\ |
| 112 |
(C)[1] = (a)*(A)[1] + (b)*(B)[1];\ |
| 113 |
(C)[2] = (a)*(A)[2] + (b)*(B)[2];} |
| 114 |
#define V3_COPY(A,C) {(C)[0] = (A)[0];\ |
| 115 |
(C)[1] = (A)[1];\ |
| 116 |
(C)[2] = (A)[2];} |
| 117 |
#define V3_SUBTRACT(A,B,C) {(C)[0] = (A)[0] - (B)[0];\ |
| 118 |
(C)[1] = (A)[1] - (B)[1];\ |
| 119 |
(C)[2] = (A)[2] - (B)[2];} |
| 120 |
#define V3_ADD(A,B,C) {(C)[0] = (A)[0] + (B)[0];\ |
| 121 |
(C)[1] = (A)[1] + (B)[1];\ |
| 122 |
(C)[2] = (A)[2] + (B)[2];} |
| 123 |
#define V3_SCALE(c,C) {(C)[0] = (c)*(C)[0];\ |
| 124 |
(C)[1] = (c)*(C)[1];\ |
| 125 |
(C)[2] = (c)*(C)[2];} |
| 126 |
#define V3_VECTOR_PRODUCT(A,B,C) {(C)[0] = (A)[1]*(B)[2] - (A)[2]*(B)[1];\ |
| 127 |
(C)[1] = (A)[2]*(B)[0] - (A)[0]*(B)[2];\ |
| 128 |
(C)[2] = (A)[0]*(B)[1] - (A)[1]*(B)[0];} |
| 129 |
#define V3_EUKLIDNORM(A,b) (b) = (sqrt((double)((A)[0]*(A)[0]+(A)[1]*(A)[1]+(A)[2]*(A)[2]))); |
| 130 |
#define V3_ISEQUAL(A,B) ((std::abs((A)[0]-(B)[0])<SMALL_C)&&(std::abs((A)[1]-(B)[1])<SMALL_C)&&(std::abs((A)[2]-(B)[2])<SMALL_C)) |
| 131 |
#define V3_EUKLIDNORM_OF_DIFF(A,B,b) (b) = (sqrt((double)(((A)[0]-(B)[0])*((A)[0]-(B)[0])+((A)[1]-(B)[1])*((A)[1]-(B)[1])+((A)[2]-(B)[2])*((A)[2]-(B)[2])))); |
| 132 |
#define V3_CLEAR(A) {(A)[0] = 0.0; (A)[1]= 0.0; (A)[2] = 0.0;} |
| 133 |
#define V3_SCALAR_PRODUCT(A,B,c) (c) = ((A)[0]*(B)[0]+(A)[1]*(B)[1]+(A)[2]*(B)[2]); |
| 134 |
#define V3_SCAL_PROD(A,B) ((A)[0]*(B)[0]+(A)[1]*(B)[1]+(A)[2]*(B)[2]) |
| 135 |
|
| 136 |
/* macros for matrix-vector operations */ |
| 137 |
#define M3_TIMES_V3(M,A,B) {(B)[0] = (M)[0]*(A)[0] + (M)[3]*(A)[1] + (M)[6]*(A)[2];\ |
| 138 |
(B)[1] = (M)[1]*(A)[0] + (M)[4]*(A)[1] + (M)[7]*(A)[2];\ |
| 139 |
(B)[2] = (M)[2]*(A)[0] + (M)[5]*(A)[1] + (M)[8]*(A)[2];} |
| 140 |
|
| 141 |
#define MT3_TIMES_V3(M,A,B) {(B)[0] = (M)[0][0]*(A)[0] + (M)[1][0]*(A)[1] + (M)[2][0]*(A)[2];\ |
| 142 |
(B)[1] = (M)[0][1]*(A)[0] + (M)[1][1]*(A)[1] + (M)[2][1]*(A)[2];\ |
| 143 |
(B)[2] = (M)[0][2]*(A)[0] + (M)[1][2]*(A)[1] + (M)[2][2]*(A)[2];} |
| 144 |
|
| 145 |
/* macros for matrix operations */ |
| 146 |
#define M3_DET(M) ((M)[0]*(M)[4]*(M)[8] + (M)[1]*(M)[5]*(M)[6] + (M)[2]*(M)[3]*(M)[7] \ |
| 147 |
-(M)[2]*(M)[4]*(M)[6] - (M)[0]*(M)[5]*(M)[7] - (M)[1]*(M)[3]*(M)[8]) |
| 148 |
|
| 149 |
#define M3_INVERT(M,IM,det) \ |
| 150 |
{ DOUBLE invdet; \ |
| 151 |
(det) = (M)[0][0]*(M)[1][1]*(M)[2][2] \ |
| 152 |
+ (M)[0][1]*(M)[1][2]*(M)[2][0] \ |
| 153 |
+ (M)[0][2]*(M)[1][0]*(M)[2][1] \ |
| 154 |
- (M)[0][2]*(M)[1][1]*(M)[2][0] \ |
| 155 |
- (M)[0][0]*(M)[1][2]*(M)[2][1] \ |
| 156 |
- (M)[0][1]*(M)[1][0]*(M)[2][2]; \ |
| 157 |
if (std::abs((det))<SMALL_D*SMALL_D) \ |
| 158 |
return (1); \ |
| 159 |
invdet = 1.0 / (det); \ |
| 160 |
(IM)[0][0] = ( (M)[1][1]*(M)[2][2] - (M)[1][2]*(M)[2][1]) * invdet; \ |
| 161 |
(IM)[0][1] = (-(M)[0][1]*(M)[2][2] + (M)[0][2]*(M)[2][1]) * invdet; \ |
| 162 |
(IM)[0][2] = ( (M)[0][1]*(M)[1][2] - (M)[0][2]*(M)[1][1]) * invdet; \ |
| 163 |
(IM)[1][0] = (-(M)[1][0]*(M)[2][2] + (M)[1][2]*(M)[2][0]) * invdet; \ |
| 164 |
(IM)[1][1] = ( (M)[0][0]*(M)[2][2] - (M)[0][2]*(M)[2][0]) * invdet; \ |
| 165 |
(IM)[1][2] = (-(M)[0][0]*(M)[1][2] + (M)[0][2]*(M)[1][0]) * invdet; \ |
| 166 |
(IM)[2][0] = ( (M)[1][0]*(M)[2][1] - (M)[1][1]*(M)[2][0]) * invdet; \ |
| 167 |
(IM)[2][1] = (-(M)[0][0]*(M)[2][1] + (M)[0][1]*(M)[2][0]) * invdet; \ |
| 168 |
(IM)[2][2] = ( (M)[0][0]*(M)[1][1] - (M)[0][1]*(M)[1][0]) * invdet;} |
| 169 |
|
| 170 |
/* macros for exact solver (EX) */ |
| 171 |
#define EX_MAT(m,b,i,j) ((m)[2*(b)*(i) + (j)]) |
| 172 |
|
| 173 |
/****************************************************************************/ |
| 174 |
/* */ |
| 175 |
/* typedef of DIM-routines */ |
| 176 |
/* */ |
| 177 |
/****************************************************************************/ |
| 178 |
|
| 179 |
#ifdef UG_DIM_2 |
| 180 |
|
| 181 |
#define V_DIM_LINCOMB(a,A,b,B,C) V2_LINCOMB(a,A,b,B,C) |
| 182 |
#define V_DIM_COPY(A,C) V2_COPY(A,C) |
| 183 |
#define V_DIM_SUBTRACT(A,B,C) V2_SUBTRACT(A,B,C) |
| 184 |
#define V_DIM_ADD(A,B,C) V2_ADD(A,B,C) |
| 185 |
#define V_DIM_SCALE(c,C) V2_SCALE(c,C) |
| 186 |
#define V_DIM_ISEQUAL(A,B) V2_ISEQUAL(A,B) |
| 187 |
#define V_DIM_EUKLIDNORM(A,b) V2_EUKLIDNORM(A,b) |
| 188 |
#define V_DIM_EUKLIDNORM_OF_DIFF(A,B,b) V2_EUKLIDNORM_OF_DIFF(A,B,b) |
| 189 |
#define V_DIM_CLEAR(A) V2_CLEAR(A) |
| 190 |
#define V_DIM_SCALAR_PRODUCT(A,B,c) V2_SCALAR_PRODUCT(A,B,c) |
| 191 |
#define V_DIM_SCAL_PROD(A,B) V2_SCAL_PROD(A,B) |
| 192 |
|
| 193 |
#define MT_TIMES_V_DIM(M,A,B) MT2_TIMES_V2(M,A,B) |
| 194 |
#define M_DIM_INVERT(M,IM,det) M2_INVERT(M,IM,det) |
| 195 |
|
| 196 |
#endif |
| 197 |
|
| 198 |
#ifdef UG_DIM_3 |
| 199 |
|
| 200 |
#define V_DIM_LINCOMB(a,A,b,B,C) V3_LINCOMB(a,A,b,B,C) |
| 201 |
#define V_DIM_COPY(A,C) V3_COPY(A,C) |
| 202 |
#define V_DIM_SUBTRACT(A,B,C) V3_SUBTRACT(A,B,C) |
| 203 |
#define V_DIM_ADD(A,B,C) V3_ADD(A,B,C) |
| 204 |
#define V_DIM_SCALE(c,C) V3_SCALE(c,C) |
| 205 |
#define V_DIM_ISEQUAL(A,B) V3_ISEQUAL(A,B) |
| 206 |
#define V_DIM_EUKLIDNORM(A,b) V3_EUKLIDNORM(A,b) |
| 207 |
#define V_DIM_EUKLIDNORM_OF_DIFF(A,B,b) V3_EUKLIDNORM_OF_DIFF(A,B,b) |
| 208 |
#define V_DIM_CLEAR(A) V3_CLEAR(A) |
| 209 |
#define V_DIM_SCALAR_PRODUCT(A,B,c) V3_SCALAR_PRODUCT(A,B,c) |
| 210 |
#define V_DIM_SCAL_PROD(A,B) V3_SCAL_PROD(A,B) |
| 211 |
|
| 212 |
#define MT_TIMES_V_DIM(M,A,B) MT3_TIMES_V3(M,A,B) |
| 213 |
#define M_DIM_INVERT(M,IM,det) M3_INVERT(M,IM,det) |
| 214 |
|
| 215 |
#endif |
| 216 |
|
| 217 |
|
| 218 |
/****************************************************************************/ |
| 219 |
/* */ |
| 220 |
/* function declarations */ |
| 221 |
/* */ |
| 222 |
/****************************************************************************/ |
| 223 |
|
| 224 |
/* 2D routines */ |
| 225 |
DOUBLE vp (const DOUBLE x1, const DOUBLE y1, const DOUBLE x2, const DOUBLE y2); |
| 226 |
DOUBLE c_tarea (const DOUBLE *x0, const DOUBLE *x1, const DOUBLE *x2); |
| 227 |
DOUBLE c_qarea (const DOUBLE *x0, const DOUBLE *x1, const DOUBLE *x2, const DOUBLE *x3); |
| 228 |
DOUBLE V_te (const DOUBLE *x0, const DOUBLE *x1, |
| 229 |
const DOUBLE *x2, const DOUBLE *x3); |
| 230 |
DOUBLE V_py (const DOUBLE *x0, const DOUBLE *x1, const DOUBLE *x2, |
| 231 |
const DOUBLE *x3, const DOUBLE *x4); |
| 232 |
DOUBLE V_pr (const DOUBLE *x0, const DOUBLE *x1, const DOUBLE *x2, |
| 233 |
const DOUBLE *x3, const DOUBLE *x4, const DOUBLE *x5); |
| 234 |
DOUBLE V_he (const DOUBLE *x0, const DOUBLE *x1, const DOUBLE *x2, const DOUBLE *x3, |
| 235 |
const DOUBLE *x4, const DOUBLE *x5, const DOUBLE *x6, const DOUBLE *x7); |
| 236 |
|
| 237 |
|
| 238 |
/* 3D routines */ |
| 239 |
INT M3_Invert (DOUBLE *Inverse, const DOUBLE *Matrix); |
| 240 |
INT V3_Normalize (FieldVector<DOUBLE,3>& a); |
| 241 |
|
| 242 |
|
| 243 |
/* volume calculations*/ |
| 244 |
DOUBLE GeneralElementVolume (INT tag, DOUBLE *x_co[]); |
| 245 |
DOUBLE ElementVolume (const ELEMENT *elem); |
| 246 |
|
| 247 |
END_UGDIM_NAMESPACE |
| 248 |
|
| 249 |
#endif |