G4ErrorSymMatrix.hh File Reference

#include <vector>
#include "globals.hh"
#include "G4ErrorSymMatrix.icc"

Go to the source code of this file.

Classes
class	G4ErrorSymMatrix
class	G4ErrorSymMatrix::G4ErrorSymMatrix_row
class	G4ErrorSymMatrix::G4ErrorSymMatrix_row_const

Functions
std::ostream &	operator<< (std::ostream &s, const G4ErrorSymMatrix &q)
G4ErrorMatrix	operator* (const G4ErrorMatrix &m1, const G4ErrorSymMatrix &m2)
G4ErrorMatrix	operator* (const G4ErrorSymMatrix &m1, const G4ErrorMatrix &m2)
G4ErrorMatrix	operator* (const G4ErrorSymMatrix &m1, const G4ErrorSymMatrix &m2)
G4ErrorSymMatrix	operator* (G4double t, const G4ErrorSymMatrix &s1)
G4ErrorSymMatrix	operator* (const G4ErrorSymMatrix &s1, G4double t)
G4ErrorSymMatrix	operator/ (const G4ErrorSymMatrix &m1, G4double t)
G4ErrorMatrix	operator+ (const G4ErrorMatrix &m1, const G4ErrorSymMatrix &s2)
G4ErrorMatrix	operator+ (const G4ErrorSymMatrix &s1, const G4ErrorMatrix &m2)
G4ErrorSymMatrix	operator+ (const G4ErrorSymMatrix &s1, const G4ErrorSymMatrix &s2)
G4ErrorMatrix	operator- (const G4ErrorMatrix &m1, const G4ErrorSymMatrix &s2)
G4ErrorMatrix	operator- (const G4ErrorSymMatrix &m1, const G4ErrorMatrix &m2)
G4ErrorSymMatrix	operator- (const G4ErrorSymMatrix &s1, const G4ErrorSymMatrix &s2)
G4ErrorSymMatrix	dsum (const G4ErrorSymMatrix &s1, const G4ErrorSymMatrix &s2)
G4double	condition (const G4ErrorSymMatrix &m)
void	diag_step (G4ErrorSymMatrix *t, G4int begin, G4int end)
void	diag_step (G4ErrorSymMatrix *t, G4ErrorMatrix *u, G4int begin, G4int end)
G4ErrorMatrix	diagonalize (G4ErrorSymMatrix *s)
void	house_with_update2 (G4ErrorSymMatrix *a, G4ErrorMatrix *v, G4int row=1, G4int col=1)
void	tridiagonal (G4ErrorSymMatrix *a, G4ErrorMatrix *hsm)
G4ErrorMatrix	tridiagonal (G4ErrorSymMatrix *a)

Function Documentation

condition()

G4double condition

(

const G4ErrorSymMatrix &

m

)

Referenced by G4AdjointProcessEquivalentToDirectProcess::AtRestGetPhysicalInteractionLength(), G4BiasingProcessInterface::AtRestGetPhysicalInteractionLength(), G4Decay::AtRestGetPhysicalInteractionLength(), G4DNAMolecularDissociation::AtRestGetPhysicalInteractionLength(), G4eplusAnnihilation::AtRestGetPhysicalInteractionLength(), G4FastSimulationManagerProcess::AtRestGetPhysicalInteractionLength(), G4HadronStoppingProcess::AtRestGetPhysicalInteractionLength(), G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4MuonMinusAtomicCapture::AtRestGetPhysicalInteractionLength(), G4ParallelWorldProcess::AtRestGetPhysicalInteractionLength(), G4ParallelWorldScoringProcess::AtRestGetPhysicalInteractionLength(), G4ScoreSplittingProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4WrapperProcess::AtRestGetPhysicalInteractionLength(), G4VProcess::AtRestGPIL(), G4BOptnCloning::DistanceToApplyOperation(), G4Channeling::GetMeanFreePath(), G4ForwardXrayTR::GetMeanFreePath(), G4GammaGeneralProcess::GetMeanFreePath(), G4hImpactIonisation::GetMeanFreePath(), G4MicroElecSurface::GetMeanFreePath(), G4NeutronGeneralProcess::GetMeanFreePath(), G4OpBoundaryProcess::GetMeanFreePath(), G4PhononDownconversion::GetMeanFreePath(), G4PhononReflection::GetMeanFreePath(), G4PhononScattering::GetMeanFreePath(), G4PolarizedAnnihilation::GetMeanFreePath(), G4PolarizedCompton::GetMeanFreePath(), G4Scintillation::GetMeanFreePath(), G4SynchrotronRadiation::GetMeanFreePath(), G4SynchrotronRadiationInMat::GetMeanFreePath(), G4TransitionRadiation::GetMeanFreePath(), G4UCNBoundaryProcess::GetMeanFreePath(), G4VAdjointReverseReaction::GetMeanFreePath(), G4VEmProcess::GetMeanFreePath(), G4VEnergyLossProcess::GetMeanFreePath(), G4VMultipleScattering::GetMeanFreePath(), G4VTransitionRadiation::GetMeanFreePath(), G4VXTRenergyLoss::GetMeanFreePath(), G4XrayReflection::GetMeanFreePath(), G4Scintillation::GetMeanLifeTime(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4AdjointProcessEquivalentToDirectProcess::PostStepGetPhysicalInteractionLength(), G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(), G4Cerenkov::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4ElNeutrinoNucleusProcess::PostStepGetPhysicalInteractionLength(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), G4ErrorStepLengthLimitProcess::PostStepGetPhysicalInteractionLength(), G4ErrorTrackLengthTarget::PostStepGetPhysicalInteractionLength(), G4FastSimulationManagerProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4HadronicProcess::PostStepGetPhysicalInteractionLength(), G4HadronStoppingProcess::PostStepGetPhysicalInteractionLength(), G4ImportanceProcess::PostStepGetPhysicalInteractionLength(), G4LowECapture::PostStepGetPhysicalInteractionLength(), G4MaxTimeCuts::PostStepGetPhysicalInteractionLength(), G4MinEkineCuts::PostStepGetPhysicalInteractionLength(), G4MuNeutrinoNucleusProcess::PostStepGetPhysicalInteractionLength(), G4MuonicAtomDecay::PostStepGetPhysicalInteractionLength(), G4NeutrinoElectronProcess::PostStepGetPhysicalInteractionLength(), G4NeutronGeneralProcess::PostStepGetPhysicalInteractionLength(), G4NeutronKiller::PostStepGetPhysicalInteractionLength(), G4ParallelGeometriesLimiterProcess::PostStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::PostStepGetPhysicalInteractionLength(), G4ParallelWorldScoringProcess::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4ScoreSplittingProcess::PostStepGetPhysicalInteractionLength(), G4StepLimiter::PostStepGetPhysicalInteractionLength(), G4TauNeutrinoNucleusProcess::PostStepGetPhysicalInteractionLength(), G4UnknownDecay::PostStepGetPhysicalInteractionLength(), G4UserSpecialCuts::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VMultipleScattering::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4WeightCutOffProcess::PostStepGetPhysicalInteractionLength(), G4WeightWindowProcess::PostStepGetPhysicalInteractionLength(), G4WrapperProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::PostStepGPIL().

diag_step() [1/2]

void diag_step	(	G4ErrorSymMatrix *	t,
		G4ErrorMatrix *	u,
		G4int	begin,
		G4int	end )

diag_step() [2/2]

void diag_step	(	G4ErrorSymMatrix *	t,
		G4int	begin,
		G4int	end )

diagonalize()

G4ErrorMatrix diagonalize

(

G4ErrorSymMatrix *

s

)

dsum()

G4ErrorSymMatrix dsum	(	const G4ErrorSymMatrix &	s1,
		const G4ErrorSymMatrix &	s2 )

Definition at line 195 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1.num_row() + mat2.num_row(), 0);
  mret.sub(1, mat1);
  mret.sub(mat1.num_row() + 1, mat2);
  return mret;
}

