Matrix Class Reference

Standard class for every matrix in Carmen. More...

#include <Matrix.h>

Public Member Functions
	Matrix ()
	Constructor of matrix class. Generates a 1,1 matrix equal to zero. More...
	Matrix (const int i, const int j)
	Generates a matrix with i lines and j columns, each component being equal to zero. Example : More...
	Matrix (const int i)
	Generates a square matrix with i lines and i columns, each component being equal to zero. Example : More...
	Matrix (const Matrix &M)
	Generates a copy of the matrix M. Example : More...
	Matrix (const Vector &V)
	Generates a vector-matrix identical to V. Example : More...
	~Matrix ()
	Distructor of matrix class. Deallocate memory of the matrix. More...
void	setValue (const int i, const int j, const real a)
	Sets the component i, j to value a. More...
void	setZero ()
	Sets all the components to zero. More...
real	value (const int i, const int j) const
	Returns the value of the component i, j. More...
int	lines () const
	Returns the number of lines of the matrix. More...
int	columns () const
	Returns the number of columns of the matrix. More...
bool	operator== (const Matrix &M) const
	Compares the current matrix to a matrix M and returns true if they are equal. More...
void	operator= (const Matrix &M)
	Set the current matrix to the dimension and the value of M. More...
void	operator+= (const Matrix &M)
	Adds M to the current matrix. More...
Matrix	operator+ (const Matrix &M) const
	Returns the addition of the current matrix and M. More...
void	operator-= (const Matrix &M)
	Subtracts M to the current matrix. More...
Matrix	operator- (const Matrix &M) const
	Returns the difference between the current matrix and M. More...
Matrix	operator- () const
	Returns the opposite of the current matrix. More...
void	operator*= (const real a)
	Multiplies the current matrix by a real a. More...
Matrix	operator* (const real a) const
	Returns the product of the current matrix and a real a. More...
void	operator/= (const real a)
	Divides the current matrix by a real a. More...
Matrix	operator/ (const real a) const
	Returns the division of the current matrix by a real a. More...
Matrix	operator* (const Matrix &M) const
	Returns the product of the current matrix and a matrix M. More...
Vector	operator* (const Vector &V) const
	Returns the product of the current matrix and a vectorV. More...
void	setEigenMatrix (const bool isLeft, const int AxisNo, const Vector V, const real c, const real h=0.)
	Sets matrix as eigenmatrix. More...

Public Attributes
int	Lines
int	Columns
real *	U

Detailed Description

Standard class for every matrix in Carmen.

It contains the following data:
the number of lines Lines ;
the number of columns Columns ;
the array of reals *U.

Constructor & Destructor Documentation

Matrix::Matrix

(

)

Constructor of matrix class. Generates a 1,1 matrix equal to zero.

Example :

#include "Matrix.h"

Matrix M;

{
    Lines = Columns = 1;
    U  = new real;
    *U = 0.;
}

Matrix::Matrix	(	const int	i,
		const int	j
	)

Generates a matrix with i lines and j columns, each component being equal to zero. Example :

#include "Matrix.h"

Matrix M(4,5);

Parameters

i
j

{
    int n; // Counter

    Lines = i;
    Columns = j;

    // If the size of the matrix is equal to zero, do not allocate memory
    if (Lines==0 && Columns==0) return;

    U = new real[Lines*Columns];

    for (n = 1; n <= Lines*Columns; n++)
        *(U+n-1) = 0.;
}

Matrix::Matrix

(

const int

i

)

Generates a square matrix with i lines and i columns, each component being equal to zero. Example :

#include "Matrix.h"

Matrix M(4);

Parameters

i

{
    int n; // Counter

    Lines = i;
  Columns = i;

    U = new real[Lines*Columns];

    for (n = 1; n <= Lines*Columns; n++)
        *(U+n-1) = 0.;
}

Matrix::Matrix

(

const Matrix &

M

)

Generates a copy of the matrix M. Example :

#include "Matrix.h"

Matrix M(2,3);
Matrix P(M)

Parameters

M

Matrix

{
    int i,j;

    Lines = M.lines();
  Columns = M.columns();

    U = new real[Lines*Columns];

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        setValue(i, j, M.value(i,j));
}

Matrix::Matrix

(

const Vector &

V

)

Generates a vector-matrix identical to V. Example :

#include "Matrix.h"

Matrix V(3);
Matrix P(V);

Parameters

V

{
    int i;

    Lines = V.dimension();
  Columns = 1;

    U = new real[Lines*Columns];

    for (i = 1; i <= Lines; i++)
        setValue(i, 1, V.value(i));
}

Matrix::~Matrix

(

)

Distructor of matrix class. Deallocate memory of the matrix.

{
    // If the size of the matrix is equal to zero, do not deallocate memory
    if (Lines==0 && Columns==0) return;

    delete[] U;
}

Member Function Documentation

int Matrix::columns ( ) const

inline

