research/cantera
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Made the CanteraError exception inherit from std::exception

Browse source 
Added in mdp_allo package. It's not really linked in anywhere except
for applications, so call it provisional.
This commit is contained in:
Harry Moffat 2009-02-11 19:55:56 +00:00
parent a5f37dfa00
commit 08cc65d5d4
6 changed files with 2654 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Cantera/src/base/Makefile.in
View file

@ -29,12 +29,12 @@ PIC_FLAG=@PIC@
CXX_FLAGS = @CXXFLAGS@ $(LOCAL_DEFS) $(CXX_OPT) $(PIC_FLAG) $(DEBUG_FLAG)
BASE_OBJ = ct2ctml.o ctml.o misc.o plots.o stringUtils.o xml.o clockWC.o\
PrintCtrl.o LogPrintCtrl.o
PrintCtrl.o LogPrintCtrl.o mdp_allo.o
BASE_H = ct_defs.h ctexceptions.h logger.h XML_Writer.h \
ctml.h plots.h stringUtils.h xml.h config.h utilities.h \
Array.h vec_functions.h global.h FactoryBase.h clockWC.h \
PrintCtrl.h LogPrintCtrl.h
PrintCtrl.h LogPrintCtrl.h mdp_allo.h
CXX_INCLUDES = -I. @CXX_INCLUDES@
LIB = @buildlib@/libctbase.a

112
Cantera/src/base/checkFinite.cpp Normal file
View file

@ -0,0 +1,112 @@
/**
* @file checkFinite.cpp
* Declarations for Multi Dimensional Pointer (mdp) routines that
* check for the presence of NaNs in the code.
*/
/*
* $Revision$
* $Date$
*/
/*
* Copywrite 2004 Sandia Corporation. Under the terms of Contract
* DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
* retains certain rights in this software.
* See file License.txt for licensing information.
*/
#include <stdexcept>
#include <string>
#include <cmath>
#include <cstdlib>
#include <cstdio>
// We expect that there will be special casing based on the computer
// system here
#ifdef SOLARIS
#include <ieeefp.h>
#include <sunmath.h>
#endif
using namespace std;
namespace mdp {
// Utility routine to check to see that a number is finite.
/*
* @param tmp number to be checked
*/
void checkFinite(const double tmp) throw(std::range_error) {
if (! finite(tmp)) {
if(isnan(tmp)) {
printf("ERROR: we have encountered a nan!\n");
} else if (isinf(tmp) == 1) {
printf("ERROR: we have encountered a pos inf!\n");
} else {
printf("ERROR: we have encountered a neg inf!\n");
}
const std::string s = "checkFinite()";
throw std::range_error(s);
}
}
// Utility routine to link checkFinte() to fortran program
/*
* This routine is accessible from fortran, usually
*
* @param tmp Pointer to the number to check
*
* @todo link it into the usual way Cantera handles Fortran calls
*/
extern "C" void checkfinite_(double * tmp) {
checkFinite(*tmp);
}
// Utility routine to check that a double stays bounded
/*
* This routine checks to see if a number stays bounded. The absolute
* value of the number is required to stay below the trigger.
*
* @param tmp Number to be checked
* @param trigger bounds on the number. Defaults to 1.0E20
*/
void checkMagnitude(const double tmp, const double trigger) throw(std::range_error) {
checkFinite(tmp);
if (fabs(tmp) >= trigger) {
char sbuf[64];
sprintf(sbuf, "checkMagnitude: Trigger %g exceeded: %g\n", trigger,
tmp);
throw std::range_error(sbuf);
}
}
// Utility routine to check to see that a number is neither zero
// nor indefinite.
/*
* This check can be used before using the number in a denominator.
*
* @param tmp number to be checked
*/
void checkZeroFinite(const double tmp) throw(std::range_error) {
if ((tmp == 0.0) || (! finite(tmp))) {
if (tmp == 0.0) {
printf("ERROR: we have encountered a zero!\n");
} else if(isnan(tmp)) {
printf("ERROR: we have encountered a nan!\n");
} else if (isinf(tmp) == 1) {
printf("ERROR: we have encountered a pos inf!\n");
} else {
printf("ERROR: we have encountered a neg inf!\n");
}
char sbuf[64];
sprintf(sbuf, "checkZeroFinite: zero or indef exceeded: %g\n",
tmp);
throw std::range_error(sbuf);
}
}
}

