LORENE
param.C
1/*
2 * Methods of class Param
3 *
4 * (see file param.h for documentation)
5 *
6 */
7
8/*
9 * Copyright (c) 1999-2005 Eric Gourgoulhon
10 * Copyright (c) 2000-2003 Jerome Novak
11 *
12 * This file is part of LORENE.
13 *
14 * LORENE is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * LORENE is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with LORENE; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 *
28 */
29
30
31char param_C[] = "$Header: /cvsroot/Lorene/C++/Source/Param/param.C,v 1.9 2014/10/13 08:53:37 j_novak Exp $" ;
32
33/*
34 * $Id: param.C,v 1.9 2014/10/13 08:53:37 j_novak Exp $
35 * $Log: param.C,v $
36 * Revision 1.9 2014/10/13 08:53:37 j_novak
37 * Lorene classes and functions now belong to the namespace Lorene.
38 *
39 * Revision 1.8 2014/10/06 15:13:16 j_novak
40 * Modified #include directives to use c++ syntax.
41 *
42 * Revision 1.7 2006/06/15 08:15:39 j_novak
43 * Removed members linked to Qtenseur objects.
44 * Added members for Matrice objects.
45 *
46 * Revision 1.6 2005/08/13 16:11:44 m_saijo
47 * Added storage of a Star
48 *
49 * Revision 1.5 2005/03/24 21:56:31 e_gourgoulhon
50 * Added storage of a Scalar.
51 *
52 * Revision 1.4 2003/09/25 12:08:03 j_novak
53 * Tensors can be stored in Param objects
54 *
55 * Revision 1.3 2002/10/16 14:37:12 j_novak
56 * Reorganization of #include instructions of standard C++, in order to
57 * use experimental version 3 of gcc.
58 *
59 * Revision 1.2 2002/09/19 09:52:42 j_novak
60 * Added objects Qtenseur and Qmetrique for 4D tensor and metric handling.
61 *
62 * Revision 1.1.1.1 2001/11/20 15:19:27 e_gourgoulhon
63 * LORENE
64 *
65 * Revision 1.8 2001/10/11 07:44:27 eric
66 * Ajout du stokage des Etoile's
67 *
68 * Revision 1.7 2000/10/24 14:55:20 novak
69 * Added the function clean_all()
70 *
71 * Revision 1.6 2000/05/25 12:40:47 eric
72 * MODIFICATION MAJEURE: pour les int et les double, ce sont desormais les
73 * dresses qui sont stokees, et non plus les nombres eux-memes
74 * (le traitement des int et des double est donc desormais completement
75 * aligne sur celui des Tbl, Cmp, etc...)
76 *
77 * Revision 1.5 1999/12/29 13:10:54 eric
78 * Ajout du stokage des Mtbl_cf.
79 *
80 * Revision 1.4 1999/12/27 12:17:02 eric
81 * Ajout du stokage des mappings (class Map).
82 *
83 * Revision 1.3 1999/12/16 10:28:25 eric
84 * Ajout des membres modifiables.
85 * Par defaut, les objets listes sont const.
86 *
87 * Revision 1.2 1999/12/15 16:23:22 eric
88 * Changement de l'ordre des arguments dans add_*
89 * Argument par defaut: position = 0
90 * Ajout du stokage des int et des double.
91 *
92 * Revision 1.1 1999/12/13 14:36:00 eric
93 * Initial revision
94 *
95 *
96 * $Header: /cvsroot/Lorene/C++/Source/Param/param.C,v 1.9 2014/10/13 08:53:37 j_novak Exp $
97 *
98 */
99
100// Headers C
101#include <cstdlib>
102#include <cassert>
103
104// Headers Lorene
105#include "param.h"
106#include "tenseur.h"
107#include "tensor.h"
108#include "matrice.h"
109
110 //------------------------//
111 // Constructor //
112 //------------------------//
113
114namespace Lorene {
115Param::Param() : n_int(0),
116 n_int_mod(0),
117 n_double(0),
118 n_double_mod(0),
119 n_tbl(0),
120 n_tbl_mod(0),
121 n_itbl(0),
122 n_itbl_mod(0),
123 n_matrice(0),
124 n_matrice_mod(0),
125 n_cmp(0),
126 n_cmp_mod(0),
127 n_tenseur(0),
128 n_tenseur_mod(0),
129 n_map(0),
130 n_mtbl_cf(0),
131 n_scalar(0),
132 n_scalar_mod(0),
133 n_tensor(0),
134 n_tensor_mod(0),
135 n_etoile(0),
136 n_star(0)
137 {}
138
139
140 //----------------------//
141 // Destructor //
142 //----------------------//
143
145
146 if (n_int > 0) delete [] p_int ;
147 if (n_int_mod > 0) delete [] p_int_mod ;
148 if (n_double > 0) delete [] p_double ;
149 if (n_double_mod > 0) delete [] p_double_mod ;
150 if (n_tbl > 0) delete [] p_tbl ;
151 if (n_tbl_mod > 0) delete [] p_tbl_mod ;
152 if (n_itbl > 0) delete [] p_itbl ;
153 if (n_itbl_mod > 0) delete [] p_itbl_mod ;
154 if (n_matrice > 0) delete [] p_matrice ;
155 if (n_matrice_mod > 0) delete [] p_matrice_mod ;
156 if (n_cmp > 0) delete [] p_cmp ;
157 if (n_cmp_mod > 0) delete [] p_cmp_mod ;
158 if (n_tenseur > 0) delete [] p_tenseur ;
159 if (n_tenseur_mod > 0) delete [] p_tenseur_mod ;
160 if (n_map > 0) delete [] p_map ;
161 if (n_mtbl_cf > 0) delete [] p_mtbl_cf ;
162 if (n_scalar > 0) delete [] p_scalar ;
163 if (n_scalar_mod > 0) delete [] p_scalar_mod ;
164 if (n_tensor > 0) delete [] p_tensor ;
165 if (n_tensor_mod > 0) delete [] p_tensor_mod ;
166 if (n_etoile > 0) delete [] p_etoile ;
167 if (n_star > 0) delete [] p_star ;
168}
169
170 //------------------------------------//
171 // cleaning the memory //
172 //------------------------------------//
173
175
176 for (int i=0; i<n_int_mod; i++)
177 if (p_int_mod[i] != 0x0) {
178 delete p_int_mod[i] ;
179 p_int_mod[i] = 0x0 ;
180 }
181
182 for (int i=0; i<n_double_mod; i++)
183 if (p_double_mod[i] != 0x0) {
184 delete p_double_mod[i] ;
185 p_double_mod[i] = 0x0 ;
186 }
187
188 for (int i=0; i<n_tbl_mod; i++)
189 if (p_tbl_mod[i] != 0x0) {
190 delete p_tbl_mod[i] ;
191 p_tbl_mod[i] = 0x0 ;
192 }
193
194 for (int i=0; i<n_itbl_mod; i++)
195 if (p_itbl_mod[i] != 0x0) {
196 delete p_itbl_mod[i] ;
197 p_itbl_mod[i] = 0x0 ;
198 }
199
200 for (int i=0; i<n_matrice_mod; i++)
201 if (p_matrice_mod[i] != 0x0) {
202 delete p_matrice_mod[i] ;
203 p_matrice_mod[i] = 0x0 ;
204 }
205
206 for (int i=0; i<n_cmp_mod; i++)
207 if (p_cmp_mod[i] != 0x0) {
208 delete p_cmp_mod[i] ;
209 p_cmp_mod[i] = 0x0 ;
210 }
211
212 for (int i=0; i<n_tenseur_mod; i++)
213 if (p_tenseur_mod[i] != 0x0) {
214 delete p_tenseur_mod[i] ;
215 p_tenseur_mod[i] = 0x0 ;
216 }
217
218 for (int i=0; i<n_scalar_mod; i++)
219 if (p_scalar_mod[i] != 0x0) {
220 delete p_scalar_mod[i] ;
221 p_scalar_mod[i] = 0x0 ;
222 }
223
224 for (int i=0; i<n_tensor_mod; i++)
225 if (p_tensor_mod[i] != 0x0) {
226 delete p_tensor_mod[i] ;
227 p_tensor_mod[i] = 0x0 ;
228 }
229}
230
231
232 //------------------------------------//
233 // int storage //
234 //------------------------------------//
235
236// Total number of stored int
237// --------------------------
238
239int Param::get_n_int() const {
240 return n_int ;
241}
242
243// Addition
244// --------
245
246void Param::add_int(const int& ti, int index){
247
248 if (index >= n_int) { // p_int must be rescaled
249
250 int n_int_nouveau = index + 1 ;
251 const int** p_int_nouveau = new const int*[n_int_nouveau] ;
252
253
254 // Copy of the previous addresses
255 for (int i=0; i<n_int; i++) {
256 p_int_nouveau[i] = p_int[i] ;
257 }
258
259
260 // The intermediate addresses are set to 0x0
261 for (int i=n_int; i<index; i++) {
262 p_int_nouveau[i] = 0x0 ;
263 }
264
265 // The new address
266 p_int_nouveau[index] = &ti ;
267
268 // Update
269 if (n_int > 0) delete [] p_int ;
272
273 }
274 else {
275
276 if (p_int[index] != 0x0) {
277 cout << "Param::add_int : the position " << index
278 << " is already occupied !" << endl ;
279 abort() ;
280 }
281 else{
282 p_int[index] = &ti ;
283 }
284
285 }
286
287}
288
289// Extraction
290// ----------
291
292const int& Param::get_int(int index) const {
293
294 assert(index >= 0) ;
295 assert(index < n_int) ;
296
297 return *(p_int[index]) ;
298
299}
300
301 //------------------------------------//
302 // double storage //
303 //------------------------------------//
304
305// Total number of stored doubles
306// ------------------------------
307
309 return n_double ;
310}
311
312// Addition
313// --------
314
315void Param::add_double(const double& ti, int index){
316
317 if (index >= n_double) { // p_double must be rescaled
318
319 int n_double_nouveau = index + 1 ;
320 const double** p_double_nouveau =
321 new const double*[n_double_nouveau] ;
322
323
324 // Copy of the previous addresses
325 for (int i=0; i<n_double; i++) {
327 }
328
329 // The intermediate addresses are set to 0x0
330 for (int i=n_double; i<index; i++) {
331 p_double_nouveau[i] = 0x0 ;
332 }
333
334 // The new address
335 p_double_nouveau[index] = &ti ;
336
337 // Update
338 if (n_double > 0) delete [] p_double ;
341
342 }
343 else {
344
345 if (p_double[index] != 0x0) {
346 cout << "Param::add_double : the position " << index
347 << " is already occupied !" << endl ;
348 abort() ;
349 }
350 else{
351 p_double[index] = &ti ;
352 }
353
354 }
355
356}
357
358// Extraction
359// ----------
360
361const double& Param::get_double(int index) const {
362
363 assert(index >= 0) ;
364 assert(index < n_double) ;
365
366 return *(p_double[index]) ;
367
368}
369
370
371 //------------------------------------//
372 // Modifiable int storage //
373 //------------------------------------//
374
375// Total number of stored addresses
376// --------------------------------
377
379 return n_int_mod ;
380}
381
382// Addition
383// --------
384
385void Param::add_int_mod(int& ti, int index){
386
387 if (index >= n_int_mod) { // p_int_mod must be rescaled
388
389 int n_int_nouveau = index + 1 ;
390 int** p_int_nouveau = new int*[n_int_nouveau] ;
391
392
393 // Copy of the previous addresses
394 for (int i=0; i<n_int_mod; i++) {
396 }
397
398 // The intermediate addresses are set to 0x0
399 for (int i=n_int_mod; i<index; i++) {
400 p_int_nouveau[i] = 0x0 ;
401 }
402
403 // The new address
404 p_int_nouveau[index] = &ti ;
405
406 // Update
407 if (n_int_mod > 0) delete [] p_int_mod ;
410
411 }
412 else {
413
414 if (p_int_mod[index] != 0x0) {
415 cout << "Param::add_int_mod : the position " << index
416 << " is already occupied !" << endl ;
417 abort() ;
418 }
419 else{
420 p_int_mod[index] = &ti ;
421 }
422
423 }
424
425}
426
427// Extraction
428// ----------
429
430int& Param::get_int_mod(int index) const {
431
432 assert(index >= 0) ;
433 assert(index < n_int_mod) ;
434
435 return *(p_int_mod[index]) ;
436
437}
438
439 //------------------------------------//
440 // Modifiable double storage //
441 //------------------------------------//
442
443// Total number of stored addresses
444// --------------------------------
445
447 return n_double_mod ;
448}
449
450// Addition
451// --------
452
453void Param::add_double_mod(double& ti, int index){
454
455 if (index >= n_double_mod) { // p_double_mod must be rescaled
456
457 int n_double_nouveau = index + 1 ;
458 double** p_double_nouveau = new double*[n_double_nouveau] ;
459
460
461 // Copy of the previous addresses
462 for (int i=0; i<n_double_mod; i++) {
464 }
465
466 // The intermediate addresses are set to 0x0
467 for (int i=n_double_mod; i<index; i++) {
468 p_double_nouveau[i] = 0x0 ;
469 }
470
471 // The new address
472 p_double_nouveau[index] = &ti ;
473
474 // Update
475 if (n_double_mod > 0) delete [] p_double_mod ;
478
479 }
480 else {
481
482 if (p_double_mod[index] != 0x0) {
483 cout << "Param::add_double_mod : the position " << index
484 << " is already occupied !" << endl ;
485 abort() ;
486 }
487 else{
488 p_double_mod[index] = &ti ;
489 }
490
491 }
492
493}
494
495// Extraction
496// ----------
497
498double& Param::get_double_mod(int index) const {
499
500 assert(index >= 0) ;
501 assert(index < n_double_mod) ;
502
503 return *(p_double_mod[index]) ;
504
505}
506
507
508 //------------------------------------//
509 // Tbl storage //
510 //------------------------------------//
511
512// Total number of stored addresses
513// --------------------------------
514
515int Param::get_n_tbl() const {
516 return n_tbl ;
517}
518
519// Addition
520// --------
521
522void Param::add_tbl(const Tbl& ti, int index){
523
524 if (index >= n_tbl) { // p_tbl must be rescaled
525
526 int n_tbl_nouveau = index + 1 ;
527 const Tbl** p_tbl_nouveau = new const Tbl*[n_tbl_nouveau] ;
528
529
530 // Copy of the previous addresses
531 for (int i=0; i<n_tbl; i++) {
532 p_tbl_nouveau[i] = p_tbl[i] ;
533 }
534
535 // The intermediate addresses are set to 0x0
536 for (int i=n_tbl; i<index; i++) {
537 p_tbl_nouveau[i] = 0x0 ;
538 }
539
540 // The new address
541 p_tbl_nouveau[index] = &ti ;
542
543 // Update
544 if (n_tbl > 0) delete [] p_tbl ;
547
548 }
549 else {
550
551 if (p_tbl[index] != 0x0) {
552 cout << "Param::add_tbl : the position " << index
553 << " is already occupied !" << endl ;
554 abort() ;
555 }
556 else{
557 p_tbl[index] = &ti ;
558 }
559
560 }
561
562}
563
564// Extraction
565// ----------
566
567const Tbl& Param::get_tbl(int index) const {
568
569 assert(index >= 0) ;
570 assert(index < n_tbl) ;
571
572 return *(p_tbl[index]) ;
573
574}
575
576
577 //------------------------------------//
578 // Modifiable Tbl storage //
579 //------------------------------------//
580
581// Total number of stored addresses
582// --------------------------------
583
585 return n_tbl_mod ;
586}
587
588// Addition
589// --------
590
591void Param::add_tbl_mod(Tbl& ti, int index){
592
593 if (index >= n_tbl_mod) { // p_tbl_mod must be rescaled
594
595 int n_tbl_nouveau = index + 1 ;
597
598
599 // Copy of the previous addresses
600 for (int i=0; i<n_tbl_mod; i++) {
602 }
603
604 // The intermediate addresses are set to 0x0
605 for (int i=n_tbl_mod; i<index; i++) {
606 p_tbl_nouveau[i] = 0x0 ;
607 }
608
609 // The new address
610 p_tbl_nouveau[index] = &ti ;
611
612 // Update
613 if (n_tbl_mod > 0) delete [] p_tbl_mod ;
616
617 }
618 else {
619
620 if (p_tbl_mod[index] != 0x0) {
621 cout << "Param::add_tbl_mod : the position " << index
622 << " is already occupied !" << endl ;
623 abort() ;
624 }
625 else{
626 p_tbl_mod[index] = &ti ;
627 }
628
629 }
630
631}
632
633// Extraction
634// ----------
635
636Tbl& Param::get_tbl_mod(int index) const {
637
638 assert(index >= 0) ;
639 assert(index < n_tbl_mod) ;
640
641 return *(p_tbl_mod[index]) ;
642
643}
644
645
646 //------------------------------------//
647 // Itbl storage //
648 //------------------------------------//
649
650// Total number of stored addresses
651// --------------------------------
652
653int Param::get_n_itbl() const {
654 return n_itbl ;
655}
656
657// Addition
658// --------
659
660void Param::add_itbl(const Itbl& ti, int index){
661
662 if (index >= n_itbl) { // p_itbl must be rescaled
663
664 int n_itbl_nouveau = index + 1 ;
665 const Itbl** p_itbl_nouveau = new const Itbl*[n_itbl_nouveau] ;
666
667
668 // Copy of the previous addresses
669 for (int i=0; i<n_itbl; i++) {
670 p_itbl_nouveau[i] = p_itbl[i] ;
671 }
672
673 // The intermediate addresses are set to 0x0
674 for (int i=n_itbl; i<index; i++) {
675 p_itbl_nouveau[i] = 0x0 ;
676 }
677
678 // The new address
679 p_itbl_nouveau[index] = &ti ;
680
681 // Update
682 if (n_itbl > 0) delete [] p_itbl ;
685
686 }
687 else {
688
689 if (p_itbl[index] != 0x0) {
690 cout << "Param::add_itbl : the position " << index
691 << " is already occupied !" << endl ;
692 abort() ;
693 }
694 else{
695 p_itbl[index] = &ti ;
696 }
697
698 }
699
700}
701
702// Extraction
703// ----------
704
705const Itbl& Param::get_itbl(int index) const {
706
707 assert(index >= 0) ;
708 assert(index < n_itbl) ;
709
710 return *(p_itbl[index]) ;
711
712}
713
714
715 //------------------------------------//
716 // Modifiable Itbl storage //
717 //------------------------------------//
718
719// Total number of stored addresses
720// --------------------------------
721
723 return n_itbl_mod ;
724}
725
726// Addition
727// --------
728
729void Param::add_itbl_mod(Itbl& ti, int index){
730
731 if (index >= n_itbl_mod) { // p_itbl_mod must be rescaled
732
733 int n_itbl_nouveau = index + 1 ;
735
736
737 // Copy of the previous addresses
738 for (int i=0; i<n_itbl_mod; i++) {
740 }
741
742 // The intermediate addresses are set to 0x0
743 for (int i=n_itbl_mod; i<index; i++) {
744 p_itbl_nouveau[i] = 0x0 ;
745 }
746
747 // The new address
748 p_itbl_nouveau[index] = &ti ;
749
750 // Update
751 if (n_itbl_mod > 0) delete [] p_itbl_mod ;
754
755 }
756 else {
757
758 if (p_itbl_mod[index] != 0x0) {
759 cout << "Param::add_itbl_mod : the position " << index
760 << " is already occupied !" << endl ;
761 abort() ;
762 }
763 else{
764 p_itbl_mod[index] = &ti ;
765 }
766
767 }
768
769}
770
771// Extraction
772// ----------
773
774Itbl& Param::get_itbl_mod(int index) const {
775
776 assert(index >= 0) ;
777 assert(index < n_itbl_mod) ;
778
779 return *(p_itbl_mod[index]) ;
780
781}
782
783 //------------------------------------//
784 // Matrice storage //
785 //------------------------------------//
786
787// Total number of stored addresses
788// --------------------------------
789
791 return n_matrice ;
792}
793
794// Addition
795// --------
796
797void Param::add_matrice(const Matrice& ti, int index){
798
799 if (index >= n_matrice) { // p_matrice must be rescaled
800
801 int n_matrice_nouveau = index + 1 ;
802 const Matrice** p_matrice_nouveau = new const Matrice*[n_matrice_nouveau] ;
803
804
805 // Copy of the previous addresses
806 for (int i=0; i<n_matrice; i++) {
808 }
809
810 // The intermediate addresses are set to 0x0
811 for (int i=n_matrice; i<index; i++) {
812 p_matrice_nouveau[i] = 0x0 ;
813 }
814
815 // The new address
816 p_matrice_nouveau[index] = &ti ;
817
818 // Update
819 if (n_matrice > 0) delete [] p_matrice ;
822
823 }
824 else {
825
826 if (p_matrice[index] != 0x0) {
827 cout << "Param::add_matrice : the position " << index
828 << " is already occupied !" << endl ;
829 abort() ;
830 }
831 else{
832 p_matrice[index] = &ti ;
833 }
834
835 }
836
837}
838
839// Extraction
840// ----------
841
842const Matrice& Param::get_matrice(int index) const {
843
844 assert(index >= 0) ;
845 assert(index < n_matrice) ;
846
847 return *(p_matrice[index]) ;
848
849}
850
851
852 //------------------------------------//
853 // Modifiable Matrice storage //
854 //------------------------------------//
855
856// Total number of stored addresses
857// --------------------------------
858
860 return n_matrice_mod ;
861}
862
863// Addition
864// --------
865
867
868 if (index >= n_matrice_mod) { // p_matrice_mod must be rescaled
869
870 int n_matrice_nouveau = index + 1 ;
872
873
874 // Copy of the previous addresses
875 for (int i=0; i<n_matrice_mod; i++) {
877 }
878
879 // The intermediate addresses are set to 0x0
880 for (int i=n_matrice_mod; i<index; i++) {
881 p_matrice_nouveau[i] = 0x0 ;
882 }
883
884 // The new address
885 p_matrice_nouveau[index] = &ti ;
886
887 // Update
888 if (n_matrice_mod > 0) delete [] p_matrice_mod ;
891
892 }
893 else {
894
895 if (p_matrice_mod[index] != 0x0) {
896 cout << "Param::add_matrice_mod : the position " << index
897 << " is already occupied !" << endl ;
898 abort() ;
899 }
900 else{
901 p_matrice_mod[index] = &ti ;
902 }
903
904 }
905
906}
907
908// Extraction
909// ----------
910
912
913 assert(index >= 0) ;
914 assert(index < n_matrice_mod) ;
915
916 return *(p_matrice_mod[index]) ;
917
918}
919
920
921 //------------------------------------//
922 // Cmp storage //
923 //------------------------------------//
924
925// Total number of stored addresses
926// --------------------------------
927
928int Param::get_n_cmp() const {
929 return n_cmp ;
930}
931
932// Addition
933// --------
934
935void Param::add_cmp(const Cmp& ti, int index){
936
937 if (index >= n_cmp) { // p_cmp must be rescaled
938
939 int n_cmp_nouveau = index + 1 ;
940 const Cmp** p_cmp_nouveau = new const Cmp*[n_cmp_nouveau] ;
941
942
943 // Copy of the previous addresses
944 for (int i=0; i<n_cmp; i++) {
945 p_cmp_nouveau[i] = p_cmp[i] ;
946 }
947
948 // The intermediate addresses are set to 0x0
949 for (int i=n_cmp; i<index; i++) {
950 p_cmp_nouveau[i] = 0x0 ;
951 }
952
953 // The new address
954 p_cmp_nouveau[index] = &ti ;
955
956 // Update
957 if (n_cmp > 0) delete [] p_cmp ;
960
961 }
962 else {
963
964 if (p_cmp[index] != 0x0) {
965 cout << "Param::add_cmp : the position " << index
966 << " is already occupied !" << endl ;
967 abort() ;
968 }
969 else{
970 p_cmp[index] = &ti ;
971 }
972
973 }
974
975}
976
977// Extraction
978// ----------
979
980const Cmp& Param::get_cmp(int index) const {
981
982 assert(index >= 0) ;
983 assert(index < n_cmp) ;
984
985 return *(p_cmp[index]) ;
986
987}
988
989
990 //------------------------------------//
991 // Modifiable Cmp storage //
992 //------------------------------------//
993
994// Total number of stored addresses
995// --------------------------------
996
998 return n_cmp_mod ;
999}
1000
1001// Addition
1002// --------
1003
1004void Param::add_cmp_mod(Cmp& ti, int index){
1005
1006 if (index >= n_cmp_mod) { // p_cmp_mod must be rescaled
1007
1008 int n_cmp_nouveau = index + 1 ;
1009 Cmp** p_cmp_nouveau = new Cmp*[n_cmp_nouveau] ;
1010
1011
1012 // Copy of the previous addresses
1013 for (int i=0; i<n_cmp_mod; i++) {
1014 p_cmp_nouveau[i] = p_cmp_mod[i] ;
1015 }
1016
1017 // The intermediate addresses are set to 0x0
1018 for (int i=n_cmp_mod; i<index; i++) {
1019 p_cmp_nouveau[i] = 0x0 ;
1020 }
1021
1022 // The new address
1023 p_cmp_nouveau[index] = &ti ;
1024
1025 // Update
1026 if (n_cmp_mod > 0) delete [] p_cmp_mod ;
1029
1030 }
1031 else {
1032
1033 if (p_cmp_mod[index] != 0x0) {
1034 cout << "Param::add_cmp_mod : the position " << index
1035 << " is already occupied !" << endl ;
1036 abort() ;
1037 }
1038 else{
1039 p_cmp_mod[index] = &ti ;
1040 }
1041
1042 }
1043
1044}
1045
1046// Extraction
1047// ----------
1048
1049Cmp& Param::get_cmp_mod(int index) const {
1050
1051 assert(index >= 0) ;
1052 assert(index < n_cmp_mod) ;
1053
1054 return *(p_cmp_mod[index]) ;
1055
1056}
1057
1058
1059 //------------------------------------//
1060 // Tenseur storage //
1061 //------------------------------------//
1062
1063// Total number of stored addresses
1064// --------------------------------
1065
1067 return n_tenseur ;
1068}
1069
1070// Addition
1071// --------
1072
1073void Param::add_tenseur(const Tenseur& ti, int index){
1074
1075 if (index >= n_tenseur) { // p_tenseur must be rescaled
1076
1077 int n_tenseur_nouveau = index + 1 ;
1078 const Tenseur** p_tenseur_nouveau = new const Tenseur*[n_tenseur_nouveau] ;
1079
1080
1081 // Copy of the previous addresses
1082 for (int i=0; i<n_tenseur; i++) {
1084 }
1085
1086 // The intermediate addresses are set to 0x0
1087 for (int i=n_tenseur; i<index; i++) {
1088 p_tenseur_nouveau[i] = 0x0 ;
1089 }
1090
1091 // The new address
1092 p_tenseur_nouveau[index] = &ti ;
1093
1094 // Update
1095 if (n_tenseur > 0) delete [] p_tenseur ;
1098
1099 }
1100 else {
1101
1102 if (p_tenseur[index] != 0x0) {
1103 cout << "Param::add_tenseur : the position " << index
1104 << " is already occupied !" << endl ;
1105 abort() ;
1106 }
1107 else{
1108 p_tenseur[index] = &ti ;
1109 }
1110
1111 }
1112
1113}
1114
1115// Extraction
1116// ----------
1117
1118const Tenseur& Param::get_tenseur(int index) const {
1119
1120 assert(index >= 0) ;
1121 assert(index < n_tenseur) ;
1122
1123 return *(p_tenseur[index]) ;
1124
1125}
1126
1127
1128 //------------------------------------//
1129 // Modifiable Tenseur storage //
1130 //------------------------------------//
1131
1132// Total number of stored addresses
1133// --------------------------------
1134
1136 return n_tenseur_mod ;
1137}
1138
1139// Addition
1140// --------
1141
1143
1144 if (index >= n_tenseur_mod) { // p_tenseur_mod must be rescaled
1145
1146 int n_tenseur_nouveau = index + 1 ;
1148
1149
1150 // Copy of the previous addresses
1151 for (int i=0; i<n_tenseur_mod; i++) {
1153 }
1154
1155 // The intermediate addresses are set to 0x0
1156 for (int i=n_tenseur_mod; i<index; i++) {
1157 p_tenseur_nouveau[i] = 0x0 ;
1158 }
1159
1160 // The new address
1161 p_tenseur_nouveau[index] = &ti ;
1162
1163 // Update
1164 if (n_tenseur_mod > 0) delete [] p_tenseur_mod ;
1167
1168 }
1169 else {
1170
1171 if (p_tenseur_mod[index] != 0x0) {
1172 cout << "Param::add_tenseur_mod : the position " << index
1173 << " is already occupied !" << endl ;
1174 abort() ;
1175 }
1176 else{
1177 p_tenseur_mod[index] = &ti ;
1178 }
1179
1180 }
1181
1182}
1183
1184// Extraction
1185// ----------
1186
1188
1189 assert(index >= 0) ;
1190 assert(index < n_tenseur_mod) ;
1191
1192 return *(p_tenseur_mod[index]) ;
1193
1194}
1195
1196
1197 //------------------------------------//
1198 // Map storage //
1199 //------------------------------------//
1200
1201// Total number of stored addresses
1202// --------------------------------
1203
1204int Param::get_n_map() const {
1205 return n_map ;
1206}
1207
1208// Addition
1209// --------
1210
1211void Param::add_map(const Map& mi, int index){
1212
1213 if (index >= n_map) { // p_map must be rescaled
1214
1215 int n_map_nouveau = index + 1 ;
1216 const Map** p_map_nouveau = new const Map*[n_map_nouveau] ;
1217
1218
1219 // Copy of the previous addresses
1220 for (int i=0; i<n_map; i++) {
1221 p_map_nouveau[i] = p_map[i] ;
1222 }
1223
1224 // The intermediate addresses are set to 0x0
1225 for (int i=n_map; i<index; i++) {
1226 p_map_nouveau[i] = 0x0 ;
1227 }
1228
1229 // The new address
1230 p_map_nouveau[index] = &mi ;
1231
1232 // Update
1233 if (n_map > 0) delete [] p_map ;
1234 p_map = p_map_nouveau ;
1235 n_map = n_map_nouveau ;
1236
1237 }
1238 else {
1239
1240 if (p_map[index] != 0x0) {
1241 cout << "Param::add_map : the position " << index
1242 << " is already occupied !" << endl ;
1243 abort() ;
1244 }
1245 else{
1246 p_map[index] = &mi ;
1247 }
1248
1249 }
1250
1251}
1252
1253// Extraction
1254// ----------
1255
1256const Map& Param::get_map(int index) const {
1257
1258 assert(index >= 0) ;
1259 assert(index < n_map) ;
1260
1261 return *(p_map[index]) ;
1262
1263}
1264
1265 //------------------------------------//
1266 // Mtbl_cf storage //
1267 //------------------------------------//
1268
1269// Total number of stored addresses
1270// --------------------------------
1271
1273 return n_mtbl_cf ;
1274}
1275
1276// Addition
1277// --------
1278
1279void Param::add_mtbl_cf(const Mtbl_cf& mi, int index){
1280
1281 if (index >= n_mtbl_cf) { // p_mtbl_cf must be rescaled
1282
1283 int n_mtbl_cf_nouveau = index + 1 ;
1284 const Mtbl_cf** p_mtbl_cf_nouveau =
1285 new const Mtbl_cf*[n_mtbl_cf_nouveau] ;
1286
1287
1288 // Copy of the previous addresses
1289 for (int i=0; i<n_mtbl_cf; i++) {
1291 }
1292
1293 // The intermediate addresses are set to 0x0
1294 for (int i=n_mtbl_cf; i<index; i++) {
1295 p_mtbl_cf_nouveau[i] = 0x0 ;
1296 }
1297
1298 // The new address
1299 p_mtbl_cf_nouveau[index] = &mi ;
1300
1301 // Update
1302 if (n_mtbl_cf > 0) delete [] p_mtbl_cf ;
1305
1306 }
1307 else {
1308
1309 if (p_mtbl_cf[index] != 0x0) {
1310 cout << "Param::add_mtbl_cf : the position " << index
1311 << " is already occupied !" << endl ;
1312 abort() ;
1313 }
1314 else{
1315 p_mtbl_cf[index] = &mi ;
1316 }
1317
1318 }
1319
1320}
1321
1322// Extraction
1323// ----------
1324
1325const Mtbl_cf& Param::get_mtbl_cf(int index) const {
1326
1327 assert(index >= 0) ;
1328 assert(index < n_mtbl_cf) ;
1329
1330 return *(p_mtbl_cf[index]) ;
1331
1332}
1333
1334 //------------------------------------//
1335 // Scalar storage //
1336 //------------------------------------//
1337
1338// Total number of stored addresses
1339// --------------------------------
1340
1342 return n_scalar ;
1343}
1344
1345// Addition
1346// --------
1347
1348void Param::add_scalar(const Scalar& ti, int index){
1349
1350 if (index >= n_scalar) { // p_scalar must be rescaled
1351
1352 int n_scalar_nouveau = index + 1 ;
1353 const Scalar** p_scalar_nouveau = new const Scalar*[n_scalar_nouveau] ;
1354
1355
1356 // Copy of the previous addresses
1357 for (int i=0; i<n_scalar; i++) {
1359 }
1360
1361 // The intermediate addresses are set to 0x0
1362 for (int i=n_scalar; i<index; i++) {
1363 p_scalar_nouveau[i] = 0x0 ;
1364 }
1365
1366 // The new address
1367 p_scalar_nouveau[index] = &ti ;
1368
1369 // Update
1370 if (n_scalar > 0) delete [] p_scalar ;
1373
1374 }
1375 else {
1376
1377 if (p_scalar[index] != 0x0) {
1378 cout << "Param::add_scalar : the position " << index
1379 << " is already occupied !" << endl ;
1380 abort() ;
1381 }
1382 else{
1383 p_scalar[index] = &ti ;
1384 }
1385
1386 }
1387
1388}
1389
1390// Extraction
1391// ----------
1392
1393const Scalar& Param::get_scalar(int index) const {
1394
1395 assert(index >= 0) ;
1396 assert(index < n_scalar) ;
1397
1398 return *(p_scalar[index]) ;
1399
1400}
1401
1402
1403 //------------------------------------//
1404 // Modifiable Scalar storage //
1405 //------------------------------------//
1406
1407// Total number of stored addresses
1408// --------------------------------
1409
1411 return n_scalar_mod ;
1412}
1413
1414// Addition
1415// --------
1416
1418
1419 if (index >= n_scalar_mod) { // p_scalar_mod must be rescaled
1420
1421 int n_scalar_nouveau = index + 1 ;
1423
1424
1425 // Copy of the previous addresses
1426 for (int i=0; i<n_scalar_mod; i++) {
1428 }
1429
1430 // The intermediate addresses are set to 0x0
1431 for (int i=n_scalar_mod; i<index; i++) {
1432 p_scalar_nouveau[i] = 0x0 ;
1433 }
1434
1435 // The new address
1436 p_scalar_nouveau[index] = &ti ;
1437
1438 // Update
1439 if (n_scalar_mod > 0) delete [] p_scalar_mod ;
1442
1443 }
1444 else {
1445
1446 if (p_scalar_mod[index] != 0x0) {
1447 cout << "Param::add_scalar_mod : the position " << index
1448 << " is already occupied !" << endl ;
1449 abort() ;
1450 }
1451 else{
1452 p_scalar_mod[index] = &ti ;
1453 }
1454
1455 }
1456
1457}
1458
1459// Extraction
1460// ----------
1461
1463
1464 assert(index >= 0) ;
1465 assert(index < n_scalar_mod) ;
1466
1467 return *(p_scalar_mod[index]) ;
1468
1469}
1470
1471
1472 //------------------------------------//
1473 // Tensor storage //
1474 //------------------------------------//
1475
1476// Total number of stored addresses
1477// --------------------------------
1478
1480 return n_tensor ;
1481}
1482
1483// Addition
1484// --------
1485
1486void Param::add_tensor(const Tensor& ti, int index){
1487
1488 if (index >= n_tensor) { // p_tensor must be rescaled
1489
1490 int n_tensor_nouveau = index + 1 ;
1491 const Tensor** p_tensor_nouveau = new const Tensor*[n_tensor_nouveau] ;
1492
1493
1494 // Copy of the previous addresses
1495 for (int i=0; i<n_tensor; i++) {
1497 }
1498
1499 // The intermediate addresses are set to 0x0
1500 for (int i=n_tensor; i<index; i++) {
1501 p_tensor_nouveau[i] = 0x0 ;
1502 }
1503
1504 // The new address
1505 p_tensor_nouveau[index] = &ti ;
1506
1507 // Update
1508 if (n_tensor > 0) delete [] p_tensor ;
1511
1512 }
1513 else {
1514
1515 if (p_tensor[index] != 0x0) {
1516 cout << "Param::add_tensor : the position " << index
1517 << " is already occupied !" << endl ;
1518 abort() ;
1519 }
1520 else{
1521 p_tensor[index] = &ti ;
1522 }
1523
1524 }
1525
1526}
1527
1528// Extraction
1529// ----------
1530
1531const Tensor& Param::get_tensor(int index) const {
1532
1533 assert(index >= 0) ;
1534 assert(index < n_tensor) ;
1535
1536 return *(p_tensor[index]) ;
1537
1538}
1539
1540
1541 //------------------------------------//
1542 // Modifiable Tensor storage //
1543 //------------------------------------//
1544
1545// Total number of stored addresses
1546// --------------------------------
1547
1549 return n_tensor_mod ;
1550}
1551
1552// Addition
1553// --------
1554
1556
1557 if (index >= n_tensor_mod) { // p_tensor_mod must be rescaled
1558
1559 int n_tensor_nouveau = index + 1 ;
1561
1562
1563 // Copy of the previous addresses
1564 for (int i=0; i<n_tensor_mod; i++) {
1566 }
1567
1568 // The intermediate addresses are set to 0x0
1569 for (int i=n_tensor_mod; i<index; i++) {
1570 p_tensor_nouveau[i] = 0x0 ;
1571 }
1572
1573 // The new address
1574 p_tensor_nouveau[index] = &ti ;
1575
1576 // Update
1577 if (n_tensor_mod > 0) delete [] p_tensor_mod ;
1580
1581 }
1582 else {
1583
1584 if (p_tensor_mod[index] != 0x0) {
1585 cout << "Param::add_tensor_mod : the position " << index
1586 << " is already occupied !" << endl ;
1587 abort() ;
1588 }
1589 else{
1590 p_tensor_mod[index] = &ti ;
1591 }
1592
1593 }
1594
1595}
1596
1597// Extraction
1598// ----------
1599
1601
1602 assert(index >= 0) ;
1603 assert(index < n_tensor_mod) ;
1604
1605 return *(p_tensor_mod[index]) ;
1606
1607}
1608
1609
1610 //------------------------------------//
1611 // Etoile storage //
1612 //------------------------------------//
1613
1614// Total number of stored addresses
1615// --------------------------------
1616
1618 return n_etoile ;
1619}
1620
1621// Addition
1622// --------
1623
1624void Param::add_etoile(const Etoile& eti, int index){
1625
1626 if (index >= n_etoile) { // p_etoile must be rescaled
1627
1628 int n_etoile_nouveau = index + 1 ;
1629 const Etoile** p_etoile_nouveau = new const Etoile*[n_etoile_nouveau] ;
1630
1631
1632 // Copy of the previous addresses
1633 for (int i=0; i<n_etoile; i++) {
1635 }
1636
1637 // The intermediate addresses are set to 0x0
1638 for (int i=n_etoile; i<index; i++) {
1639 p_etoile_nouveau[i] = 0x0 ;
1640 }
1641
1642 // The new address
1643 p_etoile_nouveau[index] = &eti ;
1644
1645 // Update
1646 if (n_etoile > 0) delete [] p_etoile ;
1649
1650 }
1651 else {
1652
1653 if (p_etoile[index] != 0x0) {
1654 cout << "Param::add_etoile : the position " << index
1655 << " is already occupied !" << endl ;
1656 abort() ;
1657 }
1658 else{
1659 p_etoile[index] = &eti ;
1660 }
1661
1662 }
1663
1664}
1665
1666// Extraction
1667// ----------
1668
1669const Etoile& Param::get_etoile(int index) const {
1670
1671 assert(index >= 0) ;
1672 assert(index < n_etoile) ;
1673
1674 return *(p_etoile[index]) ;
1675}
1676 //------------------------------------//
1677 // Star storage //
1678 //------------------------------------//
1679
1680// Total number of stored addresses
1681// --------------------------------
1682
1684 return n_star ;
1685}
1686
1687// Addition
1688// --------
1689
1690void Param::add_star(const Star& eti, int index){
1691
1692 if (index >= n_star) { // p_star must be rescaled
1693
1694 int n_star_nouveau = index + 1 ;
1695 const Star** p_star_nouveau = new const Star*[n_star_nouveau] ;
1696
1697
1698 // Copy of the previous addresses
1699 for (int i=0; i<n_star; i++) {
1700 p_star_nouveau[i] = p_star[i] ;
1701 }
1702
1703 // The intermediate addresses are set to 0x0
1704 for (int i=n_star; i<index; i++) {
1705 p_star_nouveau[i] = 0x0 ;
1706 }
1707
1708 // The new address
1709 p_star_nouveau[index] = &eti ;
1710
1711 // Update
1712 if (n_star > 0) delete [] p_star ;
1715
1716 }
1717 else {
1718
1719 if (p_star[index] != 0x0) {
1720 cout << "Param::add_star : the position " << index
1721 << " is already occupied !" << endl ;
1722 abort() ;
1723 }
1724 else{
1725 p_star[index] = &eti ;
1726 }
1727
1728 }
1729
1730}
1731
1732// Extraction
1733// ----------
1734
1735const Star& Param::get_star(int index) const {
1736
1737 assert(index >= 0) ;
1738 assert(index < n_star) ;
1739
1740 return *(p_star[index]) ;
1741
1742
1743}
1744}
Component of a tensorial field *** DEPRECATED : use class Scalar instead ***.
Definition cmp.h:446
Base class for stars *** DEPRECATED : use class Star instead ***.
Definition etoile.h:424
Time evolution with partial storage (*** under development ***).
Definition evolution.h:371
Basic integer array class.
Definition itbl.h:122
Base class for coordinate mappings.
Definition map.h:670
Matrix handling.
Definition matrice.h:152
Coefficients storage for the multi-domain spectral method.
Definition mtbl_cf.h:186
int get_n_cmp_mod() const
Returns the number of modifiable Cmp 's addresses in the list.
Definition param.C:997
Tensor & get_tensor_mod(int position=0) const
Returns the reference of a modifiable Tensor stored in the list.
Definition param.C:1600
void add_double(const double &x, int position=0)
Adds the the address of a new double to the list.
Definition param.C:315
const Itbl & get_itbl(int position=0) const
Returns the reference of a Itbl stored in the list.
Definition param.C:705
int get_n_itbl() const
Returns the number of Itbl 's addresses in the list.
Definition param.C:653
const Map ** p_map
Array (size n_map ) of the Map 's addresses.
Definition param.h:189
int get_n_itbl_mod() const
Returns the number of modifiable Itbl 's addresses in the list.
Definition param.C:722
const Mtbl_cf ** p_mtbl_cf
Array (size n_mtbl_cf ) of the Mtbl_cf 's addresses.
Definition param.h:193
const int ** p_int
Array (size n_int ) of the int 's addresses.
Definition param.h:132
int n_scalar
Number of Scalar 's
Definition param.h:195
~Param()
Destructor.
Definition param.C:144
int n_matrice
Number of Matrice 's
Definition param.h:163
void add_scalar_mod(Scalar &ti, int position=0)
Adds the address of a new modifiable Scalar to the list.
Definition param.C:1417
Cmp & get_cmp_mod(int position=0) const
Returns the reference of a modifiable Cmp stored in the list.
Definition param.C:1049
Scalar ** p_scalar_mod
Array (size n_scalar_mod ) of the modifiable Scalar 's addresses.
Definition param.h:201
int get_n_matrice_mod() const
Returns the number of modifiable Matrice 's addresses in the list.
Definition param.C:859
void add_matrice(const Matrice &ti, int position=0)
Adds the address of a new Matrice to the list.
Definition param.C:797
Tbl ** p_tbl_mod
Array (size n_tbl_mod ) of the modifiable Tbl 's addresses.
Definition param.h:153
const Matrice ** p_matrice
Array (size n_matrice ) of the Matrice 's addresses.
Definition param.h:165
const double ** p_double
Array (size n_double ) of the double 's addresses.
Definition param.h:140
void add_map(const Map &mi, int position=0)
Adds the address of a new Map to the list.
Definition param.C:1211
int n_int_mod
Number of modifiable int 's (integers).
Definition param.h:134
Scalar & get_scalar_mod(int position=0) const
Returns the reference of a modifiable Scalar stored in the list.
Definition param.C:1462
const Star ** p_star
Array (size n_star ) of the Star 's addresses.
Definition param.h:217
const Scalar ** p_scalar
Array (size n_scalar ) of the Scalar 's addresses.
Definition param.h:197
const int & get_int(int position=0) const
Returns the reference of a int stored in the list.
Definition param.C:292
const double & get_double(int position=0) const
Returns the reference of a double stored in the list.
Definition param.C:361
void add_mtbl_cf(const Mtbl_cf &mi, int position=0)
Adds the address of a new Mtbl_cf to the list.
Definition param.C:1279
int get_n_tbl_mod() const
Returns the number of modifiable Tbl 's addresses in the list.
Definition param.C:584
Itbl & get_itbl_mod(int position=0) const
Returns the reference of a stored modifiable Itbl .
Definition param.C:774
int get_n_double_mod() const
Returns the number of stored modifiable double 's addresses.
Definition param.C:446
void add_tensor_mod(Tensor &ti, int position=0)
Adds the address of a new modifiable Tensor to the list.
Definition param.C:1555
int get_n_tenseur() const
Returns the number of Tenseur 's addresses in the list.
Definition param.C:1066
void add_star(const Star &eti, int position=0)
Adds the address of a new Star to the list.
Definition param.C:1690
int get_n_int_mod() const
Returns the number of modifiable int 's addresses in the list.
Definition param.C:378
Tbl & get_tbl_mod(int position=0) const
Returns the reference of a modifiable Tbl stored in the list.
Definition param.C:636
const Star & get_star(int position=0) const
Returns the reference of a Star stored in the list.
Definition param.C:1735
int get_n_scalar_mod() const
Returns the number of modifiable Scalar 's addresses in the list.
Definition param.C:1410
Tensor ** p_tensor_mod
Array (size n_tensor_mod ) of the modifiable Tensor 's addresses.
Definition param.h:209
void clean_all()
Deletes all the objects stored as modifiables, i.e.
Definition param.C:174
const Tenseur & get_tenseur(int position=0) const
Returns the reference of a Tenseur stored in the list.
Definition param.C:1118
int get_n_etoile() const
Returns the number of Etoile 's addresses in the list.
Definition param.C:1617
void add_cmp_mod(Cmp &ti, int position=0)
Adds the address of a new modifiable Cmp to the list.
Definition param.C:1004
void add_etoile(const Etoile &eti, int position=0)
Adds the address of a new Etoile to the list.
Definition param.C:1624
int get_n_tenseur_mod() const
Returns the number of modifiable Tenseur 's addresses in the list.
Definition param.C:1135
int n_itbl
Number of Itbl 's
Definition param.h:155
Tenseur ** p_tenseur_mod
Array (size n_tenseur_mod ) of the modifiable Tenseur 's addresses.
Definition param.h:185
double ** p_double_mod
Array (size n_double_mod ) of the double 's addresses.
Definition param.h:144
int n_tbl
Number of Tbl 's
Definition param.h:147
void add_matrice_mod(Matrice &ti, int position=0)
Adds the address of a new modifiable Matrice to the list.
Definition param.C:866
int get_n_tensor() const
Returns the number of Tensor 's addresses in the list.
Definition param.C:1479
int get_n_map() const
Returns the number of Map 's addresses in the list.
Definition param.C:1204
const Map & get_map(int position=0) const
Returns the reference of a Map stored in the list.
Definition param.C:1256
int get_n_cmp() const
Returns the number of Cmp 's addresses in the list.
Definition param.C:928
int n_double_mod
Number of modifiable double 's (double precis.
Definition param.h:142
void add_tensor(const Tensor &ti, int position=0)
Adds the address of a new Tensor to the list.
Definition param.C:1486
const Scalar & get_scalar(int position=0) const
Returns the reference of a Scalar stored in the list.
Definition param.C:1393
const Tensor ** p_tensor
Array (size n_tensor ) of the Tensor 's addresses.
Definition param.h:205
int n_int
Number of int 's (integers).
Definition param.h:130
Tenseur & get_tenseur_mod(int position=0) const
Returns the reference of a modifiable Tenseur stored in the list.
Definition param.C:1187
int get_n_mtbl_cf() const
Returns the number of Mtbl_cf 's addresses in the list.
Definition param.C:1272
void add_cmp(const Cmp &ti, int position=0)
Adds the address of a new Cmp to the list.
Definition param.C:935
Matrice ** p_matrice_mod
Array (size n_matrice_mod ) of the modifiable Matrice 's addresses.
Definition param.h:169
const Tbl ** p_tbl
Array (size n_tbl ) of the Tbl 's addresses.
Definition param.h:149
int get_n_tensor_mod() const
Returns the number of modifiable Tensor 's addresses in the list.
Definition param.C:1548
void add_scalar(const Scalar &ti, int position=0)
Adds the address of a new Scalar to the list.
Definition param.C:1348
void add_double_mod(double &x, int position=0)
Adds the address of a new modifiable double to the list.
Definition param.C:453
Matrice & get_matrice_mod(int position=0) const
Returns the reference of a modifiable Matrice stored in the list.
Definition param.C:911
Cmp ** p_cmp_mod
Array (size n_cmp_mod ) of the modifiable Cmp 's addresses.
Definition param.h:177
int get_n_matrice() const
Returns the number of Matrice 's addresses in the list.
Definition param.C:790
void add_int_mod(int &n, int position=0)
Adds the address of a new modifiable int to the list.
Definition param.C:385
int ** p_int_mod
Array (size n_int_mod ) of the modifiable int 's addresses.
Definition param.h:136
Itbl ** p_itbl_mod
Array (size n_itbl_mod ) of the modifiable Itbl 's addresses.
Definition param.h:161
int n_itbl_mod
Number of modifiable Itbl 's
Definition param.h:159
const Tenseur ** p_tenseur
Array (size n_tenseur ) of the Tenseur 's addresses.
Definition param.h:181
int n_mtbl_cf
Number of Mtbl_cf 's
Definition param.h:191
void add_tenseur(const Tenseur &ti, int position=0)
Adds the address of a new Tenseur to the list.
Definition param.C:1073
void add_tbl_mod(Tbl &ti, int position=0)
Adds the address of a new modifiable Tbl to the list.
Definition param.C:591
int n_tensor
Number of Tensor 's
Definition param.h:203
int n_tenseur
Number of Tenseur 's
Definition param.h:179
void add_itbl_mod(Itbl &ti, int position=0)
Adds the address of a new modifiable Itbl to the list.
Definition param.C:729
const Cmp ** p_cmp
Array (size n_cmp ) of the Cmp 's addresses.
Definition param.h:173
const Etoile ** p_etoile
Array (size n_etoile ) of the Etoile 's addresses.
Definition param.h:213
void add_tenseur_mod(Tenseur &ti, int position=0)
Adds the address of a new modifiable Tenseur to the list.
Definition param.C:1142
const Tbl & get_tbl(int position=0) const
Returns the reference of a Tbl stored in the list.
Definition param.C:567
int get_n_scalar() const
Returns the number of Scalar 's addresses in the list.
Definition param.C:1341
Param()
Default constructor is the only constructor.
Definition param.C:115
int get_n_star() const
Returns the number of Star 's addresses in the list.
Definition param.C:1683
const Itbl ** p_itbl
Array (size n_itbl ) of the Itbl 's addresses.
Definition param.h:157
int n_double
Number of double 's (double precis.
Definition param.h:138
int n_etoile
Number of Etoile 's.
Definition param.h:211
const Tensor & get_tensor(int position=0) const
Returns the reference of a Tensor stored in the list.
Definition param.C:1531
int get_n_double() const
Returns the number of stored double 's addresses.
Definition param.C:308
int get_n_int() const
Returns the number of stored int 's addresses.
Definition param.C:239
const Cmp & get_cmp(int position=0) const
Returns the reference of a Cmp stored in the list.
Definition param.C:980
int n_tenseur_mod
Number of modifiable Tenseur 's
Definition param.h:183
int n_cmp_mod
Number of modifiable Cmp 's
Definition param.h:175
int n_matrice_mod
Number of modifiable Matrice 's
Definition param.h:167
int & get_int_mod(int position=0) const
Returns the reference of a modifiable int stored in the list.
Definition param.C:430
int n_tbl_mod
Number of modifiable Tbl 's
Definition param.h:151
void add_itbl(const Itbl &ti, int position=0)
Adds the address of a new Itbl to the list.
Definition param.C:660
double & get_double_mod(int position=0) const
Returns the reference of a stored modifiable double .
Definition param.C:498
int n_star
Number of Star 's.
Definition param.h:215
int n_map
Number of Map 's
Definition param.h:187
void add_int(const int &n, int position=0)
Adds the address of a new int to the list.
Definition param.C:246
int n_scalar_mod
Number of modifiable Scalar 's
Definition param.h:199
const Etoile & get_etoile(int position=0) const
Returns the reference of a Etoile stored in the list.
Definition param.C:1669
const Matrice & get_matrice(int position=0) const
Returns the reference of a Matrice stored in the list.
Definition param.C:842
int get_n_tbl() const
Returns the number of Tbl 's addresses in the list.
Definition param.C:515
int n_tensor_mod
Number of modifiable Tensor 's
Definition param.h:207
int n_cmp
Number of Cmp 's
Definition param.h:171
void add_tbl(const Tbl &ti, int position=0)
Adds the address of a new Tbl to the list.
Definition param.C:522
const Mtbl_cf & get_mtbl_cf(int position=0) const
Returns the reference of a Mtbl_cf stored in the list.
Definition param.C:1325
Tensor field of valence 0 (or component of a tensorial field).
Definition scalar.h:387
Base class for stars.
Definition star.h:175
Basic array class.
Definition tbl.h:161
Tensor handling *** DEPRECATED : use class Tensor instead ***.
Definition tenseur.h:301
Tensor handling.
Definition tensor.h:288
Lorene prototypes.
Definition app_hor.h:64