G4AnalyticalPolSolver Class Reference

#include <G4AnalyticalPolSolver.hh>

Public Member Functions
	G4AnalyticalPolSolver ()
	~G4AnalyticalPolSolver ()
G4int	QuadRoots (G4double p[5], G4double r[3][5])
G4int	CubicRoots (G4double p[5], G4double r[3][5])
G4int	BiquadRoots (G4double p[5], G4double r[3][5])
G4int	QuarticRoots (G4double p[5], G4double r[3][5])

Detailed Description

Definition at line 64 of file G4AnalyticalPolSolver.hh.

Constructor & Destructor Documentation

G4AnalyticalPolSolver::G4AnalyticalPolSolver

(

)

Definition at line 37 of file G4AnalyticalPolSolver.cc.

{;}

G4AnalyticalPolSolver::~G4AnalyticalPolSolver

(

)

Definition at line 41 of file G4AnalyticalPolSolver.cc.

{;}

Member Function Documentation

G4int G4AnalyticalPolSolver::BiquadRoots	(	G4double	p[5],
		G4double	r[3][5]
	)

Definition at line 172 of file G4AnalyticalPolSolver.cc.

{
  G4double a, b, c, d, e;
  G4int i, k, j;

  if(p[0] != 1.0)
  {
    for( k = 1; k < 5; k++) { p[k] = p[k]/p[0]; }
    p[0] = 1.;
  }
  e = 0.25*p[1];
  b = 2*e;
  c = b*b;
  d = 0.75*c;
  b = p[3] + b*( c - p[2] );
  a = p[2] - d;
  c = p[4] + e*( e*a - p[3] );
  a = a - d;

  p[1] = 0.5*a;
  p[2] = (p[1]*p[1]-c)*0.25;
  p[3] = b*b/(-64.0);

  if( p[3] < 0. )
  {
    CubicRoots(p,r);

    for( k = 1; k < 4; k++ )
    {
      if( r[2][k] == 0. && r[1][k] > 0 )
      {
        d = r[1][k]*4; 
        a = a + d;

        if     ( a >= 0. && b >= 0.) { p[1] =  std::sqrt(d); }
        else if( a <= 0. && b <= 0.) { p[1] =  std::sqrt(d); }
        else                         { p[1] = -std::sqrt(d); }

        b = 0.5*( a + b/p[1] );

        p[2]    = c/b; 
        QuadRoots(p,r);

        for( i = 1; i < 3; i++ )
        {
          for( j = 1; j < 3; j++ ) { r[j][i+2] = r[j][i]; }
        }
        p[1]    = -p[1]; 
        p[2]    =  b; 
        QuadRoots(p,r);

        for( i = 1; i < 5; i++ ) { r[1][i] = r[1][i] - e; }

        return 4;
      }
    }
  }
  if( p[2] < 0. )
  {
    b    = std::sqrt(c); 
    d    = b + b - a;
    p[1] = 0.; 
    
    if( d > 0. ) { p[1] = std::sqrt(d); }
  }
  else
  {
    if( p[1] > 0.) { b =  std::sqrt(p[2])*2.0 + p[1]; }
    else           { b = -std::sqrt(p[2])*2.0 + p[1]; }

    if( b != 0.) { p[1] = 0; }
    else
    {
      for(k = 1; k < 5; k++ )
      {
          r[1][k] = -e;
          r[2][k] =  0;
      }
      return 0;
    }
  }

  p[2]    = c/b; 
  QuadRoots(p,r);

  for( k = 1; k < 3; k++ )
  {
    for( j = 1; j < 3; j++ ) { r[j][k+2] = r[j][k]; }
  }
  p[1]    = -p[1]; 
  p[2]    =  b; 
  QuadRoots(p,r);

  for( k = 1; k < 5; k++ ) { r[1][k] = r[1][k] - e; }

  return 4;
}

Here is the call graph for this function:

G4int G4AnalyticalPolSolver::CubicRoots	(	G4double	p[5],
		G4double	r[3][5]
	)

Definition at line 85 of file G4AnalyticalPolSolver.cc.

