G4ErrorMatrix Class Reference

#include <G4ErrorMatrix.hh>

Collaboration diagram for G4ErrorMatrix:

Classes
class	G4ErrorMatrix_row
class	G4ErrorMatrix_row_const

Public Member Functions
	G4ErrorMatrix ()
	G4ErrorMatrix (G4int p, G4int q)
	G4ErrorMatrix (G4int p, G4int q, G4int i)
	G4ErrorMatrix (const G4ErrorMatrix &m1)
	G4ErrorMatrix (const G4ErrorSymMatrix &m1)
virtual	~G4ErrorMatrix ()
virtual G4int	num_row () const
virtual G4int	num_col () const
virtual const G4double &	operator() (G4int row, G4int col) const
virtual G4double &	operator() (G4int row, G4int col)
G4ErrorMatrix &	operator*= (G4double t)
G4ErrorMatrix &	operator/= (G4double t)
G4ErrorMatrix &	operator+= (const G4ErrorMatrix &m2)
G4ErrorMatrix &	operator+= (const G4ErrorSymMatrix &m2)
G4ErrorMatrix &	operator-= (const G4ErrorMatrix &m2)
G4ErrorMatrix &	operator-= (const G4ErrorSymMatrix &m2)
G4ErrorMatrix &	operator= (const G4ErrorMatrix &m2)
G4ErrorMatrix &	operator= (const G4ErrorSymMatrix &m2)
G4ErrorMatrix	operator- () const
G4ErrorMatrix	apply (G4double(*f)(G4double, G4int, G4int)) const
G4ErrorMatrix	T () const
G4ErrorMatrix	sub (G4int min_row, G4int max_row, G4int min_col, G4int max_col) const
void	sub (G4int row, G4int col, const G4ErrorMatrix &m1)
G4ErrorMatrix	inverse (G4int &ierr) const
virtual void	invert (G4int &ierr)
G4double	determinant () const
G4double	trace () const
G4ErrorMatrix_row	operator[] (G4int)
const G4ErrorMatrix_row_const	operator[] (G4int) const

Static Public Member Functions
static void	error (const char *s)

Protected Member Functions
virtual G4int	num_size () const
virtual void	invertHaywood4 (G4int &ierr)
virtual void	invertHaywood5 (G4int &ierr)
virtual void	invertHaywood6 (G4int &ierr)

Private Member Functions
G4int	dfact_matrix (G4double &det, G4int *ir)
G4int	dfinv_matrix (G4int *ir)

Private Attributes
std::vector< G4double >	m
G4int	nrow
G4int	ncol
G4int	size

Friends
class	G4ErrorMatrix_row
class	G4ErrorMatrix_row_const
class	G4ErrorSymMatrix
G4ErrorMatrix	operator+ (const G4ErrorMatrix &m1, const G4ErrorMatrix &m2)
G4ErrorMatrix	operator- (const G4ErrorMatrix &m1, const G4ErrorMatrix &m2)
G4ErrorMatrix	operator* (const G4ErrorMatrix &m1, const G4ErrorMatrix &m2)
G4ErrorMatrix	operator* (const G4ErrorMatrix &m1, const G4ErrorSymMatrix &m2)
G4ErrorMatrix	operator* (const G4ErrorSymMatrix &m1, const G4ErrorMatrix &m2)
G4ErrorMatrix	operator* (const G4ErrorSymMatrix &m1, const G4ErrorSymMatrix &m2)
G4ErrorMatrix	qr_solve (G4ErrorMatrix *, const G4ErrorMatrix &b)
void	tridiagonal (G4ErrorSymMatrix *a, G4ErrorMatrix *hsm)
void	row_house (G4ErrorMatrix *, const G4ErrorMatrix &, G4double, G4int, G4int, G4int, G4int)
void	back_solve (const G4ErrorMatrix &R, G4ErrorMatrix *b)
void	col_givens (G4ErrorMatrix *A, G4double c, G4double s, G4int k1, G4int k2, G4int rowmin, G4int rowmax)
void	row_givens (G4ErrorMatrix *A, G4double c, G4double s, G4int k1, G4int k2, G4int colmin, G4int colmax)
void	col_house (G4ErrorMatrix *, const G4ErrorMatrix &, G4double, G4int, G4int, G4int, G4int)
void	house_with_update (G4ErrorMatrix *a, G4int row, G4int col)
void	house_with_update (G4ErrorMatrix *a, G4ErrorMatrix *v, G4int row, G4int col)
void	house_with_update2 (G4ErrorSymMatrix *a, G4ErrorMatrix *v, G4int row, G4int col)

Detailed Description

Definition at line 46 of file G4ErrorMatrix.hh.

Constructor & Destructor Documentation

G4ErrorMatrix() [1/5]

G4ErrorMatrix::G4ErrorMatrix

(

)

G4ErrorMatrix() [2/5]

G4ErrorMatrix::G4ErrorMatrix	(	G4int	p,
		G4int	q
	)

Definition at line 74 of file G4ErrorMatrix.cc.

   : m(p*q), nrow(p), ncol(q)
{
  size = nrow * ncol;
}

G4ErrorMatrix() [3/5]

G4ErrorMatrix::G4ErrorMatrix	(	G4int	p,
		G4int	q,
		G4int	i
	)

Definition at line 80 of file G4ErrorMatrix.cc.

   : m(p*q), nrow(p), ncol(q)
{
   size = nrow * ncol;

   if (size > 0)
   {
      switch(init)
      {
      case 0:
         break;

      case 1:
         {
            if ( ncol == nrow )
            {
               G4ErrorMatrixIter a = m.begin();
               G4ErrorMatrixIter b = m.end();
               for( ; a<b; a+=(ncol+1)) *a = 1.0;
            } else {
               error("Invalid dimension in G4ErrorMatrix(G4int,G4int,1).");
            }
            break;
         }
      default:
         error("G4ErrorMatrix: initialization must be either 0 or 1.");
      }
   }
}

Here is the call graph for this function:

G4ErrorMatrix() [4/5]

G4ErrorMatrix::G4ErrorMatrix

(

const G4ErrorMatrix &

m1

)

Definition at line 117 of file G4ErrorMatrix.cc.

   : m(mat1.size), nrow(mat1.nrow), ncol(mat1.ncol), size(mat1.size)
{
   m = mat1.m;
}

G4ErrorMatrix() [5/5]

G4ErrorMatrix::G4ErrorMatrix

(

const G4ErrorSymMatrix &

m1

)

Definition at line 123 of file G4ErrorMatrix.cc.

   : m(mat1.nrow*mat1.nrow), nrow(mat1.nrow), ncol(mat1.nrow)
{
   size = nrow * ncol;

   G4int n = ncol;
   G4ErrorMatrixConstIter sjk = mat1.m.begin();
   G4ErrorMatrixIter m1j = m.begin();
   G4ErrorMatrixIter mj  = m.begin();
   // j >= k
   for(G4int j=1;j<=nrow;j++)
   {
      G4ErrorMatrixIter mjk = mj;
      G4ErrorMatrixIter mkj = m1j;
      for(G4int k=1;k<=j;k++)
      {
         *(mjk++) = *sjk;
         if(j!=k) *mkj = *sjk;
         sjk++;
         mkj += n;
      }
      mj += n;
      m1j++;
   }
}

~G4ErrorMatrix()

G4ErrorMatrix::~G4ErrorMatrix ( )

virtual

Definition at line 113 of file G4ErrorMatrix.cc.

{
}

Member Function Documentation

apply()

G4ErrorMatrix G4ErrorMatrix::apply

(

G4double(*)(G4double, G4int, G4int)

f

)

const

Definition at line 390 of file G4ErrorMatrix.cc.

{
  G4ErrorMatrix mret(num_row(),num_col());
  G4ErrorMatrixConstIter a = m.begin();
  G4ErrorMatrixIter b = mret.m.begin();
  for(G4int ir=1;ir<=num_row();ir++)
  {
    for(G4int ic=1;ic<=num_col();ic++)
    {
      *(b++) = (*f)(*(a++), ir, ic);
    }
  }
  return mret;
}

Here is the call graph for this function:

determinant()

G4double G4ErrorMatrix::determinant

(

)

const

Definition at line 776 of file G4ErrorMatrix.cc.

{
  static G4ThreadLocal G4int max_array = 20;
  static G4ThreadLocal G4int *ir  = 0 ; if (!ir) ir= new G4int [max_array+1];
  if(ncol != nrow)
    { error("G4ErrorMatrix::determinant: G4ErrorMatrix is not NxN"); }
  if (ncol > max_array)
  {
    delete [] ir;
    max_array = nrow;
    ir = new G4int [max_array+1];
  }
  G4double det;
  G4ErrorMatrix mt(*this);
  G4int i = mt.dfact_matrix(det, ir);
  if(i==0) return det;
  return 0;
}

Here is the call graph for this function:

dfact_matrix()

G4int G4ErrorMatrix::dfact_matrix ( G4double &  det, G4int *  ir  )

private

Definition at line 518 of file G4ErrorMatrix.cc.