Returns the number of columns of the matrix.

Returns

int

{
    return Columns;
}

Here is the caller graph for this function:

int Matrix::lines ( ) const

inline

Returns the number of lines of the matrix.

Returns

int

{
    return Lines;
}

Here is the caller graph for this function:

Matrix Matrix::operator*

(

const real

a

)

const

Returns the product of the current matrix and a real a.

Example :

#include "Matrix.h"

Matrix M(2,2);
Matrix P;
real x = 2.;
...
P = M*x;


The operation P = x*M can also be done. See operator*(const real a, const Matrix& M).

Parameters

a	Real value

Returns

Matrix

{
    int i,j;
    Matrix result(Lines, Columns);

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        result.setValue(i, j, value(i,j)*a);

    return result;
}

Matrix Matrix::operator*

(

const Matrix &

M

)

const

Returns the product of the current matrix and a matrix M.

Example :

#include "Matrix.h"

Matrix M(2,3);
Matrix P(3,1);
Matrix Q;
...
Q = M*P;


Parameters

M

Matrix

Returns

Matrix

{
    int i, j, k;
    Matrix result(lines(), M.columns());

    for (i = 1; i <= lines(); i++)
    for (j = 1; j <= M.columns(); j++)
    for (k = 1; k <= columns(); k++)
        result.setValue(i,j, result.value(i,j) + value(i,k)*M.value(k,j));

    return result;
}

Vector Matrix::operator*

(

const Vector &

V

)

const

Returns the product of the current matrix and a vectorV.

Example :

#include "Matrix.h"

Matrix M(2,3);
Vector V(3);
Vector P;
...
P = M*V;


Parameters

V

Vector

Returns

Vector

{
    int i, k;

    Vector result(lines());

    for (i = 1; i <= lines(); i++)
    for (k = 1; k <= columns(); k++)
        result.setValue(i, result.value(i) + value(i,k)*V.value(k));

    return result;

}

void Matrix::operator*=

(

const real

a

)

Multiplies the current matrix by a real a.

Example :

#include "Matrix.h"

Matrix M(2,2);
real x = 2.;
...
M *= x;


Parameters

a	Real value

Returns

void

{
    int n;

    for (n=1; n<=Lines*Columns; n++)
        *(U+n-1) *= a;
}

Matrix Matrix::operator+

(

const Matrix &

M

)

const

Returns the addition of the current matrix and M.

Example :

#include "Matrix.h"

Matrix M(2,2);
Matrix P(2,2);
Matrix U;
...
U = M + P;

Parameters

M

Matrix

Returns

Matrix

{
    int i, j;
    Matrix result(Lines, Columns);

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        result.setValue(i, j, value(i,j) + M.value(i,j));

    return result;
}

void Matrix::operator+=

(

const Matrix &

M

)

Adds M to the current matrix.

Example :

#include "Matrix.h"

Matrix M(2,2);
Matrix P(2,2);
...
P += M;


Parameters

M

Matrix

Returns

void

{
    int i, j;

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        setValue(i, j, value(i,j) + M.value(i,j));
}

Matrix Matrix::operator-

(

const Matrix &

M

)

const

Returns the difference between the current matrix and M.

Example :

#include "Matrix.h"

Matrix M(2,2);
Matrix P(2,2);
Matrix U;
...
U = M - P;


Parameters

M

Matrix

Returns

Matrix

{
    int i, j;
    Matrix result(Lines, Columns);

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        result.setValue(i, j, value(i,j) - M.value(i,j));

    return result;
}

Matrix Matrix::operator-

(

)

const

Returns the opposite of the current matrix.

Example :

#include "Matrix.h"

Matrix M(2,2);
Matrix P;
...
P = -M;


Returns

Matrix

{
    int i, j;
    Matrix result(Lines, Columns);

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        result.setValue(i, j, -value(i,j));

    return result;
}

void Matrix::operator-=

(

const Matrix &

M

)

Subtracts M to the current matrix.

Example :

#include "Matrix.h"

Matrix M(2,2);
Matrix P(2,2);
...
P -= M;


Parameters

M

Matrix

Returns

void

{
    int i, j;

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        setValue(i, j, value(i,j) - M.value(i,j));
}

Matrix Matrix::operator/

(

const real

a

)

const

Returns the division of the current matrix by a real a.

Example :

#include "Matrix.h"

Matrix M(2,2);
Matrix P;
real x = 2.;
...
P = M / x;


Parameters

a	Real value

Returns

Matrix

{
    int i,j;
    Matrix result(Lines, Columns);

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        result.setValue(i, j, value(i,j)/a);

    return result;
}

void Matrix::operator/=

(

const real

a

)

Divides the current matrix by a real a.

Example :

#include "Matrix.h"

Matrix M(2,2);
real x = 2.;
...
M /= x;


Parameters

a	Real value

Returns

void

{
    int n;

    for (n=1; n<=Lines*Columns; n++)
        *(U+n-1) /= a;
}