house_with_update2()

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

operator*() [1/5]

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

Definition at line 302 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*() [2/5]

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

Definition at line 339 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*() [3/5]

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

Definition at line 372 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*() [4/5]

G4ErrorSymMatrix operator*	(	const G4ErrorSymMatrix &	s1,
		G4double	t )

Definition at line 288 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1);
  mret *= t;
  return mret;
}

operator*() [5/5]

G4ErrorSymMatrix operator*	(	G4double	t,
		const G4ErrorSymMatrix &	s1 )

Definition at line 295 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1);
  mret *= t;
  return mret;
}

operator+() [1/3]

G4ErrorMatrix operator+	(	const G4ErrorMatrix &	m1,
		const G4ErrorSymMatrix &	s2 )

Definition at line 222 of file G4ErrorSymMatrix.cc.

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

operator+() [2/3]

G4ErrorMatrix operator+	(	const G4ErrorSymMatrix &	s1,
		const G4ErrorMatrix &	m2 )

Definition at line 230 of file G4ErrorSymMatrix.cc.

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

operator+() [3/3]

G4ErrorSymMatrix operator+	(	const G4ErrorSymMatrix &	s1,
		const G4ErrorSymMatrix &	s2 )

Definition at line 238 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1.nrow);
  CHK_DIM_1(mat1.nrow, mat2.nrow, +);
  SIMPLE_TOP(+)
  return mret;
}

operator-() [1/3]

G4ErrorMatrix operator-	(	const G4ErrorMatrix &	m1,
		const G4ErrorSymMatrix &	s2 )

Definition at line 251 of file G4ErrorSymMatrix.cc.

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

operator-() [2/3]

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

Definition at line 259 of file G4ErrorSymMatrix.cc.

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

operator-() [3/3]

G4ErrorSymMatrix operator-	(	const G4ErrorSymMatrix &	s1,
		const G4ErrorSymMatrix &	s2 )

Definition at line 267 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1.num_row());
  CHK_DIM_1(mat1.num_row(), mat2.num_row(), -);
  SIMPLE_TOP(-)
  return mret;
}

operator/()

G4ErrorSymMatrix operator/	(	const G4ErrorSymMatrix &	m1,
		G4double	t )

Definition at line 281 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1);
  mret /= t;
  return mret;
}

operator<<()

std::ostream & operator<<	(	std::ostream &	s,
		const G4ErrorSymMatrix &	q )

Definition at line 564 of file G4ErrorSymMatrix.cc.

{
  os << G4endl;
 
  // Fixed format needs 3 extra characters for field,
  // while scientific needs 7
 
  std::size_t width;
  if(os.flags() & std::ios::fixed)
  {
    width = os.precision() + 3;
  }
  else
  {
    width = os.precision() + 7;
  }
  for(G4int irow = 1; irow <= q.num_row(); ++irow)
  {
    for(G4int icol = 1; icol <= q.num_col(); ++icol)
    {
      os.width(width);
      os << q(irow, icol) << " ";
    }
    os << G4endl;
  }
  return os;
}

tridiagonal() [1/2]

G4ErrorMatrix tridiagonal

(

G4ErrorSymMatrix *

a

)

tridiagonal() [2/2]

void tridiagonal	(	G4ErrorSymMatrix *	a,
		G4ErrorMatrix *	hsm )