Debian Codegraph @

dune/uggrid/gm/evm.h

raw
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