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 
24 char 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 
105 namespace Lorene {
106 int 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 
120 int 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 
133 int 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 
151 int 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 
165 int 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 
179 int 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 
199 int 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 
219 int 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 
233 int 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 
249 int 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
fct. de Legendre associees
Definition: type_parite.h:236
#define T_LEG_MP
fct. de Legendre associees avec m pair
Definition: type_parite.h:238
#define P_COSSIN
dev. standart
Definition: type_parite.h:245
#define T_LEG_PI
fct. de Legendre associees paires avec m impair
Definition: type_parite.h:224
#define T_LEG_MI
fct. de Legendre associees avec m impair
Definition: type_parite.h:240
Lorene prototypes.
Definition: app_hor.h:64
#define MSQ_P
Extraction de l&#39;info sur Phi.
Definition: type_parite.h:156
#define T_LEG_I
fct. de Legendre associees impaires
Definition: type_parite.h:220
#define MSQ_T
Extraction de l&#39;info sur Theta.
Definition: type_parite.h:154
#define T_LEG_IP
fct. de Legendre associees impaires avec m pair
Definition: type_parite.h:222
#define T_LEG_P
fct. de Legendre associees paires
Definition: type_parite.h:216
#define P_COSSIN_I
dev. sur Phi = 2*phi, freq. impaires
Definition: type_parite.h:249
#define P_COSSIN_P
dev. sur Phi = 2*phi, freq. paires
Definition: type_parite.h:247
#define T_LEG_II
fct. de Legendre associees impaires avec m impair
Definition: type_parite.h:226
#define T_LEG_PP
fct. de Legendre associees paires avec m pair
Definition: type_parite.h:218