1+ // ______ ______ _____ _ _ //
2+ // | ____| ____| /\ / ____| (_) | | //
3+ // | |__ | |__ / \ | (___ ___ ____ _ ____ | |_ //
4+ // | __| | __| / /\ \ \___ \ / __| __| | _ \| __| //
5+ // | | | |____ / ____ \ ____) | (__| | | | |_) | | //
6+ // |_| |______/_/ \_\_____/ \___|_| |_| __/| | //
7+ // | | | | //
8+ // |_| | |_ //
9+ // Website: https://feascript.com/ \__| //
10+
11+ export class residualsScript {
12+ /**
13+ * Constructor to initialize the residualsScript class
14+ * @param {string } dimension - The dimension of the element ('1D' or '2D')
15+ * @param {number } order - The order of the element
16+ */
17+ constructor ( { dimension, order } ) {
18+ this . dimension = dimension ;
19+ this . order = order ;
20+ }
21+
22+ /**
23+ * Return the basis functions and their derivatives based on the dimension and order
24+ * @param {number } ksi - Natural coordinate (for both 1D and 2D)
25+ * @param {number } [eta] - Second natural coordinate (only for 2D elements)
26+ * @returns {object } An object containing:
27+ * - basisFunction: Array of evaluated basis functions
28+ * - basisFunctionDerivKsi: Array of derivatives of basis functions with respect to ksi
29+ * - basisFunctionDerivEta: Array of derivatives of basis functions with respect to eta (only for 2D elements)
30+ */
31+ getBasisFunctions ( ksi , eta = null ) {
32+ let basisFunction = [ ] ;
33+ let basisFunctionDerivKsi = [ ] ;
34+ let basisFunctionDerivEta = [ ] ;
35+
36+ if ( this . dimension === "1D" && this . order === 1 ) {
37+ // Linear basis functions for 1D elements
38+ basisFunction [ 0 ] = 1 - ksi ;
39+ basisFunction [ 1 ] = ksi ;
40+
41+ // Derivatives of basis functions with respect to ksi
42+ basisFunctionDerivKsi [ 0 ] = - 1 ;
43+ basisFunctionDerivKsi [ 1 ] = 1 ;
44+ } else if ( this . dimension === "2D" && this . order === 1 ) {
45+ if ( eta === null ) {
46+ console . log ( "Eta coordinate is required for 2D elements" ) ;
47+ return ;
48+ }
49+
50+ // Linear basis functions for 2D elements
51+ function l1 ( c ) {
52+ return 1 - c ;
53+ }
54+ function l2 ( c ) {
55+ return c ;
56+ }
57+ function dl1 ( ) {
58+ return - 1 ;
59+ }
60+ function dl2 ( ) {
61+ return 1 ;
62+ }
63+
64+ // Evaluate basis functions at (ksi, eta)
65+ basisFunction [ 0 ] = l1 ( ksi ) * l1 ( eta ) ;
66+ basisFunction [ 1 ] = l1 ( ksi ) * l2 ( eta ) ;
67+ basisFunction [ 2 ] = l2 ( ksi ) * l1 ( eta ) ;
68+ basisFunction [ 3 ] = l2 ( ksi ) * l2 ( eta ) ;
69+
70+ // Derivatives with respect to ksi
71+ basisFunctionDerivKsi [ 0 ] = dl1 ( ) * l1 ( eta ) ;
72+ basisFunctionDerivKsi [ 1 ] = dl1 ( ) * l2 ( eta ) ;
73+ basisFunctionDerivKsi [ 2 ] = dl2 ( ) * l1 ( eta ) ;
74+ basisFunctionDerivKsi [ 3 ] = dl2 ( ) * l2 ( eta ) ;
75+
76+ // Derivatives with respect to eta
77+ basisFunctionDerivEta [ 0 ] = l1 ( ksi ) * dl1 ( ) ;
78+ basisFunctionDerivEta [ 1 ] = l1 ( ksi ) * dl2 ( ) ;
79+ basisFunctionDerivEta [ 2 ] = l2 ( ksi ) * dl1 ( ) ;
80+ basisFunctionDerivEta [ 3 ] = l2 ( ksi ) * dl2 ( ) ;
81+ } else if ( this . dimension === "2D" && this . order === 2 ) {
82+ if ( eta === null ) {
83+ console . log ( "Eta coordinate is required for 2D elements" ) ;
84+ return ;
85+ }
86+
87+ // Quadratic basis functions for 2D elements
88+ function l1 ( c ) {
89+ return 2 * c ** 2 - 3 * c + 1 ;
90+ }
91+ function l2 ( c ) {
92+ return - 4 * c ** 2 + 4 * c ;
93+ }
94+ function l3 ( c ) {
95+ return 2 * c ** 2 - c ;
96+ }
97+ function dl1 ( c ) {
98+ return 4 * c - 3 ;
99+ }
100+ function dl2 ( c ) {
101+ return - 8 * c + 4 ;
102+ }
103+ function dl3 ( c ) {
104+ return 4 * c - 1 ;
105+ }
106+
107+ // Evaluate basis functions at (ksi, eta)
108+ basisFunction [ 0 ] = l1 ( ksi ) * l1 ( eta ) ;
109+ basisFunction [ 1 ] = l1 ( ksi ) * l2 ( eta ) ;
110+ basisFunction [ 2 ] = l1 ( ksi ) * l3 ( eta ) ;
111+ basisFunction [ 3 ] = l2 ( ksi ) * l1 ( eta ) ;
112+ basisFunction [ 4 ] = l2 ( ksi ) * l2 ( eta ) ;
113+ basisFunction [ 5 ] = l2 ( ksi ) * l3 ( eta ) ;
114+ basisFunction [ 6 ] = l3 ( ksi ) * l1 ( eta ) ;
115+ basisFunction [ 7 ] = l3 ( ksi ) * l2 ( eta ) ;
116+ basisFunction [ 8 ] = l3 ( ksi ) * l3 ( eta ) ;
117+
118+ // Derivatives with respect to ksi
119+ basisFunctionDerivKsi [ 0 ] = dl1 ( ksi ) * l1 ( eta ) ;
120+ basisFunctionDerivKsi [ 1 ] = dl1 ( ksi ) * l2 ( eta ) ;
121+ basisFunctionDerivKsi [ 2 ] = dl1 ( ksi ) * l3 ( eta ) ;
122+ basisFunctionDerivKsi [ 3 ] = dl2 ( ksi ) * l1 ( eta ) ;
123+ basisFunctionDerivKsi [ 4 ] = dl2 ( ksi ) * l2 ( eta ) ;
124+ basisFunctionDerivKsi [ 5 ] = dl2 ( ksi ) * l3 ( eta ) ;
125+ basisFunctionDerivKsi [ 6 ] = dl3 ( ksi ) * l1 ( eta ) ;
126+ basisFunctionDerivKsi [ 7 ] = dl3 ( ksi ) * l2 ( eta ) ;
127+ basisFunctionDerivKsi [ 8 ] = dl3 ( ksi ) * l3 ( eta ) ;
128+
129+ // Derivatives with respect to eta
130+ basisFunctionDerivEta [ 0 ] = l1 ( ksi ) * dl1 ( eta ) ;
131+ basisFunctionDerivEta [ 1 ] = l1 ( ksi ) * dl2 ( eta ) ;
132+ basisFunctionDerivEta [ 2 ] = l1 ( ksi ) * dl3 ( eta ) ;
133+ basisFunctionDerivEta [ 3 ] = l2 ( ksi ) * dl1 ( eta ) ;
134+ basisFunctionDerivEta [ 4 ] = l2 ( ksi ) * dl2 ( eta ) ;
135+ basisFunctionDerivEta [ 5 ] = l2 ( ksi ) * dl3 ( eta ) ;
136+ basisFunctionDerivEta [ 6 ] = l3 ( ksi ) * dl1 ( eta ) ;
137+ basisFunctionDerivEta [ 7 ] = l3 ( ksi ) * dl2 ( eta ) ;
138+ basisFunctionDerivEta [ 8 ] = l3 ( ksi ) * dl3 ( eta ) ;
139+ } else {
140+ console . log ( "Unsupported dimension or element order" ) ;
141+ }
142+
143+ return { basisFunction, basisFunctionDerivKsi, basisFunctionDerivEta } ;
144+ }
145+
146+ /**
147+ * Return Gauss points and weights based on element configuration
148+ * @returns {object } An object containing:
149+ * - gaussPoints: Array of Gauss points
150+ * - gaussWeights: Array of Gauss weights
151+ */
152+ getGaussPointsAndWeights ( ) {
153+ let gaussPoints = [ ] ; // Gauss points
154+ let gaussWeights = [ ] ; // Gauss weights
155+
156+ if ( this . dimension === "1D" && this . order === 1 ) {
157+ console . log ( "Unsupported dimension or element order" ) ;
158+ } else if ( this . dimension === "2D" && this . order === 2 ) {
159+ // For 2D quadratic elements, use 3-point Gauss quadrature in each direction
160+ gaussPoints [ 0 ] = ( 1 - Math . sqrt ( 3 / 5 ) ) / 2 ;
161+ gaussPoints [ 1 ] = 0.5 ;
162+ gaussPoints [ 2 ] = ( 1 + Math . sqrt ( 3 / 5 ) ) / 2 ;
163+ gaussWeights [ 0 ] = 5 / 18 ;
164+ gaussWeights [ 1 ] = 8 / 18 ;
165+ gaussWeights [ 2 ] = 5 / 18 ;
166+ } else {
167+ console . log ( "Unsupported dimension or element order" ) ;
168+ }
169+
170+ return { gaussPoints, gaussWeights } ;
171+ }
172+ }
0 commit comments