[Getdp] Circuit Coupling MagDyn av 3D

Zacharie De Grève zacharie.degreve at umons.ac.be
Fri Nov 26 16:48:46 CET 2010


Dear all,

I am trying to set up a 3D magnetodynamic model (a-v formulation) with circuit 
coupling. 

My test case consists of an inductor with two conductors 1 and 2 that I want 
to put in serial. It can be observed on the attached .png file. The model  (see 
attached files Magdyn_av3D.pro, getdplist.pro, getdplist.geo, getdplist.dat) 
works fine except when I want to include the circuit relations. In that case, I 
get the following error during the solving process (the pre-processing is OK) 
: 

Error   : Not 1 Dof associated with GlobalQuantity (Region #5000)

I think it is related to the way I link the global quantities U and I in 
massive conducting regions with the circuit related quantities Uz and Iz, but 
I cannot figure out what the problem is. 

Does anyone have an idea ?

Thank you very much in advance.

Zacharie De Grève


-- 
---------------------------------------------------
Ir Zacharie De Grève
PhD student - FNRS Research Fellow
Dept. of Power Electrical Engineering
University of Mons - Faculty of Engineering

Bd Dolez, 31
BE - 7000 Mons
Belgique
Tél : +32 65 374125
---------------------------------------------------
-------------- next part --------------
A non-text attachment was scrubbed...
Name: inductor.png
Type: image/png
Size: 17436 bytes
Desc: inductor.png
URL: <http://www.geuz.org/pipermail/getdp/attachments/20101126/001f6ce2/attachment.png>
-------------- next part --------------
Include "getdplist.dat";

//////////////////////////// Bobines du TFO /////////////////////////////////////
///// Points, Lines and Surfaces /////
ncond = 1;
For i In {0:ncond-1}
xa=0.0044435;
ya=0.0030165;
r = 0.000315/2;
ystep = -0.000387;
pwin5[] += newp ; Point(pwin5[5*i+0]) = {xa,ya+i*ystep, 0, lc_cond}; //centres des arcs de cercle
pwin5[] += newp ; Point(pwin5[5*i+1]) = {xa+r, ya+i*ystep, 0, lc_cond};
pwin5[] += newp ; Point(pwin5[5*i+2]) = {xa, ya+r+i*ystep, 0, lc_cond};
pwin5[] += newp ; Point(pwin5[5*i+3]) = {xa-r, ya+i*ystep, 0, lc_cond};
pwin5[] += newp ; Point(pwin5[5*i+4]) = {xa, ya-r+i*ystep, 0, lc_cond};
lwin5[] += newc ; Circle(lwin5[4*i+0]) = {pwin5[5*i+1], pwin5[5*i+0], pwin5[5*i+2]};
lwin5[] += newc ; Circle(lwin5[4*i+1]) = {pwin5[5*i+2], pwin5[5*i+0], pwin5[5*i+3]};
lwin5[] += newc ; Circle(lwin5[4*i+2]) = {pwin5[5*i+3], pwin5[5*i+0], pwin5[5*i+4]};
lwin5[] += newc ; Circle(lwin5[4*i+3]) = {pwin5[5*i+4], pwin5[5*i+0], pwin5[5*i+1]};
llwin5[] += newc ; Line Loop(llwin5[i]) = {lwin5[4*i+1], lwin5[4*i+2], lwin5[4*i+3], lwin5[4*i+0]};
swin5[] += news ; Plane Surface(swin5[i]) = {llwin5[i]};
cutsym0[]+= swin5[i];
EndFor

ncond = 1;
For i In {0:ncond-1}
xa=0.0052175;
ya=0.0016125;
r = 0.000315/2;
ystep = -0.000387;
pwin4[] += newp ; Point(pwin4[5*i+0]) = {xa,ya+i*ystep, 0, lc_cond}; //centres des arcs de cercle
pwin4[] += newp ; Point(pwin4[5*i+1]) = {xa+r, ya+i*ystep, 0, lc_cond};
pwin4[] += newp ; Point(pwin4[5*i+2]) = {xa, ya+r+i*ystep, 0, lc_cond};
pwin4[] += newp ; Point(pwin4[5*i+3]) = {xa-r, ya+i*ystep, 0, lc_cond};
pwin4[] += newp ; Point(pwin4[5*i+4]) = {xa, ya-r+i*ystep, 0, lc_cond};
lwin4[] += newc ; Circle(lwin4[4*i+0]) = {pwin4[5*i+1], pwin4[5*i+0], pwin4[5*i+2]};
lwin4[] += newc ; Circle(lwin4[4*i+1]) = {pwin4[5*i+2], pwin4[5*i+0], pwin4[5*i+3]};
lwin4[] += newc ; Circle(lwin4[4*i+2]) = {pwin4[5*i+3], pwin4[5*i+0], pwin4[5*i+4]};
lwin4[] += newc ; Circle(lwin4[4*i+3]) = {pwin4[5*i+4], pwin4[5*i+0], pwin4[5*i+1]};
llwin4[] += newc ; Line Loop(llwin4[i]) = {lwin4[4*i+1], lwin4[4*i+2], lwin4[4*i+3], lwin4[4*i+0]};
swin4[] += news ; Plane Surface(swin4[i]) = {llwin4[i]};
cutsym0[]+= swin4[i];
EndFor

//////////////////////////// FerriteCore and Insulation /////////////////////////////////////
// Points
pCore[]+= newp ; Point(pCore[0]) = {0.003625, 0.0042, 0, lc_ferrite};
pCore[]+= newp ; Point(pCore[1]) = {0.003625, -0.0042, 0, lc_ferrite};
pCore[]+= newp ; Point(pCore[2]) = {0.007375, -0.0042, 0, lc_ferrite};
pCore[]+= newp ; Point(pCore[3]) = {0.007375, 0.0042, 0, lc_ferrite};
pCore[]+= newp ; Point(pCore[4]) = {0, 0.0067, 0, lc_ferrite};
pCore[]+= newp ; Point(pCore[5]) = {0, -0.0067, 0, lc_ferrite};
pCore[]+= newp ; Point(pCore[6]) = {0.01015, -0.0067, 0, lc_ferrite};
pCore[]+= newp ; Point(pCore[7]) = {0.01015, 0.0067, 0, lc_ferrite};
// Lines
lCore[]+= newl ; Line(lCore[0]) = {pCore[0],pCore[1]};
lCore[]+= newl ; Line(lCore[1]) = {pCore[1],pCore[2]};
lCore[]+= newl ; Line(lCore[2]) = {pCore[2],pCore[3]};
lCore[]+= newl ; Line(lCore[3]) = {pCore[3],pCore[0]};
lCore[]+= newl ; Line(lCore[4]) = {pCore[4],pCore[5]};
lCore[]+= newl ; Line(lCore[5]) = {pCore[5],pCore[6]};
lCore[]+= newl ; Line(lCore[6]) = {pCore[6],pCore[7]};
lCore[]+= newl ; Line(lCore[7]) = {pCore[7],pCore[4]};
// Surfaces
llCore[]+= newll ; Line Loop(llCore[0]) = {lCore[0],lCore[1],lCore[2],lCore[3]};//int
llCore[]+= newll ; Line Loop(llCore[1]) = {lCore[4],lCore[5],lCore[6],lCore[7]};//ext
sIns = news ; Plane Surface(sIns) = {llCore[0],llwin5[],llwin4[]};// Insulation
cutsym0[] +=sIns;
sCore = news ; Plane Surface(sCore) = {llCore[1],llCore[0]};// Ferrite Core
cutsym0[] +=sCore;
//////////////////////////// Air Box /////////////////////////////////////
// Points
pAir[]+= newp ; Point(pAir[0]) = {0, 0.02, 0, lc_ferrite*5};
pAir[]+= newp ; Point(pAir[1]) = {0, -0.02, 0, lc_ferrite*5};
pAir[]+= newp ; Point(pAir[2]) = {0.02, -0.02, 0, lc_ferrite*5};
pAir[]+= newp ; Point(pAir[3]) = {0.02, 0.02, 0, lc_ferrite*5};
// Lines
lAir[]+= newl ; Line(lAir[0]) = {pAir[0],pCore[4]};
lAir[]+= newl ; Line(lAir[1]) = {pCore[5],pAir[1]};
lAir[]+= newl ; Line(lAir[2]) = {pAir[1],pAir[2]};
lAir[]+= newl ; Line(lAir[3]) = {pAir[2],pAir[3]};
lAir[]+= newl ; Line(lAir[4]) = {pAir[3],pAir[0]};
// Surfaces
llAir = newll ; Line Loop(llAir) = {lAir[0],-lCore[7],-lCore[6], -lCore[5],lAir[1],lAir[2],lAir[3],lAir[4]};
sAir = news ; Plane Surface(sAir) = {llAir}; 
cutsym0[]+= sAir;
//////////////////////////// Extrusion /////////////////////////////////////
// Winding 5
For i In {0:0:1}
win5[] += Extrude { {0,1,0} , {0,0,0} , -Pi/4} { Surface{swin5[i]} ; Layers{8}; Recombine;};
skinwin5[]+={win5[2+i*6],win5[3+i*6],win5[4+i*6],win5[5+i*6]};
//Printf("%g",skinwin5[0+i*4]);
//Printf("%g",skinwin5[1+i*4]);
//Printf("%g",skinwin5[2+i*4]);
//Printf("%g",skinwin5[3+i*4]);
genwin5[]+=win5[0+i*6];
volwin5[]+=win5[1+i*6];
cutsym1[]+=win5[0+i*6];
EndFor
//Printf("%g",cutsym1[]);
// Winding 4
For i In {0:0:1}
win4[] += Extrude { {0,1,0} , {0,0,0} , -Pi/4} { Surface{swin4[i]} ; Layers{8}; Recombine;};
skinwin4[]+={win4[2+i*6],win4[3+i*6],win4[4+i*6],win4[5+i*6]};
genwin4[]+=win4[0+i*6];
volwin4[]+=win4[1+i*6];
cutsym1[]+=win4[0+i*6];
EndFor
//Insulation
ins[]=Extrude { {0,1,0} , {0,0,0} , -Pi/4} { Surface{sIns} ; Layers{8}; Recombine;};
cutsym1[]+=ins[0];
//Ferrite Core
core[]=Extrude { {0,1,0} , {0,0,0} , -Pi/4} { Surface{sCore} ; Layers{8}; Recombine;};
cutsym1[]+=core[0];
//Air
air[]=Extrude { {0,1,0} , {0,0,0} , -Pi/4} { Surface{sAir} ; Layers{8}; Recombine;};
cutsym1[]+=air[0];
//////////////////////////// Physical domains /////////////////////////////////////
//// Volumes
Physical Volume(AirBox) = {air[1]};//%%%AirBox
Physical Volume(FerriteCore) = {core[1]};//%%%FerriteCore
Physical Volume(Insulation) = {ins[1]};//%%%Insulation
Physical Volume(Cond1) = {volwin5[0]};//%%%Cond1Win5
Physical Volume(Cond2) = {volwin4[0]};//%%%Cond1Win4
/// Surfaces
Physical Surface(GammaExt) = {air[5],air[6],air[7]};//%%%Gamma_Ext
Physical Surface(Cut_SymTheta1) = {cutsym1[]};//%%%Cut_SymTheta1
Physical Surface(Cut_SymTheta0) = {cutsym0[]};//%%%Cut_SymTheta0
Physical Surface(Skin_Cond) = {skinwin4[],skinwin5[]};//%%%Skin_Windings
Physical Surface(Gen_Cond1) = {genwin4[0]};//%%%Gen_Win4
Physical Surface(Gen_Cond2) = {genwin5[0]};//%%%Gen_Win5
-------------- next part --------------
Include "getdplist.dat";

// FEM domain group data
Group {

  //Volumes
  AirBox = # AirBox;
  FerriteCore = # FerriteCore;
  Insulation = # Insulation;
  Cond1 = # Cond1;
  Cond2 = # Cond2;
  
  DomainCC_Mag = Region[ { AirBox,  FerriteCore,  Insulation} ];
  DomainC_Mag  = Region[ {Cond1,Cond2} ];
  DomainS_Mag = Region[ {} ];
  Domain_Mag = Region[ {DomainCC_Mag, DomainC_Mag} ];
  
  // Surfaces
  GammaExt = # GammaExt;
  Cut_SymTheta0 = # Cut_SymTheta0;
  Cut_SymTheta1 = # Cut_SymTheta1;
  Gen_Cond1 = # Gen_Cond1;
  Gen_Cond2 = # Gen_Cond2;
  Skin_Cond = # Skin_Cond;
    
  SkinDomainC_Mag = Region[ {Skin_Cond} ]; // Boundary of DomainC - no tree on it !
  Surface_FixedMagneticVectorPotential3D = Region[ {Cut_SymTheta0,Cut_SymTheta1,GammaExt} ]; // Zero tangential electric field
  SurfaceElec_Mag = Region[{Gen_Cond1,Gen_Cond2}];// Electrodes
}

// Circuit group data
Group {
  // Circuitfictive regions
  //CurrentSource=Region[{10000}];//Vsource for winding i
  SourceI_Cir=Region[{}];//current sources

  VoltageSource=Region[{10001}];//Vsource for winding i
  SourceV_Cir=Region[{VoltageSource}];
  
  Resistance_Cir=Region[{}];//external impedances
  Inductance_Cir=Region[{}];
  Capacitance_Cir=Region[{}];
  
  DomainZ_Cir = Region[{Resistance_Cir,Inductance_Cir,Capacitance_Cir}];//external impedances
  DomainSource_Cir = Region[{SourceV_Cir,SourceI_Cir}];//external sources
  DomainZtot_Cir = Region[{DomainZ_Cir,DomainSource_Cir}];//circuit domains
}

// FEM domain function data
Function {
  mu0 = 4.e-7 * Pi;
  mur_ferrite = 1500;
  sigma_Cu = 6.e7;
  
  sigma[DomainCC_Mag] = 0;
  sigma[DomainC_Mag] = sigma_Cu;
  sigma[DomainS_Mag] = sigma_Cu;
  
  nu[DomainC_Mag] = 1/mu0;
  nu[DomainS_Mag] = 1/mu0;
  nu[FerriteCore] = 1/(mu0*mur_ferrite);
  nu[AirBox] = 1/mu0;
  nu[Insulation] = 1/mu0;

  // Frequency for frequency domain analysis (Hz)
  Freq = 1;
  
  // Unit current density for stranded inductors
  js0[ DomainS_Mag ] = -Vector[-Sin[Atan2[Z[],X[]]], 0, Cos[Atan2[Z[],X[]]]] ;
}

// Circuit domain function data
Function {
  //External impedances functions
  Resistance[Resistance_Cir]=0;
  Inductance[Inductance_Cir]=0;
  Capacitance[Capacitance_Cir]=0;
}

// FEM domain constraint data
Constraint {
 { Name MagneticVectorPotential_3D ; Type Assign ;
    Case {
      { Region Surface_FixedMagneticVectorPotential3D  ; Value 0. ; }
    }
  }

 { Name Current_3D ; Type Assign ;
   Case {}   
 }

 { Name Voltage_3D ; Type Assign ;
   Case {
   }
 }
}


// Circuit domain constraint data
Constraint {
  { Name Current_Cir ;
    Case {
      //{Region CurrentSource ; Value 1;}
    }
  }
  
  { Name Voltage_Cir ;
    Case {
      { Region VoltageSource ; Value 1 ; }
    }
  }

  { Name VoltageInit_Cir ; Type Init ;
    Case {
    }
  }
  
  { Name ElectricalCircuit ; Type Network ;
    Case Circuit1 {
      { Region Cond1 ; Branch{1,2} ; }
      { Region Cond2 ; Branch{2,3} ; }
      { Region VoltageSource; Branch {3,1};}
    }
  }
}

Include "Jacobian_Lib.pro"
Include "Integration_Lib.pro"
Include "Mag_Dyn_av_3D.pro"

PostOperation {

  { Name Map_local; NameOfPostProcessing MagDyn_a_3D;
    Operation {
      Print[ a, OnElementsOf Domain_Mag, File "a.pos"] ;
      Print[ b, OnElementsOf Domain_Mag, File "b.pos"] ;
      Print[ j, OnElementsOf DomainC_Mag, File "j.pos"] ;
      Print[ v, OnElementsOf DomainC_Mag, File "v.pos"] ;
    }
  }

  { Name U_av; NameOfPostProcessing MagDyn_a_3D; 
    Operation {
      Print["%%%Freq",Freq];
      Print[ U, OnRegion SurfaceElec_Mag, Format Table] ;
      Print[ I, OnRegion SurfaceElec_Mag, Format Table] ;
    }
  }
}

-------------- next part --------------
Group {
  DefineGroup[ Domain_Mag, DomainCC_Mag, DomainC_Mag,
               DomainS_Mag, DomainV_Mag ];
}

Group {
  Surface_a_3D_NoGauge =
    Region [ {Surface_FixedMagneticVectorPotential3D, SkinDomainC_Mag} ] ;
}

Function {
  DefineFunction[ nu, sigma ];
  DefineFunction[ Velocity ];
  DefineVariable[ Freq ];
}

Constraint {
  { Name GaugeCondition_a_Mag_3D ; Type Assign ;
    Case {
      { Region DomainCC_Mag ; SubRegion Surface_a_3D_NoGauge ; Value 0. ; }
    }
  }
}

// Magnetic Vector Potential a with gauge in non conducting regions
FunctionSpace {
  { Name Hcurl_a_Mag_3D ; Type Form1 ;
    BasisFunction {
      // a = a_e s_e
      { Name se ; NameOfCoef ae ; Function BF_Edge ;
        Support Domain_Mag ; Entity EdgesOf[ All, Not SkinDomainC_Mag ] ; }
      { Name se2 ; NameOfCoef ae2 ; Function BF_Edge ;
        Support Domain_Mag ; Entity EdgesOf[ SkinDomainC_Mag ] ; }
    }
    Constraint {
      { NameOfCoef ae ; // Bdry conditions : circulation of a equal to 0 on all the edges of the co-tree of GammaExt
        EntityType EdgesOf ; NameOfConstraint MagneticVectorPotential_3D ; }
      { NameOfCoef ae2 ;// Excluding Skin_DomainC of the gauge condition
        EntityType EdgesOf ; NameOfConstraint MagneticVectorPotential_3D ; }
      { NameOfCoef ae ;// Gauge conditions : circulation of a equal to 0 on all the edges of the tree starting on GammaExt
        EntityType EdgesOfTreeIn ; EntitySubType StartingOn ;
	NameOfConstraint GaugeCondition_a_Mag_3D ; }
    }
  }

  // Electric scalar potential v.
  // Global basis function, with support limited to a transition layer starting from SurfaceElec_Mag
  { Name Hregion_u_Mag_3D ; Type Form0 ;
    BasisFunction {
      { Name sr ; NameOfCoef ur ; Function BF_GroupOfNodes ; 
	Support DomainC_Mag ; Entity GroupsOfNodesOf[ SurfaceElec_Mag ] ; }
    }
    
    GlobalQuantity {
      { Name U ; Type AliasOf        ; NameOfCoef ur ; }
      { Name I ; Type AssociatedWith ; NameOfCoef ur ; }
    }
    Constraint {
      { NameOfCoef U ;
        EntityType GroupsOfNodesOf ; NameOfConstraint Voltage_3D ; }
      { NameOfCoef I ;
        EntityType GroupsOfNodesOf ; NameOfConstraint Current_3D ; }
    }
  }

  
  // Uz et Iz for circuit relations 
  { Name Hregion_Cir ; Type Scalar ;
    BasisFunction {
      { Name sr ; NameOfCoef ir ; Function BF_Region ;
        Support DomainZtot_Cir ; Entity DomainZtot_Cir ; }
    }
    GlobalQuantity {
      { Name Iz ; Type AliasOf        ; NameOfCoef ir ; }
      { Name Uz ; Type AssociatedWith ; NameOfCoef ir ; }
    }
    Constraint {
      { NameOfCoef Uz ; EntityType Region ; NameOfConstraint VoltageInit_Cir ; }
      { NameOfCoef Uz ; EntityType Region ; NameOfConstraint Voltage_Cir ; }
      { NameOfCoef Iz ; EntityType Region ; NameOfConstraint Current_Cir ; }
    }
  }
}

Formulation {
  { Name Magnetodynamics_a_3D ; Type FemEquation ;
    Quantity {
      { Name a  ; Type Local ; NameOfSpace Hcurl_a_Mag_3D ; }
      { Name v  ; Type Local  ; NameOfSpace Hregion_u_Mag_3D ; }
      { Name U  ; Type Global ; NameOfSpace Hregion_u_Mag_3D [U] ; }
      { Name I  ; Type Global ; NameOfSpace Hregion_u_Mag_3D [I] ; }
      { Name Uz ; Type Global ; NameOfSpace Hregion_Cir [Uz] ; }
      { Name Iz ; Type Global ; NameOfSpace Hregion_Cir [Iz] ; }
    }
    Equation {
      Galerkin { [ nu[] * Dof{d a} , {d a} ] ; In Domain_Mag ;
                 Jacobian Vol ; Integration Gauss_dv_dv ; }

      Galerkin { DtDof[ sigma[] * Dof{a} , {a} ] ; In DomainC_Mag ;
                 Jacobian Vol ; Integration Gauss_dv_dv ; }
      Galerkin { [ sigma[] * Dof{d v} , {a} ] ; In DomainC_Mag ;
                 Jacobian Vol ; Integration Gauss_dv_dv ; }
      
      // Moving domain
      Galerkin { [ - sigma[] * (Velocity[] *^ Dof{d a}) , {a} ];
	In DomainV_Mag; Jacobian Vol; Integration Gauss_dv_dv ; }

      // Massive conductors
      Galerkin { DtDof[ sigma[] * Dof{a} , {d v} ] ; In DomainC_Mag ;
                 Jacobian Vol ; Integration Gauss_dv_dv ; }
      Galerkin { [ sigma[] * Dof{d v} , {d v} ] ; In DomainC_Mag ;
                 Jacobian Vol ; Integration Gauss_dv_dv ; }
      GlobalTerm { [ Dof{I} , {U} ] ; In SurfaceElec_Mag ; }

      // Inductors with fixed current density
      Galerkin { [ - js0[], {a} ] ; In DomainS_Mag ;
                 Jacobian Vol ; Integration Gauss_dv_dv ; }
      
      //Circuit related terms for massive cond
      // Resistance equation
      GlobalTerm { [ Dof{Uz}                , {Iz} ] ; In Resistance_Cir; }
      GlobalTerm { [ Resistance[] * Dof{Iz} , {Iz} ] ; In Resistance_Cir; }
      // Inductance equation
      GlobalTerm { [ Dof{Uz}                , {Iz} ] ; In Inductance_Cir; }
      GlobalTerm { DtDof [ Inductance[] * Dof{Iz} , {Iz} ] ; In Inductance_Cir; }      
      // Capacitance equation
      GlobalTerm { [ Dof{Iz}                       , {Iz} ] ; In Capacitance_Cir ; }
      GlobalTerm { DtDof [ Capacitance[] * Dof{Uz} , {Iz} ] ; In Capacitance_Cir ; }
      
      GlobalEquation {
        Type Network ; NameOfConstraint ElectricalCircuit ;
        { Node {I};  Loop {U};  Equation {I};  In DomainC_Mag ; }
        { Node {Iz}; Loop {Uz}; Equation {Uz}; In DomainZtot_Cir ; }
      }
      
    }
  }
}

Resolution {
  { Name MagDyn_av_3D ;
    System {
      { Name Sys_Mag ; NameOfFormulation Magnetodynamics_a_3D ;
        Type ComplexValue ; Frequency Freq ; }
    }
    Operation {
      Generate[Sys_Mag]; Solve[Sys_Mag]; SaveSolution[Sys_Mag];
    }
  }

  { Name MagDyn_av_3D_t ;
    System {
      { Name Sys_Mag ; NameOfFormulation Magnetodynamics_a_3D ; }
    }
    Operation {
      InitSolution[Sys_Mag]; SaveSolution[Sys_Mag];
      TimeLoopTheta[0, 1, 0.1, 1.]{
        Generate[Sys_Mag] ; Solve[Sys_Mag]; SaveSolution[Sys_Mag]; 
      }
    }
  }
}

PostProcessing {
  { Name MagDyn_a_3D ; NameOfFormulation Magnetodynamics_a_3D ;
    Quantity {
      { Name a ; Value { 
	  Local { [ {a} ] ; In Domain_Mag ; Jacobian Vol; } 
	}
      }
      { Name b ; Value { 
	  Local { [ {d a} ]; In Domain_Mag ; Jacobian Vol; }
	}
      }
      { Name h ; Value { 
	  Local { [ nu[] * {d a} ] ; In Domain_Mag ; Jacobian Vol;} 
	}
      }
      { Name v ; Value {
	  Local { [ {v} ]; In DomainC_Mag ; Jacobian Vol;}
	}
      }
      { Name dv ; Value { 
	  Local { [ - {d v} ]     ; In DomainC_Mag ; Jacobian Vol;}
	}
      }
      { Name dadt ; Value { 
	  Local { [ - Dt[{a}] ]  ; In DomainC_Mag ; Jacobian Vol;} 
	}
      }
      { Name e ; Value { 
	  Local { [ - Dt[{a}] - {d v} ] ; In DomainC_Mag ; } 
	}
      }
      { Name j ; Value { 
          Local { [ sigma[] * (- Dt[{a}] - {d v}) ] ; In DomainC_Mag ; Jacobian Vol;} 
          //Local { [ js0[] ] ; In DomainS_Mag ; } 
        } 
      }
      { Name U ; Value { Local { [ {U} ]   ; In SurfaceElec_Mag ; } } }
      { Name I ; Value { Local { [ {I} ]   ; In SurfaceElec_Mag ; } } }

      {Name Ind;
	Value {
	  Integral { [nu[] * SquNorm[{d a}]] ; In Domain_Mag ; Integration Gauss_dv_dv ;Jacobian Vol;}
	}
      }
    }
  }
}
-------------- next part --------------
A non-text attachment was scrubbed...
Name: getdplist.dat
Type: text/x-csrc
Size: 310 bytes
Desc: getdplist.dat
URL: <http://www.geuz.org/pipermail/getdp/attachments/20101126/001f6ce2/attachment.dat>