{
  G4double x,t,b,c,d;
  G4int k;

  if( p[0] != 1. )
  {
    for(k = 1; k < 4; k++ ) { p[k] = p[k]/p[0]; }
    p[0] = 1.;
  }
  x = p[1]/3.0; 
  t = x*p[1];
  b = 0.5*( x*( t/1.5 - p[2] ) + p[3] ); 
  t = ( t - p[2] )/3.0;
  c = t*t*t; 
  d = b*b - c;

  if( d >= 0. )
  {
    d = std::pow( (std::sqrt(d) + std::fabs(b) ), 1.0/3.0 );
    
    if( d != 0. )
    {
       if( b > 0. ) { b = -d; }
       else         { b =  d; }
       c =  t/b;
    }
    d       =  std::sqrt(0.75)*(b - c); 
    r[2][2] =  d; 
    b       =  b + c;
    c       = -0.5*b-x;
    r[1][2] =  c;

    if( ( b > 0. &&  x <= 0. ) || ( b < 0. && x > 0. ) )
    {
       r[1][1] =  c; 
       r[2][1] = -d; 
       r[1][3] =  b - x;
       r[2][3] =  0;
    }
    else
    {
       r[1][1] =  b - x; 
       r[2][1] =  0.; 
       r[1][3] =  c;
       r[2][3] = -d;
    }
  }              // end of 2 equal or complex roots 
  else
  {
    if( b == 0. ) { d =  std::atan(1.0)/1.5; }
    else          { d =  std::atan( std::sqrt(-d)/std::fabs(b) )/3.0; }

    if( b < 0. )  { b =  std::sqrt(t)*2.0; }
    else          { b = -2.0*std::sqrt(t); }

    c =  std::cos(d)*b; 
    t = -std::sqrt(0.75)*std::sin(d)*b - 0.5*c;
    d = -t - c - x; 
    c =  c - x; 
    t =  t - x;

    if( std::fabs(c) > std::fabs(t) ) { r[1][3] = c; }
    else
    {
      r[1][3] = t; 
      t       = c;
    }
    if( std::fabs(d) > std::fabs(t) ) { r[1][2] = d; }
    else
    {
      r[1][2] = t; 
      t       = d;
    }
    r[1][1] = t;

    for(k = 1; k < 4; k++ ) { r[2][k] = 0.; }
  }
  return 0;
}

Here is the caller graph for this function:

G4int G4AnalyticalPolSolver::QuadRoots	(	G4double	p[5],
		G4double	r[3][5]
	)

Definition at line 50 of file G4AnalyticalPolSolver.cc.

{
  G4double b, c, d2, d;

  b  = -p[1]/p[0]/2.;
  c  =  p[2]/p[0];
  d2 =  b*b - c;
  
  if( d2 >= 0. )
  {
    d       = std::sqrt(d2);
    r[1][1] = b - d;   
    r[1][2] = b + d;   
    r[2][1] = 0.; 
    r[2][2] = 0.;
  }
  else
  {
    d       = std::sqrt(-d2);
    r[2][1] =  d; 
    r[2][2] = -d;
    r[1][1] =  b; 
    r[1][2] =  b;
  }

  return 2;
}

Here is the caller graph for this function:

G4int G4AnalyticalPolSolver::QuarticRoots	(	G4double	p[5],
		G4double	r[3][5]
	)

Definition at line 272 of file G4AnalyticalPolSolver.cc.

