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 G4BiasingProcessInterface::AtRestGetPhysicalInteractionLength(), G4AntiNeutronAnnihilationAtRest::AtRestGetPhysicalInteractionLength(), G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4FastSimulationManagerProcess::AtRestGetPhysicalInteractionLength(), G4ParallelWorldProcess::AtRestGetPhysicalInteractionLength(), G4ParallelWorldScoringProcess::AtRestGetPhysicalInteractionLength(), G4ScoreSplittingProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4AdjointProcessEquivalentToDirectProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4HadronStoppingProcess::AtRestGetPhysicalInteractionLength(), G4MuonMinusAtomicCapture::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4WrapperProcess::AtRestGetPhysicalInteractionLength(), G4Decay::AtRestGetPhysicalInteractionLength(), G4DNAMolecularDissociation::AtRestGetPhysicalInteractionLength(), G4eplusAnnihilation::AtRestGetPhysicalInteractionLength(), G4VProcess::AtRestGPIL(), G4BOptnCloning::DistanceToApplyOperation(), G4Channeling::GetMeanFreePath(), G4PhononDownconversion::GetMeanFreePath(), G4PhononReflection::GetMeanFreePath(), G4PhononScattering::GetMeanFreePath(), G4MicroElecSurface::GetMeanFreePath(), G4ForwardXrayTR::GetMeanFreePath(), G4TransitionRadiation::GetMeanFreePath(), G4OpBoundaryProcess::GetMeanFreePath(), G4PolarizedCompton::GetMeanFreePath(), G4VXTRenergyLoss::GetMeanFreePath(), G4Scintillation::GetMeanFreePath(), G4UCNBoundaryProcess::GetMeanFreePath(), G4hImpactIonisation::GetMeanFreePath(), G4VAdjointReverseReaction::GetMeanFreePath(), G4GammaGeneralProcess::GetMeanFreePath(), G4eplusPolarizedAnnihilation::GetMeanFreePath(), G4VEmProcess::GetMeanFreePath(), G4VEnergyLossProcess::GetMeanFreePath(), G4SynchrotronRadiation::GetMeanFreePath(), G4SynchrotronRadiationInMat::GetMeanFreePath(), G4VMultipleScattering::GetMeanFreePath(), G4VTransitionRadiation::GetMeanFreePath(), G4Scintillation::GetMeanLifeTime(), G4VMultipleScattering::PostStepGetPhysicalInteractionLength(), G4ParallelGeometriesLimiterProcess::PostStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::PostStepGetPhysicalInteractionLength(), G4ImportanceProcess::PostStepGetPhysicalInteractionLength(), G4WeightCutOffProcess::PostStepGetPhysicalInteractionLength(), G4WeightWindowProcess::PostStepGetPhysicalInteractionLength(), G4Cerenkov::PostStepGetPhysicalInteractionLength(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), G4ErrorStepLengthLimitProcess::PostStepGetPhysicalInteractionLength(), G4ErrorTrackLengthTarget::PostStepGetPhysicalInteractionLength(), G4MaxTimeCuts::PostStepGetPhysicalInteractionLength(), G4MinEkineCuts::PostStepGetPhysicalInteractionLength(), G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4AdjointProcessEquivalentToDirectProcess::PostStepGetPhysicalInteractionLength(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4HadronStoppingProcess::PostStepGetPhysicalInteractionLength(), G4MuonicAtomDecay::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4WrapperProcess::PostStepGetPhysicalInteractionLength(), G4FastSimulationManagerProcess::PostStepGetPhysicalInteractionLength(), G4ParallelWorldScoringProcess::PostStepGetPhysicalInteractionLength(), G4ScoreSplittingProcess::PostStepGetPhysicalInteractionLength(), G4NeutronKiller::PostStepGetPhysicalInteractionLength(), G4StepLimiter::PostStepGetPhysicalInteractionLength(), G4UserSpecialCuts::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4UnknownDecay::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4eplusPolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4LowECapture::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 182 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 286 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 320 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 353 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 272 of file G4ErrorSymMatrix.cc.

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

operator*() [5/5]

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

Definition at line 279 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 206 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 214 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 222 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 235 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 243 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 251 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 265 of file G4ErrorSymMatrix.cc.

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

operator<<()

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

Definition at line 523 of file G4ErrorSymMatrix.cc.

{
  os << G4endl;
 
  // Fixed format needs 3 extra characters for field,
  // while scientific needs 7
 
  G4int 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
	)