param.C
/*
* Methods of class Param
*
* (see file param.h for documentation)
*
*/
/*
* Copyright (c) 1999-2005 Eric Gourgoulhon
* Copyright (c) 2000-2003 Jerome Novak
*
* This file is part of LORENE.
*
* LORENE is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* LORENE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with LORENE; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
char param_C[] = "$Header: /cvsroot/Lorene/C++/Source/Param/param.C,v 1.9 2014/10/13 08:53:37 j_novak Exp $" ;
/*
* $Id: param.C,v 1.9 2014/10/13 08:53:37 j_novak Exp $
* $Log: param.C,v $
* Revision 1.9 2014/10/13 08:53:37 j_novak
* Lorene classes and functions now belong to the namespace Lorene.
*
* Revision 1.8 2014/10/06 15:13:16 j_novak
* Modified #include directives to use c++ syntax.
*
* Revision 1.7 2006/06/15 08:15:39 j_novak
* Removed members linked to Qtenseur objects.
* Added members for Matrice objects.
*
* Revision 1.6 2005/08/13 16:11:44 m_saijo
* Added storage of a Star
*
* Revision 1.5 2005/03/24 21:56:31 e_gourgoulhon
* Added storage of a Scalar.
*
* Revision 1.4 2003/09/25 12:08:03 j_novak
* Tensors can be stored in Param objects
*
* Revision 1.3 2002/10/16 14:37:12 j_novak
* Reorganization of #include instructions of standard C++, in order to
* use experimental version 3 of gcc.
*
* Revision 1.2 2002/09/19 09:52:42 j_novak
* Added objects Qtenseur and Qmetrique for 4D tensor and metric handling.
*
* Revision 1.1.1.1 2001/11/20 15:19:27 e_gourgoulhon
* LORENE
*
* Revision 1.8 2001/10/11 07:44:27 eric
* Ajout du stokage des Etoile's
*
* Revision 1.7 2000/10/24 14:55:20 novak
* Added the function clean_all()
*
* Revision 1.6 2000/05/25 12:40:47 eric
* MODIFICATION MAJEURE: pour les int et les double, ce sont desormais les
* dresses qui sont stokees, et non plus les nombres eux-memes
* (le traitement des int et des double est donc desormais completement
* aligne sur celui des Tbl, Cmp, etc...)
*
* Revision 1.5 1999/12/29 13:10:54 eric
* Ajout du stokage des Mtbl_cf.
*
* Revision 1.4 1999/12/27 12:17:02 eric
* Ajout du stokage des mappings (class Map).
*
* Revision 1.3 1999/12/16 10:28:25 eric
* Ajout des membres modifiables.
* Par defaut, les objets listes sont const.
*
* Revision 1.2 1999/12/15 16:23:22 eric
* Changement de l'ordre des arguments dans add_*
* Argument par defaut: position = 0
* Ajout du stokage des int et des double.
*
* Revision 1.1 1999/12/13 14:36:00 eric
* Initial revision
*
*
* $Header: /cvsroot/Lorene/C++/Source/Param/param.C,v 1.9 2014/10/13 08:53:37 j_novak Exp $
*
*/
// Headers C
#include <cstdlib>
#include <cassert>
// Headers Lorene
#include "param.h"
#include "tenseur.h"
#include "tensor.h"
#include "matrice.h"
//------------------------//
// Constructor //
//------------------------//
namespace Lorene {
Param::Param() : n_int(0),
n_int_mod(0),
n_double(0),
n_double_mod(0),
n_tbl(0),
n_tbl_mod(0),
n_itbl(0),
n_itbl_mod(0),
n_matrice(0),
n_matrice_mod(0),
n_cmp(0),
n_cmp_mod(0),
n_tenseur(0),
n_tenseur_mod(0),
n_map(0),
n_mtbl_cf(0),
n_scalar(0),
n_scalar_mod(0),
n_tensor(0),
n_tensor_mod(0),
n_etoile(0),
n_star(0)
{}
//----------------------//
// Destructor //
//----------------------//
Param::~Param(){
if (n_int > 0) delete [] p_int ;
if (n_int_mod > 0) delete [] p_int_mod ;
if (n_double > 0) delete [] p_double ;
if (n_double_mod > 0) delete [] p_double_mod ;
if (n_tbl > 0) delete [] p_tbl ;
if (n_tbl_mod > 0) delete [] p_tbl_mod ;
if (n_itbl > 0) delete [] p_itbl ;
if (n_itbl_mod > 0) delete [] p_itbl_mod ;
if (n_matrice > 0) delete [] p_matrice ;
if (n_matrice_mod > 0) delete [] p_matrice_mod ;
if (n_cmp > 0) delete [] p_cmp ;
if (n_cmp_mod > 0) delete [] p_cmp_mod ;
if (n_tenseur > 0) delete [] p_tenseur ;
if (n_tenseur_mod > 0) delete [] p_tenseur_mod ;
if (n_map > 0) delete [] p_map ;
if (n_mtbl_cf > 0) delete [] p_mtbl_cf ;
if (n_scalar > 0) delete [] p_scalar ;
if (n_scalar_mod > 0) delete [] p_scalar_mod ;
if (n_tensor > 0) delete [] p_tensor ;
if (n_tensor_mod > 0) delete [] p_tensor_mod ;
if (n_etoile > 0) delete [] p_etoile ;
if (n_star > 0) delete [] p_star ;
}
//------------------------------------//
// cleaning the memory //
//------------------------------------//
void Param::clean_all() {
for (int i=0; i<n_int_mod; i++)
if (p_int_mod[i] != 0x0) {
delete p_int_mod[i] ;
p_int_mod[i] = 0x0 ;
}
for (int i=0; i<n_double_mod; i++)
if (p_double_mod[i] != 0x0) {
delete p_double_mod[i] ;
p_double_mod[i] = 0x0 ;
}
for (int i=0; i<n_tbl_mod; i++)
if (p_tbl_mod[i] != 0x0) {
delete p_tbl_mod[i] ;
p_tbl_mod[i] = 0x0 ;
}
for (int i=0; i<n_itbl_mod; i++)
if (p_itbl_mod[i] != 0x0) {
delete p_itbl_mod[i] ;
p_itbl_mod[i] = 0x0 ;
}
for (int i=0; i<n_matrice_mod; i++)
if (p_matrice_mod[i] != 0x0) {
delete p_matrice_mod[i] ;
p_matrice_mod[i] = 0x0 ;
}
for (int i=0; i<n_cmp_mod; i++)
if (p_cmp_mod[i] != 0x0) {
delete p_cmp_mod[i] ;
p_cmp_mod[i] = 0x0 ;
}
for (int i=0; i<n_tenseur_mod; i++)
if (p_tenseur_mod[i] != 0x0) {
delete p_tenseur_mod[i] ;
p_tenseur_mod[i] = 0x0 ;
}
for (int i=0; i<n_scalar_mod; i++)
if (p_scalar_mod[i] != 0x0) {
delete p_scalar_mod[i] ;
p_scalar_mod[i] = 0x0 ;
}
for (int i=0; i<n_tensor_mod; i++)
if (p_tensor_mod[i] != 0x0) {
delete p_tensor_mod[i] ;
p_tensor_mod[i] = 0x0 ;
}
}
//------------------------------------//
// int storage //
//------------------------------------//
// Total number of stored int
// --------------------------
int Param::get_n_int() const {
return n_int ;
}
// Addition
// --------
void Param::add_int(const int& ti, int index){
if (index >= n_int) { // p_int must be rescaled
int n_int_nouveau = index + 1 ;
const int** p_int_nouveau = new const int*[n_int_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_int; i++) {
p_int_nouveau[i] = p_int[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_int; i<index; i++) {
p_int_nouveau[i] = 0x0 ;
}
// The new address
p_int_nouveau[index] = &ti ;
// Update
if (n_int > 0) delete [] p_int ;
p_int = p_int_nouveau ;
n_int = n_int_nouveau ;
}
else {
if (p_int[index] != 0x0) {
cout << "Param::add_int : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_int[index] = &ti ;
}
}
}
// Extraction
// ----------
const int& Param::get_int(int index) const {
assert(index >= 0) ;
assert(index < n_int) ;
return *(p_int[index]) ;
}
//------------------------------------//
// double storage //
//------------------------------------//
// Total number of stored doubles
// ------------------------------
int Param::get_n_double() const {
return n_double ;
}
// Addition
// --------
void Param::add_double(const double& ti, int index){
if (index >= n_double) { // p_double must be rescaled
int n_double_nouveau = index + 1 ;
const double** p_double_nouveau =
new const double*[n_double_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_double; i++) {
p_double_nouveau[i] = p_double[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_double; i<index; i++) {
p_double_nouveau[i] = 0x0 ;
}
// The new address
p_double_nouveau[index] = &ti ;
// Update
if (n_double > 0) delete [] p_double ;
p_double = p_double_nouveau ;
n_double = n_double_nouveau ;
}
else {
if (p_double[index] != 0x0) {
cout << "Param::add_double : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_double[index] = &ti ;
}
}
}
// Extraction
// ----------
const double& Param::get_double(int index) const {
assert(index >= 0) ;
assert(index < n_double) ;
return *(p_double[index]) ;
}
//------------------------------------//
// Modifiable int storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_int_mod() const {
return n_int_mod ;
}
// Addition
// --------
void Param::add_int_mod(int& ti, int index){
if (index >= n_int_mod) { // p_int_mod must be rescaled
int n_int_nouveau = index + 1 ;
int** p_int_nouveau = new int*[n_int_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_int_mod; i++) {
p_int_nouveau[i] = p_int_mod[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_int_mod; i<index; i++) {
p_int_nouveau[i] = 0x0 ;
}
// The new address
p_int_nouveau[index] = &ti ;
// Update
if (n_int_mod > 0) delete [] p_int_mod ;
p_int_mod = p_int_nouveau ;
n_int_mod = n_int_nouveau ;
}
else {
if (p_int_mod[index] != 0x0) {
cout << "Param::add_int_mod : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_int_mod[index] = &ti ;
}
}
}
// Extraction
// ----------
int& Param::get_int_mod(int index) const {
assert(index >= 0) ;
assert(index < n_int_mod) ;
return *(p_int_mod[index]) ;
}
//------------------------------------//
// Modifiable double storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_double_mod() const {
return n_double_mod ;
}
// Addition
// --------
void Param::add_double_mod(double& ti, int index){
if (index >= n_double_mod) { // p_double_mod must be rescaled
int n_double_nouveau = index + 1 ;
double** p_double_nouveau = new double*[n_double_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_double_mod; i++) {
p_double_nouveau[i] = p_double_mod[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_double_mod; i<index; i++) {
p_double_nouveau[i] = 0x0 ;
}
// The new address
p_double_nouveau[index] = &ti ;
// Update
if (n_double_mod > 0) delete [] p_double_mod ;
p_double_mod = p_double_nouveau ;
n_double_mod = n_double_nouveau ;
}
else {
if (p_double_mod[index] != 0x0) {
cout << "Param::add_double_mod : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_double_mod[index] = &ti ;
}
}
}
// Extraction
// ----------
double& Param::get_double_mod(int index) const {
assert(index >= 0) ;
assert(index < n_double_mod) ;
return *(p_double_mod[index]) ;
}
//------------------------------------//
// Tbl storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_tbl() const {
return n_tbl ;
}
// Addition
// --------
void Param::add_tbl(const Tbl& ti, int index){
if (index >= n_tbl) { // p_tbl must be rescaled
int n_tbl_nouveau = index + 1 ;
const Tbl** p_tbl_nouveau = new const Tbl*[n_tbl_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_tbl; i++) {
p_tbl_nouveau[i] = p_tbl[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_tbl; i<index; i++) {
p_tbl_nouveau[i] = 0x0 ;
}
// The new address
p_tbl_nouveau[index] = &ti ;
// Update
if (n_tbl > 0) delete [] p_tbl ;
p_tbl = p_tbl_nouveau ;
n_tbl = n_tbl_nouveau ;
}
else {
if (p_tbl[index] != 0x0) {
cout << "Param::add_tbl : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_tbl[index] = &ti ;
}
}
}
// Extraction
// ----------
const Tbl& Param::get_tbl(int index) const {
assert(index >= 0) ;
assert(index < n_tbl) ;
return *(p_tbl[index]) ;
}
//------------------------------------//
// Modifiable Tbl storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_tbl_mod() const {
return n_tbl_mod ;
}
// Addition
// --------
void Param::add_tbl_mod(Tbl& ti, int index){
if (index >= n_tbl_mod) { // p_tbl_mod must be rescaled
int n_tbl_nouveau = index + 1 ;
Tbl** p_tbl_nouveau = new Tbl*[n_tbl_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_tbl_mod; i++) {
p_tbl_nouveau[i] = p_tbl_mod[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_tbl_mod; i<index; i++) {
p_tbl_nouveau[i] = 0x0 ;
}
// The new address
p_tbl_nouveau[index] = &ti ;
// Update
if (n_tbl_mod > 0) delete [] p_tbl_mod ;
p_tbl_mod = p_tbl_nouveau ;
n_tbl_mod = n_tbl_nouveau ;
}
else {
if (p_tbl_mod[index] != 0x0) {
cout << "Param::add_tbl_mod : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_tbl_mod[index] = &ti ;
}
}
}
// Extraction
// ----------
Tbl& Param::get_tbl_mod(int index) const {
assert(index >= 0) ;
assert(index < n_tbl_mod) ;
return *(p_tbl_mod[index]) ;
}
//------------------------------------//
// Itbl storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_itbl() const {
return n_itbl ;
}
// Addition
// --------
void Param::add_itbl(const Itbl& ti, int index){
if (index >= n_itbl) { // p_itbl must be rescaled
int n_itbl_nouveau = index + 1 ;
const Itbl** p_itbl_nouveau = new const Itbl*[n_itbl_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_itbl; i++) {
p_itbl_nouveau[i] = p_itbl[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_itbl; i<index; i++) {
p_itbl_nouveau[i] = 0x0 ;
}
// The new address
p_itbl_nouveau[index] = &ti ;
// Update
if (n_itbl > 0) delete [] p_itbl ;
p_itbl = p_itbl_nouveau ;
n_itbl = n_itbl_nouveau ;
}
else {
if (p_itbl[index] != 0x0) {
cout << "Param::add_itbl : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_itbl[index] = &ti ;
}
}
}
// Extraction
// ----------
const Itbl& Param::get_itbl(int index) const {
assert(index >= 0) ;
assert(index < n_itbl) ;
return *(p_itbl[index]) ;
}
//------------------------------------//
// Modifiable Itbl storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_itbl_mod() const {
return n_itbl_mod ;
}
// Addition
// --------
void Param::add_itbl_mod(Itbl& ti, int index){
if (index >= n_itbl_mod) { // p_itbl_mod must be rescaled
int n_itbl_nouveau = index + 1 ;
Itbl** p_itbl_nouveau = new Itbl*[n_itbl_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_itbl_mod; i++) {
p_itbl_nouveau[i] = p_itbl_mod[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_itbl_mod; i<index; i++) {
p_itbl_nouveau[i] = 0x0 ;
}
// The new address
p_itbl_nouveau[index] = &ti ;
// Update
if (n_itbl_mod > 0) delete [] p_itbl_mod ;
p_itbl_mod = p_itbl_nouveau ;
n_itbl_mod = n_itbl_nouveau ;
}
else {
if (p_itbl_mod[index] != 0x0) {
cout << "Param::add_itbl_mod : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_itbl_mod[index] = &ti ;
}
}
}
// Extraction
// ----------
Itbl& Param::get_itbl_mod(int index) const {
assert(index >= 0) ;
assert(index < n_itbl_mod) ;
return *(p_itbl_mod[index]) ;
}
//------------------------------------//
// Matrice storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_matrice() const {
return n_matrice ;
}
// Addition
// --------
void Param::add_matrice(const Matrice& ti, int index){
if (index >= n_matrice) { // p_matrice must be rescaled
int n_matrice_nouveau = index + 1 ;
const Matrice** p_matrice_nouveau = new const Matrice*[n_matrice_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_matrice; i++) {
p_matrice_nouveau[i] = p_matrice[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_matrice; i<index; i++) {
p_matrice_nouveau[i] = 0x0 ;
}
// The new address
p_matrice_nouveau[index] = &ti ;
// Update
if (n_matrice > 0) delete [] p_matrice ;
p_matrice = p_matrice_nouveau ;
n_matrice = n_matrice_nouveau ;
}
else {
if (p_matrice[index] != 0x0) {
cout << "Param::add_matrice : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_matrice[index] = &ti ;
}
}
}
// Extraction
// ----------
const Matrice& Param::get_matrice(int index) const {
assert(index >= 0) ;
assert(index < n_matrice) ;
return *(p_matrice[index]) ;
}
//------------------------------------//
// Modifiable Matrice storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_matrice_mod() const {
return n_matrice_mod ;
}
// Addition
// --------
void Param::add_matrice_mod(Matrice& ti, int index){
if (index >= n_matrice_mod) { // p_matrice_mod must be rescaled
int n_matrice_nouveau = index + 1 ;
Matrice** p_matrice_nouveau = new Matrice*[n_matrice_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_matrice_mod; i++) {
p_matrice_nouveau[i] = p_matrice_mod[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_matrice_mod; i<index; i++) {
p_matrice_nouveau[i] = 0x0 ;
}
// The new address
p_matrice_nouveau[index] = &ti ;
// Update
if (n_matrice_mod > 0) delete [] p_matrice_mod ;
p_matrice_mod = p_matrice_nouveau ;
n_matrice_mod = n_matrice_nouveau ;
}
else {
if (p_matrice_mod[index] != 0x0) {
cout << "Param::add_matrice_mod : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_matrice_mod[index] = &ti ;
}
}
}
// Extraction
// ----------
Matrice& Param::get_matrice_mod(int index) const {
assert(index >= 0) ;
assert(index < n_matrice_mod) ;
return *(p_matrice_mod[index]) ;
}
//------------------------------------//
// Cmp storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_cmp() const {
return n_cmp ;
}
// Addition
// --------
void Param::add_cmp(const Cmp& ti, int index){
if (index >= n_cmp) { // p_cmp must be rescaled
int n_cmp_nouveau = index + 1 ;
const Cmp** p_cmp_nouveau = new const Cmp*[n_cmp_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_cmp; i++) {
p_cmp_nouveau[i] = p_cmp[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_cmp; i<index; i++) {
p_cmp_nouveau[i] = 0x0 ;
}
// The new address
p_cmp_nouveau[index] = &ti ;
// Update
if (n_cmp > 0) delete [] p_cmp ;
p_cmp = p_cmp_nouveau ;
n_cmp = n_cmp_nouveau ;
}
else {
if (p_cmp[index] != 0x0) {
cout << "Param::add_cmp : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_cmp[index] = &ti ;
}
}
}
// Extraction
// ----------
const Cmp& Param::get_cmp(int index) const {
assert(index >= 0) ;
assert(index < n_cmp) ;
return *(p_cmp[index]) ;
}
//------------------------------------//
// Modifiable Cmp storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_cmp_mod() const {
return n_cmp_mod ;
}
// Addition
// --------
void Param::add_cmp_mod(Cmp& ti, int index){
if (index >= n_cmp_mod) { // p_cmp_mod must be rescaled
int n_cmp_nouveau = index + 1 ;
Cmp** p_cmp_nouveau = new Cmp*[n_cmp_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_cmp_mod; i++) {
p_cmp_nouveau[i] = p_cmp_mod[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_cmp_mod; i<index; i++) {
p_cmp_nouveau[i] = 0x0 ;
}
// The new address
p_cmp_nouveau[index] = &ti ;
// Update
if (n_cmp_mod > 0) delete [] p_cmp_mod ;
p_cmp_mod = p_cmp_nouveau ;
n_cmp_mod = n_cmp_nouveau ;
}
else {
if (p_cmp_mod[index] != 0x0) {
cout << "Param::add_cmp_mod : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_cmp_mod[index] = &ti ;
}
}
}
// Extraction
// ----------
Cmp& Param::get_cmp_mod(int index) const {
assert(index >= 0) ;
assert(index < n_cmp_mod) ;
return *(p_cmp_mod[index]) ;
}
//------------------------------------//
// Tenseur storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_tenseur() const {
return n_tenseur ;
}
// Addition
// --------
void Param::add_tenseur(const Tenseur& ti, int index){
if (index >= n_tenseur) { // p_tenseur must be rescaled
int n_tenseur_nouveau = index + 1 ;
const Tenseur** p_tenseur_nouveau = new const Tenseur*[n_tenseur_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_tenseur; i++) {
p_tenseur_nouveau[i] = p_tenseur[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_tenseur; i<index; i++) {
p_tenseur_nouveau[i] = 0x0 ;
}
// The new address
p_tenseur_nouveau[index] = &ti ;
// Update
if (n_tenseur > 0) delete [] p_tenseur ;
p_tenseur = p_tenseur_nouveau ;
n_tenseur = n_tenseur_nouveau ;
}
else {
if (p_tenseur[index] != 0x0) {
cout << "Param::add_tenseur : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_tenseur[index] = &ti ;
}
}
}
// Extraction
// ----------
const Tenseur& Param::get_tenseur(int index) const {
assert(index >= 0) ;
assert(index < n_tenseur) ;
return *(p_tenseur[index]) ;
}
//------------------------------------//
// Modifiable Tenseur storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_tenseur_mod() const {
return n_tenseur_mod ;
}
// Addition
// --------
void Param::add_tenseur_mod(Tenseur& ti, int index){
if (index >= n_tenseur_mod) { // p_tenseur_mod must be rescaled
int n_tenseur_nouveau = index + 1 ;
Tenseur** p_tenseur_nouveau = new Tenseur*[n_tenseur_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_tenseur_mod; i++) {
p_tenseur_nouveau[i] = p_tenseur_mod[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_tenseur_mod; i<index; i++) {
p_tenseur_nouveau[i] = 0x0 ;
}
// The new address
p_tenseur_nouveau[index] = &ti ;
// Update
if (n_tenseur_mod > 0) delete [] p_tenseur_mod ;
p_tenseur_mod = p_tenseur_nouveau ;
n_tenseur_mod = n_tenseur_nouveau ;
}
else {
if (p_tenseur_mod[index] != 0x0) {
cout << "Param::add_tenseur_mod : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_tenseur_mod[index] = &ti ;
}
}
}
// Extraction
// ----------
Tenseur& Param::get_tenseur_mod(int index) const {
assert(index >= 0) ;
assert(index < n_tenseur_mod) ;
return *(p_tenseur_mod[index]) ;
}
//------------------------------------//
// Map storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_map() const {
return n_map ;
}
// Addition
// --------
void Param::add_map(const Map& mi, int index){
if (index >= n_map) { // p_map must be rescaled
int n_map_nouveau = index + 1 ;
const Map** p_map_nouveau = new const Map*[n_map_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_map; i++) {
p_map_nouveau[i] = p_map[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_map; i<index; i++) {
p_map_nouveau[i] = 0x0 ;
}
// The new address
p_map_nouveau[index] = &mi ;
// Update
if (n_map > 0) delete [] p_map ;
p_map = p_map_nouveau ;
n_map = n_map_nouveau ;
}
else {
if (p_map[index] != 0x0) {
cout << "Param::add_map : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_map[index] = &mi ;
}
}
}
// Extraction
// ----------
const Map& Param::get_map(int index) const {
assert(index >= 0) ;
assert(index < n_map) ;
return *(p_map[index]) ;
}
//------------------------------------//
// Mtbl_cf storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_mtbl_cf() const {
return n_mtbl_cf ;
}
// Addition
// --------
void Param::add_mtbl_cf(const Mtbl_cf& mi, int index){
if (index >= n_mtbl_cf) { // p_mtbl_cf must be rescaled
int n_mtbl_cf_nouveau = index + 1 ;
const Mtbl_cf** p_mtbl_cf_nouveau =
new const Mtbl_cf*[n_mtbl_cf_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_mtbl_cf; i++) {
p_mtbl_cf_nouveau[i] = p_mtbl_cf[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_mtbl_cf; i<index; i++) {
p_mtbl_cf_nouveau[i] = 0x0 ;
}
// The new address
p_mtbl_cf_nouveau[index] = &mi ;
// Update
if (n_mtbl_cf > 0) delete [] p_mtbl_cf ;
p_mtbl_cf = p_mtbl_cf_nouveau ;
n_mtbl_cf = n_mtbl_cf_nouveau ;
}
else {
if (p_mtbl_cf[index] != 0x0) {
cout << "Param::add_mtbl_cf : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_mtbl_cf[index] = &mi ;
}
}
}
// Extraction
// ----------
const Mtbl_cf& Param::get_mtbl_cf(int index) const {
assert(index >= 0) ;
assert(index < n_mtbl_cf) ;
return *(p_mtbl_cf[index]) ;
}
//------------------------------------//
// Scalar storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_scalar() const {
return n_scalar ;
}
// Addition
// --------
void Param::add_scalar(const Scalar& ti, int index){
if (index >= n_scalar) { // p_scalar must be rescaled
int n_scalar_nouveau = index + 1 ;
const Scalar** p_scalar_nouveau = new const Scalar*[n_scalar_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_scalar; i++) {
p_scalar_nouveau[i] = p_scalar[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_scalar; i<index; i++) {
p_scalar_nouveau[i] = 0x0 ;
}
// The new address
p_scalar_nouveau[index] = &ti ;
// Update
if (n_scalar > 0) delete [] p_scalar ;
p_scalar = p_scalar_nouveau ;
n_scalar = n_scalar_nouveau ;
}
else {
if (p_scalar[index] != 0x0) {
cout << "Param::add_scalar : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_scalar[index] = &ti ;
}
}
}
// Extraction
// ----------
const Scalar& Param::get_scalar(int index) const {
assert(index >= 0) ;
assert(index < n_scalar) ;
return *(p_scalar[index]) ;
}
//------------------------------------//
// Modifiable Scalar storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_scalar_mod() const {
return n_scalar_mod ;
}
// Addition
// --------
void Param::add_scalar_mod(Scalar& ti, int index){
if (index >= n_scalar_mod) { // p_scalar_mod must be rescaled
int n_scalar_nouveau = index + 1 ;
Scalar** p_scalar_nouveau = new Scalar*[n_scalar_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_scalar_mod; i++) {
p_scalar_nouveau[i] = p_scalar_mod[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_scalar_mod; i<index; i++) {
p_scalar_nouveau[i] = 0x0 ;
}
// The new address
p_scalar_nouveau[index] = &ti ;
// Update
if (n_scalar_mod > 0) delete [] p_scalar_mod ;
p_scalar_mod = p_scalar_nouveau ;
n_scalar_mod = n_scalar_nouveau ;
}
else {
if (p_scalar_mod[index] != 0x0) {
cout << "Param::add_scalar_mod : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_scalar_mod[index] = &ti ;
}
}
}
// Extraction
// ----------
Scalar& Param::get_scalar_mod(int index) const {
assert(index >= 0) ;
assert(index < n_scalar_mod) ;
return *(p_scalar_mod[index]) ;
}
//------------------------------------//
// Tensor storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_tensor() const {
return n_tensor ;
}
// Addition
// --------
void Param::add_tensor(const Tensor& ti, int index){
if (index >= n_tensor) { // p_tensor must be rescaled
int n_tensor_nouveau = index + 1 ;
const Tensor** p_tensor_nouveau = new const Tensor*[n_tensor_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_tensor; i++) {
p_tensor_nouveau[i] = p_tensor[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_tensor; i<index; i++) {
p_tensor_nouveau[i] = 0x0 ;
}
// The new address
p_tensor_nouveau[index] = &ti ;
// Update
if (n_tensor > 0) delete [] p_tensor ;
p_tensor = p_tensor_nouveau ;
n_tensor = n_tensor_nouveau ;
}
else {
if (p_tensor[index] != 0x0) {
cout << "Param::add_tensor : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_tensor[index] = &ti ;
}
}
}
// Extraction
// ----------
const Tensor& Param::get_tensor(int index) const {
assert(index >= 0) ;
assert(index < n_tensor) ;
return *(p_tensor[index]) ;
}
//------------------------------------//
// Modifiable Tensor storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_tensor_mod() const {
return n_tensor_mod ;
}
// Addition
// --------
void Param::add_tensor_mod(Tensor& ti, int index){
if (index >= n_tensor_mod) { // p_tensor_mod must be rescaled
int n_tensor_nouveau = index + 1 ;
Tensor** p_tensor_nouveau = new Tensor*[n_tensor_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_tensor_mod; i++) {
p_tensor_nouveau[i] = p_tensor_mod[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_tensor_mod; i<index; i++) {
p_tensor_nouveau[i] = 0x0 ;
}
// The new address
p_tensor_nouveau[index] = &ti ;
// Update
if (n_tensor_mod > 0) delete [] p_tensor_mod ;
p_tensor_mod = p_tensor_nouveau ;
n_tensor_mod = n_tensor_nouveau ;
}
else {
if (p_tensor_mod[index] != 0x0) {
cout << "Param::add_tensor_mod : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_tensor_mod[index] = &ti ;
}
}
}
// Extraction
// ----------
Tensor& Param::get_tensor_mod(int index) const {
assert(index >= 0) ;
assert(index < n_tensor_mod) ;
return *(p_tensor_mod[index]) ;
}
//------------------------------------//
// Etoile storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_etoile() const {
return n_etoile ;
}
// Addition
// --------
void Param::add_etoile(const Etoile& eti, int index){
if (index >= n_etoile) { // p_etoile must be rescaled
int n_etoile_nouveau = index + 1 ;
const Etoile** p_etoile_nouveau = new const Etoile*[n_etoile_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_etoile; i++) {
p_etoile_nouveau[i] = p_etoile[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_etoile; i<index; i++) {
p_etoile_nouveau[i] = 0x0 ;
}
// The new address
p_etoile_nouveau[index] = &eti ;
// Update
if (n_etoile > 0) delete [] p_etoile ;
p_etoile = p_etoile_nouveau ;
n_etoile = n_etoile_nouveau ;
}
else {
if (p_etoile[index] != 0x0) {
cout << "Param::add_etoile : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_etoile[index] = &eti ;
}
}
}
// Extraction
// ----------
const Etoile& Param::get_etoile(int index) const {
assert(index >= 0) ;
assert(index < n_etoile) ;
return *(p_etoile[index]) ;
}
//------------------------------------//
// Star storage //
//------------------------------------//
// Total number of stored addresses
// --------------------------------
int Param::get_n_star() const {
return n_star ;
}
// Addition
// --------
void Param::add_star(const Star& eti, int index){
if (index >= n_star) { // p_star must be rescaled
int n_star_nouveau = index + 1 ;
const Star** p_star_nouveau = new const Star*[n_star_nouveau] ;
// Copy of the previous addresses
for (int i=0; i<n_star; i++) {
p_star_nouveau[i] = p_star[i] ;
}
// The intermediate addresses are set to 0x0
for (int i=n_star; i<index; i++) {
p_star_nouveau[i] = 0x0 ;
}
// The new address
p_star_nouveau[index] = &eti ;
// Update
if (n_star > 0) delete [] p_star ;
p_star = p_star_nouveau ;
n_star = n_star_nouveau ;
}
else {
if (p_star[index] != 0x0) {
cout << "Param::add_star : the position " << index
<< " is already occupied !" << endl ;
abort() ;
}
else{
p_star[index] = &eti ;
}
}
}
// Extraction
// ----------
const Star& Param::get_star(int index) const {
assert(index >= 0) ;
assert(index < n_star) ;
return *(p_star[index]) ;
}
}
Lorene::Cmp
Component of a tensorial field *** DEPRECATED : use class Scalar instead ***.
Definition cmp.h:446
Lorene::Etoile
Base class for stars *** DEPRECATED : use class Star instead ***.
Definition etoile.h:424
Lorene::Itbl
Basic integer array class.
Definition itbl.h:122
Lorene::Matrice
Matrix handling.
Definition matrice.h:152
Lorene::Mtbl_cf
Coefficients storage for the multi-domain spectral method.
Definition mtbl_cf.h:186
Lorene::Param::get_n_cmp_mod
int get_n_cmp_mod() const
Returns the number of modifiable Cmp 's addresses in the list.
Definition param.C:997
Lorene::Param::get_tensor_mod
Tensor & get_tensor_mod(int position=0) const
Returns the reference of a modifiable Tensor stored in the list.
Definition param.C:1600
Lorene::Param::add_double
void add_double(const double &x, int position=0)
Adds the the address of a new double to the list.
Definition param.C:315
Lorene::Param::get_itbl
const Itbl & get_itbl(int position=0) const
Returns the reference of a Itbl stored in the list.
Definition param.C:705
Lorene::Param::get_n_itbl
int get_n_itbl() const
Returns the number of Itbl 's addresses in the list.
Definition param.C:653
Lorene::Param::p_map
const Map ** p_map
Array (size n_map ) of the Map 's addresses.
Definition param.h:189
Lorene::Param::get_n_itbl_mod
int get_n_itbl_mod() const
Returns the number of modifiable Itbl 's addresses in the list.
Definition param.C:722
Lorene::Param::p_mtbl_cf
const Mtbl_cf ** p_mtbl_cf
Array (size n_mtbl_cf ) of the Mtbl_cf 's addresses.
Definition param.h:193
Lorene::Param::p_int
const int ** p_int
Array (size n_int ) of the int 's addresses.
Definition param.h:132
Lorene::Param::n_scalar
int n_scalar
Number of Scalar 's.
Definition param.h:195
Lorene::Param::~Param
~Param()
Destructor.
Definition param.C:144
Lorene::Param::n_matrice
int n_matrice
Number of Matrice 's.
Definition param.h:163
Lorene::Param::add_scalar_mod
void add_scalar_mod(Scalar &ti, int position=0)
Adds the address of a new modifiable Scalar to the list.
Definition param.C:1417
Lorene::Param::get_cmp_mod
Cmp & get_cmp_mod(int position=0) const
Returns the reference of a modifiable Cmp stored in the list.
Definition param.C:1049
Lorene::Param::p_scalar_mod
Scalar ** p_scalar_mod
Array (size n_scalar_mod ) of the modifiable Scalar 's addresses.
Definition param.h:201
Lorene::Param::get_n_matrice_mod
int get_n_matrice_mod() const
Returns the number of modifiable Matrice 's addresses in the list.
Definition param.C:859
Lorene::Param::add_matrice
void add_matrice(const Matrice &ti, int position=0)
Adds the address of a new Matrice to the list.
Definition param.C:797
Lorene::Param::p_tbl_mod
Tbl ** p_tbl_mod
Array (size n_tbl_mod ) of the modifiable Tbl 's addresses.
Definition param.h:153
Lorene::Param::p_matrice
const Matrice ** p_matrice
Array (size n_matrice ) of the Matrice 's addresses.
Definition param.h:165
Lorene::Param::p_double
const double ** p_double
Array (size n_double ) of the double 's addresses.
Definition param.h:140
Lorene::Param::add_map
void add_map(const Map &mi, int position=0)
Adds the address of a new Map to the list.
Definition param.C:1211
Lorene::Param::n_int_mod
int n_int_mod
Number of modifiable int 's (integers).
Definition param.h:134
Lorene::Param::get_scalar_mod
Scalar & get_scalar_mod(int position=0) const
Returns the reference of a modifiable Scalar stored in the list.
Definition param.C:1462
Lorene::Param::p_star
const Star ** p_star
Array (size n_star ) of the Star 's addresses.
Definition param.h:217
Lorene::Param::p_scalar
const Scalar ** p_scalar
Array (size n_scalar ) of the Scalar 's addresses.
Definition param.h:197
Lorene::Param::get_int
const int & get_int(int position=0) const
Returns the reference of a int stored in the list.
Definition param.C:292
Lorene::Param::get_double
const double & get_double(int position=0) const
Returns the reference of a double stored in the list.
Definition param.C:361
Lorene::Param::add_mtbl_cf
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
Lorene::Param::get_n_tbl_mod
int get_n_tbl_mod() const
Returns the number of modifiable Tbl 's addresses in the list.
Definition param.C:584
Lorene::Param::get_itbl_mod
Itbl & get_itbl_mod(int position=0) const
Returns the reference of a stored modifiable Itbl .
Definition param.C:774
Lorene::Param::get_n_double_mod
int get_n_double_mod() const
Returns the number of stored modifiable double 's addresses.
Definition param.C:446
Lorene::Param::add_tensor_mod
void add_tensor_mod(Tensor &ti, int position=0)
Adds the address of a new modifiable Tensor to the list.
Definition param.C:1555
Lorene::Param::get_n_tenseur
int get_n_tenseur() const
Returns the number of Tenseur 's addresses in the list.
Definition param.C:1066
Lorene::Param::add_star
void add_star(const Star &eti, int position=0)
Adds the address of a new Star to the list.
Definition param.C:1690
Lorene::Param::get_n_int_mod
int get_n_int_mod() const
Returns the number of modifiable int 's addresses in the list.
Definition param.C:378
Lorene::Param::get_tbl_mod
Tbl & get_tbl_mod(int position=0) const
Returns the reference of a modifiable Tbl stored in the list.
Definition param.C:636
Lorene::Param::get_star
const Star & get_star(int position=0) const
Returns the reference of a Star stored in the list.
Definition param.C:1735
Lorene::Param::get_n_scalar_mod
int get_n_scalar_mod() const
Returns the number of modifiable Scalar 's addresses in the list.
Definition param.C:1410
Lorene::Param::p_tensor_mod
Tensor ** p_tensor_mod
Array (size n_tensor_mod ) of the modifiable Tensor 's addresses.
Definition param.h:209
Lorene::Param::clean_all
void clean_all()
Deletes all the objects stored as modifiables, i.e.
Definition param.C:174
Lorene::Param::get_tenseur
const Tenseur & get_tenseur(int position=0) const
Returns the reference of a Tenseur stored in the list.
Definition param.C:1118
Lorene::Param::get_n_etoile
int get_n_etoile() const
Returns the number of Etoile 's addresses in the list.
Definition param.C:1617
Lorene::Param::add_cmp_mod
void add_cmp_mod(Cmp &ti, int position=0)
Adds the address of a new modifiable Cmp to the list.
Definition param.C:1004
Lorene::Param::add_etoile
void add_etoile(const Etoile &eti, int position=0)
Adds the address of a new Etoile to the list.
Definition param.C:1624
Lorene::Param::get_n_tenseur_mod
int get_n_tenseur_mod() const
Returns the number of modifiable Tenseur 's addresses in the list.
Definition param.C:1135
Lorene::Param::n_itbl
int n_itbl
Number of Itbl 's.
Definition param.h:155
Lorene::Param::p_tenseur_mod
Tenseur ** p_tenseur_mod
Array (size n_tenseur_mod ) of the modifiable Tenseur 's addresses.
Definition param.h:185
Lorene::Param::p_double_mod
double ** p_double_mod
Array (size n_double_mod ) of the double 's addresses.
Definition param.h:144
Lorene::Param::n_tbl
int n_tbl
Number of Tbl 's.
Definition param.h:147
Lorene::Param::add_matrice_mod
void add_matrice_mod(Matrice &ti, int position=0)
Adds the address of a new modifiable Matrice to the list.
Definition param.C:866
Lorene::Param::get_n_tensor
int get_n_tensor() const
Returns the number of Tensor 's addresses in the list.
Definition param.C:1479
Lorene::Param::get_n_map
int get_n_map() const
Returns the number of Map 's addresses in the list.
Definition param.C:1204
Lorene::Param::get_map
const Map & get_map(int position=0) const
Returns the reference of a Map stored in the list.
Definition param.C:1256
Lorene::Param::get_n_cmp
int get_n_cmp() const
Returns the number of Cmp 's addresses in the list.
Definition param.C:928
Lorene::Param::n_double_mod
int n_double_mod
Number of modifiable double 's (double precis.
Definition param.h:142
Lorene::Param::add_tensor
void add_tensor(const Tensor &ti, int position=0)
Adds the address of a new Tensor to the list.
Definition param.C:1486
Lorene::Param::get_scalar
const Scalar & get_scalar(int position=0) const
Returns the reference of a Scalar stored in the list.
Definition param.C:1393
Lorene::Param::p_tensor
const Tensor ** p_tensor
Array (size n_tensor ) of the Tensor 's addresses.
Definition param.h:205
Lorene::Param::n_int
int n_int
Number of int 's (integers).
Definition param.h:130
Lorene::Param::get_tenseur_mod
Tenseur & get_tenseur_mod(int position=0) const
Returns the reference of a modifiable Tenseur stored in the list.
Definition param.C:1187
Lorene::Param::get_n_mtbl_cf
int get_n_mtbl_cf() const
Returns the number of Mtbl_cf 's addresses in the list.
Definition param.C:1272
Lorene::Param::add_cmp
void add_cmp(const Cmp &ti, int position=0)
Adds the address of a new Cmp to the list.
Definition param.C:935
Lorene::Param::p_matrice_mod
Matrice ** p_matrice_mod
Array (size n_matrice_mod ) of the modifiable Matrice 's addresses.
Definition param.h:169
Lorene::Param::p_tbl
const Tbl ** p_tbl
Array (size n_tbl ) of the Tbl 's addresses.
Definition param.h:149
Lorene::Param::get_n_tensor_mod
int get_n_tensor_mod() const
Returns the number of modifiable Tensor 's addresses in the list.
Definition param.C:1548
Lorene::Param::add_scalar
void add_scalar(const Scalar &ti, int position=0)
Adds the address of a new Scalar to the list.
Definition param.C:1348
Lorene::Param::add_double_mod
void add_double_mod(double &x, int position=0)
Adds the address of a new modifiable double to the list.
Definition param.C:453
Lorene::Param::get_matrice_mod
Matrice & get_matrice_mod(int position=0) const
Returns the reference of a modifiable Matrice stored in the list.
Definition param.C:911
Lorene::Param::p_cmp_mod
Cmp ** p_cmp_mod
Array (size n_cmp_mod ) of the modifiable Cmp 's addresses.
Definition param.h:177
Lorene::Param::get_n_matrice
int get_n_matrice() const
Returns the number of Matrice 's addresses in the list.
Definition param.C:790
Lorene::Param::add_int_mod
void add_int_mod(int &n, int position=0)
Adds the address of a new modifiable int to the list.
Definition param.C:385
Lorene::Param::p_int_mod
int ** p_int_mod
Array (size n_int_mod ) of the modifiable int 's addresses.
Definition param.h:136
Lorene::Param::p_itbl_mod
Itbl ** p_itbl_mod
Array (size n_itbl_mod ) of the modifiable Itbl 's addresses.
Definition param.h:161
Lorene::Param::n_itbl_mod
int n_itbl_mod
Number of modifiable Itbl 's.
Definition param.h:159
Lorene::Param::p_tenseur
const Tenseur ** p_tenseur
Array (size n_tenseur ) of the Tenseur 's addresses.
Definition param.h:181
Lorene::Param::n_mtbl_cf
int n_mtbl_cf
Number of Mtbl_cf 's.
Definition param.h:191
Lorene::Param::add_tenseur
void add_tenseur(const Tenseur &ti, int position=0)
Adds the address of a new Tenseur to the list.
Definition param.C:1073
Lorene::Param::add_tbl_mod
void add_tbl_mod(Tbl &ti, int position=0)
Adds the address of a new modifiable Tbl to the list.
Definition param.C:591
Lorene::Param::n_tensor
int n_tensor
Number of Tensor 's.
Definition param.h:203
Lorene::Param::n_tenseur
int n_tenseur
Number of Tenseur 's.
Definition param.h:179
Lorene::Param::add_itbl_mod
void add_itbl_mod(Itbl &ti, int position=0)
Adds the address of a new modifiable Itbl to the list.
Definition param.C:729
Lorene::Param::p_cmp
const Cmp ** p_cmp
Array (size n_cmp ) of the Cmp 's addresses.
Definition param.h:173
Lorene::Param::p_etoile
const Etoile ** p_etoile
Array (size n_etoile ) of the Etoile 's addresses.
Definition param.h:213
Lorene::Param::add_tenseur_mod
void add_tenseur_mod(Tenseur &ti, int position=0)
Adds the address of a new modifiable Tenseur to the list.
Definition param.C:1142
Lorene::Param::get_tbl
const Tbl & get_tbl(int position=0) const
Returns the reference of a Tbl stored in the list.
Definition param.C:567
Lorene::Param::get_n_scalar
int get_n_scalar() const
Returns the number of Scalar 's addresses in the list.
Definition param.C:1341
Lorene::Param::Param
Param()
Default constructor is the only constructor.
Definition param.C:115
Lorene::Param::get_n_star
int get_n_star() const
Returns the number of Star 's addresses in the list.
Definition param.C:1683
Lorene::Param::p_itbl
const Itbl ** p_itbl
Array (size n_itbl ) of the Itbl 's addresses.
Definition param.h:157
Lorene::Param::n_double
int n_double
Number of double 's (double precis.
Definition param.h:138
Lorene::Param::n_etoile
int n_etoile
Number of Etoile 's.
Definition param.h:211
Lorene::Param::get_tensor
const Tensor & get_tensor(int position=0) const
Returns the reference of a Tensor stored in the list.
Definition param.C:1531
Lorene::Param::get_n_double
int get_n_double() const
Returns the number of stored double 's addresses.
Definition param.C:308
Lorene::Param::get_n_int
int get_n_int() const
Returns the number of stored int 's addresses.
Definition param.C:239
Lorene::Param::get_cmp
const Cmp & get_cmp(int position=0) const
Returns the reference of a Cmp stored in the list.
Definition param.C:980
Lorene::Param::n_tenseur_mod
int n_tenseur_mod
Number of modifiable Tenseur 's.
Definition param.h:183
Lorene::Param::n_cmp_mod
int n_cmp_mod
Number of modifiable Cmp 's.
Definition param.h:175
Lorene::Param::n_matrice_mod
int n_matrice_mod
Number of modifiable Matrice 's.
Definition param.h:167
Lorene::Param::get_int_mod
int & get_int_mod(int position=0) const
Returns the reference of a modifiable int stored in the list.
Definition param.C:430
Lorene::Param::n_tbl_mod
int n_tbl_mod
Number of modifiable Tbl 's.
Definition param.h:151
Lorene::Param::add_itbl
void add_itbl(const Itbl &ti, int position=0)
Adds the address of a new Itbl to the list.
Definition param.C:660
Lorene::Param::get_double_mod
double & get_double_mod(int position=0) const
Returns the reference of a stored modifiable double .
Definition param.C:498
Lorene::Param::n_star
int n_star
Number of Star 's.
Definition param.h:215
Lorene::Param::n_map
int n_map
Number of Map 's.
Definition param.h:187
Lorene::Param::add_int
void add_int(const int &n, int position=0)
Adds the address of a new int to the list.
Definition param.C:246
Lorene::Param::n_scalar_mod
int n_scalar_mod
Number of modifiable Scalar 's.
Definition param.h:199
Lorene::Param::get_etoile
const Etoile & get_etoile(int position=0) const
Returns the reference of a Etoile stored in the list.
Definition param.C:1669
Lorene::Param::get_matrice
const Matrice & get_matrice(int position=0) const
Returns the reference of a Matrice stored in the list.
Definition param.C:842
Lorene::Param::get_n_tbl
int get_n_tbl() const
Returns the number of Tbl 's addresses in the list.
Definition param.C:515
Lorene::Param::n_tensor_mod
int n_tensor_mod
Number of modifiable Tensor 's.
Definition param.h:207
Lorene::Param::n_cmp
int n_cmp
Number of Cmp 's.
Definition param.h:171
Lorene::Param::add_tbl
void add_tbl(const Tbl &ti, int position=0)
Adds the address of a new Tbl to the list.
Definition param.C:522
Lorene::Param::get_mtbl_cf
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
Lorene::Scalar
Tensor field of valence 0 (or component of a tensorial field).
Definition scalar.h:387
Lorene::Star
Base class for stars.
Definition star.h:175
Lorene::Tbl
Basic array class.
Definition tbl.h:161
Lorene::Tenseur
Tensor handling *** DEPRECATED : use class Tensor instead ***.
Definition tenseur.h:301
Lorene::Tensor
Tensor handling.
Definition tensor.h:288
Lorene
Lorene prototypes.
Definition app_hor.h:64
Lorene::Map
Map(const Mg3d &)
Constructor from a multi-domain 3D grid.
Definition map.C:139