help with GetDP needed

Samuel Kvasnica kvasnica at iaee.tuwien.ac.at
Tue Nov 30 14:10:54 CET 1999


> Please send me also all included .pro files, so I'm sure to solve the
> same problem you defined.

o.k., here is it.

-------------- next part --------------
/* -------------------------------------------------------------------
   File "Jacobian_Lib.pro"

   Definition of a jacobian method
   -------------------------------------------------------------------

   I N P U T
   ---------

   GlobalGroup :
   -----------
   DomainInf                Regions with Spherical Shell Transformation

   Parameters :
   ----------
   Val_Rint, Val_Rext       Inner and outer radius of the Spherical Shell
                            of DomainInf
*/

Group {
  DefineGroup[ DomainInf ] ;
  DefineVariable[ Val_Rint, Val_Rext ] ;
}

JacobianMethod {
  { Name Vol ;
    Case { { Region DomainInf ;
             Jacobian VolSphShell {Val_Rint, Val_Rext} ; }
           { Region All ; Jacobian Vol ; }
    }
  }
}
-------------- next part --------------
/* -------------------------------------------------------------------
   File "MagSta_a_2D.pro"

    Magnetostatics - Magnetic vector potential a formulation (2D)
   -------------------------------------------------------------------

   I N P U T
   ---------

   GlobalGroup :  (Extension '_Mag' is for Magnetic problem)
   -----------
   Domain_Mag               Whole magnetic domain
   DomainS_Mag              Inductor regions (Source)

   Function :
   --------
   nu[]                     Magnetic reluctivity

   Constraint :
   ----------
   MagneticVectorPotential_2D
                            Fixed magnetic vector potential (2D)
                            (classical boundary condition)
   SourceCurrentDensityZ    Fixed source current density (in Z direction)
*/

Group {
  DefineGroup[ Domain_Mag, DomainS_Mag ] ;
}

Function {
  DefineFunction[ nu ] ;
}

FunctionSpace {

  // Magnetic vector potential a (b = curl a)
  { Name Hcurl_a_Mag_2D ; Type Form1P ;
    BasisFunction {
      // a = a  s
      //      e  e
      { Name se ; NameOfCoef ae ; Function BF_PerpendicularEdge ;
        Support Domain_Mag ; Entity NodesOf[ All ] ; }
	{Name se2; NameOfCoef ae2; Function HBF_PerpendicularEdge_2E;
	Support Domain_Mag ; Entity NodesOf[ All ]; }
}
    Constraint {
      { NameOfCoef ae ;
        Entity NodesOf UsingConstraint MagneticVectorPotential_2D ; }
      { NameOfCoef ae2 ;
        Entity NodesOf UsingConstraint MagneticVectorPotential_2D ; }
    }
  }

  // Source current density js (fully fixed space)
  { Name Hregion_j_Mag_2D ; Type Vector ;
    BasisFunction {
      { Name sr ; NameOfCoef jsr ; Function BF_RegionZ ;
        Support DomainS_Mag ; Entity DomainS_Mag ; }
    }
    Constraint {
      { NameOfCoef jsr ;
        Entity Region UsingConstraint SourceCurrentDensityZ ; }
    }
  }

}

Formulation {
  { Name Magnetostatics_a_2D ; Type FemEquation ;
    Quantity {
      { Name a  ; Type Local ; NameOfSpace Hcurl_a_Mag_2D ; }
      { Name js ; Type Local ; NameOfSpace Hregion_j_Mag_2D ; }
    }
    Equation {
      Galerkin { [ nu[] * Dof{d a} , {d a} ]  ; In Domain_Mag ;
                 Jacobian Vol ; Integration CurlCurl ; }
      Galerkin { [ - Dof{js} , {a} ] ; In DomainS_Mag ;
                 Jacobian Vol ; Integration CurlCurl ; }
    }
  }
}

Resolution {
  { Name MagSta_a_2D ;
    System {
      { Name Sys_Mag ; NameOfFormulation Magnetostatics_a_2D ; }
    }
    Operation {
      Generate Sys_Mag ; Solve Sys_Mag ; SaveSolution Sys_Mag ;
    }
  }
}

PostProcessing {
  { Name MagSta_a_2D ; NameOfFormulation Magnetostatics_a_2D ;
    PostQuantity {
      { Name a  ; Value { Term { [ {a} ]          ; In Domain_Mag ; } } }
      { Name az ; Value { Term { [ CompZ[{a}] ]   ; In Domain_Mag ; } } }
      { Name b  ; Value { Term { [ {d a} ]        ; In Domain_Mag ; } } }
      { Name h  ; Value { Term { [ nu[] * {d a} ] ; In Domain_Mag ; } } }
    }
  }
}
-------------- next part --------------
/* -------------------------------------------------------------------
   File "Integration_Lib.pro"

   Definition of integration methods
   ------------------------------------------------------------------- */