{
  G4double a0, a1, a2, a3, y1;
  G4double R2, D2, E2, D, E, R = 0.;
  G4double a, b, c, d, ds;

  G4double reRoot[4];
  G4int k, noReRoots = 0;
  
  for( k = 0; k < 4; k++ ) { reRoot[k] = DBL_MAX; }

  if( p[0] != 1.0 )
  {
    for( k = 1; k < 5; k++) { p[k] = p[k]/p[0]; }
    p[0] = 1.;
  }
  a3 = p[1];
  a2 = p[2];
  a1 = p[3];
  a0 = p[4];

  // resolvent cubic equation cofs:

  p[1] = -a2;
  p[2] = a1*a3 - 4*a0;
  p[3] = 4*a2*a0 - a1*a1 - a3*a3*a0;

  CubicRoots(p,r);

  for( k = 1; k < 4; k++ )
  {
    if( r[2][k] == 0. ) // find a real root
    {
      noReRoots++;
      reRoot[k] = r[1][k];
    }
    else reRoot[k] = DBL_MAX; // kInfinity;
  }
  y1 = DBL_MAX; // kInfinity;  
  for( k = 1; k < 4; k++ )
  {
    if ( reRoot[k] < y1 ) { y1 = reRoot[k]; }
  }

  R2 = 0.25*a3*a3 - a2 + y1;
  b  = 0.25*(4*a3*a2 - 8*a1 - a3*a3*a3);
  c  = 0.75*a3*a3 - 2*a2;
  a  = c - R2;
  d  = 4*y1*y1 - 16*a0;

  if( R2 > 0.)
  {
    R = std::sqrt(R2);
    D2 = a + b/R;
    E2 = a - b/R;

    if( D2 >= 0. )
    {
      D       = std::sqrt(D2);
      r[1][1] = -0.25*a3 + 0.5*R + 0.5*D;
      r[1][2] = -0.25*a3 + 0.5*R - 0.5*D;
      r[2][1] = 0.;
      r[2][2] = 0.;
    }
    else
    {
      D       = std::sqrt(-D2);
      r[1][1] = -0.25*a3 + 0.5*R;
      r[1][2] = -0.25*a3 + 0.5*R;
      r[2][1] =  0.5*D;
      r[2][2] = -0.5*D;
    }
    if( E2 >= 0. )
    {
      E       = std::sqrt(E2);
      r[1][3] = -0.25*a3 - 0.5*R + 0.5*E;
      r[1][4] = -0.25*a3 - 0.5*R - 0.5*E;
      r[2][3] = 0.;
      r[2][4] = 0.;
    }
    else
    {
      E       = std::sqrt(-E2);
      r[1][3] = -0.25*a3 - 0.5*R;
      r[1][4] = -0.25*a3 - 0.5*R;
      r[2][3] =  0.5*E;
      r[2][4] = -0.5*E;
    }
  }
  else if( R2 < 0.)
  {
    R = std::sqrt(-R2);
    G4complex CD2(a,-b/R);
    G4complex CD = std::sqrt(CD2);

    r[1][1] = -0.25*a3 + 0.5*real(CD);
    r[1][2] = -0.25*a3 - 0.5*real(CD);
    r[2][1] =  0.5*R + 0.5*imag(CD);
    r[2][2] =  0.5*R - 0.5*imag(CD);
    G4complex CE2(a,b/R);
    G4complex CE = std::sqrt(CE2);

    r[1][3] = -0.25*a3 + 0.5*real(CE);
    r[1][4] = -0.25*a3 - 0.5*real(CE);
    r[2][3] =  -0.5*R + 0.5*imag(CE);
    r[2][4] =  -0.5*R - 0.5*imag(CE);
  }
  else // R2=0 case
  {
    if(d >= 0.)
    {
      D2 = c + std::sqrt(d);
      E2 = c - std::sqrt(d);

      if( D2 >= 0. )
      {
        D       = std::sqrt(D2);
        r[1][1] = -0.25*a3 + 0.5*R + 0.5*D;
        r[1][2] = -0.25*a3 + 0.5*R - 0.5*D;
        r[2][1] = 0.;
        r[2][2] = 0.;
      }
      else
      {
        D       = std::sqrt(-D2);
        r[1][1] = -0.25*a3 + 0.5*R;
        r[1][2] = -0.25*a3 + 0.5*R;
        r[2][1] =  0.5*D;
        r[2][2] = -0.5*D;
      }
      if( E2 >= 0. )
      {
        E       = std::sqrt(E2);
        r[1][3] = -0.25*a3 - 0.5*R + 0.5*E;
        r[1][4] = -0.25*a3 - 0.5*R - 0.5*E;
        r[2][3] = 0.;
        r[2][4] = 0.;
      }
      else
      {
        E       = std::sqrt(-E2);
        r[1][3] = -0.25*a3 - 0.5*R;
        r[1][4] = -0.25*a3 - 0.5*R;
        r[2][3] =  0.5*E;
        r[2][4] = -0.5*E;
      }
    }
    else
    {
      ds = std::sqrt(-d);
      G4complex CD2(c,ds);
      G4complex CD = std::sqrt(CD2);

      r[1][1] = -0.25*a3 + 0.5*real(CD);
      r[1][2] = -0.25*a3 - 0.5*real(CD);
      r[2][1] =  0.5*R + 0.5*imag(CD);
      r[2][2] =  0.5*R - 0.5*imag(CD);

      G4complex CE2(c,-ds);
      G4complex CE = std::sqrt(CE2);

      r[1][3] = -0.25*a3 + 0.5*real(CE);
      r[1][4] = -0.25*a3 - 0.5*real(CE);
      r[2][3] =  -0.5*R + 0.5*imag(CE);
      r[2][4] =  -0.5*R - 0.5*imag(CE);
    }  
  }
  return 4;
}

Here is the call graph for this function:

---

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

• geant4.10.03.p01/source/global/HEPNumerics/include/G4AnalyticalPolSolver.hh
• geant4.10.03.p01/source/global/HEPNumerics/src/G4AnalyticalPolSolver.cc