LORENE
base_val_name_theta.C
1/*
2 * Method Base_val::name_theta
3 *
4 * (see file base_val.h for documentation).
5 *
6 */
7
8/*
9 * Copyright (c) 2003 Eric Gourgoulhon.
10 *
11 * This file is part of LORENE.
12 *
13 * LORENE is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License version 2
15 * as published by the Free Software Foundation.
16 *
17 * LORENE is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with LORENE; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 */
27
28char base_val_name_theta_C[] = "$Header: /cvsroot/Lorene/C++/Source/Base_val/base_val_name_theta.C,v 1.9 2014/10/13 08:52:39 j_novak Exp $" ;
29
30/*
31 * $Id: base_val_name_theta.C,v 1.9 2014/10/13 08:52:39 j_novak Exp $
32 * $Log: base_val_name_theta.C,v $
33 * Revision 1.9 2014/10/13 08:52:39 j_novak
34 * Lorene classes and functions now belong to the namespace Lorene.
35 *
36 * Revision 1.8 2014/10/06 15:12:57 j_novak
37 * Modified #include directives to use c++ syntax.
38 *
39 * Revision 1.7 2009/10/23 12:55:16 j_novak
40 * New base T_LEG_MI
41 *
42 * Revision 1.6 2009/10/08 16:20:13 j_novak
43 * Addition of new bases T_COS and T_SIN.
44 *
45 * Revision 1.5 2004/12/17 13:35:01 m_forot
46 * Add the case T_LEG
47 *
48 * Revision 1.4 2004/11/23 15:08:01 m_forot
49 * Added the bases for the cases without any equatorial symmetry
50 * (T_COSSIN_C, T_COSSIN_S, T_LEG, R_CHEBPI_P, R_CHEBPI_I).
51 *
52 * Revision 1.3 2004/10/04 13:40:38 j_novak
53 * Added the T_COS base case.
54 *
55 * Revision 1.2 2004/08/24 09:14:41 p_grandclement
56 * Addition of some new operators, like Poisson in 2d... It now requieres the
57 * GSL library to work.
58 *
59 * Also, the way a variable change is stored by a Param_elliptic is changed and
60 * no longer uses Change_var but rather 2 Scalars. The codes using that feature
61 * will requiere some modification. (It should concern only the ones about monopoles)
62 *
63 * Revision 1.1 2003/10/19 19:49:40 e_gourgoulhon
64 * First version
65 *
66 *
67 *
68 * $Header: /cvsroot/Lorene/C++/Source/Base_val/base_val_name_theta.C,v 1.9 2014/10/13 08:52:39 j_novak Exp $
69 *
70 */
71
72// C headers
73#include <cstring>
74#include <cstdlib>
75
76// Lorene headers
77#include "type_parite.h"
78#include "base_val.h"
79
80// Local prototypes
81namespace Lorene {
82void basename_t_unknown(int, int, char*) ;
83void basename_t_cos(int, int, char*) ;
84void basename_t_sin(int, int, char*) ;
85void basename_t_cos_p(int, int, char*) ;
86void basename_t_sin_p(int, int, char*) ;
87void basename_t_cos_i(int, int, char*) ;
88void basename_t_sin_i(int, int, char*) ;
89void basename_t_cossin_cp(int, int, char*) ;
90void basename_t_cossin_sp(int, int, char*) ;
91void basename_t_cossin_c(int, int, char*) ;
92void basename_t_cossin_s(int, int, char*) ;
93void basename_t_cossin_ci(int, int, char*) ;
94void basename_t_cossin_si(int, int, char*) ;
95void basename_t_leg_p(int, int, char*) ;
96void basename_t_leg(int, int, char*) ;
97void basename_t_leg_mp(int, int, char*) ;
98void basename_t_leg_mi(int, int, char*) ;
99void basename_t_leg_pp(int, int, char*) ;
100void basename_t_leg_i(int, int, char*) ;
101void basename_t_leg_ip(int, int, char*) ;
102void basename_t_leg_pi(int, int, char*) ;
103void basename_t_leg_ii(int, int, char*) ;
104void basename_t_cl_cos_p(int, int, char*) ;
105void basename_t_cl_sin_p(int, int, char*) ;
106void basename_t_cl_cos_i(int, int, char*) ;
107void basename_t_cl_sin_i(int, int, char*) ;
108
109
110 //----------------------------//
111 // Base_val method //
112 //----------------------------//
113
114void Base_val::name_theta(int l, int k, int j, char* name) const {
115
116 // Array of actual base name functions
117 static void(*vbasename_t[MAX_BASE])(int, int, char*) ;
118
119 static bool first_call = true ;
120
121 // Initializations at first call
122 // -----------------------------
123 if ( first_call ) {
124
125 first_call = false ;
126
127 for (int i=0 ; i<MAX_BASE ; i++) {
128 vbasename_t[i] = basename_t_unknown ;
129 }
130
131 vbasename_t[T_COS >> TRA_T] = basename_t_cos ;
132 vbasename_t[T_SIN >> TRA_T] = basename_t_sin ;
133 vbasename_t[T_COS_P >> TRA_T] = basename_t_cos_p ;
134 vbasename_t[T_SIN_P >> TRA_T] = basename_t_sin_p ;
135 vbasename_t[T_COS_I >> TRA_T] = basename_t_cos_i ;
136 vbasename_t[T_SIN_I >> TRA_T] = basename_t_sin_i ;
137 vbasename_t[T_COSSIN_CP >> TRA_T] = basename_t_cossin_cp ;
138 vbasename_t[T_COSSIN_SP >> TRA_T] = basename_t_cossin_sp ;
139 vbasename_t[T_COSSIN_CI >> TRA_T] = basename_t_cossin_ci ;
140 vbasename_t[T_COSSIN_SI >> TRA_T] = basename_t_cossin_si ;
141 vbasename_t[T_COSSIN_C >> TRA_T] = basename_t_cossin_c ;
142 vbasename_t[T_COSSIN_S >> TRA_T] = basename_t_cossin_s ;
143 vbasename_t[T_LEG_P >> TRA_T] = basename_t_leg_p ;
144 vbasename_t[T_LEG_MP >> TRA_T] = basename_t_leg_mp ;
145 vbasename_t[T_LEG_MI >> TRA_T] = basename_t_leg_mi ;
146 vbasename_t[T_LEG >> TRA_T] = basename_t_leg ;
147 vbasename_t[T_LEG_PP >> TRA_T] = basename_t_leg_pp ;
148 vbasename_t[T_LEG_I >> TRA_T] = basename_t_leg_i ;
149 vbasename_t[T_LEG_IP >> TRA_T] = basename_t_leg_ip ;
150 vbasename_t[T_LEG_PI >> TRA_T] = basename_t_leg_pi ;
151 vbasename_t[T_LEG_II >> TRA_T] = basename_t_leg_ii ;
152 vbasename_t[T_CL_COS_P >> TRA_T] = basename_t_cl_cos_p ;
153 vbasename_t[T_CL_SIN_P >> TRA_T] = basename_t_cl_sin_p ;
154 vbasename_t[T_CL_COS_I >> TRA_T] = basename_t_cl_cos_i ;
155 vbasename_t[T_CL_SIN_I >> TRA_T] = basename_t_cl_sin_i ;
156
157 }
158
159 // Call to the function adapted to the basis in domain l
160 //------------------------------------------------------
161
162 assert( (l>=0) && (l<nzone) ) ;
163
164 int base_t = ( b[l] & MSQ_T ) >> TRA_T ;
165
166 vbasename_t[base_t](k, j, name) ;
167
168}
169
170
171 //-------------------------------//
172 // individual basis functions //
173 //-------------------------------//
174
175void basename_t_unknown(int, int, char*) {
176 cout << "Base_val::name_theta : unknwon basis !" << endl ;
177 abort() ;
178}
179
180
181void basename_t_cos(int , int j, char* name) {
182
183 assert( j>=0 ) ;
184
185 strcpy(name, "cos") ;
186
187 int xt = j ;
188
189 char cxt[4] ;
190 assert( xt < 1000) ;
191 sprintf(cxt, "%d", xt) ;
192 strcat(name, cxt) ;
193 strcat(name, "t") ;
194}
195
196void basename_t_sin(int , int j, char* name) {
197
198 assert( j>=0 ) ;
199
200 strcpy(name, "sin") ;
201
202 int xt = j ;
203
204 char cxt[4] ;
205 assert( xt < 1000) ;
206 sprintf(cxt, "%d", xt) ;
207 strcat(name, cxt) ;
208 strcat(name, "t") ;
209}
210
211
212void basename_t_cos_p(int , int j, char* name) {
213
214 assert( j>=0 ) ;
215
216 strcpy(name, "cos") ;
217
218 int xt = 2*j ;
219
220 char cxt[4] ;
221 assert( xt < 1000) ;
222 sprintf(cxt, "%d", xt) ;
223 strcat(name, cxt) ;
224 strcat(name, "t") ;
225}
226
227
228void basename_t_sin_p(int , int j, char* name) {
229
230 assert( j>=0 ) ;
231
232 if (j == 0) {
233 strcpy(name, "unused") ;
234 return ;
235 }
236
237 strcpy(name, "sin") ;
238
239 int xt = 2*j ;
240
241 char cxt[4] ;
242 assert( xt < 1000) ;
243 sprintf(cxt, "%d", xt) ;
244 strcat(name, cxt) ;
245 strcat(name, "t") ;
246}
247
248void basename_t_cl_cos_p(int , int j, char* name) {
249
250 assert( j>=0 ) ;
251
252 strcpy(name, "cl_cos") ;
253
254 int xt = 2*j ;
255
256 char cxt[4] ;
257 assert( xt < 1000) ;
258 sprintf(cxt, "%d", xt) ;
259 strcat(name, cxt) ;
260 strcat(name, "t") ;
261}
262
263void basename_t_cl_sin_p(int , int j, char* name) {
264
265 assert( j>=0 ) ;
266
267 strcpy(name, "cl_sin") ;
268
269 int xt = 2*j ;
270
271 char cxt[4] ;
272 assert( xt < 1000) ;
273 sprintf(cxt, "%d", xt) ;
274 strcat(name, cxt) ;
275 strcat(name, "t") ;
276}
277
278void basename_t_cos_i(int , int j, char* name) {
279
280 assert( j>=0 ) ;
281
282 strcpy(name, "cos") ;
283
284 int xt = 2*j + 1 ;
285
286 char cxt[4] ;
287 assert( xt < 1000) ;
288 sprintf(cxt, "%d", xt) ;
289 strcat(name, cxt) ;
290 strcat(name, "t") ;
291}
292
293void basename_t_cl_cos_i(int , int j, char* name) {
294
295 assert( j>=0 ) ;
296
297 strcpy(name, "cl_cos") ;
298
299 int xt = 2*j + 1 ;
300
301 char cxt[4] ;
302 assert( xt < 1000) ;
303 sprintf(cxt, "%d", xt) ;
304 strcat(name, cxt) ;
305 strcat(name, "t") ;
306}
307
308void basename_t_sin_i(int , int j, char* name) {
309
310 assert( j>=0 ) ;
311
312 strcpy(name, "sin") ;
313
314 int xt = 2*j + 1 ;
315
316 char cxt[4] ;
317 assert( xt < 1000) ;
318 sprintf(cxt, "%d", xt) ;
319 strcat(name, cxt) ;
320 strcat(name, "t") ;
321}
322
323void basename_t_cl_sin_i(int , int j, char* name) {
324
325 assert( j>=0 ) ;
326
327 strcpy(name, "cl_sin") ;
328
329 int xt = 2*j + 1 ;
330
331 char cxt[4] ;
332 assert( xt < 1000) ;
333 sprintf(cxt, "%d", xt) ;
334 strcat(name, cxt) ;
335 strcat(name, "t") ;
336}
337
338
339void basename_t_cossin_cp(int k, int j, char* name) {
340
341 assert( k>=0 ) ;
342 assert( j>=0 ) ;
343
344 int m = k / 2 ;
345 int xt ;
346 if (m%2 == 0) {
347 strcpy(name, "cos") ;
348 xt = 2*j ;
349 }
350 else {
351 strcpy(name, "sin") ;
352 xt = 2*j + 1 ;
353 }
354
355 char cxt[4] ;
356 assert( xt < 1000) ;
357 sprintf(cxt, "%d", xt) ;
358 strcat(name, cxt) ;
359 strcat(name, "t") ;
360}
361
362
363void basename_t_cossin_sp(int k, int j, char* name) {
364
365 assert( k>=0 ) ;
366 assert( j>=0 ) ;
367
368 int m = k / 2 ;
369 int xt ;
370 if (m%2 == 0) {
371 if (j == 0) {
372 strcpy(name, "unused") ;
373 return ;
374 }
375 else {
376 strcpy(name, "sin") ;
377 xt = 2*j ;
378 }
379 }
380 else {
381 strcpy(name, "cos") ;
382 xt = 2*j + 1 ;
383 }
384
385 char cxt[4] ;
386 assert( xt < 1000) ;
387 sprintf(cxt, "%d", xt) ;
388 strcat(name, cxt) ;
389 strcat(name, "t") ;
390}
391
392void basename_t_cossin_c(int k, int j, char* name) {
393
394 assert( k>=0 ) ;
395 assert( j>=0 ) ;
396
397 int m = k / 2 ;
398 int xt ;
399 if (m%2 == 0) {
400 strcpy(name, "cos") ;
401 xt = j ;
402 }
403 else {
404 if (j == 0) {
405 strcpy(name, "unused") ;
406 return ;
407 } else {
408 strcpy(name, "sin") ;
409 xt = j ;
410 }
411 }
412
413 char cxt[4] ;
414 assert( xt < 1000) ;
415 sprintf(cxt, "%d", xt) ;
416 strcat(name, cxt) ;
417 strcat(name, "t") ;
418}
419
420
421void basename_t_cossin_s(int k, int j, char* name) {
422
423 assert( k>=0 ) ;
424 assert( j>=0 ) ;
425
426 int m = k / 2 ;
427 int xt ;
428 if (m%2 == 0) {
429 if (j == 0) {
430 strcpy(name, "unused") ;
431 return ;
432 }
433 else {
434 strcpy(name, "sin") ;
435 xt = j ;
436 }
437 }
438 else {
439 strcpy(name, "cos") ;
440 xt = j ;
441 }
442
443 char cxt[4] ;
444 assert( xt < 1000) ;
445 sprintf(cxt, "%d", xt) ;
446 strcat(name, cxt) ;
447 strcat(name, "t") ;
448}
449
450
451void basename_t_cossin_ci(int k, int j, char* name) {
452
453 assert( k>=0 ) ;
454 assert( j>=0 ) ;
455
456 int m = k / 2 ;
457 int xt ;
458 if (m%2 == 0) {
459 strcpy(name, "cos") ;
460 xt = 2*j + 1;
461 }
462 else {
463 if (j == 0) {
464 strcpy(name, "unused") ;
465 return ;
466 }
467 else {
468 strcpy(name, "sin") ;
469 xt = 2*j ;
470 }
471 }
472
473 char cxt[4] ;
474 assert( xt < 1000) ;
475 sprintf(cxt, "%d", xt) ;
476 strcat(name, cxt) ;
477 strcat(name, "t") ;
478}
479
480
481void basename_t_cossin_si(int k, int j, char* name) {
482
483 assert( k>=0 ) ;
484 assert( j>=0 ) ;
485
486 int m = k / 2 ;
487 int xt ;
488 if (m%2 == 0) {
489 strcpy(name, "sin") ;
490 xt = 2*j + 1;
491 }
492 else {
493 strcpy(name, "cos") ;
494 xt = 2*j ;
495 }
496
497 char cxt[4] ;
498 assert( xt < 1000) ;
499 sprintf(cxt, "%d", xt) ;
500 strcat(name, cxt) ;
501 strcat(name, "t") ;
502}
503
504void basename_t_leg(int k, int j, char* name) {
505
506 assert( k>=0 ) ;
507 assert( j>=0 ) ;
508
509 int m = k / 2 ;
510
511 if (j < m/2) {
512 strcpy (name, "unused") ;
513 return ;
514 }
515
516 strcpy(name, "P_") ;
517
518 int xt = j;
519
520 char cxt[4] ;
521 assert( xt < 1000) ;
522 sprintf(cxt, "%d", xt) ;
523 strcat(name, cxt) ;
524 strcat(name, "^") ;
525
526 assert( m < 1000) ;
527 sprintf(cxt, "%d", m) ;
528 strcat(name, cxt) ;
529}
530
531void basename_t_leg_mp(int k, int j, char* name) {
532
533 assert( k>=0 ) ;
534 assert( j>=0 ) ;
535
536 int m = 2 * (k / 2) ;
537
538 if (j < m/2) {
539 strcpy (name, "unused") ;
540 return ;
541 }
542
543 strcpy(name, "P_") ;
544
545 int xt = j;
546
547 char cxt[4] ;
548 assert( xt < 1000) ;
549 sprintf(cxt, "%d", xt) ;
550 strcat(name, cxt) ;
551 strcat(name, "^") ;
552
553 assert( m < 1000) ;
554 sprintf(cxt, "%d", m) ;
555 strcat(name, cxt) ;
556}
557
558void basename_t_leg_mi(int k, int j, char* name) {
559
560 assert( k>=0 ) ;
561 assert( j>=0 ) ;
562
563 int m = 2 * ((k-1) / 2) + 1 ;
564
565 if (j < m/2) {
566 strcpy (name, "unused") ;
567 return ;
568 }
569
570 strcpy(name, "P_") ;
571
572 int xt = j;
573
574 char cxt[4] ;
575 assert( xt < 1000) ;
576 sprintf(cxt, "%d", xt) ;
577 strcat(name, cxt) ;
578 strcat(name, "^") ;
579
580 assert( m < 1000) ;
581 sprintf(cxt, "%d", m) ;
582 strcat(name, cxt) ;
583}
584
585void basename_t_leg_p(int k, int j, char* name) {
586
587 assert( k>=0 ) ;
588 assert( j>=0 ) ;
589
590 int m = k / 2 ;
591
592 if (j < m/2) {
593 strcpy (name, "unused") ;
594 return ;
595 }
596
597 strcpy(name, "P_") ;
598
599 int xt = (m%2 == 0) ? 2*j : 2*j + 1 ;
600
601 char cxt[4] ;
602 assert( xt < 1000) ;
603 sprintf(cxt, "%d", xt) ;
604 strcat(name, cxt) ;
605 strcat(name, "^") ;
606
607 assert( m < 1000) ;
608 sprintf(cxt, "%d", m) ;
609 strcat(name, cxt) ;
610}
611
612
613void basename_t_leg_pp(int k, int j, char* name) {
614
615 assert( k>=0 ) ;
616 assert( j>=0 ) ;
617
618 int m = 2 * (k / 2) ;
619
620 if (j < m/2) {
621 strcpy (name, "unused") ;
622 return ;
623 }
624
625 strcpy(name, "P_") ;
626
627 int xt = 2*j ;
628
629 char cxt[4] ;
630 assert( xt < 1000) ;
631 sprintf(cxt, "%d", xt) ;
632 strcat(name, cxt) ;
633 strcat(name, "^") ;
634
635 assert( m < 1000) ;
636 sprintf(cxt, "%d", m) ;
637 strcat(name, cxt) ;
638}
639
640
641void basename_t_leg_i(int k, int j, char* name) {
642
643 assert( k>=0 ) ;
644 assert( j>=0 ) ;
645
646 int m = k / 2 ;
647
648 if (j < m/2 + m%2) {
649 strcpy (name, "unused") ;
650 return ;
651 }
652
653 strcpy(name, "P_") ;
654
655 int xt = (m%2 == 0) ? 2*j + 1 : 2*j ;
656
657 char cxt[4] ;
658 assert( xt < 1000) ;
659 sprintf(cxt, "%d", xt) ;
660 strcat(name, cxt) ;
661 strcat(name, "^") ;
662
663 assert( m < 1000) ;
664 sprintf(cxt, "%d", m) ;
665 strcat(name, cxt) ;
666}
667
668
669void basename_t_leg_ip(int k, int j, char* name) {
670
671 assert( k>=0 ) ;
672 assert( j>=0 ) ;
673
674 int m = 2 * (k / 2) ;
675
676 if (j < m/2) {
677 strcpy (name, "unused") ;
678 return ;
679 }
680
681 strcpy(name, "P_") ;
682
683 int xt = 2*j + 1 ;
684
685 char cxt[4] ;
686 assert( xt < 1000) ;
687 sprintf(cxt, "%d", xt) ;
688 strcat(name, cxt) ;
689 strcat(name, "^") ;
690
691 assert( m < 1000) ;
692 sprintf(cxt, "%d", m) ;
693 strcat(name, cxt) ;
694}
695
696
697void basename_t_leg_pi(int k, int j, char* name) {
698
699 assert( k>=0 ) ;
700 assert( j>=0 ) ;
701
702 int m = 2 * ((k-1) / 2) + 1 ;
703
704 if (j < m/2) {
705 strcpy (name, "unused") ;
706 return ;
707 }
708
709 strcpy(name, "P_") ;
710
711 int xt = 2*j + 1 ;
712
713 char cxt[4] ;
714 assert( xt < 1000) ;
715 sprintf(cxt, "%d", xt) ;
716 strcat(name, cxt) ;
717 strcat(name, "^") ;
718
719 assert( m < 1000) ;
720 sprintf(cxt, "%d", m) ;
721 strcat(name, cxt) ;
722}
723
724
725void basename_t_leg_ii(int k, int j, char* name) {
726
727 assert( k>=0 ) ;
728 assert( j>=0 ) ;
729
730 int m = 2 * ((k-1) / 2) + 1 ;
731
732 if (j < m/2 + 1) {
733 strcpy (name, "unused") ;
734 return ;
735 }
736
737 strcpy(name, "P_") ;
738
739 int xt = 2*j ;
740
741 char cxt[4] ;
742 assert( xt < 1000) ;
743 sprintf(cxt, "%d", xt) ;
744 strcat(name, cxt) ;
745 strcat(name, "^") ;
746
747 assert( m < 1000) ;
748 sprintf(cxt, "%d", m) ;
749 strcat(name, cxt) ;
750}
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765}
void name_theta(int l, int k, int j, char *basename) const
Name of the basis function in .
int * b
Array (size: nzone ) of the spectral basis in each domain.
Definition base_val.h:331
int nzone
Number of domains (zones)
Definition base_val.h:327
#define T_CL_COS_I
CL of odd cosines.
#define T_CL_SIN_I
CL of odd sines.
#define TRA_T
Translation en Theta, used for a bitwise shift (in hex)
#define T_LEG_MP
fct. de Legendre associees avec m pair
#define MAX_BASE
Nombre max. de bases differentes.
#define T_LEG_PI
fct. de Legendre associees paires avec m impair
#define T_COSSIN_SP
sin pair-cos impair alternes, sin pour m=0
#define T_LEG
fct. de Legendre associees
#define T_SIN_P
dev. sin seulement, harmoniques paires
#define T_COSSIN_S
dev. cos-sin alternes, sin pour m=0
#define T_COSSIN_SI
sin impair-cos pair alternes, sin pour m=0
#define T_CL_SIN_P
CL of even sines.
#define T_LEG_P
fct. de Legendre associees paires
#define T_LEG_IP
fct. de Legendre associees impaires avec m pair
#define T_COS_P
dev. cos seulement, harmoniques paires
#define T_COSSIN_CI
cos impair-sin pair alternes, cos pour m=0
#define T_CL_COS_P
CL of even cosines.
#define T_LEG_MI
fct. de Legendre associees avec m impair
#define MSQ_T
Extraction de l'info sur Theta.
#define T_COSSIN_CP
cos pair-sin impair alternes, cos pour m=0
#define T_LEG_II
fct. de Legendre associees impaires avec m impair
#define T_LEG_I
fct. de Legendre associees impaires
#define T_SIN_I
dev. sin seulement, harmoniques impaires
#define T_COS
dev. cos seulement
#define T_SIN
dev. sin seulement
#define T_LEG_PP
fct. de Legendre associees paires avec m pair
#define T_COS_I
dev. cos seulement, harmoniques impaires
#define T_COSSIN_C
dev. cos-sin alternes, cos pour m=0
Lorene prototypes.
Definition app_hor.h:64