Integration {
  { Name GradGrad ;
    Case { {Type Gauss ;
            Case { { GeoElement Triangle    ; NumberOfPoints  4 ; }
                   { GeoElement Quadrangle  ; NumberOfPoints  4 ; }
                   { GeoElement Tetrahedron ; NumberOfPoints  4 ; }
                   { GeoElement Hexahedron  ; NumberOfPoints  6 ; }
                   { GeoElement Prism       ; NumberOfPoints  9 ; } }
           }
         }
  }
  { Name CurlCurl ;
    Case { {Type Gauss ;
            Case { { GeoElement Triangle    ; NumberOfPoints  4 ; }
                   { GeoElement Quadrangle  ; NumberOfPoints  4 ; }
                   { GeoElement Tetrahedron ; NumberOfPoints  4 ; }
                   { GeoElement Hexahedron  ; NumberOfPoints  6 ; }
                   { GeoElement Prism       ; NumberOfPoints  9 ; } }
           }
         }
  }
}
-------------- next part --------------
/*

Matrix_Format : 
    - 1  Sparse 
    - 2  Full 
    - default : 1

Matrix_Printing : Disk write ('fort.*') 
    - 1  matrix (csr) 
    - 2  preconditioner (msr) 
    - 3  both 
    - default : 0

Matrix_Storage : Disk Write or Read in internal format 
    - 0  none 
    - 1  write matrix (sparse) 
    - 2  read matrix (sparse) 
    - default : 0

Renumbering_Technique : 
    - 0  No renumbering 
    - 1  Reverse Cuthill-Mc Kee 
    - default : 1 

Preconditioner : 
    - 0  NONE     No Factorization
    - 1  ILUT     Incomplete LU factorization with dual truncation strategy 
    - 2  ILUTP    ILUT with column  pivoting                                
    - 3  ILUD     ILU with single dropping + diagonal compensation (~MILUT) 
    - 4  ILUDP    ILUD with column pivoting                                 
    - 5  ILUK     level-k ILU                                               
    - 6  ILU0     simple ILU(0) preconditioning                             
    - 7  MILU0    MILU(0) preconditioning                                   
    - 8  DIAGONAL                                                           
    - default : 1 

Preconditioner_Position : 
    - 0  No Preconditioner 
    - 1  Left Preconditioner 
    - 2  Right Preconditioner 
    - 3  Both Left and Right Preconditioner 
    - default : 1 

Nb_Fill : 
    - ILUT/ILUTP : maximum number of elements per line 
      of L and U (except diagonal element) 
    - ILUK : each element whose fill-in level is greater than NB_FILL 
      is dropped. 
    - default : 5

Permutation_Tolerance : Tolerance for column permutation in ILUTP/ILUDP. 
    At stage i, columns i and j are permuted if 
    abs(a(i,j))*PERMUTATION_TOLERANCE > abs(a(i,i)). 
    - 0  no permutations 
    - 0.001 -> 0.1  classical 
    - default :  5.00000E-02

Dropping_Tolerance : 
    - ILUT/ILUTP/ILUK: a(i,j) is dropped if 
      abs(a(i,j)) < DROPPING_TOLERANCE * abs(diagonal element in U). 
    - ILUD/ILUDP : a(i,j) is dropped if 
      abs(a(i,j)) < DROPPING_TOLERANCE * [weighted norm of line i]. 
      Weighted norm = 1-norm / number of nonzero elements on the line. 
    - default :  0.00000E+00

Diagonal_Compensation : ILUD/ILUDP: the term 'DIAGONAL_COMPENSATION * (sum 
    of all dropped elements of the line)' is added to the diagonal element in U 
    - 0  ~ ILU with threshold 
      1  ~ MILU with threshold. 
    - default :  0.00000E+00

Re_Use_ILU : Reuse ILU decomposition (and renumbering if any)
    - 0  no 
    - 1  yes 
    - default : 0

Algorithm : 
    - 1  CG       Conjugate Gradient                    
    - 2  CGNR     CG (Normal Residual equation)         
    - 3  BCG      Bi-Conjugate Gradient                 
    - 4  DBCG     BCG with partial pivoting             
    - 5  BCGSTAB  BCG stabilized                        
    - 6  TFQMR    Transpose-Free Quasi-Minimum Residual 
    - 7  FOM      Full Orthogonalization Method         
    - 8  GMRES    Generalized Minimum RESidual          
    - 9  FGMRES   Flexible version of GMRES             
    - 10 DQGMRES  Direct versions of GMRES              
    - 11 LU       LU Factorization                      
    - 12 PGMRES   Alternative version of GMRES          
    - default : 8

Krylov_Size : Krylov subspace size 
    - default : 20

IC_Acceleration : IC accelerator
    - default :  1.00000E+00 

Re_Use_LU : Reuse LU decomposition
    - 0  no 
    - 1  yes 
    - default : 0

Iterative_Improvement : Iterative improvement of the solution obtained by a LU 
    - default : 0

Nb_Iter_Max : Maximum number of iterations 
    - default : 10000 

Stopping_Test : Target residual 
    - default :  1.00000E-10 

*/

            Matrix_Format            1
          Matrix_Printing            0
           Matrix_Storage            0
    Renumbering_Technique            1
           Preconditioner            1
  Preconditioner_Position            1
                  Nb_Fill            8
    Permutation_Tolerance  5.00000E-02
       Dropping_Tolerance  0.00000E+00
    Diagonal_Compensation  0.00000E+00
               Re_Use_ILU            0
                Algorithm            8
              Krylov_Size           30
          IC_Acceleration  1.00000E+00
                Re_Use_LU            0
    Iterative_Improvement            0
              Nb_Iter_Max        20000
            Stopping_Test  1.00000E-12