{
  if (ncol!=nrow)
     error("dfact_matrix: G4ErrorMatrix is not NxN");

  G4int ifail, jfail;
  G4int n = ncol;

  G4double tf;
  G4double g1 = 1.0e-19, g2 = 1.0e19;

  G4double p, q, t;
  G4double s11, s12;

  G4double epsilon = 8*DBL_EPSILON;
  // could be set to zero (like it was before)
  // but then the algorithm often doesn't detect
  // that a matrix is singular

  G4int normal = 0, imposs = -1;
  G4int jrange = 0, jover = 1, junder = -1;
  ifail = normal;
  jfail = jrange;
  G4int nxch = 0;
  det = 1.0;
  G4ErrorMatrixIter mj = m.begin();
  G4ErrorMatrixIter mjj = mj;
  for (G4int j=1;j<=n;j++)
  {
    G4int k = j;
    p = (std::fabs(*mjj));
    if (j!=n) {
      G4ErrorMatrixIter mij = mj + n + j - 1; 
      for (G4int i=j+1;i<=n;i++)
      {
        q = (std::fabs(*(mij)));
        if (q > p)
        {
          k = i;
          p = q;
        }
        mij += n;
      }
      if (k==j)
      {
        if (p <= epsilon)
        {
          det = 0;
          ifail = imposs;
          jfail = jrange;
          return ifail;
        }
        det = -det; // in this case the sign of the determinant
                    // must not change. So I change it twice. 
      }
      G4ErrorMatrixIter mjl = mj;
      G4ErrorMatrixIter mkl = m.begin() + (k-1)*n;
      for (G4int l=1;l<=n;l++)
      {
        tf = *mjl;
        *(mjl++) = *mkl;
        *(mkl++) = tf;
      }
      nxch = nxch + 1;  // this makes the determinant change its sign
      ir[nxch] = (((j)<<12)+(k));
    }
    else
    {
      if (p <= epsilon)
      {
        det = 0.0;
        ifail = imposs;
        jfail = jrange;
        return ifail;
      }
    }
    det *= *mjj;
    *mjj = 1.0 / *mjj;
    t = (std::fabs(det));
    if (t < g1)
    {
      det = 0.0;
      if (jfail == jrange) jfail = junder;
    }
    else if (t > g2)
    {
      det = 1.0;
      if (jfail==jrange) jfail = jover;
    }
    if (j!=n)
    {
      G4ErrorMatrixIter mk = mj + n;
      G4ErrorMatrixIter mkjp = mk + j;
      G4ErrorMatrixIter mjk = mj + j;
      for (k=j+1;k<=n;k++)
      {
        s11 = - (*mjk);
        s12 = - (*mkjp);
        if (j!=1)
        {
          G4ErrorMatrixIter mik = m.begin() + k - 1;
          G4ErrorMatrixIter mijp = m.begin() + j;
          G4ErrorMatrixIter mki = mk;
          G4ErrorMatrixIter mji = mj;
          for (G4int i=1;i<j;i++)
          {
            s11 += (*mik) * (*(mji++));
            s12 += (*mijp) * (*(mki++));
            mik += n;
            mijp += n;
          }
        }
        *(mjk++) = -s11 * (*mjj);
        *(mkjp) = -(((*(mjj+1)))*((*(mkjp-1)))+(s12));
        mk += n;
        mkjp += n;
      }
    }
    mj += n;
    mjj += (n+1);
  }
  if (nxch%2==1) det = -det;
  if (jfail !=jrange) det = 0.0;
  ir[n] = nxch;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dfinv_matrix()

G4int G4ErrorMatrix::dfinv_matrix ( G4int *  ir )

private

Definition at line 405 of file G4ErrorMatrix.cc.

                                           {
  if (num_col()!=num_row())
    { error("dfinv_matrix: G4ErrorMatrix is not NxN"); }
  G4int n = num_col();
  if (n==1) { return 0; }

  G4double s31, s32;
  G4double s33, s34;

  G4ErrorMatrixIter m11 = m.begin();
  G4ErrorMatrixIter m12 = m11 + 1;
  G4ErrorMatrixIter m21 = m11 + n;
  G4ErrorMatrixIter m22 = m12 + n;
  *m21 = -(*m22) * (*m11) * (*m21);
  *m12 = -(*m12);
  if (n>2)
  {
    G4ErrorMatrixIter mi = m.begin() + 2 * n;
    G4ErrorMatrixIter mii= m.begin() + 2 * n + 2;
    G4ErrorMatrixIter mimim = m.begin() + n + 1;
    for (G4int i=3;i<=n;i++)
    {
      G4int im2 = i - 2;
      G4ErrorMatrixIter mj = m.begin();
      G4ErrorMatrixIter mji = mj + i - 1;
      G4ErrorMatrixIter mij = mi;
      for (G4int j=1;j<=im2;j++)
      { 
        s31 = 0.0;
        s32 = *mji;
        G4ErrorMatrixIter mkj = mj + j - 1;
        G4ErrorMatrixIter mik = mi + j - 1;
        G4ErrorMatrixIter mjkp = mj + j;
        G4ErrorMatrixIter mkpi = mj + n + i - 1;
        for (G4int k=j;k<=im2;k++)
        {
          s31 += (*mkj) * (*(mik++));
          s32 += (*(mjkp++)) * (*mkpi);
          mkj += n;
          mkpi += n;
        }
        *mij = -(*mii) * (((*(mij-n)))*( (*(mii-1)))+(s31));
        *mji = -s32;
        mj += n;
        mji += n;
        mij++;
      }
      *(mii-1) = -(*mii) * (*mimim) * (*(mii-1));
      *(mimim+1) = -(*(mimim+1));
      mi += n;
      mimim += (n+1);
      mii += (n+1);
    }
  }
  G4ErrorMatrixIter mi = m.begin();
  G4ErrorMatrixIter mii = m.begin();
  for (G4int i=1;i<n;i++)
  {
    G4int ni = n - i;
    G4ErrorMatrixIter mij = mi;
    G4int j;
    for (j=1; j<=i;j++)
    {
      s33 = *mij;
      G4ErrorMatrixIter mikj = mi + n + j - 1;
      G4ErrorMatrixIter miik = mii + 1;
      G4ErrorMatrixIter min_end = mi + n;
      for (;miik<min_end;)
      {
        s33 += (*mikj) * (*(miik++));
        mikj += n;
      }
      *(mij++) = s33;
    }
    for (j=1;j<=ni;j++)
    {
      s34 = 0.0;
      G4ErrorMatrixIter miik = mii + j;
      G4ErrorMatrixIter mikij = mii + j * n + j;
      for (G4int k=j;k<=ni;k++)
      {
        s34 += *mikij * (*(miik++));
        mikij += n;
      }
      *(mii+j) = s34;
    }
    mi += n;
    mii += (n+1);
  }
  G4int nxch = ir[n];
  if (nxch==0) return 0;
  for (G4int mq=1;mq<=nxch;mq++)
  {
    G4int k = nxch - mq + 1;
    G4int ij = ir[k];
    G4int i = ij >> 12;
    G4int j = ij%4096;
    G4ErrorMatrixIter mki = m.begin() + i - 1;
    G4ErrorMatrixIter mkj = m.begin() + j - 1;
    for (k=1; k<=n;k++)
    {
      // 2/24/05 David Sachs fix of improper swap bug that was present
      // for many years:
      G4double ti = *mki; // 2/24/05
      *mki = *mkj;
      *mkj = ti;        // 2/24/05
      mki += n;
      mkj += n;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

error()

void G4ErrorMatrix::error ( const char *  s )

static

Definition at line 805 of file G4ErrorMatrix.cc.

{
  std::ostringstream message;
  message << msg;
  G4Exception("G4ErrorMatrix::error()", "GEANT4e-Error",
              FatalException, message, "Exiting to System.");
}

Here is the call graph for this function:

Here is the caller graph for this function:

inverse()

G4ErrorMatrix G4ErrorMatrix::inverse ( G4int &  ierr ) const

inline

invert()

void G4ErrorMatrix::invert ( G4int &  ierr )

virtual

Definition at line 645 of file G4ErrorMatrix.cc.

{
  if(ncol != nrow)
     { error("G4ErrorMatrix::invert: G4ErrorMatrix is not NxN"); }

  static G4ThreadLocal G4int max_array = 20;
  static G4ThreadLocal G4int *ir  = 0 ; if (!ir) ir= new G4int [max_array+1];

  if (ncol > max_array)
  {
    delete [] ir;
    max_array = nrow;
    ir = new G4int [max_array+1];
  }
  G4double t1, t2, t3;
  G4double det, temp, ss;
  G4int ifail;
  switch(nrow)
  {
  case 3:
    G4double c11,c12,c13,c21,c22,c23,c31,c32,c33;
    ifail = 0;
    c11 = (*(m.begin()+4)) * (*(m.begin()+8))
        - (*(m.begin()+5)) * (*(m.begin()+7));
    c12 = (*(m.begin()+5)) * (*(m.begin()+6))
        - (*(m.begin()+3)) * (*(m.begin()+8));
    c13 = (*(m.begin()+3)) * (*(m.begin()+7))
        - (*(m.begin()+4)) * (*(m.begin()+6));
    c21 = (*(m.begin()+7)) * (*(m.begin()+2))
        - (*(m.begin()+8)) * (*(m.begin()+1));
    c22 = (*(m.begin()+8)) * (*m.begin())
        - (*(m.begin()+6)) * (*(m.begin()+2));
    c23 = (*(m.begin()+6)) * (*(m.begin()+1))
        - (*(m.begin()+7)) * (*m.begin());
    c31 = (*(m.begin()+1)) * (*(m.begin()+5))
        - (*(m.begin()+2)) * (*(m.begin()+4));
    c32 = (*(m.begin()+2)) * (*(m.begin()+3))
        - (*m.begin()) * (*(m.begin()+5));
    c33 = (*m.begin()) * (*(m.begin()+4))
        - (*(m.begin()+1)) * (*(m.begin()+3));
    t1 = std::fabs(*m.begin());
    t2 = std::fabs(*(m.begin()+3));
    t3 = std::fabs(*(m.begin()+6));
    if (t1 >= t2)
    {
      if (t3 >= t1)
      {
        temp = *(m.begin()+6);
        det = c23*c12-c22*c13;
      }
      else
      {
        temp = *(m.begin());
        det = c22*c33-c23*c32;
      }
    }
    else if (t3 >= t2)
    {
      temp = *(m.begin()+6);
      det = c23*c12-c22*c13;
    }
    else
    {
      temp = *(m.begin()+3);
      det = c13*c32-c12*c33;
    }
    if (det==0)
    {
      ierr = 1;
      return;
    }
    {
      ss = temp/det;
      G4ErrorMatrixIter mq = m.begin();
      *(mq++) = ss*c11;
      *(mq++) = ss*c21;
      *(mq++) = ss*c31;
      *(mq++) = ss*c12;
      *(mq++) = ss*c22;
      *(mq++) = ss*c32;
      *(mq++) = ss*c13;
      *(mq++) = ss*c23;
      *(mq) = ss*c33;
    }
    break;
  case 2:
    ifail = 0;
    det = (*m.begin())*(*(m.begin()+3)) - (*(m.begin()+1))*(*(m.begin()+2));
    if (det==0)
    {
      ierr = 1;
      return;
    }
    ss = 1.0/det;
    temp = ss*(*(m.begin()+3));
    *(m.begin()+1) *= -ss;
    *(m.begin()+2) *= -ss;
    *(m.begin()+3) = ss*(*m.begin());
    *(m.begin()) = temp;
    break;
  case 1:
    ifail = 0;
    if ((*(m.begin()))==0)
    {
      ierr = 1;
      return;
    }
    *(m.begin()) = 1.0/(*(m.begin()));
    break;
  case 4:
    invertHaywood4(ierr);
    return;
  case 5:
    invertHaywood5(ierr);
    return;
  case 6:
    invertHaywood6(ierr);
    return;
  default:
    ifail = dfact_matrix(det, ir);
    if(ifail) {
      ierr = 1;
      return;
    }
    dfinv_matrix(ir);
    break;
  }
  ierr = 0;
  return;
}

Here is the call graph for this function:

invertHaywood4()

void G4ErrorMatrix::invertHaywood4 ( G4int &  ierr )

protectedvirtual

Definition at line 911 of file G4ErrorMatrix.cc.

{
  ifail = 0;

  // Find all NECESSARY 2x2 dets:  (18 of them)

  G4double Det2_12_01 = m[F10]*m[F21] - m[F11]*m[F20];
  G4double Det2_12_02 = m[F10]*m[F22] - m[F12]*m[F20];
  G4double Det2_12_03 = m[F10]*m[F23] - m[F13]*m[F20];
  G4double Det2_12_13 = m[F11]*m[F23] - m[F13]*m[F21];
  G4double Det2_12_23 = m[F12]*m[F23] - m[F13]*m[F22];
  G4double Det2_12_12 = m[F11]*m[F22] - m[F12]*m[F21];
  G4double Det2_13_01 = m[F10]*m[F31] - m[F11]*m[F30];
  G4double Det2_13_02 = m[F10]*m[F32] - m[F12]*m[F30];
  G4double Det2_13_03 = m[F10]*m[F33] - m[F13]*m[F30];
  G4double Det2_13_12 = m[F11]*m[F32] - m[F12]*m[F31];
  G4double Det2_13_13 = m[F11]*m[F33] - m[F13]*m[F31];
  G4double Det2_13_23 = m[F12]*m[F33] - m[F13]*m[F32];
  G4double Det2_23_01 = m[F20]*m[F31] - m[F21]*m[F30];
  G4double Det2_23_02 = m[F20]*m[F32] - m[F22]*m[F30];
  G4double Det2_23_03 = m[F20]*m[F33] - m[F23]*m[F30];
  G4double Det2_23_12 = m[F21]*m[F32] - m[F22]*m[F31];
  G4double Det2_23_13 = m[F21]*m[F33] - m[F23]*m[F31];
  G4double Det2_23_23 = m[F22]*m[F33] - m[F23]*m[F32];

  // Find all NECESSARY 3x3 dets:   (16 of them)

  G4double Det3_012_012 = m[F00]*Det2_12_12 - m[F01]*Det2_12_02 
                                + m[F02]*Det2_12_01;
  G4double Det3_012_013 = m[F00]*Det2_12_13 - m[F01]*Det2_12_03 
                                + m[F03]*Det2_12_01;
  G4double Det3_012_023 = m[F00]*Det2_12_23 - m[F02]*Det2_12_03 
                                + m[F03]*Det2_12_02;
  G4double Det3_012_123 = m[F01]*Det2_12_23 - m[F02]*Det2_12_13 
                                + m[F03]*Det2_12_12;
  G4double Det3_013_012 = m[F00]*Det2_13_12 - m[F01]*Det2_13_02 
                                + m[F02]*Det2_13_01;
  G4double Det3_013_013 = m[F00]*Det2_13_13 - m[F01]*Det2_13_03
                                + m[F03]*Det2_13_01;
  G4double Det3_013_023 = m[F00]*Det2_13_23 - m[F02]*Det2_13_03
                                + m[F03]*Det2_13_02;
  G4double Det3_013_123 = m[F01]*Det2_13_23 - m[F02]*Det2_13_13
                                + m[F03]*Det2_13_12;
  G4double Det3_023_012 = m[F00]*Det2_23_12 - m[F01]*Det2_23_02 
                                + m[F02]*Det2_23_01;
  G4double Det3_023_013 = m[F00]*Det2_23_13 - m[F01]*Det2_23_03
                                + m[F03]*Det2_23_01;
  G4double Det3_023_023 = m[F00]*Det2_23_23 - m[F02]*Det2_23_03
                                + m[F03]*Det2_23_02;
  G4double Det3_023_123 = m[F01]*Det2_23_23 - m[F02]*Det2_23_13
                                + m[F03]*Det2_23_12;
  G4double Det3_123_012 = m[F10]*Det2_23_12 - m[F11]*Det2_23_02 
                                + m[F12]*Det2_23_01;
  G4double Det3_123_013 = m[F10]*Det2_23_13 - m[F11]*Det2_23_03 
                                + m[F13]*Det2_23_01;
  G4double Det3_123_023 = m[F10]*Det2_23_23 - m[F12]*Det2_23_03 
                                + m[F13]*Det2_23_02;
  G4double Det3_123_123 = m[F11]*Det2_23_23 - m[F12]*Det2_23_13 
                                + m[F13]*Det2_23_12;

  // Find the 4x4 det:

  G4double det =    m[F00]*Det3_123_123 
                - m[F01]*Det3_123_023 
                + m[F02]*Det3_123_013 
                - m[F03]*Det3_123_012;

  if ( det == 0 )
  {  
    ifail = 1;
    return;
  } 

  G4double oneOverDet = 1.0/det;
  G4double mn1OverDet = - oneOverDet;

  m[F00] =  Det3_123_123 * oneOverDet;
  m[F01] =  Det3_023_123 * mn1OverDet;
  m[F02] =  Det3_013_123 * oneOverDet;
  m[F03] =  Det3_012_123 * mn1OverDet;

  m[F10] =  Det3_123_023 * mn1OverDet;
  m[F11] =  Det3_023_023 * oneOverDet;
  m[F12] =  Det3_013_023 * mn1OverDet;
  m[F13] =  Det3_012_023 * oneOverDet;

  m[F20] =  Det3_123_013 * oneOverDet;
  m[F21] =  Det3_023_013 * mn1OverDet;
  m[F22] =  Det3_013_013 * oneOverDet;
  m[F23] =  Det3_012_013 * mn1OverDet;

  m[F30] =  Det3_123_012 * mn1OverDet;
  m[F31] =  Det3_023_012 * oneOverDet;
  m[F32] =  Det3_013_012 * mn1OverDet;
  m[F33] =  Det3_012_012 * oneOverDet;

  return;
}

Here is the caller graph for this function:

invertHaywood5()

void G4ErrorMatrix::invertHaywood5 ( G4int &  ierr )

protectedvirtual

Definition at line 1010 of file G4ErrorMatrix.cc.

{
  ifail = 0;

  // Find all NECESSARY 2x2 dets:  (30 of them)

  G4double Det2_23_01 = m[M20]*m[M31] - m[M21]*m[M30];
  G4double Det2_23_02 = m[M20]*m[M32] - m[M22]*m[M30];
  G4double Det2_23_03 = m[M20]*m[M33] - m[M23]*m[M30];
  G4double Det2_23_04 = m[M20]*m[M34] - m[M24]*m[M30];
  G4double Det2_23_12 = m[M21]*m[M32] - m[M22]*m[M31];
  G4double Det2_23_13 = m[M21]*m[M33] - m[M23]*m[M31];
  G4double Det2_23_14 = m[M21]*m[M34] - m[M24]*m[M31];
  G4double Det2_23_23 = m[M22]*m[M33] - m[M23]*m[M32];
  G4double Det2_23_24 = m[M22]*m[M34] - m[M24]*m[M32];
  G4double Det2_23_34 = m[M23]*m[M34] - m[M24]*m[M33];
  G4double Det2_24_01 = m[M20]*m[M41] - m[M21]*m[M40];
  G4double Det2_24_02 = m[M20]*m[M42] - m[M22]*m[M40];
  G4double Det2_24_03 = m[M20]*m[M43] - m[M23]*m[M40];
  G4double Det2_24_04 = m[M20]*m[M44] - m[M24]*m[M40];
  G4double Det2_24_12 = m[M21]*m[M42] - m[M22]*m[M41];
  G4double Det2_24_13 = m[M21]*m[M43] - m[M23]*m[M41];
  G4double Det2_24_14 = m[M21]*m[M44] - m[M24]*m[M41];
  G4double Det2_24_23 = m[M22]*m[M43] - m[M23]*m[M42];
  G4double Det2_24_24 = m[M22]*m[M44] - m[M24]*m[M42];
  G4double Det2_24_34 = m[M23]*m[M44] - m[M24]*m[M43];
  G4double Det2_34_01 = m[M30]*m[M41] - m[M31]*m[M40];
  G4double Det2_34_02 = m[M30]*m[M42] - m[M32]*m[M40];
  G4double Det2_34_03 = m[M30]*m[M43] - m[M33]*m[M40];
  G4double Det2_34_04 = m[M30]*m[M44] - m[M34]*m[M40];
  G4double Det2_34_12 = m[M31]*m[M42] - m[M32]*m[M41];
  G4double Det2_34_13 = m[M31]*m[M43] - m[M33]*m[M41];
  G4double Det2_34_14 = m[M31]*m[M44] - m[M34]*m[M41];
  G4double Det2_34_23 = m[M32]*m[M43] - m[M33]*m[M42];
  G4double Det2_34_24 = m[M32]*m[M44] - m[M34]*m[M42];
  G4double Det2_34_34 = m[M33]*m[M44] - m[M34]*m[M43];

  // Find all NECESSARY 3x3 dets:   (40 of them)

  G4double Det3_123_012 = m[M10]*Det2_23_12 - m[M11]*Det2_23_02 
                                + m[M12]*Det2_23_01;
  G4double Det3_123_013 = m[M10]*Det2_23_13 - m[M11]*Det2_23_03 
                                + m[M13]*Det2_23_01;
  G4double Det3_123_014 = m[M10]*Det2_23_14 - m[M11]*Det2_23_04 
                                + m[M14]*Det2_23_01;
  G4double Det3_123_023 = m[M10]*Det2_23_23 - m[M12]*Det2_23_03 
                                + m[M13]*Det2_23_02;
  G4double Det3_123_024 = m[M10]*Det2_23_24 - m[M12]*Det2_23_04 
                                + m[M14]*Det2_23_02;
  G4double Det3_123_034 = m[M10]*Det2_23_34 - m[M13]*Det2_23_04 
                                + m[M14]*Det2_23_03;
  G4double Det3_123_123 = m[M11]*Det2_23_23 - m[M12]*Det2_23_13 
                                + m[M13]*Det2_23_12;
  G4double Det3_123_124 = m[M11]*Det2_23_24 - m[M12]*Det2_23_14 
                                + m[M14]*Det2_23_12;
  G4double Det3_123_134 = m[M11]*Det2_23_34 - m[M13]*Det2_23_14 
                                + m[M14]*Det2_23_13;
  G4double Det3_123_234 = m[M12]*Det2_23_34 - m[M13]*Det2_23_24 
                                + m[M14]*Det2_23_23;
  G4double Det3_124_012 = m[M10]*Det2_24_12 - m[M11]*Det2_24_02 
                                + m[M12]*Det2_24_01;
  G4double Det3_124_013 = m[M10]*Det2_24_13 - m[M11]*Det2_24_03 
                                + m[M13]*Det2_24_01;
  G4double Det3_124_014 = m[M10]*Det2_24_14 - m[M11]*Det2_24_04 
                                + m[M14]*Det2_24_01;
  G4double Det3_124_023 = m[M10]*Det2_24_23 - m[M12]*Det2_24_03 
                                + m[M13]*Det2_24_02;
  G4double Det3_124_024 = m[M10]*Det2_24_24 - m[M12]*Det2_24_04 
                                + m[M14]*Det2_24_02;
  G4double Det3_124_034 = m[M10]*Det2_24_34 - m[M13]*Det2_24_04 
                                + m[M14]*Det2_24_03;
  G4double Det3_124_123 = m[M11]*Det2_24_23 - m[M12]*Det2_24_13 
                                + m[M13]*Det2_24_12;
  G4double Det3_124_124 = m[M11]*Det2_24_24 - m[M12]*Det2_24_14 
                                + m[M14]*Det2_24_12;
  G4double Det3_124_134 = m[M11]*Det2_24_34 - m[M13]*Det2_24_14 
                                + m[M14]*Det2_24_13;
  G4double Det3_124_234 = m[M12]*Det2_24_34 - m[M13]*Det2_24_24 
                                + m[M14]*Det2_24_23;
  G4double Det3_134_012 = m[M10]*Det2_34_12 - m[M11]*Det2_34_02 
                                + m[M12]*Det2_34_01;
  G4double Det3_134_013 = m[M10]*Det2_34_13 - m[M11]*Det2_34_03 
                                + m[M13]*Det2_34_01;
  G4double Det3_134_014 = m[M10]*Det2_34_14 - m[M11]*Det2_34_04 
                                + m[M14]*Det2_34_01;
  G4double Det3_134_023 = m[M10]*Det2_34_23 - m[M12]*Det2_34_03 
                                + m[M13]*Det2_34_02;
  G4double Det3_134_024 = m[M10]*Det2_34_24 - m[M12]*Det2_34_04 
                                + m[M14]*Det2_34_02;
  G4double Det3_134_034 = m[M10]*Det2_34_34 - m[M13]*Det2_34_04 
                                + m[M14]*Det2_34_03;
  G4double Det3_134_123 = m[M11]*Det2_34_23 - m[M12]*Det2_34_13 
                                + m[M13]*Det2_34_12;
  G4double Det3_134_124 = m[M11]*Det2_34_24 - m[M12]*Det2_34_14 
                                + m[M14]*Det2_34_12;
  G4double Det3_134_134 = m[M11]*Det2_34_34 - m[M13]*Det2_34_14 
                                + m[M14]*Det2_34_13;
  G4double Det3_134_234 = m[M12]*Det2_34_34 - m[M13]*Det2_34_24 
                                + m[M14]*Det2_34_23;
  G4double Det3_234_012 = m[M20]*Det2_34_12 - m[M21]*Det2_34_02 
                                + m[M22]*Det2_34_01;
  G4double Det3_234_013 = m[M20]*Det2_34_13 - m[M21]*Det2_34_03 
                                + m[M23]*Det2_34_01;
  G4double Det3_234_014 = m[M20]*Det2_34_14 - m[M21]*Det2_34_04 
                                + m[M24]*Det2_34_01;
  G4double Det3_234_023 = m[M20]*Det2_34_23 - m[M22]*Det2_34_03 
                                + m[M23]*Det2_34_02;
  G4double Det3_234_024 = m[M20]*Det2_34_24 - m[M22]*Det2_34_04 
                                + m[M24]*Det2_34_02;
  G4double Det3_234_034 = m[M20]*Det2_34_34 - m[M23]*Det2_34_04 
                                + m[M24]*Det2_34_03;
  G4double Det3_234_123 = m[M21]*Det2_34_23 - m[M22]*Det2_34_13 
                                + m[M23]*Det2_34_12;
  G4double Det3_234_124 = m[M21]*Det2_34_24 - m[M22]*Det2_34_14 
                                + m[M24]*Det2_34_12;
  G4double Det3_234_134 = m[M21]*Det2_34_34 - m[M23]*Det2_34_14 
                                + m[M24]*Det2_34_13;
  G4double Det3_234_234 = m[M22]*Det2_34_34 - m[M23]*Det2_34_24 
                                + m[M24]*Det2_34_23;

  // Find all NECESSARY 4x4 dets:   (25 of them)

  G4double Det4_0123_0123 = m[M00]*Det3_123_123 - m[M01]*Det3_123_023 
                                + m[M02]*Det3_123_013 - m[M03]*Det3_123_012;
  G4double Det4_0123_0124 = m[M00]*Det3_123_124 - m[M01]*Det3_123_024 
                                + m[M02]*Det3_123_014 - m[M04]*Det3_123_012;
  G4double Det4_0123_0134 = m[M00]*Det3_123_134 - m[M01]*Det3_123_034 
                                + m[M03]*Det3_123_014 - m[M04]*Det3_123_013;
  G4double Det4_0123_0234 = m[M00]*Det3_123_234 - m[M02]*Det3_123_034 
                                + m[M03]*Det3_123_024 - m[M04]*Det3_123_023;
  G4double Det4_0123_1234 = m[M01]*Det3_123_234 - m[M02]*Det3_123_134 
                                + m[M03]*Det3_123_124 - m[M04]*Det3_123_123;
  G4double Det4_0124_0123 = m[M00]*Det3_124_123 - m[M01]*Det3_124_023 
                                + m[M02]*Det3_124_013 - m[M03]*Det3_124_012;
  G4double Det4_0124_0124 = m[M00]*Det3_124_124 - m[M01]*Det3_124_024 
                                + m[M02]*Det3_124_014 - m[M04]*Det3_124_012;
  G4double Det4_0124_0134 = m[M00]*Det3_124_134 - m[M01]*Det3_124_034 
                                + m[M03]*Det3_124_014 - m[M04]*Det3_124_013;
  G4double Det4_0124_0234 = m[M00]*Det3_124_234 - m[M02]*Det3_124_034 
                                + m[M03]*Det3_124_024 - m[M04]*Det3_124_023;
  G4double Det4_0124_1234 = m[M01]*Det3_124_234 - m[M02]*Det3_124_134 
                                + m[M03]*Det3_124_124 - m[M04]*Det3_124_123;
  G4double Det4_0134_0123 = m[M00]*Det3_134_123 - m[M01]*Det3_134_023 
                                + m[M02]*Det3_134_013 - m[M03]*Det3_134_012;
  G4double Det4_0134_0124 = m[M00]*Det3_134_124 - m[M01]*Det3_134_024 
                                + m[M02]*Det3_134_014 - m[M04]*Det3_134_012;
  G4double Det4_0134_0134 = m[M00]*Det3_134_134 - m[M01]*Det3_134_034 
                                + m[M03]*Det3_134_014 - m[M04]*Det3_134_013;
  G4double Det4_0134_0234 = m[M00]*Det3_134_234 - m[M02]*Det3_134_034 
                                + m[M03]*Det3_134_024 - m[M04]*Det3_134_023;
  G4double Det4_0134_1234 = m[M01]*Det3_134_234 - m[M02]*Det3_134_134 
                                + m[M03]*Det3_134_124 - m[M04]*Det3_134_123;
  G4double Det4_0234_0123 = m[M00]*Det3_234_123 - m[M01]*Det3_234_023 
                                + m[M02]*Det3_234_013 - m[M03]*Det3_234_012;
  G4double Det4_0234_0124 = m[M00]*Det3_234_124 - m[M01]*Det3_234_024 
                                + m[M02]*Det3_234_014 - m[M04]*Det3_234_012;
  G4double Det4_0234_0134 = m[M00]*Det3_234_134 - m[M01]*Det3_234_034 
                                + m[M03]*Det3_234_014 - m[M04]*Det3_234_013;
  G4double Det4_0234_0234 = m[M00]*Det3_234_234 - m[M02]*Det3_234_034 
                                + m[M03]*Det3_234_024 - m[M04]*Det3_234_023;
  G4double Det4_0234_1234 = m[M01]*Det3_234_234 - m[M02]*Det3_234_134 
                                + m[M03]*Det3_234_124 - m[M04]*Det3_234_123;
  G4double Det4_1234_0123 = m[M10]*Det3_234_123 - m[M11]*Det3_234_023 
                                + m[M12]*Det3_234_013 - m[M13]*Det3_234_012;
  G4double Det4_1234_0124 = m[M10]*Det3_234_124 - m[M11]*Det3_234_024 
                                + m[M12]*Det3_234_014 - m[M14]*Det3_234_012;
  G4double Det4_1234_0134 = m[M10]*Det3_234_134 - m[M11]*Det3_234_034 
                                + m[M13]*Det3_234_014 - m[M14]*Det3_234_013;
  G4double Det4_1234_0234 = m[M10]*Det3_234_234 - m[M12]*Det3_234_034 
                                + m[M13]*Det3_234_024 - m[M14]*Det3_234_023;
  G4double Det4_1234_1234 = m[M11]*Det3_234_234 - m[M12]*Det3_234_134 
                                + m[M13]*Det3_234_124 - m[M14]*Det3_234_123;

  // Find the 5x5 det:

  G4double det =  m[M00]*Det4_1234_1234 
                - m[M01]*Det4_1234_0234 
                + m[M02]*Det4_1234_0134 
                - m[M03]*Det4_1234_0124 
                + m[M04]*Det4_1234_0123;

  if ( det == 0 )
  {  
    ifail = 1;
    return;
  } 

  G4double oneOverDet = 1.0/det;
  G4double mn1OverDet = - oneOverDet;

  m[M00] =  Det4_1234_1234 * oneOverDet;
  m[M01] =  Det4_0234_1234 * mn1OverDet;
  m[M02] =  Det4_0134_1234 * oneOverDet;
  m[M03] =  Det4_0124_1234 * mn1OverDet;
  m[M04] =  Det4_0123_1234 * oneOverDet;

  m[M10] =  Det4_1234_0234 * mn1OverDet;
  m[M11] =  Det4_0234_0234 * oneOverDet;
  m[M12] =  Det4_0134_0234 * mn1OverDet;
  m[M13] =  Det4_0124_0234 * oneOverDet;
  m[M14] =  Det4_0123_0234 * mn1OverDet;

  m[M20] =  Det4_1234_0134 * oneOverDet;
  m[M21] =  Det4_0234_0134 * mn1OverDet;
  m[M22] =  Det4_0134_0134 * oneOverDet;
  m[M23] =  Det4_0124_0134 * mn1OverDet;
  m[M24] =  Det4_0123_0134 * oneOverDet;

  m[M30] =  Det4_1234_0124 * mn1OverDet;
  m[M31] =  Det4_0234_0124 * oneOverDet;
  m[M32] =  Det4_0134_0124 * mn1OverDet;
  m[M33] =  Det4_0124_0124 * oneOverDet;
  m[M34] =  Det4_0123_0124 * mn1OverDet;

  m[M40] =  Det4_1234_0123 * oneOverDet;
  m[M41] =  Det4_0234_0123 * mn1OverDet;
  m[M42] =  Det4_0134_0123 * oneOverDet;
  m[M43] =  Det4_0124_0123 * mn1OverDet;
  m[M44] =  Det4_0123_0123 * oneOverDet;

  return;
}

Here is the caller graph for this function:

invertHaywood6()

void G4ErrorMatrix::invertHaywood6 ( G4int &  ierr )

protectedvirtual

Definition at line 1233 of file G4ErrorMatrix.cc.

{
  ifail = 0;

  // Find all NECESSARY 2x2 dets:  (45 of them)

  G4double Det2_34_01 = m[A30]*m[A41] - m[A31]*m[A40];
  G4double Det2_34_02 = m[A30]*m[A42] - m[A32]*m[A40];
  G4double Det2_34_03 = m[A30]*m[A43] - m[A33]*m[A40];
  G4double Det2_34_04 = m[A30]*m[A44] - m[A34]*m[A40];
  G4double Det2_34_05 = m[A30]*m[A45] - m[A35]*m[A40];
  G4double Det2_34_12 = m[A31]*m[A42] - m[A32]*m[A41];
  G4double Det2_34_13 = m[A31]*m[A43] - m[A33]*m[A41];
  G4double Det2_34_14 = m[A31]*m[A44] - m[A34]*m[A41];
  G4double Det2_34_15 = m[A31]*m[A45] - m[A35]*m[A41];
  G4double Det2_34_23 = m[A32]*m[A43] - m[A33]*m[A42];
  G4double Det2_34_24 = m[A32]*m[A44] - m[A34]*m[A42];
  G4double Det2_34_25 = m[A32]*m[A45] - m[A35]*m[A42];
  G4double Det2_34_34 = m[A33]*m[A44] - m[A34]*m[A43];
  G4double Det2_34_35 = m[A33]*m[A45] - m[A35]*m[A43];
  G4double Det2_34_45 = m[A34]*m[A45] - m[A35]*m[A44];
  G4double Det2_35_01 = m[A30]*m[A51] - m[A31]*m[A50];
  G4double Det2_35_02 = m[A30]*m[A52] - m[A32]*m[A50];
  G4double Det2_35_03 = m[A30]*m[A53] - m[A33]*m[A50];
  G4double Det2_35_04 = m[A30]*m[A54] - m[A34]*m[A50];
  G4double Det2_35_05 = m[A30]*m[A55] - m[A35]*m[A50];
  G4double Det2_35_12 = m[A31]*m[A52] - m[A32]*m[A51];
  G4double Det2_35_13 = m[A31]*m[A53] - m[A33]*m[A51];
  G4double Det2_35_14 = m[A31]*m[A54] - m[A34]*m[A51];
  G4double Det2_35_15 = m[A31]*m[A55] - m[A35]*m[A51];
  G4double Det2_35_23 = m[A32]*m[A53] - m[A33]*m[A52];
  G4double Det2_35_24 = m[A32]*m[A54] - m[A34]*m[A52];
  G4double Det2_35_25 = m[A32]*m[A55] - m[A35]*m[A52];
  G4double Det2_35_34 = m[A33]*m[A54] - m[A34]*m[A53];
  G4double Det2_35_35 = m[A33]*m[A55] - m[A35]*m[A53];
  G4double Det2_35_45 = m[A34]*m[A55] - m[A35]*m[A54];
  G4double Det2_45_01 = m[A40]*m[A51] - m[A41]*m[A50];
  G4double Det2_45_02 = m[A40]*m[A52] - m[A42]*m[A50];
  G4double Det2_45_03 = m[A40]*m[A53] - m[A43]*m[A50];
  G4double Det2_45_04 = m[A40]*m[A54] - m[A44]*m[A50];
  G4double Det2_45_05 = m[A40]*m[A55] - m[A45]*m[A50];
  G4double Det2_45_12 = m[A41]*m[A52] - m[A42]*m[A51];
  G4double Det2_45_13 = m[A41]*m[A53] - m[A43]*m[A51];
  G4double Det2_45_14 = m[A41]*m[A54] - m[A44]*m[A51];
  G4double Det2_45_15 = m[A41]*m[A55] - m[A45]*m[A51];
  G4double Det2_45_23 = m[A42]*m[A53] - m[A43]*m[A52];
  G4double Det2_45_24 = m[A42]*m[A54] - m[A44]*m[A52];
  G4double Det2_45_25 = m[A42]*m[A55] - m[A45]*m[A52];
  G4double Det2_45_34 = m[A43]*m[A54] - m[A44]*m[A53];
  G4double Det2_45_35 = m[A43]*m[A55] - m[A45]*m[A53];
  G4double Det2_45_45 = m[A44]*m[A55] - m[A45]*m[A54];

  // Find all NECESSARY 3x3 dets:  (80 of them)

  G4double Det3_234_012 = m[A20]*Det2_34_12 - m[A21]*Det2_34_02 
                                                + m[A22]*Det2_34_01;
  G4double Det3_234_013 = m[A20]*Det2_34_13 - m[A21]*Det2_34_03 
                                                + m[A23]*Det2_34_01;
  G4double Det3_234_014 = m[A20]*Det2_34_14 - m[A21]*Det2_34_04 
                                                + m[A24]*Det2_34_01;
  G4double Det3_234_015 = m[A20]*Det2_34_15 - m[A21]*Det2_34_05
                                                + m[A25]*Det2_34_01;
  G4double Det3_234_023 = m[A20]*Det2_34_23 - m[A22]*Det2_34_03 
                                                + m[A23]*Det2_34_02;
  G4double Det3_234_024 = m[A20]*Det2_34_24 - m[A22]*Det2_34_04 
                                                + m[A24]*Det2_34_02;
  G4double Det3_234_025 = m[A20]*Det2_34_25 - m[A22]*Det2_34_05 
                                                + m[A25]*Det2_34_02;
  G4double Det3_234_034 = m[A20]*Det2_34_34 - m[A23]*Det2_34_04 
                                                + m[A24]*Det2_34_03;
  G4double Det3_234_035 = m[A20]*Det2_34_35 - m[A23]*Det2_34_05                 
                                                + m[A25]*Det2_34_03;
  G4double Det3_234_045 = m[A20]*Det2_34_45 - m[A24]*Det2_34_05 
                                                + m[A25]*Det2_34_04;
  G4double Det3_234_123 = m[A21]*Det2_34_23 - m[A22]*Det2_34_13 
                                                + m[A23]*Det2_34_12;
  G4double Det3_234_124 = m[A21]*Det2_34_24 - m[A22]*Det2_34_14 
                                                + m[A24]*Det2_34_12;
  G4double Det3_234_125 = m[A21]*Det2_34_25 - m[A22]*Det2_34_15 
                                                + m[A25]*Det2_34_12;
  G4double Det3_234_134 = m[A21]*Det2_34_34 - m[A23]*Det2_34_14 
                                                + m[A24]*Det2_34_13;
  G4double Det3_234_135 = m[A21]*Det2_34_35 - m[A23]*Det2_34_15 
                                                + m[A25]*Det2_34_13;
  G4double Det3_234_145 = m[A21]*Det2_34_45 - m[A24]*Det2_34_15 
                                                + m[A25]*Det2_34_14;
  G4double Det3_234_234 = m[A22]*Det2_34_34 - m[A23]*Det2_34_24 
                                                + m[A24]*Det2_34_23;
  G4double Det3_234_235 = m[A22]*Det2_34_35 - m[A23]*Det2_34_25
                                                + m[A25]*Det2_34_23;
  G4double Det3_234_245 = m[A22]*Det2_34_45 - m[A24]*Det2_34_25
                                                + m[A25]*Det2_34_24;
  G4double Det3_234_345 = m[A23]*Det2_34_45 - m[A24]*Det2_34_35
                                                + m[A25]*Det2_34_34;
  G4double Det3_235_012 = m[A20]*Det2_35_12 - m[A21]*Det2_35_02 
                                                + m[A22]*Det2_35_01;
  G4double Det3_235_013 = m[A20]*Det2_35_13 - m[A21]*Det2_35_03 
                                                + m[A23]*Det2_35_01;
  G4double Det3_235_014 = m[A20]*Det2_35_14 - m[A21]*Det2_35_04 
                                                + m[A24]*Det2_35_01;
  G4double Det3_235_015 = m[A20]*Det2_35_15 - m[A21]*Det2_35_05 
                                                + m[A25]*Det2_35_01;
  G4double Det3_235_023 = m[A20]*Det2_35_23 - m[A22]*Det2_35_03 
                                                + m[A23]*Det2_35_02;
  G4double Det3_235_024 = m[A20]*Det2_35_24 - m[A22]*Det2_35_04 
                                                + m[A24]*Det2_35_02;
  G4double Det3_235_025 = m[A20]*Det2_35_25 - m[A22]*Det2_35_05 
                                                + m[A25]*Det2_35_02;
  G4double Det3_235_034 = m[A20]*Det2_35_34 - m[A23]*Det2_35_04 
                                                + m[A24]*Det2_35_03;
  G4double Det3_235_035 = m[A20]*Det2_35_35 - m[A23]*Det2_35_05 
                                                + m[A25]*Det2_35_03;
  G4double Det3_235_045 = m[A20]*Det2_35_45 - m[A24]*Det2_35_05 
                                                + m[A25]*Det2_35_04;
  G4double Det3_235_123 = m[A21]*Det2_35_23 - m[A22]*Det2_35_13 
                                                + m[A23]*Det2_35_12;
  G4double Det3_235_124 = m[A21]*Det2_35_24 - m[A22]*Det2_35_14 
                                                + m[A24]*Det2_35_12;
  G4double Det3_235_125 = m[A21]*Det2_35_25 - m[A22]*Det2_35_15 
                                                + m[A25]*Det2_35_12;
  G4double Det3_235_134 = m[A21]*Det2_35_34 - m[A23]*Det2_35_14 
                                                + m[A24]*Det2_35_13;
  G4double Det3_235_135 = m[A21]*Det2_35_35 - m[A23]*Det2_35_15 
                                                + m[A25]*Det2_35_13;
  G4double Det3_235_145 = m[A21]*Det2_35_45 - m[A24]*Det2_35_15 
                                                + m[A25]*Det2_35_14;
  G4double Det3_235_234 = m[A22]*Det2_35_34 - m[A23]*Det2_35_24 
                                                + m[A24]*Det2_35_23;
  G4double Det3_235_235 = m[A22]*Det2_35_35 - m[A23]*Det2_35_25 
                                                + m[A25]*Det2_35_23;
  G4double Det3_235_245 = m[A22]*Det2_35_45 - m[A24]*Det2_35_25 
                                                + m[A25]*Det2_35_24;
  G4double Det3_235_345 = m[A23]*Det2_35_45 - m[A24]*Det2_35_35 
                                                + m[A25]*Det2_35_34;
  G4double Det3_245_012 = m[A20]*Det2_45_12 - m[A21]*Det2_45_02 
                                                + m[A22]*Det2_45_01;
  G4double Det3_245_013 = m[A20]*Det2_45_13 - m[A21]*Det2_45_03 
                                                + m[A23]*Det2_45_01;
  G4double Det3_245_014 = m[A20]*Det2_45_14 - m[A21]*Det2_45_04 
                                                + m[A24]*Det2_45_01;
  G4double Det3_245_015 = m[A20]*Det2_45_15 - m[A21]*Det2_45_05 
                                                + m[A25]*Det2_45_01;
  G4double Det3_245_023 = m[A20]*Det2_45_23 - m[A22]*Det2_45_03 
                                                + m[A23]*Det2_45_02;
  G4double Det3_245_024 = m[A20]*Det2_45_24 - m[A22]*Det2_45_04 
                                                + m[A24]*Det2_45_02;
  G4double Det3_245_025 = m[A20]*Det2_45_25 - m[A22]*Det2_45_05 
                                                + m[A25]*Det2_45_02;
  G4double Det3_245_034 = m[A20]*Det2_45_34 - m[A23]*Det2_45_04 
                                                + m[A24]*Det2_45_03;
  G4double Det3_245_035 = m[A20]*Det2_45_35 - m[A23]*Det2_45_05 
                                                + m[A25]*Det2_45_03;
  G4double Det3_245_045 = m[A20]*Det2_45_45 - m[A24]*Det2_45_05 
                                                + m[A25]*Det2_45_04;
  G4double Det3_245_123 = m[A21]*Det2_45_23 - m[A22]*Det2_45_13 
                                                + m[A23]*Det2_45_12;
  G4double Det3_245_124 = m[A21]*Det2_45_24 - m[A22]*Det2_45_14 
                                                + m[A24]*Det2_45_12;
  G4double Det3_245_125 = m[A21]*Det2_45_25 - m[A22]*Det2_45_15 
                                                + m[A25]*Det2_45_12;
  G4double Det3_245_134 = m[A21]*Det2_45_34 - m[A23]*Det2_45_14 
                                                + m[A24]*Det2_45_13;
  G4double Det3_245_135 = m[A21]*Det2_45_35 - m[A23]*Det2_45_15 
                                                + m[A25]*Det2_45_13;
  G4double Det3_245_145 = m[A21]*Det2_45_45 - m[A24]*Det2_45_15 
                                                + m[A25]*Det2_45_14;
  G4double Det3_245_234 = m[A22]*Det2_45_34 - m[A23]*Det2_45_24 
                                                + m[A24]*Det2_45_23;
  G4double Det3_245_235 = m[A22]*Det2_45_35 - m[A23]*Det2_45_25 
                                                + m[A25]*Det2_45_23;
  G4double Det3_245_245 = m[A22]*Det2_45_45 - m[A24]*Det2_45_25 
                                                + m[A25]*Det2_45_24;
  G4double Det3_245_345 = m[A23]*Det2_45_45 - m[A24]*Det2_45_35 
                                                + m[A25]*Det2_45_34;
  G4double Det3_345_012 = m[A30]*Det2_45_12 - m[A31]*Det2_45_02 
                                                + m[A32]*Det2_45_01;
  G4double Det3_345_013 = m[A30]*Det2_45_13 - m[A31]*Det2_45_03 
                                                + m[A33]*Det2_45_01;
  G4double Det3_345_014 = m[A30]*Det2_45_14 - m[A31]*Det2_45_04 
                                                + m[A34]*Det2_45_01;
  G4double Det3_345_015 = m[A30]*Det2_45_15 - m[A31]*Det2_45_05 
                                                + m[A35]*Det2_45_01;
  G4double Det3_345_023 = m[A30]*Det2_45_23 - m[A32]*Det2_45_03 
                                                + m[A33]*Det2_45_02;
  G4double Det3_345_024 = m[A30]*Det2_45_24 - m[A32]*Det2_45_04 
                                                + m[A34]*Det2_45_02;
  G4double Det3_345_025 = m[A30]*Det2_45_25 - m[A32]*Det2_45_05 
                                                + m[A35]*Det2_45_02;
  G4double Det3_345_034 = m[A30]*Det2_45_34 - m[A33]*Det2_45_04 
                                                + m[A34]*Det2_45_03;
  G4double Det3_345_035 = m[A30]*Det2_45_35 - m[A33]*Det2_45_05 
                                                + m[A35]*Det2_45_03;
  G4double Det3_345_045 = m[A30]*Det2_45_45 - m[A34]*Det2_45_05 
                                                + m[A35]*Det2_45_04;
  G4double Det3_345_123 = m[A31]*Det2_45_23 - m[A32]*Det2_45_13 
                                                + m[A33]*Det2_45_12;
  G4double Det3_345_124 = m[A31]*Det2_45_24 - m[A32]*Det2_45_14 
                                                + m[A34]*Det2_45_12;
  G4double Det3_345_125 = m[A31]*Det2_45_25 - m[A32]*Det2_45_15 
                                                + m[A35]*Det2_45_12;
  G4double Det3_345_134 = m[A31]*Det2_45_34 - m[A33]*Det2_45_14 
                                                + m[A34]*Det2_45_13;
  G4double Det3_345_135 = m[A31]*Det2_45_35 - m[A33]*Det2_45_15 
                                                + m[A35]*Det2_45_13;
  G4double Det3_345_145 = m[A31]*Det2_45_45 - m[A34]*Det2_45_15 
                                                + m[A35]*Det2_45_14;
  G4double Det3_345_234 = m[A32]*Det2_45_34 - m[A33]*Det2_45_24 
                                                + m[A34]*Det2_45_23;
  G4double Det3_345_235 = m[A32]*Det2_45_35 - m[A33]*Det2_45_25 
                                                + m[A35]*Det2_45_23;
  G4double Det3_345_245 = m[A32]*Det2_45_45 - m[A34]*Det2_45_25 
                                                + m[A35]*Det2_45_24;
  G4double Det3_345_345 = m[A33]*Det2_45_45 - m[A34]*Det2_45_35 
                                                + m[A35]*Det2_45_34;

  // Find all NECESSARY 4x4 dets:  (75 of them)

  G4double Det4_1234_0123 = m[A10]*Det3_234_123 - m[A11]*Det3_234_023 
                        + m[A12]*Det3_234_013 - m[A13]*Det3_234_012;
  G4double Det4_1234_0124 = m[A10]*Det3_234_124 - m[A11]*Det3_234_024 
                        + m[A12]*Det3_234_014 - m[A14]*Det3_234_012;
  G4double Det4_1234_0125 = m[A10]*Det3_234_125 - m[A11]*Det3_234_025 
                        + m[A12]*Det3_234_015 - m[A15]*Det3_234_012;
  G4double Det4_1234_0134 = m[A10]*Det3_234_134 - m[A11]*Det3_234_034 
                        + m[A13]*Det3_234_014 - m[A14]*Det3_234_013;
  G4double Det4_1234_0135 = m[A10]*Det3_234_135 - m[A11]*Det3_234_035
                        + m[A13]*Det3_234_015 - m[A15]*Det3_234_013;
  G4double Det4_1234_0145 = m[A10]*Det3_234_145 - m[A11]*Det3_234_045
                        + m[A14]*Det3_234_015 - m[A15]*Det3_234_014;
  G4double Det4_1234_0234 = m[A10]*Det3_234_234 - m[A12]*Det3_234_034 
                        + m[A13]*Det3_234_024 - m[A14]*Det3_234_023;
  G4double Det4_1234_0235 = m[A10]*Det3_234_235 - m[A12]*Det3_234_035 
                        + m[A13]*Det3_234_025 - m[A15]*Det3_234_023;
  G4double Det4_1234_0245 = m[A10]*Det3_234_245 - m[A12]*Det3_234_045 
                        + m[A14]*Det3_234_025 - m[A15]*Det3_234_024;
  G4double Det4_1234_0345 = m[A10]*Det3_234_345 - m[A13]*Det3_234_045 
                        + m[A14]*Det3_234_035 - m[A15]*Det3_234_034;
  G4double Det4_1234_1234 = m[A11]*Det3_234_234 - m[A12]*Det3_234_134 
                        + m[A13]*Det3_234_124 - m[A14]*Det3_234_123;
  G4double Det4_1234_1235 = m[A11]*Det3_234_235 - m[A12]*Det3_234_135 
                        + m[A13]*Det3_234_125 - m[A15]*Det3_234_123;
  G4double Det4_1234_1245 = m[A11]*Det3_234_245 - m[A12]*Det3_234_145 
                        + m[A14]*Det3_234_125 - m[A15]*Det3_234_124;
  G4double Det4_1234_1345 = m[A11]*Det3_234_345 - m[A13]*Det3_234_145 
                        + m[A14]*Det3_234_135 - m[A15]*Det3_234_134;
  G4double Det4_1234_2345 = m[A12]*Det3_234_345 - m[A13]*Det3_234_245 
                        + m[A14]*Det3_234_235 - m[A15]*Det3_234_234;
  G4double Det4_1235_0123 = m[A10]*Det3_235_123 - m[A11]*Det3_235_023 
                        + m[A12]*Det3_235_013 - m[A13]*Det3_235_012;
  G4double Det4_1235_0124 = m[A10]*Det3_235_124 - m[A11]*Det3_235_024 
                        + m[A12]*Det3_235_014 - m[A14]*Det3_235_012;
  G4double Det4_1235_0125 = m[A10]*Det3_235_125 - m[A11]*Det3_235_025 
                        + m[A12]*Det3_235_015 - m[A15]*Det3_235_012;
  G4double Det4_1235_0134 = m[A10]*Det3_235_134 - m[A11]*Det3_235_034 
                        + m[A13]*Det3_235_014 - m[A14]*Det3_235_013;
  G4double Det4_1235_0135 = m[A10]*Det3_235_135 - m[A11]*Det3_235_035 
                        + m[A13]*Det3_235_015 - m[A15]*Det3_235_013;
  G4double Det4_1235_0145 = m[A10]*Det3_235_145 - m[A11]*Det3_235_045 
                        + m[A14]*Det3_235_015 - m[A15]*Det3_235_014;
  G4double Det4_1235_0234 = m[A10]*Det3_235_234 - m[A12]*Det3_235_034 
                        + m[A13]*Det3_235_024 - m[A14]*Det3_235_023;
  G4double Det4_1235_0235 = m[A10]*Det3_235_235 - m[A12]*Det3_235_035 
                        + m[A13]*Det3_235_025 - m[A15]*Det3_235_023;
  G4double Det4_1235_0245 = m[A10]*Det3_235_245 - m[A12]*Det3_235_045 
                        + m[A14]*Det3_235_025 - m[A15]*Det3_235_024;
  G4double Det4_1235_0345 = m[A10]*Det3_235_345 - m[A13]*Det3_235_045 
                        + m[A14]*Det3_235_035 - m[A15]*Det3_235_034;
  G4double Det4_1235_1234 = m[A11]*Det3_235_234 - m[A12]*Det3_235_134 
                        + m[A13]*Det3_235_124 - m[A14]*Det3_235_123;
  G4double Det4_1235_1235 = m[A11]*Det3_235_235 - m[A12]*Det3_235_135 
                        + m[A13]*Det3_235_125 - m[A15]*Det3_235_123;
  G4double Det4_1235_1245 = m[A11]*Det3_235_245 - m[A12]*Det3_235_145 
                        + m[A14]*Det3_235_125 - m[A15]*Det3_235_124;
  G4double Det4_1235_1345 = m[A11]*Det3_235_345 - m[A13]*Det3_235_145 
                        + m[A14]*Det3_235_135 - m[A15]*Det3_235_134;
  G4double Det4_1235_2345 = m[A12]*Det3_235_345 - m[A13]*Det3_235_245 
                        + m[A14]*Det3_235_235 - m[A15]*Det3_235_234;
  G4double Det4_1245_0123 = m[A10]*Det3_245_123 - m[A11]*Det3_245_023 
                        + m[A12]*Det3_245_013 - m[A13]*Det3_245_012;
  G4double Det4_1245_0124 = m[A10]*Det3_245_124 - m[A11]*Det3_245_024 
                        + m[A12]*Det3_245_014 - m[A14]*Det3_245_012;
  G4double Det4_1245_0125 = m[A10]*Det3_245_125 - m[A11]*Det3_245_025 
                        + m[A12]*Det3_245_015 - m[A15]*Det3_245_012;
  G4double Det4_1245_0134 = m[A10]*Det3_245_134 - m[A11]*Det3_245_034 
                        + m[A13]*Det3_245_014 - m[A14]*Det3_245_013;
  G4double Det4_1245_0135 = m[A10]*Det3_245_135 - m[A11]*Det3_245_035 
                        + m[A13]*Det3_245_015 - m[A15]*Det3_245_013;
  G4double Det4_1245_0145 = m[A10]*Det3_245_145 - m[A11]*Det3_245_045 
                        + m[A14]*Det3_245_015 - m[A15]*Det3_245_014;
  G4double Det4_1245_0234 = m[A10]*Det3_245_234 - m[A12]*Det3_245_034 
                        + m[A13]*Det3_245_024 - m[A14]*Det3_245_023;
  G4double Det4_1245_0235 = m[A10]*Det3_245_235 - m[A12]*Det3_245_035 
                        + m[A13]*Det3_245_025 - m[A15]*Det3_245_023;
  G4double Det4_1245_0245 = m[A10]*Det3_245_245 - m[A12]*Det3_245_045 
                        + m[A14]*Det3_245_025 - m[A15]*Det3_245_024;
  G4double Det4_1245_0345 = m[A10]*Det3_245_345 - m[A13]*Det3_245_045 
                        + m[A14]*Det3_245_035 - m[A15]*Det3_245_034;
  G4double Det4_1245_1234 = m[A11]*Det3_245_234 - m[A12]*Det3_245_134 
                        + m[A13]*Det3_245_124 - m[A14]*Det3_245_123;
  G4double Det4_1245_1235 = m[A11]*Det3_245_235 - m[A12]*Det3_245_135 
                        + m[A13]*Det3_245_125 - m[A15]*Det3_245_123;
  G4double Det4_1245_1245 = m[A11]*Det3_245_245 - m[A12]*Det3_245_145 
                        + m[A14]*Det3_245_125 - m[A15]*Det3_245_124;
  G4double Det4_1245_1345 = m[A11]*Det3_245_345 - m[A13]*Det3_245_145 
                        + m[A14]*Det3_245_135 - m[A15]*Det3_245_134;
  G4double Det4_1245_2345 = m[A12]*Det3_245_345 - m[A13]*Det3_245_245 
                        + m[A14]*Det3_245_235 - m[A15]*Det3_245_234;
  G4double Det4_1345_0123 = m[A10]*Det3_345_123 - m[A11]*Det3_345_023 
                        + m[A12]*Det3_345_013 - m[A13]*Det3_345_012;
  G4double Det4_1345_0124 = m[A10]*Det3_345_124 - m[A11]*Det3_345_024 
                        + m[A12]*Det3_345_014 - m[A14]*Det3_345_012;
  G4double Det4_1345_0125 = m[A10]*Det3_345_125 - m[A11]*Det3_345_025 
                        + m[A12]*Det3_345_015 - m[A15]*Det3_345_012;
  G4double Det4_1345_0134 = m[A10]*Det3_345_134 - m[A11]*Det3_345_034 
                        + m[A13]*Det3_345_014 - m[A14]*Det3_345_013;
  G4double Det4_1345_0135 = m[A10]*Det3_345_135 - m[A11]*Det3_345_035 
                        + m[A13]*Det3_345_015 - m[A15]*Det3_345_013;
  G4double Det4_1345_0145 = m[A10]*Det3_345_145 - m[A11]*Det3_345_045 
                        + m[A14]*Det3_345_015 - m[A15]*Det3_345_014;
  G4double Det4_1345_0234 = m[A10]*Det3_345_234 - m[A12]*Det3_345_034 
                        + m[A13]*Det3_345_024 - m[A14]*Det3_345_023;
  G4double Det4_1345_0235 = m[A10]*Det3_345_235 - m[A12]*Det3_345_035 
                        + m[A13]*Det3_345_025 - m[A15]*Det3_345_023;
  G4double Det4_1345_0245 = m[A10]*Det3_345_245 - m[A12]*Det3_345_045 
                        + m[A14]*Det3_345_025 - m[A15]*Det3_345_024;
  G4double Det4_1345_0345 = m[A10]*Det3_345_345 - m[A13]*Det3_345_045 
                        + m[A14]*Det3_345_035 - m[A15]*Det3_345_034;
  G4double Det4_1345_1234 = m[A11]*Det3_345_234 - m[A12]*Det3_345_134 
                        + m[A13]*Det3_345_124 - m[A14]*Det3_345_123;
  G4double Det4_1345_1235 = m[A11]*Det3_345_235 - m[A12]*Det3_345_135 
                        + m[A13]*Det3_345_125 - m[A15]*Det3_345_123;
  G4double Det4_1345_1245 = m[A11]*Det3_345_245 - m[A12]*Det3_345_145 
                        + m[A14]*Det3_345_125 - m[A15]*Det3_345_124;
  G4double Det4_1345_1345 = m[A11]*Det3_345_345 - m[A13]*Det3_345_145 
                        + m[A14]*Det3_345_135 - m[A15]*Det3_345_134;
  G4double Det4_1345_2345 = m[A12]*Det3_345_345 - m[A13]*Det3_345_245 
                        + m[A14]*Det3_345_235 - m[A15]*Det3_345_234;
  G4double Det4_2345_0123 = m[A20]*Det3_345_123 - m[A21]*Det3_345_023 
                        + m[A22]*Det3_345_013 - m[A23]*Det3_345_012;
  G4double Det4_2345_0124 = m[A20]*Det3_345_124 - m[A21]*Det3_345_024 
                        + m[A22]*Det3_345_014 - m[A24]*Det3_345_012;
  G4double Det4_2345_0125 = m[A20]*Det3_345_125 - m[A21]*Det3_345_025 
                        + m[A22]*Det3_345_015 - m[A25]*Det3_345_012;
  G4double Det4_2345_0134 = m[A20]*Det3_345_134 - m[A21]*Det3_345_034 
                        + m[A23]*Det3_345_014 - m[A24]*Det3_345_013;
  G4double Det4_2345_0135 = m[A20]*Det3_345_135 - m[A21]*Det3_345_035 
                        + m[A23]*Det3_345_015 - m[A25]*Det3_345_013;
  G4double Det4_2345_0145 = m[A20]*Det3_345_145 - m[A21]*Det3_345_045 
                        + m[A24]*Det3_345_015 - m[A25]*Det3_345_014;
  G4double Det4_2345_0234 = m[A20]*Det3_345_234 - m[A22]*Det3_345_034 
                        + m[A23]*Det3_345_024 - m[A24]*Det3_345_023;
  G4double Det4_2345_0235 = m[A20]*Det3_345_235 - m[A22]*Det3_345_035 
                        + m[A23]*Det3_345_025 - m[A25]*Det3_345_023;
  G4double Det4_2345_0245 = m[A20]*Det3_345_245 - m[A22]*Det3_345_045 
                        + m[A24]*Det3_345_025 - m[A25]*Det3_345_024;
  G4double Det4_2345_0345 = m[A20]*Det3_345_345 - m[A23]*Det3_345_045 
                        + m[A24]*Det3_345_035 - m[A25]*Det3_345_034;
  G4double Det4_2345_1234 = m[A21]*Det3_345_234 - m[A22]*Det3_345_134 
                        + m[A23]*Det3_345_124 - m[A24]*Det3_345_123;
  G4double Det4_2345_1235 = m[A21]*Det3_345_235 - m[A22]*Det3_345_135 
                        + m[A23]*Det3_345_125 - m[A25]*Det3_345_123;
  G4double Det4_2345_1245 = m[A21]*Det3_345_245 - m[A22]*Det3_345_145 
                        + m[A24]*Det3_345_125 - m[A25]*Det3_345_124;
  G4double Det4_2345_1345 = m[A21]*Det3_345_345 - m[A23]*Det3_345_145 
                        + m[A24]*Det3_345_135 - m[A25]*Det3_345_134;
  G4double Det4_2345_2345 = m[A22]*Det3_345_345 - m[A23]*Det3_345_245 
                        + m[A24]*Det3_345_235 - m[A25]*Det3_345_234;

  // Find all NECESSARY 5x5 dets:  (36 of them)

  G4double Det5_01234_01234 = m[A00]*Det4_1234_1234 - m[A01]*Det4_1234_0234 
    + m[A02]*Det4_1234_0134 - m[A03]*Det4_1234_0124 + m[A04]*Det4_1234_0123;
  G4double Det5_01234_01235 = m[A00]*Det4_1234_1235 - m[A01]*Det4_1234_0235
    + m[A02]*Det4_1234_0135 - m[A03]*Det4_1234_0125 + m[A05]*Det4_1234_0123;
  G4double Det5_01234_01245 = m[A00]*Det4_1234_1245 - m[A01]*Det4_1234_0245
    + m[A02]*Det4_1234_0145 - m[A04]*Det4_1234_0125 + m[A05]*Det4_1234_0124;
  G4double Det5_01234_01345 = m[A00]*Det4_1234_1345 - m[A01]*Det4_1234_0345
    + m[A03]*Det4_1234_0145 - m[A04]*Det4_1234_0135 + m[A05]*Det4_1234_0134;
  G4double Det5_01234_02345 = m[A00]*Det4_1234_2345 - m[A02]*Det4_1234_0345
    + m[A03]*Det4_1234_0245 - m[A04]*Det4_1234_0235 + m[A05]*Det4_1234_0234;
  G4double Det5_01234_12345 = m[A01]*Det4_1234_2345 - m[A02]*Det4_1234_1345
    + m[A03]*Det4_1234_1245 - m[A04]*Det4_1234_1235 + m[A05]*Det4_1234_1234;
  G4double Det5_01235_01234 = m[A00]*Det4_1235_1234 - m[A01]*Det4_1235_0234 
    + m[A02]*Det4_1235_0134 - m[A03]*Det4_1235_0124 + m[A04]*Det4_1235_0123;
  G4double Det5_01235_01235 = m[A00]*Det4_1235_1235 - m[A01]*Det4_1235_0235 
    + m[A02]*Det4_1235_0135 - m[A03]*Det4_1235_0125 + m[A05]*Det4_1235_0123;
  G4double Det5_01235_01245 = m[A00]*Det4_1235_1245 - m[A01]*Det4_1235_0245 
    + m[A02]*Det4_1235_0145 - m[A04]*Det4_1235_0125 + m[A05]*Det4_1235_0124;
  G4double Det5_01235_01345 = m[A00]*Det4_1235_1345 - m[A01]*Det4_1235_0345 
    + m[A03]*Det4_1235_0145 - m[A04]*Det4_1235_0135 + m[A05]*Det4_1235_0134;
  G4double Det5_01235_02345 = m[A00]*Det4_1235_2345 - m[A02]*Det4_1235_0345 
    + m[A03]*Det4_1235_0245 - m[A04]*Det4_1235_0235 + m[A05]*Det4_1235_0234;
  G4double Det5_01235_12345 = m[A01]*Det4_1235_2345 - m[A02]*Det4_1235_1345 
    + m[A03]*Det4_1235_1245 - m[A04]*Det4_1235_1235 + m[A05]*Det4_1235_1234;
  G4double Det5_01245_01234 = m[A00]*Det4_1245_1234 - m[A01]*Det4_1245_0234 
    + m[A02]*Det4_1245_0134 - m[A03]*Det4_1245_0124 + m[A04]*Det4_1245_0123;
  G4double Det5_01245_01235 = m[A00]*Det4_1245_1235 - m[A01]*Det4_1245_0235 
    + m[A02]*Det4_1245_0135 - m[A03]*Det4_1245_0125 + m[A05]*Det4_1245_0123;
  G4double Det5_01245_01245 = m[A00]*Det4_1245_1245 - m[A01]*Det4_1245_0245 
    + m[A02]*Det4_1245_0145 - m[A04]*Det4_1245_0125 + m[A05]*Det4_1245_0124;
  G4double Det5_01245_01345 = m[A00]*Det4_1245_1345 - m[A01]*Det4_1245_0345 
    + m[A03]*Det4_1245_0145 - m[A04]*Det4_1245_0135 + m[A05]*Det4_1245_0134;
  G4double Det5_01245_02345 = m[A00]*Det4_1245_2345 - m[A02]*Det4_1245_0345 
    + m[A03]*Det4_1245_0245 - m[A04]*Det4_1245_0235 + m[A05]*Det4_1245_0234;
  G4double Det5_01245_12345 = m[A01]*Det4_1245_2345 - m[A02]*Det4_1245_1345 
    + m[A03]*Det4_1245_1245 - m[A04]*Det4_1245_1235 + m[A05]*Det4_1245_1234;
  G4double Det5_01345_01234 = m[A00]*Det4_1345_1234 - m[A01]*Det4_1345_0234 
    + m[A02]*Det4_1345_0134 - m[A03]*Det4_1345_0124 + m[A04]*Det4_1345_0123;
  G4double Det5_01345_01235 = m[A00]*Det4_1345_1235 - m[A01]*Det4_1345_0235 
    + m[A02]*Det4_1345_0135 - m[A03]*Det4_1345_0125 + m[A05]*Det4_1345_0123;
  G4double Det5_01345_01245 = m[A00]*Det4_1345_1245 - m[A01]*Det4_1345_0245 
    + m[A02]*Det4_1345_0145 - m[A04]*Det4_1345_0125 + m[A05]*Det4_1345_0124;
  G4double Det5_01345_01345 = m[A00]*Det4_1345_1345 - m[A01]*Det4_1345_0345 
    + m[A03]*Det4_1345_0145 - m[A04]*Det4_1345_0135 + m[A05]*Det4_1345_0134;
  G4double Det5_01345_02345 = m[A00]*Det4_1345_2345 - m[A02]*Det4_1345_0345 
    + m[A03]*Det4_1345_0245 - m[A04]*Det4_1345_0235 + m[A05]*Det4_1345_0234;
  G4double Det5_01345_12345 = m[A01]*Det4_1345_2345 - m[A02]*Det4_1345_1345 
    + m[A03]*Det4_1345_1245 - m[A04]*Det4_1345_1235 + m[A05]*Det4_1345_1234; //
  G4double Det5_02345_01234 = m[A00]*Det4_2345_1234 - m[A01]*Det4_2345_0234 
    + m[A02]*Det4_2345_0134 - m[A03]*Det4_2345_0124 + m[A04]*Det4_2345_0123;
  G4double Det5_02345_01235 = m[A00]*Det4_2345_1235 - m[A01]*Det4_2345_0235 
    + m[A02]*Det4_2345_0135 - m[A03]*Det4_2345_0125 + m[A05]*Det4_2345_0123;
  G4double Det5_02345_01245 = m[A00]*Det4_2345_1245 - m[A01]*Det4_2345_0245 
    + m[A02]*Det4_2345_0145 - m[A04]*Det4_2345_0125 + m[A05]*Det4_2345_0124;
  G4double Det5_02345_01345 = m[A00]*Det4_2345_1345 - m[A01]*Det4_2345_0345 
    + m[A03]*Det4_2345_0145 - m[A04]*Det4_2345_0135 + m[A05]*Det4_2345_0134;
  G4double Det5_02345_02345 = m[A00]*Det4_2345_2345 - m[A02]*Det4_2345_0345 
    + m[A03]*Det4_2345_0245 - m[A04]*Det4_2345_0235 + m[A05]*Det4_2345_0234;
  G4double Det5_02345_12345 = m[A01]*Det4_2345_2345 - m[A02]*Det4_2345_1345 
    + m[A03]*Det4_2345_1245 - m[A04]*Det4_2345_1235 + m[A05]*Det4_2345_1234;
  G4double Det5_12345_01234 = m[A10]*Det4_2345_1234 - m[A11]*Det4_2345_0234 
    + m[A12]*Det4_2345_0134 - m[A13]*Det4_2345_0124 + m[A14]*Det4_2345_0123;
  G4double Det5_12345_01235 = m[A10]*Det4_2345_1235 - m[A11]*Det4_2345_0235 
    + m[A12]*Det4_2345_0135 - m[A13]*Det4_2345_0125 + m[A15]*Det4_2345_0123;
  G4double Det5_12345_01245 = m[A10]*Det4_2345_1245 - m[A11]*Det4_2345_0245 
    + m[A12]*Det4_2345_0145 - m[A14]*Det4_2345_0125 + m[A15]*Det4_2345_0124;
  G4double Det5_12345_01345 = m[A10]*Det4_2345_1345 - m[A11]*Det4_2345_0345 
    + m[A13]*Det4_2345_0145 - m[A14]*Det4_2345_0135 + m[A15]*Det4_2345_0134;
  G4double Det5_12345_02345 = m[A10]*Det4_2345_2345 - m[A12]*Det4_2345_0345 
    + m[A13]*Det4_2345_0245 - m[A14]*Det4_2345_0235 + m[A15]*Det4_2345_0234;
  G4double Det5_12345_12345 = m[A11]*Det4_2345_2345 - m[A12]*Det4_2345_1345 
    + m[A13]*Det4_2345_1245 - m[A14]*Det4_2345_1235 + m[A15]*Det4_2345_1234;

  // Find the determinant 

  G4double det =  m[A00]*Det5_12345_12345 
                - m[A01]*Det5_12345_02345 
                + m[A02]*Det5_12345_01345 
                - m[A03]*Det5_12345_01245 
                + m[A04]*Det5_12345_01235 
                - m[A05]*Det5_12345_01234;

  if ( det == 0 )
  {  
    ifail = 1;
    return;
  } 

  G4double oneOverDet = 1.0/det;
  G4double mn1OverDet = - oneOverDet;

  m[A00] =  Det5_12345_12345*oneOverDet;
  m[A01] =  Det5_02345_12345*mn1OverDet;
  m[A02] =  Det5_01345_12345*oneOverDet;
  m[A03] =  Det5_01245_12345*mn1OverDet;
  m[A04] =  Det5_01235_12345*oneOverDet;
  m[A05] =  Det5_01234_12345*mn1OverDet;

  m[A10] =  Det5_12345_02345*mn1OverDet;
  m[A11] =  Det5_02345_02345*oneOverDet;
  m[A12] =  Det5_01345_02345*mn1OverDet;
  m[A13] =  Det5_01245_02345*oneOverDet;
  m[A14] =  Det5_01235_02345*mn1OverDet;
  m[A15] =  Det5_01234_02345*oneOverDet;

  m[A20] =  Det5_12345_01345*oneOverDet;
  m[A21] =  Det5_02345_01345*mn1OverDet;
  m[A22] =  Det5_01345_01345*oneOverDet;
  m[A23] =  Det5_01245_01345*mn1OverDet;
  m[A24] =  Det5_01235_01345*oneOverDet;
  m[A25] =  Det5_01234_01345*mn1OverDet;

  m[A30] =  Det5_12345_01245*mn1OverDet;
  m[A31] =  Det5_02345_01245*oneOverDet;
  m[A32] =  Det5_01345_01245*mn1OverDet;
  m[A33] =  Det5_01245_01245*oneOverDet;
  m[A34] =  Det5_01235_01245*mn1OverDet;
  m[A35] =  Det5_01234_01245*oneOverDet;

  m[A40] =  Det5_12345_01235*oneOverDet;
  m[A41] =  Det5_02345_01235*mn1OverDet;
  m[A42] =  Det5_01345_01235*oneOverDet;
  m[A43] =  Det5_01245_01235*mn1OverDet;
  m[A44] =  Det5_01235_01235*oneOverDet;
  m[A45] =  Det5_01234_01235*mn1OverDet;

  m[A50] =  Det5_12345_01234*mn1OverDet;
  m[A51] =  Det5_02345_01234*oneOverDet;
  m[A52] =  Det5_01345_01234*mn1OverDet;
  m[A53] =  Det5_01245_01234*oneOverDet;
  m[A54] =  Det5_01235_01234*mn1OverDet;
  m[A55] =  Det5_01234_01234*oneOverDet;

  return;
}

Here is the caller graph for this function:

num_col()

virtual G4int G4ErrorMatrix::num_col ( ) const

inlinevirtual

Here is the caller graph for this function:

num_row()

virtual G4int G4ErrorMatrix::num_row ( ) const

inlinevirtual

Here is the caller graph for this function:

num_size()

virtual G4int G4ErrorMatrix::num_size ( ) const

inlineprotectedvirtual

operator()() [1/2]

virtual const G4double& G4ErrorMatrix::operator() ( G4int  row, G4int  col  ) const

inlinevirtual

operator()() [2/2]

virtual G4double& G4ErrorMatrix::operator() ( G4int  row, G4int  col  )

inlinevirtual

operator*=()

G4ErrorMatrix & G4ErrorMatrix::operator*=

(

G4double

t

)

Definition at line 326 of file G4ErrorMatrix.cc.

{
  SIMPLE_UOP(*=)
  return (*this);
}

operator+=() [1/2]

G4ErrorMatrix & G4ErrorMatrix::operator+=

(

const G4ErrorMatrix &

m2

)

Definition at line 306 of file G4ErrorMatrix.cc.

{
  CHK_DIM_2(num_row(),mat2.num_row(),num_col(),mat2.num_col(),+=);
  SIMPLE_BOP(+=)
  return (*this);
}

Here is the call graph for this function:

operator+=() [2/2]

G4ErrorMatrix & G4ErrorMatrix::operator+=

(

const G4ErrorSymMatrix &

m2

)

Definition at line 402 of file G4ErrorSymMatrix.cc.

{
  CHK_DIM_2(num_row(),mat2.num_row(),num_col(),mat2.num_col(),+=);
  G4int n = num_col();
  G4ErrorMatrixConstIter sjk = mat2.m.begin();
  G4ErrorMatrixIter m1j = m.begin();
  G4ErrorMatrixIter mj = m.begin();
  // j >= k
  for(G4int j=1;j<=num_row();j++)
  {
    G4ErrorMatrixIter mjk = mj;
    G4ErrorMatrixIter mkj = m1j;
    for(G4int k=1;k<=j;k++)
    {
      *(mjk++) += *sjk;
      if(j!=k) *mkj += *sjk;
      sjk++;
      mkj += n;
    }
    mj += n;
    m1j++;
  }
  return (*this);
}

Here is the call graph for this function:

operator-()

G4ErrorMatrix G4ErrorMatrix::operator-

(

)

const

Definition at line 215 of file G4ErrorMatrix.cc.

{
   G4ErrorMatrix mat2(nrow, ncol);
   G4ErrorMatrixConstIter a=m.begin();
   G4ErrorMatrixIter b=mat2.m.begin();
   G4ErrorMatrixConstIter e=m.end();
   for(;a<e; a++, b++) (*b) = -(*a);
   return mat2;
}

operator-=() [1/2]

G4ErrorMatrix & G4ErrorMatrix::operator-=

(

const G4ErrorMatrix &

m2

)

Definition at line 313 of file G4ErrorMatrix.cc.

{
  CHK_DIM_2(num_row(),mat2.num_row(),num_col(),mat2.num_col(),-=);
  SIMPLE_BOP(-=)
  return (*this);
}

Here is the call graph for this function:

operator-=() [2/2]

G4ErrorMatrix & G4ErrorMatrix::operator-=

(

const G4ErrorSymMatrix &

m2

)

Definition at line 434 of file G4ErrorSymMatrix.cc.

{
  CHK_DIM_2(num_row(),mat2.num_row(),num_col(),mat2.num_col(),-=);
  G4int n = num_col();
  G4ErrorMatrixConstIter sjk = mat2.m.begin();
  G4ErrorMatrixIter m1j = m.begin();
  G4ErrorMatrixIter mj = m.begin();
  // j >= k
  for(G4int j=1;j<=num_row();j++)
  {
    G4ErrorMatrixIter mjk = mj;
    G4ErrorMatrixIter mkj = m1j;
    for(G4int k=1;k<=j;k++)
    {
      *(mjk++) -= *sjk;
      if(j!=k) *mkj -= *sjk;
      sjk++;
      mkj += n;
    }
    mj += n;
    m1j++;
  }
  return (*this);
}

Here is the call graph for this function:

operator/=()

G4ErrorMatrix & G4ErrorMatrix::operator/=

(

G4double

t

)

Definition at line 320 of file G4ErrorMatrix.cc.

{
  SIMPLE_UOP(/=)
  return (*this);
}

operator=() [1/2]

G4ErrorMatrix & G4ErrorMatrix::operator=

(

const G4ErrorMatrix &

m2

)

Definition at line 332 of file G4ErrorMatrix.cc.

{
   if (&mat1 == this) { return *this; }

   if(mat1.nrow*mat1.ncol != size) //??fixme?? mat1.size != size
   {
      size = mat1.nrow * mat1.ncol;
      m.resize(size); //??fixme?? if (size < mat1.size) m.resize(mat1.size);
   }
   nrow = mat1.nrow;
   ncol = mat1.ncol;
   m = mat1.m;
   return (*this);
}

operator=() [2/2]

G4ErrorMatrix & G4ErrorMatrix::operator=

(

const G4ErrorSymMatrix &

m2

)

Definition at line 478 of file G4ErrorSymMatrix.cc.

{
   if(mat1.nrow*mat1.nrow != size)
   {
      size = mat1.nrow * mat1.nrow;
      m.resize(size);
   }
   nrow = mat1.nrow;
   ncol = mat1.nrow;
   G4int n = ncol;
   G4ErrorMatrixConstIter sjk = mat1.m.begin();
   G4ErrorMatrixIter m1j = m.begin();
   G4ErrorMatrixIter mj = m.begin();
   // j >= k
   for(G4int j=1;j<=num_row();j++)
   {
      G4ErrorMatrixIter mjk = mj;
      G4ErrorMatrixIter mkj = m1j;
      for(G4int k=1;k<=j;k++)
      {
         *(mjk++) = *sjk;
         if(j!=k) *mkj = *sjk;
         sjk++;
         mkj += n;
      }
      mj += n;
      m1j++;
   }
   return (*this);
}

Here is the call graph for this function:

operator[]() [1/2]

G4ErrorMatrix_row G4ErrorMatrix::operator[] ( G4int  )

inline

operator[]() [2/2]

const G4ErrorMatrix_row_const G4ErrorMatrix::operator[] ( G4int  ) const

inline

sub() [1/2]

G4ErrorMatrix G4ErrorMatrix::sub	(	G4int	min_row,
		G4int	max_row,
		G4int	min_col,
		G4int	max_col
	)		const

Definition at line 155 of file G4ErrorMatrix.cc.

{
  G4ErrorMatrix mret(max_row-min_row+1,max_col-min_col+1);
  if(max_row > num_row() || max_col >num_col())
    { error("G4ErrorMatrix::sub: Index out of range"); }
  G4ErrorMatrixIter a = mret.m.begin();
  G4int nc = num_col();
  G4ErrorMatrixConstIter b1 = m.begin() + (min_row - 1) * nc + min_col - 1;
  
  for(G4int irow=1; irow<=mret.num_row(); irow++)
  {
    G4ErrorMatrixConstIter brc = b1;
    for(G4int icol=1; icol<=mret.num_col(); icol++)
    {
      *(a++) = *(brc++);
    }
    b1 += nc;
  }
  return mret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sub() [2/2]

void G4ErrorMatrix::sub	(	G4int	row,
		G4int	col,
		const G4ErrorMatrix &	m1
	)

Definition at line 177 of file G4ErrorMatrix.cc.

{
  if(row <1 || row+mat1.num_row()-1 > num_row() || 
     col <1 || col+mat1.num_col()-1 > num_col()   )
    { error("G4ErrorMatrix::sub: Index out of range"); }
  G4ErrorMatrixConstIter a = mat1.m.begin();
  G4int nc = num_col();
  G4ErrorMatrixIter b1 = m.begin() + (row - 1) * nc + col - 1;
  
  for(G4int irow=1; irow<=mat1.num_row(); irow++)
  {
    G4ErrorMatrixIter brc = b1;
    for(G4int icol=1; icol<=mat1.num_col(); icol++)
    {
      *(brc++) = *(a++);
    }
    b1 += nc;
  }
}

Here is the call graph for this function:

T()

G4ErrorMatrix G4ErrorMatrix::T

(

)

const

Definition at line 374 of file G4ErrorMatrix.cc.

{
   G4ErrorMatrix mret(ncol,nrow);
    G4ErrorMatrixConstIter pl = m.end();
    G4ErrorMatrixConstIter pme = m.begin();
    G4ErrorMatrixIter pt = mret.m.begin();
    G4ErrorMatrixIter ptl = mret.m.end();
   for (; pme < pl; pme++, pt+=nrow)
   {
      if (pt >= ptl) { pt -= (size-1); }
      (*pt) = (*pme);
   }
   return mret;
}

Here is the caller graph for this function:

trace()

G4double G4ErrorMatrix::trace

(

)

const

Definition at line 795 of file G4ErrorMatrix.cc.

{
  G4double t = 0.0;
  for (G4ErrorMatrixConstIter d = m.begin(); d < m.end(); d += (ncol+1) )
  {
    t += *d;
  }
  return t;
}

Friends And Related Function Documentation

back_solve

void back_solve ( const G4ErrorMatrix &  R, G4ErrorMatrix *  b  )

friend

col_givens

void col_givens ( G4ErrorMatrix *  A, G4double  c, G4double  s, G4int  k1, G4int  k2, G4int  rowmin, G4int  rowmax  )

friend

col_house

void col_house ( G4ErrorMatrix *  , const G4ErrorMatrix &  , G4double  , G4int  , G4int  , G4int  , G4int    )

friend

G4ErrorMatrix_row

friend class G4ErrorMatrix_row

friend

Definition at line 174 of file G4ErrorMatrix.hh.

G4ErrorMatrix_row_const

friend class G4ErrorMatrix_row_const

friend

Definition at line 175 of file G4ErrorMatrix.hh.

G4ErrorSymMatrix

friend class G4ErrorSymMatrix

friend

Definition at line 176 of file G4ErrorMatrix.hh.

house_with_update [1/2]

void house_with_update ( G4ErrorMatrix *  a, G4int  row, G4int  col  )

friend

house_with_update [2/2]

void house_with_update ( G4ErrorMatrix *  a, G4ErrorMatrix *  v, G4int  row, G4int  col  )

friend

house_with_update2

void house_with_update2 ( G4ErrorSymMatrix *  a, G4ErrorMatrix *  v, G4int  row, G4int  col  )

friend

operator* [1/4]

G4ErrorMatrix operator* ( const G4ErrorMatrix &  m1, const G4ErrorMatrix &  m2  )

friend

Definition at line 272 of file G4ErrorMatrix.cc.

{
  // initialize matrix to 0.0
  G4ErrorMatrix mret(mat1.nrow,mat2.ncol,0);
  CHK_DIM_1(mat1.ncol,mat2.nrow,*);

  G4int m1cols = mat1.ncol;
  G4int m2cols = mat2.ncol;

  for (G4int i=0; i<mat1.nrow; i++)
  {
     for (G4int j=0; j<m1cols; j++) 
     {
         G4double temp = mat1.m[i*m1cols+j];
         G4ErrorMatrixIter pt = mret.m.begin() + i*m2cols;

        // Loop over k (the column index in matrix mat2)
        G4ErrorMatrixConstIter pb = mat2.m.begin() + m2cols*j;
        const G4ErrorMatrixConstIter pblast = pb + m2cols;
        while (pb < pblast)  // Loop checking, 06.08.2015, G.Cosmo
        {
           (*pt) += temp * (*pb);
           pb++;
           pt++;
        }
     }
  }
  return mret;
}

operator* [2/4]

G4ErrorMatrix operator* ( const G4ErrorMatrix &  m1, const G4ErrorSymMatrix &  m2  )

friend

Definition at line 287 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat1.num_row(),mat2.num_col());
  CHK_DIM_1(mat1.num_col(),mat2.num_row(),*);
  G4ErrorMatrixConstIter mit1, mit2, sp,snp; //mit2=0
  G4double temp;
  G4ErrorMatrixIter mir=mret.m.begin();
  for(mit1=mat1.m.begin();
      mit1<mat1.m.begin()+mat1.num_row()*mat1.num_col();
      mit1 = mit2)
    {
      snp=mat2.m.begin();
      for(int step=1;step<=mat2.num_row();++step)
        {
            mit2=mit1;
            sp=snp;
            snp+=step;
            temp=0;
            while(sp<snp)  // Loop checking, 06.08.2015, G.Cosmo
            {  temp+=*(sp++)*(*(mit2++));  }
            if( step<mat2.num_row() ) { // only if we aren't on the last row
                sp+=step-1;
                for(int stept=step+1;stept<=mat2.num_row();stept++)
                {
                   temp+=*sp*(*(mit2++));
                   if(stept<mat2.num_row()) sp+=stept;
                }
            }   // if(step
            *(mir++)=temp;
        }   // for(step
    }   // for(mit1
  return mret;
}

operator* [3/4]

G4ErrorMatrix operator* ( const G4ErrorSymMatrix &  m1, const G4ErrorMatrix &  m2  )

friend

Definition at line 321 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat1.num_row(),mat2.num_col());
  CHK_DIM_1(mat1.num_col(),mat2.num_row(),*);
  G4int step,stept;
  G4ErrorMatrixConstIter mit1,mit2,sp,snp;
  G4double temp;
  G4ErrorMatrixIter mir=mret.m.begin();
  for(step=1,snp=mat1.m.begin();step<=mat1.num_row();snp+=step++)
  {
    for(mit1=mat2.m.begin();mit1<mat2.m.begin()+mat2.num_col();mit1++)
    {
      mit2=mit1;
      sp=snp;
      temp=0;
      while(sp<snp+step)  // Loop checking, 06.08.2015, G.Cosmo
      {
        temp+=*mit2*(*(sp++));
        mit2+=mat2.num_col();
      }
      sp+=step-1;
      for(stept=step+1;stept<=mat1.num_row();stept++)
      {
        temp+=*mit2*(*sp);
        mit2+=mat2.num_col();
        sp+=stept;
      }
      *(mir++)=temp;
    }
  }
  return mret;
}

operator* [4/4]

G4ErrorMatrix operator* ( const G4ErrorSymMatrix &  m1, const G4ErrorSymMatrix &  m2  )

friend

Definition at line 354 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat1.num_row(),mat1.num_row());
  CHK_DIM_1(mat1.num_col(),mat2.num_row(),*);
  G4int step1,stept1,step2,stept2;
  G4ErrorMatrixConstIter snp1,sp1,snp2,sp2;
  G4double temp;
  G4ErrorMatrixIter mr = mret.m.begin();
  for(step1=1,snp1=mat1.m.begin();step1<=mat1.num_row();snp1+=step1++)
  {
    for(step2=1,snp2=mat2.m.begin();step2<=mat2.num_row();)
    {
      sp1=snp1;
      sp2=snp2;
      snp2+=step2;
      temp=0;
      if(step1<step2)
      {
        while(sp1<snp1+step1)  // Loop checking, 06.08.2015, G.Cosmo
          { temp+=(*(sp1++))*(*(sp2++)); }
        sp1+=step1-1;
        for(stept1=step1+1;stept1!=step2+1;sp1+=stept1++)
          { temp+=(*sp1)*(*(sp2++)); }
        sp2+=step2-1;
        for(stept2=++step2;stept2<=mat2.num_row();sp1+=stept1++,sp2+=stept2++)
          { temp+=(*sp1)*(*sp2); }
      }
      else
      {
        while(sp2<snp2)  // Loop checking, 06.08.2015, G.Cosmo
          { temp+=(*(sp1++))*(*(sp2++)); }
        sp2+=step2-1;
        for(stept2=++step2;stept2!=step1+1;sp2+=stept2++)
          { temp+=(*(sp1++))*(*sp2); }
        sp1+=step1-1;
        for(stept1=step1+1;stept1<=mat1.num_row();sp1+=stept1++,sp2+=stept2++)
          { temp+=(*sp1)*(*sp2); }
      }
      *(mr++)=temp;
    }
  }
  return mret;
}