void Matrix::operator=

(

const Matrix &

M

)

Set the current matrix to the dimension and the value of M.

Example :

#include "Matrix.h"

Matrix M(2,2);
Matrix P;
...
P = M;


Parameters

M

Matrix

Returns

void

{
    int i, j;

    if (M.lines() != Lines || M.columns() != Columns)
    {
        delete[] U;

        Lines   = M.lines();
        Columns = M.columns();

        U = new real[Lines*Columns];
    }

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        setValue(i, j, M.value(i,j));
}

bool Matrix::operator==

(

const Matrix &

M

)

const

Compares the current matrix to a matrix M and returns true if they are equal.

Example :

#include "Matrix.h"

Matrix M(2,2);
Matrix P(2,2);
real x;
...
if (M == P)
x = M.value(1,1);


Parameters

M

Matrix

Returns

bool

{
    int i, j;

    for (i = 1; i <= Lines; i++)
    for (j = 1; j <= Columns; j++)
        if ( value(i,j) != M.value(i,j) ) return false;

    return true;
}

void Matrix::setEigenMatrix	(	const bool	isLeft,
		const int	AxisNo,
		const Vector	V,
		const real	c,
		const real	h = 0.
	)

Sets matrix as eigenmatrix.

Parameters

isLeft	Boolean variable. True if location is on the left.
AxisNo	Axis of interest.
V	Vector
c	Real value
h	Real value

Returns

void

