LORENE
nullite_plm.C
1/*
2 * Copyright (c) 1999-2001 Philippe Grandclement
3 * Copyright (c) 2000-2001 Eric Gourgoulhon
4 *
5 * This file is part of LORENE.
6 *
7 * LORENE is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * LORENE is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with LORENE; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 */
22
23
24char nullite_plm_C[] = "$Header: /cvsroot/Lorene/C++/Source/Non_class_members/Coef/nullite_plm.C,v 1.8 2014/10/13 08:53:14 j_novak Exp $" ;
25
26/*
27 * $Id: nullite_plm.C,v 1.8 2014/10/13 08:53:14 j_novak Exp $
28 * $Log: nullite_plm.C,v $
29 * Revision 1.8 2014/10/13 08:53:14 j_novak
30 * Lorene classes and functions now belong to the namespace Lorene.
31 *
32 * Revision 1.7 2014/10/06 15:16:04 j_novak
33 * Modified #include directives to use c++ syntax.
34 *
35 * Revision 1.6 2009/10/23 12:54:47 j_novak
36 * New base T_LEG_MI
37 *
38 * Revision 1.5 2009/10/13 19:45:01 j_novak
39 * New base T_LEG_MP.
40 *
41 * Revision 1.4 2005/02/16 15:19:55 m_forot
42 * Add the case T_LEG
43 *
44 * Revision 1.3 2003/09/16 12:11:59 j_novak
45 * Added the base T_LEG_II.
46 *
47 * Revision 1.2 2002/10/16 14:36:57 j_novak
48 * Reorganization of #include instructions of standard C++, in order to
49 * use experimental version 3 of gcc.
50 *
51 * Revision 1.1.1.1 2001/11/20 15:19:28 e_gourgoulhon
52 * LORENE
53 *
54 * Revision 2.8 2000/10/04 14:56:34 eric
55 * nullite_plm_nonsym_anti : borne_sup est mise toujours egale a nt-2
56 * (et non plus a nt-1 dans le cas m pair).
57 * Ajout des bases T_LEG_IP et T_LEG_PI (deja dans la version 2.7).
58 *
59 * Revision 2.7 2000/10/03 14:20:09 eric
60 * *** empty log message ***
61 *
62 * Revision 2.6 1999/12/16 16:41:27 phil
63 * *** empty log message ***
64 *
65 * Revision 2.5 1999/12/16 16:16:45 phil
66 * correction cas nt = 1
67 *
68 * Revision 2.4 1999/09/16 12:05:51 phil
69 * correction des cas antisym en z=0
70 *
71 * Revision 2.3 1999/09/14 17:52:47 phil
72 * *** empty log message ***
73 *
74 * Revision 2.2 1999/09/14 17:41:48 phil
75 * On commence l'ajout des cas antisymetriques en z=0
76 *
77 * Revision 2.1 1999/04/13 13:49:10 phil
78 * *** empty log message ***
79 *
80 * Revision 2.0 1999/04/13 13:31:15 phil
81 * *** empty log message ***
82 *
83 *
84 * $Header: /cvsroot/Lorene/C++/Source/Non_class_members/Coef/nullite_plm.C,v 1.8 2014/10/13 08:53:14 j_novak Exp $
85 *
86 */
87
88// Entetes C
89#include <cstdlib>
90
91// Entete Lorene
92#include "headcpp.h"
93#include "type_parite.h"
94#include "base_val.h"
95
96
97// fonction testant la nullite des fonctions de developpements
98// j indice en theta -- nt nbre de points en theta
99// k indice en phi -- np nbre de points en phi
100
101 //-------------------------------------------------------
102 // Developpement en P_COSSIN pour phi et T_LEG en theta
103 //---------------------------------------------------------
104
105namespace Lorene {
106int nullite_plm_t_leg (int j, int nt, int k, int np) {
107
108 int m = (k%2 == 0) ? k/2 : (k-1)/2 ;
109 int borne_sup = nt-1 ;
110 int borne_inf = m ;
111 if ((j<borne_inf) || (j>borne_sup) || (k==1) || (k>np))
112 return 0 ; else return 1 ;
113}
114
115
116 //-------------------------------------------------------
117 // Developpement en P_COSSIN pour phi et T_LEG_P en theta
118 //---------------------------------------------------------
119
120int nullite_plm_nonsym (int j, int nt, int k, int np) {
121
122 int m = (k%2 == 0) ? k/2 : (k-1)/2 ;
123 int borne_sup = (m%2 == 0) ? nt-1 : nt-2 ;
124 int borne_inf = (m%2 == 0) ? m/2 : (m-1)/2 ;
125 if ((j<borne_inf) || (j>borne_sup) || (k==1) || (k>np))
126 return 0 ; else return 1 ;
127}
128
129 //-------------------------------------------------------
130 // Developpement en P_COSSIN pour phi et T_LEG_I en theta
131 //---------------------------------------------------------
132
133int nullite_plm_nonsym_anti (int j, int nt, int k, int np) {
134
135 int m = (k%2 == 0) ? k/2 : (k-1)/2 ;
136
137 int borne_sup = nt-2 ;
138
139 int borne_inf = (m%2 == 0) ? m/2 : (m-1)/2 ;
140 if ((j<borne_inf) || (j>borne_sup) || (k==1) || (k>np))
141 return 0 ; else return 1 ;
142}
143
144
145
146
147 //------------------------------------------------------
148 // Developpement en P_COSSIN_P pour phi et T_LEG_PP en theta
149 //------------------------------------------------------
150
151int nullite_plm_sym (int j, int nt, int k, int np) {
152
153 int m = (k%2 == 0) ? k : k-1 ;
154 int borne_inf = m/2 ;
155 int borne_sup = nt-1 ;
156 if ((j<borne_inf) || (j>borne_sup) || (k==1) || (k>np))
157 return 0 ; else return 1 ;
158}
159
160
161 //-------------------------------------------------------
162 // Developpement en P_COSSIN_P pour phi et T_LEG_IP en theta
163 //---------------------------------------------------------
164
165int nullite_plm_t_leg_ip(int j, int nt, int k, int np) {
166
167 int m = (k%2 == 0) ? k : k-1 ;
168 int borne_sup = nt-2 ;
169 int borne_inf = m/2 ;
170 if ((j<borne_inf) || (j>borne_sup) || (k==1) || (k>np))
171 return 0 ; else return 1 ;
172}
173
174
175 //-------------------------------------------------------
176 // Developpement en P_COSSIN_I pour phi et T_LEG_PI en theta
177 //---------------------------------------------------------
178
179int nullite_plm_t_leg_pi(int j, int nt, int k, int np) {
180
181 int m ;
182 if (k<=2) {
183 m = 1 ;
184 }
185 else{
186 m = (k%2 == 0) ? k-1 : k ;
187 }
188
189 int borne_sup = nt-2 ;
190 int borne_inf = (m-1)/2 ;
191 if ((j<borne_inf) || (j>borne_sup) || (k==1) || (k>np))
192 return 0 ; else return 1 ;
193}
194
195 //-------------------------------------------------------
196 // Developpement en P_COSSIN_I pour phi et T_LEG_II en theta
197 //---------------------------------------------------------
198
199int nullite_plm_t_leg_ii(int j, int nt, int k, int np) {
200
201 int m ;
202 if (k<=2) {
203 m = 1 ;
204 }
205 else{
206 m = (k%2 == 0) ? k-1 : k ;
207 }
208
209 int borne_sup = nt-2 ;
210 int borne_inf = (m+1)/2 ;
211 if ((j<borne_inf) || (j>borne_sup) || (k==1) || (k>np))
212 return 0 ; else return 1 ;
213}
214
215 //----------------------------------------------------------
216 // Developpement en P_COSSIN_P pour phi et T_LEG_MP en theta
217 //------------------------------------------------------------
218
219int nullite_plm_t_leg_mp (int j, int nt, int k, int np) {
220
221 int m = (k%2 == 0) ? k : k-1 ;
222 int borne_inf = m ;
223 int borne_sup = nt-1 ;
224 if ((j<borne_inf) || (j>borne_sup) || (k==1) || (k>np))
225 return 0 ; else return 1 ;
226}
227
228
229 //----------------------------------------------------------
230 // Developpement en P_COSSIN_P pour phi et T_LEG_MI en theta
231 //------------------------------------------------------------
232
233int nullite_plm_t_leg_mi (int j, int nt, int k, int np) {
234
235 int m = 2*( (k-1) / 2) + 1 ;
236 int borne_inf = m ;
237 int borne_sup = nt-1 ;
238 if ((j<borne_inf) || (j>borne_sup) || (k==1) || (k>np))
239 return 0 ; else return 1 ;
240}
241
242
243
244
245 //-----------------------------
246 // La fonction
247 //-------------------------------
248
249int nullite_plm (int j, int nt, int k, int np, Base_val base) {
250
251 // on recupere les bases angulaires dans le noyau :
252 // elles doivent etre identiques dans toutes les zones.
253
254 int base_t = (base.b[0] & MSQ_T) ;
255 int base_p = (base.b[0] & MSQ_P) ;
256 int result ;
257
258 switch (base_p) {
259 case P_COSSIN :
260 // cas sym ou antisym en z=0 ...
261 switch (base_t) {
262 case T_LEG_P :
263 result = nullite_plm_nonsym (j, nt, k, np) ;
264 break ;
265
266
267 case T_LEG_I :
268 result = nullite_plm_nonsym_anti (j, nt, k, np) ;
269 break ;
270
271 case T_LEG :
272 result = nullite_plm_t_leg (j, nt, k, np) ;
273 break ;
274
275 default :
276 cout << "nullite_plm : cas inconnu ..." << endl ;
277 abort() ;
278 }
279 break ;
280
281 case P_COSSIN_P :
282 switch (base_t) {
283 case T_LEG_PP :
284 result = nullite_plm_sym (j, nt, k, np) ;
285 break ;
286
287
288 case T_LEG_IP :
289 result = nullite_plm_t_leg_ip (j, nt, k, np) ;
290 break ;
291
292 case T_LEG_MP :
293 result = nullite_plm_t_leg_mp (j, nt, k, np) ;
294 break ;
295
296 default :
297 cout << "nullite_plm : cas inconnu ..." << endl ;
298 abort() ;
299 }
300 break ;
301
302 case P_COSSIN_I :
303 switch (base_t) {
304 case T_LEG_PI :
305 result = nullite_plm_t_leg_pi (j, nt, k, np) ;
306 break ;
307
308 case T_LEG_II :
309 result = nullite_plm_t_leg_ii (j, nt, k, np) ;
310 break ;
311
312 case T_LEG_MI :
313 result = nullite_plm_t_leg_mi (j, nt, k, np) ;
314 break ;
315
316 default :
317 cout << "nullite_plm : cas inconnu ..." << endl ;
318 abort() ;
319 }
320 break ;
321
322 default :
323 cout << "nullite_plm : cas inconnu ..." << endl ;
324 abort() ;
325 }
326
327 return result ;
328}
329}
#define T_LEG_MP
fct. de Legendre associees avec m pair
#define P_COSSIN_P
dev. sur Phi = 2*phi, freq. paires
#define T_LEG_PI
fct. de Legendre associees paires avec m impair
#define T_LEG
fct. de Legendre associees
#define T_LEG_P
fct. de Legendre associees paires
#define T_LEG_IP
fct. de Legendre associees impaires avec m pair
#define P_COSSIN
dev. standart
#define P_COSSIN_I
dev. sur Phi = 2*phi, freq. impaires
#define T_LEG_MI
fct. de Legendre associees avec m impair
#define MSQ_T
Extraction de l'info sur Theta.
#define T_LEG_II
fct. de Legendre associees impaires avec m impair
#define T_LEG_I
fct. de Legendre associees impaires
#define MSQ_P
Extraction de l'info sur Phi.
#define T_LEG_PP
fct. de Legendre associees paires avec m pair
Lorene prototypes.
Definition app_hor.h:64