operator+

G4ErrorMatrix operator+ ( const G4ErrorMatrix &  m1, const G4ErrorMatrix &  m2  )

friend

Definition at line 225 of file G4ErrorMatrix.cc.

{
  G4ErrorMatrix mret(mat1.nrow, mat1.ncol);
  CHK_DIM_2(mat1.num_row(),mat2.num_row(), mat1.num_col(),mat2.num_col(),+);
  SIMPLE_TOP(+)
  return mret;
}

operator-

G4ErrorMatrix operator- ( const G4ErrorMatrix &  m1, const G4ErrorMatrix &  m2  )

friend

Definition at line 237 of file G4ErrorMatrix.cc.

{
  G4ErrorMatrix mret(mat1.num_row(), mat1.num_col());
  CHK_DIM_2(mat1.num_row(),mat2.num_row(),
                         mat1.num_col(),mat2.num_col(),-);
  SIMPLE_TOP(-)
  return mret;
}

qr_solve

G4ErrorMatrix qr_solve ( G4ErrorMatrix *  , const G4ErrorMatrix &  b  )

friend

row_givens

void row_givens ( G4ErrorMatrix *  A, G4double  c, G4double  s, G4int  k1, G4int  k2, G4int  colmin, G4int  colmax  )

friend

row_house

void row_house ( G4ErrorMatrix *  , const G4ErrorMatrix &  , G4double  , G4int  , G4int  , G4int  , G4int    )

friend

tridiagonal

void tridiagonal ( G4ErrorSymMatrix *  a, G4ErrorMatrix *  hsm  )

friend

Member Data Documentation

m

std::vector<G4double > G4ErrorMatrix::m

private

Definition at line 224 of file G4ErrorMatrix.hh.

ncol

G4int G4ErrorMatrix::ncol

private

Definition at line 226 of file G4ErrorMatrix.hh.

nrow

G4int G4ErrorMatrix::nrow

private

Definition at line 226 of file G4ErrorMatrix.hh.

size

G4int G4ErrorMatrix::size

private

Definition at line 227 of file G4ErrorMatrix.hh.

---

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

• G4ErrorMatrix.hh
• G4ErrorMatrix.cc
• G4ErrorSymMatrix.cc