{

    // --- Local variables ---

    int n; // Counter
    real u = V.value(1);
    real v = (Dimension > 1) ? V.value(2): 0.;
    real w = (Dimension > 2) ? V.value(3): 0.;

     // --- Allocate memory and set to zero ---

    delete[] U;

    Lines = Columns = QuantityNb;

    U = new real[Lines*Columns];

    for (n = 1; n <= Lines*Columns; n++)
        *(U+n-1) = 0.;

    // --- Fill values ---

    switch (Dimension)
    {

        // --- 1D CASE --------------------------------------------------------------------------------

        case 1:
            if (isLeft)
            {
                // --- Left eigenmatrix ---

//            setValue(1,1, (c*c)*(1.- ((Gamma-1.)*u*u)/(2.*c*c)));
//            setValue(2,1, (c*c)*(.5*(((Gamma-1.)*u*u)/(2.*c*c) - (u/c))));
//            setValue(3,1, (c*c)*(.5*(((Gamma-1.)*u*u)/(2.*c*c) + (u/c))));
//
//            setValue(1,2, (c*c)*((Gamma-1.)*u/(c*c)));
//            setValue(2,2, (c*c)*(((Gamma-1.)/(2.*c*c))*(c/(Gamma-1.)-u)));
//            setValue(3,2, (c*c)*(((Gamma-1.)/(2.*c*c))*(-c/(Gamma-1.)-u)));
//
//            setValue(1,3, (c*c)*(-(Gamma-1.)/(c*c)));
//            setValue(2,3, (c*c)*((Gamma-1.)/(2.*c*c)));
//            setValue(3,3, (c*c)*((Gamma-1.)/(2.*c*c)));

//          matrices de Vinokur

        setValue(1,1, (1.- ((Gamma-1.)*u*u)/(2.*c*c)));
          setValue(2,1, (.5*(((Gamma-1.)*u*u)/(2.*c*c) - (u/c))));
          setValue(3,1, (.5*(((Gamma-1.)*u*u)/(2.*c*c) + (u/c))));

          setValue(1,2, ((Gamma-1.)*u/(c*c)));
          setValue(2,2, (((Gamma-1.)/(2.*c*c))*(c/(Gamma-1.)-u)));
          setValue(3,2, (((Gamma-1.)/(2.*c*c))*(-c/(Gamma-1.)-u)));

          setValue(1,3, (-(Gamma-1.)/(c*c)));
          setValue(2,3, ((Gamma-1.)/(2.*c*c)));
          setValue(3,3, ((Gamma-1.)/(2.*c*c)));

            }
            else
            {
                // --- Right eigenmatrix ---

//              setValue(1,1, 1./(c*c));
//              setValue(2,1, u/(c*c));
//              setValue(3,1, .5*(u*u)/(c*c));
//
//              setValue(1,2, 1./(c*c));
//              setValue(2,2, (u+c)/(c*c));
//              setValue(3,2, (h+ c*u)/(c*c));
//
//              setValue(1,3, 1./(c*c));
//              setValue(2,3, (u-c)/(c*c));
//              setValue(3,3, (h-u*c)/(c*c));


//          matrices de Vinokur

            setValue(1,1, 1.);
            setValue(2,1, u);
            setValue(3,1, .5*(u*u));

            setValue(1,2, 1.);
            setValue(2,2, (u+c));
            setValue(3,2, (h+ c*u));

            setValue(1,3, 1.);
            setValue(2,3, (u-c));
            setValue(3,3, (h-u*c));


            }
            break;


        // --- 2D CASE --------------------------------------------------------------------------------

        case 2:
            if (isLeft)
            {
                // --- Left eigenmatrix ---

                switch(AxisNo)
                {
                    case 1:
//                      setValue(1,1, (c*c)*(1.-((Gamma-1.)*(u*u+v*v)/(2.*c*c))));
//                      setValue(2,1, (c*c)*(-v));
//                      setValue(3,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v)/(2.*c*c) - u/c )));
//                      setValue(4,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v)/(2.*c*c) + u/c )));
//
//                      setValue(1,2, (c*c)*((Gamma-1.)*u/(c*c)));
//                      setValue(2,2, 0.);
//                      setValue(3,2, (c*c)*((c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));
//                      setValue(4,2, (c*c)*((-c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));
//
//                      setValue(1,3, (c*c)*((Gamma-1.)*v/(c*c)));
//                      setValue(2,3, (c*c)*1.);
//                      setValue(3,3, (c*c)*(-(Gamma-1.)*v/(2.*c*c)));
//                      setValue(4,3, (c*c)*(-(Gamma-1.)*v/(2.*c*c)));
//
//                      setValue(1,4, (c*c)*(-(Gamma-1.)/(c*c)));
//                      setValue(2,4, 0.);
//                      setValue(3,4, (c*c)*((Gamma-1.)/(2.*c*c)));
//                      setValue(4,4, (c*c)*((Gamma-1.)/(2.*c*c)));


//          matrix vinokur

                    setValue(1,1, (1.-((Gamma-1.)*(u*u+v*v)/(2.*c*c))));
                    setValue(2,1, (-v));
                    setValue(3,1, (.5*( (Gamma-1.)*(u*u+v*v)/(2.*c*c) - u/c )));
                    setValue(4,1, (.5*( (Gamma-1.)*(u*u+v*v)/(2.*c*c) + u/c )));

                    setValue(1,2, ((Gamma-1.)*u/(c*c)));
                    setValue(2,2, 0.);
                    setValue(3,2, ((c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));
                    setValue(4,2, ((-c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));

                    setValue(1,3, ((Gamma-1.)*v/(c*c)));
                    setValue(2,3, 1.);
                    setValue(3,3, (-(Gamma-1.)*v/(2.*c*c)));
                    setValue(4,3, (-(Gamma-1.)*v/(2.*c*c)));

                    setValue(1,4, (-(Gamma-1.)/(c*c)));
                    setValue(2,4, 0.);
                    setValue(3,4, ((Gamma-1.)/(2.*c*c)));
                    setValue(4,4, ((Gamma-1.)/(2.*c*c)));


                        break;

                    case 2:
//                  setValue(1,1, (c*c)*(1.-((Gamma-1.)*(u*u+v*v)/(2.*c*c))));
//                      setValue(2,1, (c*c)*(-v));
//                      setValue(3,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v)/(2.*c*c) - u/c )));
//                      setValue(4,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v)/(2.*c*c) + u/c )));
//
//                      setValue(1,2, (c*c)*((Gamma-1.)*u/(c*c)));
//                      setValue(2,2, 0.);
//                      setValue(3,2, (c*c)*((c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));
//                      setValue(4,2, (c*c)*((-c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));
//
//                      setValue(1,3, (c*c)*((Gamma-1.)*v/(c*c)));
//                      setValue(2,3, (c*c)*1.);
//                      setValue(3,3, (c*c)*(-(Gamma-1.)*v/(2.*c*c)));
//                      setValue(4,3, (c*c)*(-(Gamma-1.)*v/(2.*c*c)));
//
//                      setValue(1,4, (c*c)*(-(Gamma-1.)/(c*c)));
//                      setValue(2,4, 0.);
//                      setValue(3,4, (c*c)*((Gamma-1.)/(2.*c*c)));
//                      setValue(4,4, (c*c)*((Gamma-1.)/(2.*c*c)));


//          matrix vinokur
                    setValue(1,1, (1.-((Gamma-1.)*(u*u+v*v)/(2.*c*c))));
                    setValue(2,1, (-v));
                    setValue(3,1, (.5*( (Gamma-1.)*(u*u+v*v)/(2.*c*c) - u/c )));
                    setValue(4,1, (.5*( (Gamma-1.)*(u*u+v*v)/(2.*c*c) + u/c )));

                    setValue(1,2, ((Gamma-1.)*u/(c*c)));
                    setValue(2,2, 0.);
                    setValue(3,2, ((c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));
                    setValue(4,2, ((-c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));

                    setValue(1,3, ((Gamma-1.)*v/(c*c)));
                    setValue(2,3, 1.);
                    setValue(3,3, (-(Gamma-1.)*v/(2.*c*c)));
                    setValue(4,3, (-(Gamma-1.)*v/(2.*c*c)));

                    setValue(1,4, (-(Gamma-1.)/(c*c)));
                    setValue(2,4, 0.);
                    setValue(3,4, ((Gamma-1.)/(2.*c*c)));
                    setValue(4,4, ((Gamma-1.)/(2.*c*c)));


                        break;
                };
            }
            else
            {
                // --- Right eigenmatrix ---

                switch(AxisNo)
                {
                    case 1:
//                    setValue(1,1, 1./(c*c));
//                    setValue(2,1, u/(c*c));
//                    setValue(3,1, v/(c*c));
//                    setValue(4,1, .5*(u*u+v*v)/(c*c));
//
//                    setValue(1,2, 0.);
//                    setValue(2,2, 0.);
//                    setValue(3,2, 1./(c*c));
//                    setValue(4,2, v/(c*c));
//
//                    setValue(1,3, 1./(c*c));
//                    setValue(2,3, (u+c)/(c*c));
//                    setValue(3,3, v/(c*c));
//                    setValue(4,3, (h+ c*u)/(c*c));
//
//                    setValue(1,4, 1./(c*c));
//                    setValue(2,4, (u-c)/(c*c));
//                    setValue(3,4, v/(c*c));
//                    setValue(4,4, (h- c*u)/(c*c));


//          matrix vinokur
                  setValue(1,1, 1.);
                  setValue(2,1, u);
                  setValue(3,1, v);
                  setValue(4,1, .5*(u*u+v*v));

                  setValue(1,2, 0.);
                  setValue(2,2, 0.);
                  setValue(3,2, 1.);
                  setValue(4,2, v);

                  setValue(1,3, 1.);
                  setValue(2,3, (u+c));
                  setValue(3,3, v);
                  setValue(4,3, (h+ c*u));

                  setValue(1,4, 1.);
                  setValue(2,4, (u-c));
                  setValue(3,4, v);
                  setValue(4,4, (h- c*u));

                        break;

                    case 2:
//                    setValue(1,1, 0.);
//                    setValue(2,1, 0.);
//                    setValue(3,1, 1./(c*c));
//                    setValue(4,1, u/(c*c));
//
//                    setValue(1,2, 1./(c*c));
//                    setValue(2,2, u/(c*c));
//                    setValue(3,2, v/(c*c));
//                    setValue(4,2, .5*(u*u+v*v)/(c*c));
//
//                    setValue(1,3, 1./(c*c));
//                    setValue(2,3, u/(c*c));
//                    setValue(3,3, (v+c)/(c*c));
//                    setValue(4,3, (h+ c*v)/(c*c));
//
//                    setValue(1,4, 1./(c*c));
//                    setValue(2,4, u/(c*c));
//                    setValue(3,4, (v-c)/(c*c));
//                    setValue(4,4, (h- c*v)/(c*c));


//          matrix vinokur

                setValue(1,1, 0.);
                  setValue(2,1, 0.);
                  setValue(3,1, 1.);
                  setValue(4,1, u);

                  setValue(1,2, 1.);
                  setValue(2,2, u);
                  setValue(3,2, v);
                  setValue(4,2, .5*(u*u+v*v));

                  setValue(1,3, 1.);
                  setValue(2,3, u);
                  setValue(3,3, (v+c));
                  setValue(4,3, (h+ c*v));

                  setValue(1,4, 1.);
                  setValue(2,4, u);
                  setValue(3,4, (v-c));
                  setValue(4,4, (h- c*v));

                        break;
                };
            }
            break;

        // --- 3D CASE --------------------------------------------------------------------------------

        case 3:
            if (isLeft)
            {
                // --- Left eigenmatrix ---

                switch(AxisNo)
                {
//                  case 1:
//                      setValue(1,1, (c*c)*(1.-( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c))));
//                      setValue(2,1, (c*c)*(-v));
//                      setValue(3,1, (c*c)*(-w));
//                  setValue(4,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) - u/c )));
//                      setValue(5,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) + u/c )));
//
//                      setValue(1,2, (c*c)*((Gamma-1.)*u/(c*c)));
//                      setValue(2,2, 0.);
//                      setValue(3,2, 0.);
//                      setValue(4,2, (c*c)*((c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));
//                      setValue(5,2, (c*c)*((-c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));
//
//                      setValue(1,3, (c*c)*((Gamma-1.)*v/(c*c)));
//                      setValue(2,3, (c*c)*(1.));
//                      setValue(3,3, 0.);
//                      setValue(4,3, (c*c)*(-v*(Gamma-1.)/(2.*c*c)));
//                      setValue(5,3, (c*c)*(-v*(Gamma-1.)/(2.*c*c)));
//
//                      setValue(1,4, (c*c)*((Gamma-1.)*w/(c*c)));
//                      setValue(2,4, 0.);
//                      setValue(3,4, (c*c)*(1.));
//                      setValue(4,4, (c*c)*(-w*(Gamma-1.)/(2.*c*c)));
//                      setValue(5,4, (c*c)*(-w*(Gamma-1.)/(2.*c*c)));
//
//                      setValue(1,5, (c*c)*(-(Gamma-1.)/(c*c)));
//                      setValue(2,5, 0.);
//                      setValue(3,5, 0.);
//                      setValue(4,5, (c*c)*((Gamma-1.)/(2.*c*c)));
//                      setValue(5,5, (c*c)*((Gamma-1.)/(2.*c*c)));
//                      break;

//          matrix vinokur
                    case 1:
                    setValue(1,1, (1.-( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c))));
                    setValue(2,1, (-v));
                    setValue(3,1, (-w));
                    setValue(4,1, (.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) - u/c )));
                    setValue(5,1, (.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) + u/c )));

                    setValue(1,2, (Gamma-1.)*u/(c*c));
                    setValue(2,2, 0.);
                    setValue(3,2, 0.);
                    setValue(4,2, ((c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));
                    setValue(5,2, ((-c/(Gamma-1.)-u)*((Gamma-1.)/(2.*c*c))));

                    setValue(1,3, ((Gamma-1.)*v/(c*c)));
                    setValue(2,3, (1.));
                    setValue(3,3, 0.);
                    setValue(4,3, -v*(Gamma-1.)/(2.*c*c));
                    setValue(5,3, -v*(Gamma-1.)/(2.*c*c));

                    setValue(1,4, (Gamma-1.)*w/(c*c));
                    setValue(2,4, 0.);
                    setValue(3,4, (1.));
                    setValue(4,4, -w*(Gamma-1.)/(2.*c*c));
                    setValue(5,4, -w*(Gamma-1.)/(2.*c*c));

                    setValue(1,5, (-(Gamma-1.)/(c*c)));
                    setValue(2,5, 0.);
                    setValue(3,5, 0.);
                    setValue(4,5, (Gamma-1.)/(2.*c*c));
                    setValue(5,5, (Gamma-1.)/(2.*c*c));
                        break;








//                  case 2:
//                    setValue(1,1,(c*c)*( -u));
//                    setValue(2,1, (c*c)*(1.-( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c))));
//                    setValue(3,1, (c*c)*(-w));
//                    setValue(4,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) - v/c )));
//                    setValue(5,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) + v/c )));
//
//                    setValue(1,2, 0.);
//                    setValue(2,2, (c*c)*((Gamma-1.)*u/(c*c)));
//                    setValue(3,2, 0.);
//                    setValue(4,2, (c*c)*(-u*(Gamma-1.)/(2.*c*c)));
//                    setValue(5,2, (c*c)*(-u*(Gamma-1.)/(2.*c*c)));
//
//                    setValue(1,3, (c*c)*(1.));
//                    setValue(2,3, (c*c)*((Gamma-1.)*v/(c*c)));
//                    setValue(3,3, 0.);
//                    setValue(4,3, (c*c)*((c/(Gamma-1.)-v)*((Gamma-1.)/(2.*c*c))));
//                    setValue(5,3, (c*c)*((-c/(Gamma-1.)-v)*((Gamma-1.)/(2.*c*c))));
//
//                    setValue(1,4, 0.);
//                    setValue(2,4, (c*c)*((Gamma-1.)*w/(c*c)));
//                    setValue(3,4, (c*c)*(1.));
//                    setValue(4,4, (c*c)*(-w*(Gamma-1.)/(2.*c*c)));
//                    setValue(5,4, (c*c)*(-w*(Gamma-1.)/(2.*c*c)));
//
//                    setValue(1,5, 0.);
//                    setValue(2,5, (c*c)*(-(Gamma-1.)/(c*c)));
//                    setValue(3,5, 0.);
//                    setValue(4,5, (c*c)*((Gamma-1.)/(2.*c*c)));
//                    setValue(5,5, (c*c)*((Gamma-1.)/(2.*c*c)));
//                      break;

//          matrix vinokur
                    case 2:
                      setValue(1,1, -u);
                      setValue(2,1, (1.-( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c))));
                      setValue(3,1, -w);
                      setValue(4,1, (.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) - v/c )));
                      setValue(5,1, (.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) + v/c )));

                      setValue(1,2, 0.);
                      setValue(2,2, (Gamma-1.)*u/(c*c));
                      setValue(3,2, 0.);
                      setValue(4,2, (-u*(Gamma-1.)/(2.*c*c)));
                      setValue(5,2, (-u*(Gamma-1.)/(2.*c*c)));

                      setValue(1,3, (c*c)*(1.));
                      setValue(2,3, (c*c)*((Gamma-1.)*v/(c*c)));
                      setValue(3,3, 0.);
                      setValue(4,3, (c*c)*((c/(Gamma-1.)-v)*((Gamma-1.)/(2.*c*c))));
                      setValue(5,3, (c*c)*((-c/(Gamma-1.)-v)*((Gamma-1.)/(2.*c*c))));

                      setValue(1,4, 0.);
                      setValue(2,4, ((Gamma-1.)*w/(c*c)));
                      setValue(3,4, 1.);
                      setValue(4,4, -w*(Gamma-1.)/(2.*c*c));
                      setValue(5,4, -w*(Gamma-1.)/(2.*c*c));

                      setValue(1,5, 0.);
                      setValue(2,5, -(Gamma-1.)/(c*c));
                      setValue(3,5, 0.);
                      setValue(4,5, (Gamma-1.)/(2.*c*c));
                      setValue(5,5, (Gamma-1.)/(2.*c*c));
                        break;