10
Cantera/src/base/ctexceptions.h
View file

@ -16,6 +16,7 @@
#define CT_CTEXCEPTIONS_H
#include <string>
#include <exception>
// See file misc.cpp for implementations of methods/functions declared
// here.
@ -64,14 +65,17 @@ namespace Cantera {
*
*/
//! Base class for exceptions thrown by Cantera classes.
/*!
* This class is the base class for exceptions thrown by Cantera.
* It inherits from std::exception so that normal error handling
* operations from applications may automatically handle the
* errors in their own way.
*
* @ingroup errorhandling
*/
class CanteraError {
class CanteraError : public std::exception {
public:
//! Normal Constructor for the CanteraError base class
/*!
@ -86,7 +90,7 @@ namespace Cantera {
CanteraError(std::string procedure, std::string msg);
//! Destructor for base class does nothing
virtual ~CanteraError(){}
virtual ~CanteraError() throw() {}
protected:
//! Empty base constructor is made protected so that it may be used only by
//! inherited classes.

1790
Cantera/src/base/mdp_allo.cpp Normal file
View file

File diff suppressed because it is too large Load diff

739
Cantera/src/base/mdp_allo.h Normal file
View file

@ -0,0 +1,739 @@
/**
* @file mdp_allo.h
* Declarations for Multi Dimensional Pointer (mdp) malloc routines, which
* allow for dimensioning of arbitrarily dimensioned pointer arrays using
* one call.
*/
/*
* $Revision$
* $Date$
*/
/*
* Copywrite 2004 Sandia Corporation. Under the terms of Contract
* DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
* retains certain rights in this software.
* See file License.txt for licensing information.
*/
#ifndef MDP_ALLO_H
#define MDP_ALLO_H
#include <stdexcept>
/*
* Include the header here in order to pick up size_t definition
*/
#include <cstring>
/**
* The mdp routines are extremely lightweight and fast fortran compatibile
* malloc routines for allocating multiple dimensioned arrays of doubles
* ints, char, and pointers using a single call. These routines don't
* use the std C+ lib routines.
*
* All calls are essentially wrappers around the routine mdp_alloc_array()
* which allocates multidimensioned arrays. The arrays contain room for
* the data and the pointer information that is used to access data
* in the object.
*
* One convention that is always used is that a pointer that is
* not malloced always has a value of zero. If the pointer is nonnull,
* then it may be freed, always (and vica-versa).
*
* Where possible, the low leve routines
* memcopy and memset are used to copy or zero memory.
*
* No array bounds checking is ever done within these routines. buyer beware.
* The bounds of arrays are not carried with the array object, ever.
* Bounds of arrays are input via the parameter list. Normally,
* for applications this is not a problem, since the application
* knows what the array dimensions are.
*
* There are several other general principles.
*
* If an allocation size is set to 0, then the actual
* allocation size is set to 1 within the program.
* Something is always allocated whenever a call is made
* to an mdp routine.
*
* All checks for allocations are always checked for success.
* If a failure is found, thene mdp_alloc_eh() is called
* for disposition of the error condition.
*
* Error handling behavior is set by the MDP_ALLO_errorOption external
* int. The default error behavior is to print an error message to stderr, and
* then throw an exception that inherited from std::exception. Usually
* std::bad_alloc() is thrown whenever there is a problem.
*
*/
namespace mdp {
/**
* If we have array_alloc() from another Sandia program, we will not use
* the one from this mdp_array_alloc. Instead we will redefine the names
*/
#ifdef HAVE_ARRAY_ALLOC
# define mdp_array_alloc array_alloc
# define mdp_safe_free safe_free
#endif
/*!
* MDP_INT_NOINIT is a poor man's way of specifying whether a value should be
* initialized. These are seldom used numbers which can be used in place
* of real ints and dbls to indicate that initialization shouldn't take
* place.
*/
#define MDP_INT_NOINIT -68361
/*!
* MDP_DBL_NOINIT is a poor man's way of specifying whether a value should be
* initialized. These are seldom used numbers which can be used in place
* of real ints and dbls to indicate that initialization shouldn't take
* place.
*/
#define MDP_DBL_NOINIT -1.241E11
/*!
* Error Handling
* 7 print and exit
* 6 exit
* 5 print and create a divide by zero for stack trace analysis.
* 4 create a divide by zero for stack analysis trace
* 3 print a message and throw the std::bad_alloc() exception.
* 2 throw the std::bad_alloc() exception and be quiet.
* 1 print a message and return from package with the NULL pointer
* 0 Keep completely silent about the matter and return with
* a null pointer.
*
* -> Right now, the only way to change this option is to right here
*
* The default is to set it to 3.
*/
extern int MDP_ALLO_errorOption;
/****************************************************************************/
/*
* Externals that should be set by the calling program.
* These are only used for debugging purposes.
*/
#ifdef MDP_MPDEBUGIO
extern int MDP_MP_Nprocs;
extern int MDP_MP_myproc;
#endif
/****************************************************************************/
/*
* MDP_SAFE_DELETE()
* This useful define is great for delete single instances of
* mallocing using new.
*/
#define MDP_SAFE_DELETE(a) if (a) { delete (a); a = 0; }
/****************************************************************************/
#define mdp_alloc_struct(x, num) (x *) mdp_array_alloc(1, (num), sizeof(x))
/* function declarations for dynamic array allocation */
//! allocates multidimensional pointer arrays of arbitrary length
//! via a single malloc call
/*!
* The first dimension is the number of dimensions in the allocation
*/
extern double *mdp_array_alloc(int numdim, ...);
//! Free a vector and set its value to 0
/*!
* This function carries out the following operation
* @code
* free(*hndVec);
* *hndVec = 0;
* @endcode
*
* @param hndVec This is the address of the pointer, expressed as
* a void **
*
* Note, a key idea behind the mdp suite of routines is that
* a pointer that can be malloced is either malloced or its value
* is 0. This routine enforces this convention.
*/
extern void mdp_safe_free(void ** hndVec);
//! Allocate a vector of integers
/*!
* The vector is initialized, unless the default int value is set
* to MDP_INT_NOINIT
*
* @param len Length of the vector
* @param defval Default value for the int, defaults to MDP_INT_NOINIT
*
* @return returns a pointer to the vector
*/
extern int *mdp_alloc_int_1(int len, const int defval = MDP_INT_NOINIT);
//! Allocate a vector of integers, potentially freeing memory first
/*!
* The vector is initialized, unless the default int value is set
* to MDP_INT_NOINIT
*
* Input
* --------------
* @param array_hdl Previous value of pointer. If non-NULL will try
* to free the memory at this address before doing
* a new alloc
* @param len Length of the vector
* @param defval Default value for the int, defaults to MDP_INT_NOINIT
*
* Output
* ---------
* @return *array_hdl = This value is initialized to the correct address
* of the array.
* A NULL value in the position indicates an error.
*/
extern void mdp_safe_alloc_int_1(int **array_hdl, int len,
const int defval = MDP_INT_NOINIT);
//! Reallocates a one dimensional array of ints, copying old
//! information to the new array
/*!
* Reallocates a one dimensional array of ints.
* This routine always allocates space for at least one int.
* Calls the smalloc() routine to ensure that all malloc
* calls go through one location. This routine will then copy
* the pertinent information from the old array to the
* new array.
*
* NewArray[0:old_len-1] = OldArray[0:old_len-1];
* NewArray[old_len:new_len-1] = defval;
*
* Input
* --------------
* @param array_hdl Previous value of pointer. If non-NULL will try
* to free the memory at this address before doing
* a new alloc
* @param new_len New Length of the vector
* @param old_len New Length of the vector
* @param defval Default value for the int, defaults to MDP_INT_NOINIT
*
* Output
* ---------
* @return *array_hdl = This value is initialized to the correct address
* of the array.
* A NULL value in the position indicates an error.
*/
extern void mdp_realloc_int_1(int **array_hdl, int new_len, int old_len,
const int defval = MDP_INT_NOINIT);
//! Allocate a 2D matrix of integers
/*!
* The matrix is initialized, unless the default int value is set
* to MDP_INT_NOINIT, which is the default.
*
* matrix[len1][len2]
*
* All int data entries are contiguous. Therefore, it may
* be used as input into BLAS matrix function calls.
* This can be considered to be in fortran order format with
* len2 as the number of rows, and len1 as the number of columns.
*
* matrix[jcol] refers to the jcol column of the matrix.
* Therefore, matrix[0] is a pointer to the beginning of the
* data portion of the structure.
* The structure will have len1 pointers at the beginning
* that holds pointers into the top of the columns of the
* contiguous data.
*
* The entire structure may be deallocated via one free call.
*
* @param len1 Outer Length of the vector
* @param len2 Inner length of the matrix
* @param defval Default value for the int, defaults to MDP_INT_NOINIT
*
* @return returns a pointer to the matrix
*/
extern int **mdp_alloc_int_2(int len1, int len2,
const int defval = MDP_INT_NOINIT);
//! Allocate and initialize a one dimensional array of doubles.
/*!
* As per the convention in mdp, this routine always initializes
* at least one slot.
*
* @param nvalues Length of the array. If this number is
* less than one, it is set to one. Therefore,
* This routine always initializes at least
* one double.
* @param val intialization value. Set it to the
* constant MDP_DBL_NOINIT if you don't
* want any initialization. memset() is
* used for zero initialization for fast
* execution speed.
*
* @return Pointer to the intialized array of doubles
* Failures are indicated by returning the NULL pointer.
*/
extern double *mdp_alloc_dbl_1(int nvalues, const double val=MDP_DBL_NOINIT);
//! Allocates and/or initialises a one dimensional array of doubles.
/*!
* This routine will free any old memory that was located at that
* position, before it will allocate a new vector.
*
* @param hndVec Previous value of pointer. If non-NULL will try
* to free the memory at this address. On output,
* this value is initialized to the correct address
* of the array. A NULL value in the position
* indicates an error.
* @param nvalues Length of the array
* @param val initialization value
*
*/
extern void mdp_safe_alloc_dbl_1(double **hndVec, int nvalues,
const double val=MDP_DBL_NOINIT);
//! Reallocate a vector of doubles possibly retaining a subset of values
/*!
* Reallocates the array and sets:
*
* (*hndVec)[0:oldLen-1] = oldVec[0:oldLen-1]
* (*hndVec)[oldLen:newLen] = defVal
*
* Input
* ------
* @param newLen New Length of the vector
*
* Output
* -------
* @param oldLen Old Length of the vector
*
*/
extern void mdp_realloc_dbl_1(double ** hndVec, int newLen, int oldLen,
const double defVal=MDP_DBL_NOINIT);
//! Allocate and initialize a two dimensional array of doubles.
/*!
* Allocate a two dimensional array of doubles. The array is in
* fortran order and can be accessed via the following form:
*
* dblArray[ndim1][ndim2]
*
* Note, ndim2 is the inner dimension. i.e., the array is
* in column ordering.
*
* Input
* -------
* @param ndim1 Length of the first dimension of the array
* @param ndim2 Length of the second dimension of the array
* @param val Intialization value
*
*
* @return Pointer to the initialized array of doubles.
* Failures are indicated by returning the NULL pointer.
*/
extern double **mdp_alloc_dbl_2(int ndim1, int ndim2, const double val);
//! Allocate and initialize a two dimensional array of doubles.
/*!
* Allocate a two dimensional array of doubles. The array is in
* fortran order and can be accessed via the following form:
*
* (*arrayHndl)[ndim1][ndim2]
*
* Note, ndim2 is the inner dimension. i.e., the array is
* in column ordering.
*
* Input
* -------
* @param ndim1 Length of the first dimension of the array
* @param ndim2 Length of the second dimension of the array
* @param val Intialization value
* @param arrayHndl Handle to the array. If nonnull, the array
* is first freed. Failures are indicated
* by returning the NULL pointer.
*/
extern void mdp_safe_alloc_dbl_2(double ***arrayHndl, int ndim1, int ndim2,
const double val = MDP_DBL_NOINIT);
//! Reallocates a two dimensional array of doubles to a new set of
//! dimensions, copying the old results into the new array.
/*!
* This routine will then copy the pertinent information from
* the old array to the new array.
*
* If both old dimensions are set to zero or less, then this routine
* will free the old memory before mallocing the new memory. This may
* be a benefit for extremely large mallocs.
* In all other cases, the new and the old malloced arrays will
* exist for a short time together.
*
* Input
* -------
* @param hndArray = Pointer to the global variable that
* holds the old and (eventually new)
* address of the array of doubles to be reallocated
* @param ndim1 = First dimension of the new array
* @param ndim2 = Second dimension of the new array
* @param ndim1Old = First dimension of the old array
* @param ndim2Old = Second dimension of the old array
* @param defVal = Default fill value.
*
* Output
* --------------
* The resulting vector looks like this:
*
* (*hndArray)[0:ndim1Old-1][0:ndim2Old-1] = oldVec[0:ndim1Old-1][0:ndim2Old-1]
* (*hndArray)[ndim1Old:ndim1][ndim2Old:ndim2] = defVal
*
*/
extern void mdp_realloc_dbl_2(double *** hndArray, int ndim1, int ndim2,
int ndim1Old, int ndim2Old,
const double defVal=MDP_DBL_NOINIT);
//! Allocate and initialize a one dimensional array of characters.
/*!
* The array is always initialized.
*
* Input
* -------
* @param nvalues Length of the array
* @param val intialization value. defaults to the NULL char
*
* @return Pointer to the intialized character array
* Failures are indicated by returning the NULL pointer.
*/
extern char *mdp_alloc_char_1(int nvalues, const char val = '\0');
//! Allocate and initialize a one dimensional array of characters,
//! deallocating the space before hand.
/*!
* This routine will free any old memory that was located at that
* position, before it will allocate a new vector.
*
* The array is always initialized.
*
* @param arrayHnd Pointer to the global variable that
* holds the old and (eventually new)
* address of the array of char to be reallocated
* @param nvalues Length of the array
* @param val intialization value. defaults to the NULL char
*
* @return Pointer to the intialized character array
* Failures are indicated by returning the NULL pointer.
*/
extern void mdp_safe_alloc_char_1(char **arrayHnd, int nvalues,
const char val = '\0');
//! Allocate and initialize a vector of fixed-length
//! strings. Each string is initialized to the NULL string.
/*!
* @param numStrings Number of strings
* @param lenString Length of each string including the trailing null
* character
*
* @return Value is initialized to the correct address
* of the new array on exit.
* A NULL value in the position indicates an error.
*/
extern char **mdp_alloc_VecFixedStrings(int numStrings, int lenString);
//! Allocate and initialize an array of strings of fixed length
/*!
* @param numStrings Number of strings
* @param lenString Length of each string including the trailing null
* character
*
* @param array_hdl Value is initialized to the correct address
* of the new array on exit.
* A NULL value in the position indicates an error.
* If non-NULL on entry the routine will first
* free the memory at the address.
*/
extern void mdp_safe_alloc_VecFixedStrings(char ***arrayHnd, int numStrings,
int lenString);
//! Reallocate and initialize a vector of fixed-length strings.
/*!
* Each new string is initialized to the NULL string.
* Old strings are copied.
*
* @param array_hdl The pointer to the char ** location holding
* the data to be reallocated.
* @param numStrings Number of strings
* @param numOldStrings Number of old strings
* @param lenString Length of each string including the trailing null
* character
*/
extern void mdp_realloc_VecFixedStrings(char ***array_hdl, int numStrings,
int numOldStrings, int lenString);
//! Allocate and initialize a vector of pointers of type pointer to void.
/*!
* All pointers are initialized to the NULL value.
*
* @param numPointers Number of pointers
*
* @return This value is initialized to the correct address of the vector.
* A NULL value in the position indicates an error.
*/
extern void **mdp_alloc_ptr_1(int numPointers);
//! Allocate and initialize a vector of pointers of type pointer to void.
/*!
* All pointers are initialized to the NULL value.
*
* @param numPointers Number of pointers
* @param array_hdl This value is initialized to the correct address
* of the array.
* A NULL value in the position indicates an error.
* Previous value of pointer. If non-NULL will try
* to free the memory at this address.
*/
extern void mdp_safe_alloc_ptr_1(void ***array_hnd, int numPointers);
//! Reallocate and initialize a vector of pointers
/*!
* All old pointers are copied
* Each new pointer not associated with an old pointer is
* initialized to NULL.
*
* @param array_hdl The pointer to the char ** location holding
* the data to be reallocated.
* @param numLen Number of new pointers
* @param numOldLen Number of old pointers
*/
extern void mdp_realloc_ptr_1(void ***array_hdl, int numLen, int numOldLen);
//! Copies one ptr vector into another ptr vector
/*!
*
* @param copyFrom Vector of ptr values to be copied
* @param len Length of the vector
*
* @param copyTo Vector of values to receive the copy
*/
extern void mdp_copy_ptr_1(void *const copyTo,
const void * const copyFrom, const int len);
//! Duplicates one ptr vector into another ptr vector
/*!
* Mallocs a copy of one vector of pointers and returns the pointer
* to the copy.
*
* Input
* -------------
* @param *copyFrom Vector of ptr values to be copied
* @param len Length of the vector
*
* Output
* ------------
* @return Vector of values to receive the copy
*/
extern void **mdp_dupl_ptr_1(const void * const copyFrom, int len);
//! Copies an array of string vectors from one char ** vector to
//! another
/*!
* The space must have already been allocated within copyFrom and copyTo
* arrays. Overwrites are prevented by the proper application of the
* variable maxLenString. Strings are forced to be null-terminated
* Therefore copyTo[maxLenString-1] = '/0'
*
* Input
* -------
* @param copyFrom vector of C strings. It should be null terminated
* @param numStrings number of strings
* @param maxLenString maximum of the size of the string arrays,
* copyTo and copyFrom. This is used as the
* argument to strncpy() function.
*
* Output
* ------
* @param copyTo vector of strings
*
*/
extern void mdp_copy_VecFixedStrings(char ** const copyTo,
const char ** const copyFrom,
int numStrings, size_t maxLenString);
//! Allocates space for and copies a string
/*!
*
* @param copyFrom null terminated string. If NULL is supplied, then
* nothing is malloced and a NULL value is returned.
*
* @return This value is initialized to the correct address of the array.
* A NULL value in the position either indicates an error, or
* that the original pointer to the string was NULL.
*/
extern char *mdp_copy_string(const char * const copyFrom);
//! Allocates space for and copies a string
/*!
* @param stringHnd Previous value of pointer. If non-NULL will try
* to free the memory at this address.
*
* @param copyFrom null terminated string. If NULL is supplied, then
* nothing is malloced and a NULL value is returned.
*
* @return This value is initialized to the correct address of the array.
* A NULL value in the position either indicates an error, or
* that the original pointer to the string was NULL.
*/
extern void mdp_safe_copy_string(char **stringHnd, const char * const copyFrom);
//! Copy a double vector to a double vector
/*!
* copyTo[len] = copyFrom[len]
*
* Input
* -------
* @param copyFrom Vector to copy ( length >= len)
* @param len Length of the copy
*
* Output
* -------
* @param copyTo Vector to receive the copy ( length >= len)
*/
extern void mdp_copy_dbl_1(double * const copyTo,
const double * const copyFrom,
const int len);
//! Copy a double array to a double array
/*!
* This routine carries out a straight copy on the effective 1D description
* of each of the arrays. It copies
* the first len1*len2 doubless storred within copyFrom into the
* the first len1*len2 double slots in copyTo. It does not account
* for the actual dimensions of the two arrays.
*
* Input
* --------
* @param copyFrom Vector to copy ( length >= len1 * len2)
* @param len1 Length of the first dimension
* @param len2 Length of the second dimension
*
* Output
* ----------
* @param copyTo Array to receive the copy ( length >= len1 * len2)
*/
extern void mdp_copy_dbl_2(double ** const copyTo, const double ** const copyFrom,
const int len1, const int len2);
//! Copies one int vector into one int vector
/*!
* Input
* -------------
* @param copyFrom Vector of values to be copied
* @param len Length of the vector
*
* Output
* ------------
* *copyTo = Vector of values to receive the copy
*/
extern void mdp_copy_int_1(int * const copyTo, const int * const copyFrom,
const int len);
//! Copies one 2D int array into another 2D int array
/*!
* This routine carries out a straight copy. Actually it copies
* the first len1*len2 ints storred within copyFrom into the
* the first len1*len2 int slots in copyTo. It does not account
* for the actual dimensions of the two arrays.
*
* @param copyFrom Vector of values to be copied
* @param len1 Length of the first array
* @param len2 Length of the second array
* Output
* ------------
* @param copyTo Vector of values to receive the copy
*/
extern void mdp_copy_int_2(int ** const copyTo, const int ** const copyFrom,
const int len1, const int len2);
//! Assigns a single value to a double vector
/*!
* @param v Vector of values to be assigned
* @param value Value to assign with
* @param len Length of the vector
*/
extern void mdp_init_dbl_1(double * const v, const double value, const int len);
//! Zeroes a double vector
/*!
* @param v = Vector of values to be assigned
* @param len = Length of the vector
*/
extern void mdp_zero_dbl_1(double * const v , const int len);
//! Assigns a single value to a double matrix. Contiguous data for the
//! matrix is assumed.
/*!
* Input
* -------------
* @param v matrix of values to be assigned
* @param value value to assign with
* @param len1 Length one of the vector
* @param len2 length two of the vector
*/
extern void mdp_init_dbl_2(double ** const v, const double value,
const int len1, const int len2);
//! Assigns a single value to an int vector
/*!
* @param v Vector of values to be assigned
* @param value Value to assign with
* @param len Length of the vector
*/
extern void mdp_init_int_1(int * const v, const int value, const int len);
/*
* Utility routines to check that a number is finite
*/
//! Utility routine to check to see that a number is neither zero
//! nor indefinite.
/*!
* This check can be used before using the number in a denominator.
*
* @param tmp number to be checked
*/
extern void checkZeroFinite(const double tmp) throw(std::range_error);
//! Utility routine to check to see that a number is finite.
/*!
* @param tmp number to be checked
*/
extern void checkFinite(const double tmp) throw(std::range_error);
//! Utility routine to link checkFinte() to fortran program
/*!
* This routine is accessible from fortran, usually
*
* @param tmp Pointer to the number to check
*
* @todo link it into the usual way Cantera handles Fortran calls
*/
extern "C" void checkfinite_(double *tmp);
//! utility routine to check that a double stays bounded
/*!
* This routine checks to see if a number stays bounded. The absolute
* value of the number is required to stay below the trigger.
*
* @param tmp Number to be checked
* @param trigger bounds on the number. Defaults to 1.0E20
*/
extern void checkMagnitude(const double tmp, const double trigger = 1.0E20)
throw(std::range_error);
} /* end of mdp namespace */
/****************************************************************************/
#endif
/****************************************************************************/

8
Cantera/src/base/xml.cpp
View file

@ -60,7 +60,7 @@ namespace Cantera {
}
//! destructor
virtual ~XML_Error() {}
virtual ~XML_Error() throw() {}
protected:
//! Line number of the file
@ -94,7 +94,7 @@ namespace Cantera {
}
//! Destructor
virtual ~XML_TagMismatch() {}
virtual ~XML_TagMismatch() throw() {}
};
//! Class representing a specific type of XML file formatting error
@ -130,7 +130,7 @@ namespace Cantera {
}
//! Destructor
virtual ~XML_NoChild() {}
virtual ~XML_NoChild() throw() {}
};
//! Class representing a specific type of XML file formatting error
@ -157,7 +157,7 @@ namespace Cantera {
}
//! Destructor
virtual ~XML_IllegalUnits() {}
virtual ~XML_IllegalUnits() throw() {}
};