//                  case 3:
//                    setValue(1,1, (c*c)*(-u));
//                    setValue(2,1, (c*c)*(-v));
//                    setValue(3,1, (c*c)*(1.-( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c))));
//                    setValue(4,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) - w/c )));
//                    setValue(5,1, (c*c)*(.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) + w/c )));
//
//                    setValue(1,2, (c*c)*(1.));
//                    setValue(2,2, 0.);
//                    setValue(3,2, (c*c)*((Gamma-1.)*u/(c*c)));
//                    setValue(4,2, (c*c)*(-(Gamma-1.)*u/(2.*c*c)));
//                    setValue(5,2, (c*c)*(-(Gamma-1.)*u/(2.*c*c)));
//
//                    setValue(1,3, 0.);
//                    setValue(2,3, (c*c)*(1.));
//                    setValue(3,3, (c*c)*((Gamma-1.)*v/(c*c)));
//                    setValue(4,3, (c*c)*(-(Gamma-1.)*v/(2.*c*c)));
//                    setValue(5,3, (c*c)*(-(Gamma-1.)*v/(2.*c*c)));
//
//                    setValue(1,4, 0.);
//                    setValue(2,4, 0.);
//                    setValue(3,4, (c*c)*((Gamma-1.)*w/(c*c)));
//                    setValue(4,4, (c*c)*((c/(Gamma-1.)-w)*((Gamma-1.)/(2.*c*c))));
//                    setValue(5,4, (c*c)*((-c/(Gamma-1.)-w)*((Gamma-1.)/(2.*c*c))));
//
//                    setValue(1,5, 0.);
//                    setValue(2,5, 0.);
//                    setValue(3,5, (c*c)*(-(Gamma-1.)/(c*c)));
//                    setValue(4,5, (c*c)*((Gamma-1.)/(2.*c*c)));
//                    setValue(5,5, (c*c)*((Gamma-1.)/(2.*c*c)));
//                      break;


//          matrix vinokur
                    case 3:
                      setValue(1,1, -u);
                      setValue(2,1, -v);
                      setValue(3,1, (1.-( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c))));
                      setValue(4,1, (.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) - w/c )));
                      setValue(5,1, (.5*( (Gamma-1.)*(u*u+v*v+w*w)/(2.*c*c) + w/c )));

                      setValue(1,2, 1.);
                      setValue(2,2, 0.);
                      setValue(3,2, (Gamma-1.)*u/(c*c));
                      setValue(4,2, -(Gamma-1.)*u/(2.*c*c));
                      setValue(5,2, -(Gamma-1.)*u/(2.*c*c));

                      setValue(1,3, 0.);
                      setValue(2,3, 1.);
                      setValue(3,3, (Gamma-1.)*v/(c*c));
                      setValue(4,3, -(Gamma-1.)*v/(2.*c*c));
                      setValue(5,3, -(Gamma-1.)*v/(2.*c*c));

                      setValue(1,4, 0.);
                      setValue(2,4, 0.);
                      setValue(3,4, (Gamma-1.)*w/(c*c));
                      setValue(4,4, ((c/(Gamma-1.)-w)*((Gamma-1.)/(2.*c*c))));
                      setValue(5,4, ((-c/(Gamma-1.)-w)*((Gamma-1.)/(2.*c*c))));

                      setValue(1,5, 0.);
                      setValue(2,5, 0.);
                      setValue(3,5, -(Gamma-1.)/(c*c));
                      setValue(4,5, (Gamma-1.)/(2.*c*c));
                      setValue(5,5, (Gamma-1.)/(2.*c*c));
                        break;



                };
            }
            else
            {
                // --- Right eigenmatrix ---

                switch(AxisNo)
                {
//                  case 1:
//                    setValue(1,1, 1./(c*c));
//                    setValue(2,1, u/(c*c));
//                    setValue(3,1, v/(c*c));
//                    setValue(4,1, w/(c*c));
//                    setValue(5,1, .5*(u*u+v*v+w*w)/(c*c));
//
//                    setValue(1,2, 0.);
//                    setValue(2,2, 0.);
//                    setValue(3,2, 1./(c*c));
//                    setValue(4,2, 0.);
//                    setValue(5,2, v/(c*c));
//
//                    setValue(1,3, 0.);
//                    setValue(2,3, 0.);
//                    setValue(3,3, 0.);
//                    setValue(4,3, 1./(c*c));
//                    setValue(5,3, w/(c*c));
//
//                    setValue(1,4, 1./(c*c));
//                    setValue(2,4, (u+c)/(c*c));
//                    setValue(3,4, v/(c*c));
//                    setValue(4,4, w/(c*c));
//                    setValue(5,4, (h+ c*u)/(c*c));
//
//                    setValue(1,5, 1.);
//                    setValue(2,5, (u-c)/(c*c));
//                    setValue(3,5, v/(c*c));
//                    setValue(4,5, w/(c*c));
//                    setValue(5,5, (h- c*u)/(c*c));
//                      break;

//          matrix vinokur
                    case 1:
                      setValue(1,1, 1.);
                      setValue(2,1, u);
                      setValue(3,1, v);
                      setValue(4,1, w);
                      setValue(5,1, .5*(u*u+v*v+w*w));

                      setValue(1,2, 0.);
                      setValue(2,2, 0.);
                      setValue(3,2, 1.);
                      setValue(4,2, 0.);
                      setValue(5,2, v);

                      setValue(1,3, 0.);
                      setValue(2,3, 0.);
                      setValue(3,3, 0.);
                      setValue(4,3, 1.);
                      setValue(5,3, w);

                      setValue(1,4, 1.);
                      setValue(2,4, u+c);
                      setValue(3,4, v);
                      setValue(4,4, w);
                      setValue(5,4, h+ c*u);

                      setValue(1,5, 1.);
                      setValue(2,5, u-c);
                      setValue(3,5, v);
                      setValue(4,5, w);
                      setValue(5,5, h- c*u);
                        break;


//          matrix vinokur
                    case 2:
                      setValue(1,1, 0.);
                      setValue(2,1, 0.);
                      setValue(3,1, 1.);
                      setValue(4,1, 0.);
                      setValue(5,1, u);

                      setValue(1,2, 1.);
                      setValue(2,2, u);
                      setValue(3,2, v);
                      setValue(4,2, w);
                      setValue(5,2, .5*(u*u+v*v+w*w));

                      setValue(1,3, 0.);
                      setValue(2,3, 0.);
                      setValue(3,3, 0.);
                      setValue(4,3, 1.);
                      setValue(5,3, w);

                      setValue(1,4, 1.);
                      setValue(2,4, u);
                      setValue(3,4, v+c);
                      setValue(4,4, w);
                      setValue(5,4, h+ c*v);

                      setValue(1,5, 1.);
                      setValue(2,5, u);
                      setValue(3,5, v-c);
                      setValue(4,5, w);
                      setValue(5,5, h- c*v);
                        break;

//          matrix vinokur

                    case 3:
                      setValue(1,1, 0.);
                      setValue(2,1, 1.);
                      setValue(3,1, 0.);
                      setValue(4,1, 0.);
                      setValue(5,1, u);

                      setValue(1,2, 0.);
                      setValue(2,2, 0.);
                      setValue(3,2, 1.);
                      setValue(4,2, 0.);
                      setValue(5,2, v);

                      setValue(1,3, 1.);
                      setValue(2,3, u);
                      setValue(3,3, v);
                      setValue(4,3, w);
                      setValue(5,3, .5*(u*u+v*v+w*w));

                      setValue(1,4, 1.);
                      setValue(2,4, u);
                      setValue(3,4, v);
                      setValue(4,4, w+c);
                      setValue(5,4, h+ c*w);

                      setValue(1,5, 1.);
                      setValue(2,5, u);
                      setValue(3,5, v);
                      setValue(4,5, w-c);
                      setValue(5,5, h- c*w);
                        break;
                };
            }
            break;
    };

}

void Matrix::setValue ( const int  i, const int  j, const real  a  )

inline

Sets the component i, j to value a.

Example :

#include "Matrix.h"

Matrix M(2,2);
real x = 3.;
real y = 1.;
M.setValue(1,1,x);
M.setValue(2,1,y);

Parameters

i	Position
j	Position
a	Value

Returns

void

{
        *( U + (i-1)*Columns + (j-1) ) = a;
}

Here is the caller graph for this function:

void Matrix::setZero

(

)

Sets all the components to zero.

Returns

void

{
    int n;

    for (n = 1; n <= Lines*Columns; n++)
        *(U+n-1) = 0.;
}

Here is the caller graph for this function:

real Matrix::value ( const int  i, const int  j  ) const

inline

Returns the value of the component i, j.

Example :

#include "Matrix.h"

Matrix M(2,2);
real x;
real y;
...
x = M.value(1,1);
y = M.value(2,1);


Parameters

i
j

Returns

real

{
        return *(U+(i-1)*Columns+(j-1));
}

Here is the caller graph for this function:

Member Data Documentation

int Matrix::Columns

Lines and columns of the matrix

int Matrix::Lines

real* Matrix::U

Components

---

The documentation for this class was generated from the following files:

• Matrix.h
• Matrix.cpp