diff --git a/contrib/mobile/Android/res/raw/bh_pro b/contrib/mobile/Android/res/raw/bh_pro
deleted file mode 100644
index 1458d87c831c5d7b0452af70388efdf3b3929714..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/bh_pro
+++ /dev/null
@@ -1,59 +0,0 @@
-Function{
- // nu = 100. + 10. * exp ( 1.8 * b * b )
- // analytical
- nu_1a[] = 100. + 10. * Exp[1.8*SquNorm[$1]] ;
- dnudb2_1a[] = 18. * Exp[1.8*SquNorm[$1]] ;
- h_1a[] = nu_1a[$1]*$1 ;
- dhdb_1a[] = TensorDiag[1,1,1] * nu_1a[$1#1] + 2*dnudb2_1a[#1] * SquDyadicProduct[#1] ;
- dhdb_1a_NL[] = 2*dnudb2_1a[$1] * SquDyadicProduct[$1] ;
-
- // interpolated
- Mat1_h = {
- 0.0000e+00, 5.5023e+00, 1.1018e+01, 1.6562e+01, 2.2149e+01, 2.7798e+01, 3.3528e+01,
- 3.9363e+01, 4.5335e+01, 5.1479e+01, 5.7842e+01, 6.4481e+01, 7.1470e+01, 7.8906e+01,
- 8.6910e+01, 9.5644e+01, 1.0532e+02, 1.1620e+02, 1.2868e+02, 1.4322e+02, 1.6050e+02,
- 1.8139e+02, 2.0711e+02, 2.3932e+02, 2.8028e+02, 3.3314e+02, 4.0231e+02, 4.9395e+02,
- 6.1678e+02, 7.8320e+02, 1.0110e+03, 1.3257e+03, 1.7645e+03, 2.3819e+03, 3.2578e+03,
- 4.5110e+03, 6.3187e+03, 8.9478e+03, 1.2802e+04, 1.8500e+04, 2.6989e+04, 3.9739e+04,
- 5.9047e+04, 8.8520e+04, 1.3388e+05, 2.0425e+05, 3.1434e+05, 4.8796e+05, 7.6403e+05
- } ;
- Mat1_b = {
- 0.0000e+00, 5.0000e-02, 1.0000e-01, 1.5000e-01, 2.0000e-01, 2.5000e-01, 3.0000e-01,
- 3.5000e-01, 4.0000e-01, 4.5000e-01, 5.0000e-01, 5.5000e-01, 6.0000e-01, 6.5000e-01,
- 7.0000e-01, 7.5000e-01, 8.0000e-01, 8.5000e-01, 9.0000e-01, 9.5000e-01, 1.0000e+00,
- 1.0500e+00, 1.1000e+00, 1.1500e+00, 1.2000e+00, 1.2500e+00, 1.3000e+00, 1.3500e+00,
- 1.4000e+00, 1.4500e+00, 1.5000e+00, 1.5500e+00, 1.6000e+00, 1.6500e+00, 1.7000e+00,
- 1.7500e+00, 1.8000e+00, 1.8500e+00, 1.9000e+00, 1.9500e+00, 2.0000e+00, 2.0500e+00,
- 2.1000e+00, 2.1500e+00, 2.2000e+00, 2.2500e+00, 2.3000e+00, 2.3500e+00, 2.4000e+00
- } ;
- Mat1_b2 = {
- 0.0000e+00, 2.5000e-03, 1.0000e-02, 2.2500e-02, 4.0000e-02, 6.2500e-02, 9.0000e-02,
- 1.2250e-01, 1.6000e-01, 2.0250e-01, 2.5000e-01, 3.0250e-01, 3.6000e-01, 4.2250e-01,
- 4.9000e-01, 5.6250e-01, 6.4000e-01, 7.2250e-01, 8.1000e-01, 9.0250e-01, 1.0000e+00,
- 1.1025e+00, 1.2100e+00, 1.3225e+00, 1.4400e+00, 1.5625e+00, 1.6900e+00, 1.8225e+00,
- 1.9600e+00, 2.1025e+00, 2.2500e+00, 2.4025e+00, 2.5600e+00, 2.7225e+00, 2.8900e+00,
- 3.0625e+00, 3.2400e+00, 3.4225e+00, 3.6100e+00, 3.8025e+00, 4.0000e+00, 4.2025e+00,
- 4.4100e+00, 4.6225e+00, 4.8400e+00, 5.0625e+00, 5.2900e+00, 5.5225e+00, 5.7600e+00
- } ;
- Mat1_nu = {
- 1.1005e+02, 1.1005e+02, 1.1018e+02, 1.1041e+02, 1.1075e+02, 1.1119e+02, 1.1176e+02,
- 1.1247e+02, 1.1334e+02, 1.1440e+02, 1.1568e+02, 1.1724e+02, 1.1912e+02, 1.2139e+02,
- 1.2416e+02, 1.2752e+02, 1.3165e+02, 1.3671e+02, 1.4297e+02, 1.5076e+02, 1.6050e+02,
- 1.7275e+02, 1.8829e+02, 2.0810e+02, 2.3356e+02, 2.6651e+02, 3.0947e+02, 3.6589e+02,
- 4.4056e+02, 5.4014e+02, 6.7397e+02, 8.5528e+02, 1.1028e+03, 1.4436e+03, 1.9164e+03,
- 2.5777e+03, 3.5104e+03, 4.8366e+03, 6.7381e+03, 9.4870e+03, 1.3494e+04, 1.9385e+04,
- 2.8118e+04, 4.1172e+04, 6.0854e+04, 9.0779e+04, 1.3667e+05, 2.0764e+05, 3.1835e+05
- } ;
-
- Mat1_nu_b2 = ListAlt[Mat1_b2, Mat1_nu] ;
- nu_1[] = InterpolationLinear[$1]{List[Mat1_nu_b2]} ;
- dnudb2_1[] = dInterpolationLinear[$1]{List[Mat1_nu_b2]} ;
- h_1[] = nu_1[(SquNorm[$1])] * $1 ;
- dhdb_1[] = TensorDiag[1,1,1] * nu_1[SquNorm[$1]#1] + 2*dnudb2_1[#1] * SquDyadicProduct[$1] ;
-}
-
-
-
-
-
-
diff --git a/contrib/mobile/Android/res/raw/machine_magstadyn_a_pro b/contrib/mobile/Android/res/raw/machine_magstadyn_a_pro
deleted file mode 100644
index f58a22b84a3d4258d4cb3e7100e5444ee87dc8e8..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/machine_magstadyn_a_pro
+++ /dev/null
@@ -1,938 +0,0 @@
-Group {
- DefineGroup[ DomainM, DomainB, DomainS ];
- DefineGroup[ DomainL, DomainNL, Dummy ];
- DefineGroup[ Rotor_Inds, Rotor_IndsP, Rotor_IndsN, Rotor_Magnets, Rotor_Bars ];
- DefineGroup[ Surf_bn0, Rotor_Bnd_MBaux] ;
- DefineGroup[ Resistance_Cir, Inductance_Cir, Capacitance_Cir, DomainZt_Cir, DomainSource_Cir ];
-}
-
-Function{
-
- DefineConstant[ Flag_Cir, Flag_NL, Flag_ParkTransformation ];
- DefineConstant[ Term_vxb ];
- DefineConstant[ AxialLength = {1, Visible 0},
- FillFactor_Winding = {1, Visible 0},
- Factor_R_3DEffects = {1, Visible 0},
- SymmetryFactor = {1, Visible 0} ];
-
- Flag_Symmetry = (SymmetryFactor==1) ? 0 : 1 ;
-
- DefineConstant[ Nb_max_iter = {20, Visible 0},
- relaxation_factor = {1, Visible 0},
- stop_criterion = {1e-5, Visible 0},
- reltol = {1e-7, Visible 0},
- abstol = {1e-5, Visible 0} ];
-
- DefineConstant[ II, VV, pA, pB, pC, Ie, ID, IQ, I0 ];
- DefineFunction[ br, js, Resistance, Inductance, Capacitance ];
- DefineFunction[ Theta_Park, Theta_Park_deg, RotorPosition, RotorPosition_deg ] ;
-
-
- DefineConstant[ Flag_SrcType_Rotor = {0, Visible 0} ];
-
- DefineConstant[ Clean_Results = { 1, Choices {0,1},
- Label "Remove previous result files",
- Path "Input/1", Visible 1 } ] ;
-
- DefineConstant[ Flag_SaveAllSteps = {0, Label "Save all time steps",
- Path "Input/0", Choices {0,1}} ];
-
- DefineConstant[ my_output={"Output/40T_rotor", Visible 0}];
-
-}
-
-Include "bh.pro"; // nonlinear BH caracteristic of magnetic material
-
-Group {
-
- Inds = Region[ {Stator_Inds, Rotor_Inds} ] ;
-
- DomainB = Region[ {Inds} ] ;
- DomainM = Region[ {Rotor_Magnets} ] ;
-
- Stator = Region[{ StatorC, StatorCC }] ;
- Rotor = Region[{ RotorC, RotorCC }] ;
-
- Rotor_Moving = Region[{ Rotor, Rotor_Air, Rotor_Airgap, Rotor_Inds, Rotor_Bnd_MBaux} ] ; // Use in ChangeOfCoordinates
-
- MB = MovingBand2D[ MovingBand_PhysicalNb, Stator_Bnd_MB, Rotor_Bnd_MB, SymmetryFactor] ;
- Air = Region[{ Rotor_Air, Rotor_Airgap, Stator_Air, Stator_Airgap, MB } ] ;
- Inds = Region[{ Rotor_Inds, Stator_Inds } ] ;
-
- DomainV = Region[{}]; // Speed considered either with term v/\b
- If(Term_vxb) // or not dynamics in time domain + mechanics
- DomainV = Region[{ RotorC }];
- EndIf
-
- DomainCC = Region[{ Air, Inds, StatorCC, RotorCC }];
- DomainC = Region[{ StatorC, RotorC }];
- Domain = Region[{ DomainCC, DomainC }] ;
-
- If(Flag_NL)
- DomainNL = Region[ {Stator_Fe, Rotor_Fe } ];
- DomainL = Region[ {Domain,-DomainNL} ];
- EndIf
-
- DomainKin = #1234 ; // Dummy region number for mechanical equation
- DomainDummy = #12345 ; // Dummy region number for mechanical equation
-}
-
-Function {
- mu0 = 4.e-7 * Pi ;
-
- sigma_al = 3.72e7 ; // conductivity of aluminum [S/m]
- sigma_cu = 5.9e7 ; // conductivity of copper [S/m]
-
- nu [#{Air, Inds, Stator_Al, Rotor_Al, Stator_Cu, Rotor_Cu, Rotor_Magnets, Rotor_Bars}] = 1. / mu0 ;
-
- If(!Flag_NL)
- nu [#{Stator_Fe, Rotor_Fe }] = 1 / (mur_fe * mu0) ;
- EndIf
- If(Flag_NL)
- nu [#{Stator_Fe, Rotor_Fe }] = nu_1a[$1] ;
- EndIf
- dhdb_NL [ DomainNL ] = dhdb_1a_NL[$1];
-
- sigma[#{Rotor_Fe}] = sigma_fe ;
- sigma[#{Rotor_Al, Stator_Al}] = sigma_al ;
- sigma[#{Rotor_Cu, Stator_Cu}] = sigma_cu ;
- sigma[#{Inds}] = sigma_cu ;
-
- rho[] = 1/sigma[] ;
-
- Rb[] = Factor_R_3DEffects*AxialLength*FillFactor_Winding*NbWires[]^2/SurfCoil[]/sigma[] ;
- Resistance[#{Stator_Inds, Rotor_Inds}] = Rb[] ;
-
- T = 1/Freq ; // Fundamental period in s
-
- Idir[#{Stator_IndsP, Rotor_IndsP}] = 1 ;
- Idir[#{Stator_IndsN, Rotor_IndsN}] = -1 ;
-
- // Functions for Park transformation
- Idq0[] = Vector[ ID, IQ, I0 ] ;
- Pinv[] = Tensor[ Sin[Theta_Park[]], Cos[Theta_Park[]], 1,
- Sin[Theta_Park[]-2*Pi/3], Cos[Theta_Park[]-2*Pi/3], 1,
- Sin[Theta_Park[]+2*Pi/3], Cos[Theta_Park[]+2*Pi/3], 1 ];
-
- P[] = 2/3 * Tensor[ Sin[Theta_Park[]], Sin[Theta_Park[]-2*Pi/3], Sin[Theta_Park[]+2*Pi/3],
- Cos[Theta_Park[]], Cos[Theta_Park[]-2*Pi/3], Cos[Theta_Park[]+2*Pi/3],
- 1/2, 1/2, 1/2 ] ;
-
- Iabc[] = Pinv[] * Idq0[] ;
- Flux_dq0[] = P[] * Vector[#11, #22, #33] ;
-
- If(Flag_ParkTransformation)
- II = 1 ;
- IA[] = CompX[ Iabc[] ] ;
- IB[] = CompY[ Iabc[] ] ;
- IC[] = CompZ[ Iabc[] ] ;
- EndIf
- If(!Flag_ParkTransformation)
- IA[] = F_Sin_wt_p[]{2*Pi*Freq, pA} ;
- IB[] = F_Sin_wt_p[]{2*Pi*Freq, pB} ;
- IC[] = F_Sin_wt_p[]{2*Pi*Freq, pC} ;
-
- js[PhaseA] = II * NbWires[]/SurfCoil[] * IA[] * Idir[] * Vector[0, 0, 1] ;
- js[PhaseB] = II * NbWires[]/SurfCoil[] * IB[] * Idir[] * Vector[0, 0, 1] ;
- js[PhaseC] = II * NbWires[]/SurfCoil[] * IC[] * Idir[] * Vector[0, 0, 1] ;
- EndIf
-
- Velocity[] = wr*XYZ[]/\Vector[0,0,1] ;
-
- // Maxwell stress tensor
- T_max[] = ( SquDyadicProduct[$1] - SquNorm[$1] * TensorDiag[0.5, 0.5, 0.5] ) / mu0 ;
- T_max_cplx[] = ( TensorV[CompX[$1]*Conj[$1],CompY[$1]*Conj[$1],CompZ[$1]*Conj[$1]] - $1*Conj[$1] * TensorDiag[0.5, 0.5, 0.5] ) / mu0 ; // Check if valid
-
-
- AngularPosition[] = (Atan2[$Y,$X]#7 >= 0.)? #7 : #7+2*Pi ;
-
- RotatePZ[] = Rotate[ Vector[$X,$Y,$Z], 0, 0, $1 ] ;//Watch out: Do not use XYZ[]!
-
- // Kinematics
- Inertia = 8.3e-3 ; //87
- Friction[] = 0 ;
-
- Fmag[] = #55 ; // Computed in postprocessing
-}
-
-//-------------------------------------------------------------------------------------
-
-Jacobian {
- { Name Vol; Case { { Region All ; Jacobian Vol; } } }
-}
-
-Integration {
- { Name I1 ; Case {
- { Type Gauss ;
- Case {
- { GeoElement Triangle ; NumberOfPoints 6 ; }
- { GeoElement Quadrangle ; NumberOfPoints 4 ; }
- { GeoElement Line ; NumberOfPoints 13 ; }
- }
- }
- }
- }
-}
-
-//-------------------------------------------------------------------------------------
-
-Constraint {
-
- { Name MVP_2D ;
- Case {
- { Region Surf_Inf ; Type Assign; Value 0. ; }
- { Region Surf_bn0 ; Type Assign; Value 0. ; }
-
- If(Flag_Symmetry)
- { Region Surf_cutA1; SubRegion Region[{Surf_Inf,Surf_bn0}]; Type Link;
- RegionRef Surf_cutA0; SubRegionRef Region[{Surf_Inf,Surf_bn0}];
- Coefficient (NbrPoles%2)?-1:1 ; Function RotatePZ[-NbrPoles*2*Pi/NbrPolesTot]; }
- { Region Surf_cutA1; Type Link; RegionRef Surf_cutA0;
- Coefficient (NbrPoles%2)?-1:1 ; Function RotatePZ[-NbrPoles*2*Pi/NbrPolesTot]; }
-
- //For the moving band
- For k In {1:SymmetryFactor-1}
- { Region Rotor_Bnd_MB~{k+1} ; SubRegion Rotor_Bnd_MB~{(k!=SymmetryFactor-1)?k+2:1}; Type Link;
- RegionRef Rotor_Bnd_MB_1; SubRegionRef Rotor_Bnd_MB_2;
- Coefficient ((NbrPoles%2)?-1:1)^(k); Function RotatePZ[-k*NbrPoles*2*Pi/NbrPolesTot]; }
- EndFor
-
- EndIf
- }
- }
-
- { Name Current_2D ;
- Case {
- If(Flag_SrcType_Stator==1)
- { Region PhaseA ; Value II*Idir[] ; TimeFunction IA[]; }
- { Region PhaseB ; Value II*Idir[] ; TimeFunction IB[]; }
- { Region PhaseC ; Value II*Idir[] ; TimeFunction IC[]; }
- EndIf
- If(Flag_SrcType_Rotor==1)
- { Region Rotor_Inds ; Value Ie*Idir[] ; }
- EndIf
- }
- }
-
- { Name Voltage_2D ;
- Case {
- { Region RotorC ; Value 0. ; } // Not needed if Global equation not in formulation
- { Region StatorC ; Value 0. ; } // Not needed if Global equation not in formulation
- }
- }
-
- { Name Current_Cir ;
- Case {
- If(Flag_Cir && Flag_SrcType_Stator==1)
- { Region Input1 ; Value II ; TimeFunction IA[]; }
- { Region Input2 ; Value II ; TimeFunction IB[]; }
- { Region Input3 ; Value II ; TimeFunction IC[]; }
- EndIf
- }
- }
-
- { Name Voltage_Cir ; // Example induction machine
- Case {
- If(Flag_Cir && Flag_SrcType_Stator==2 && !Flag_NL)
- { Region Input1 ; Value VV ; TimeFunction IA[]; }
- { Region Input2 ; Value VV ; TimeFunction IB[]; }
- { Region Input3 ; Value VV ; TimeFunction IC[]; }
- EndIf
- If(Flag_Cir && Flag_SrcType_Stator==2 && Flag_NL)
- { Region Input1 ; Value VV ; TimeFunction IA[]*Frelax[]; }
- { Region Input2 ; Value VV ; TimeFunction IB[]*Frelax[]; }
- { Region Input3 ; Value VV ; TimeFunction IC[]*Frelax[]; }
- EndIf
- }
- }
-
-
- //Kinetics
- { Name CurrentPosition ;
- Case {
- { Region DomainKin ; Type Init ; Value 0.#66 ; }
- }
- }
-
- { Name CurrentVelocity ;
- Case {
- { Region DomainKin ; Type Init ; Value wr ; } // wr in [0,1200] rad/s
- }
- }
-
-}
-
-//-----------------------------------------------------------------------------------------------
-
-FunctionSpace {
-
- { Name Hcurl_a_2D ; Type Form1P ;
- BasisFunction {
- { Name se1 ; NameOfCoef ae1 ; Function BF_PerpendicularEdge ;
- Support Region[{ Domain, Rotor_Bnd_MBaux }] ; Entity NodesOf [ All ] ; }
- }
- Constraint {
- { NameOfCoef ae1 ; EntityType NodesOf ; NameOfConstraint MVP_2D ; }
- }
- }
-
- // Gradient of Electric scalar potential (2D)
- { Name Hregion_u_Mag_2D ; Type Form1P ;
- BasisFunction {
- { Name sr ; NameOfCoef ur ; Function BF_RegionZ ;
- Support DomainC ; Entity DomainC ; }
- }
- GlobalQuantity {
- { Name U ; Type AliasOf ; NameOfCoef ur ; }
- { Name I ; Type AssociatedWith ; NameOfCoef ur ; }
- }
- Constraint {
- { NameOfCoef U ; EntityType GroupsOfNodesOf ; NameOfConstraint Voltage_2D ; }
- { NameOfCoef I ; EntityType GroupsOfNodesOf ; NameOfConstraint Current_2D ; }
- }
- }
-
- { Name Hregion_i_Mag_2D ; Type Vector ;
- BasisFunction {
- { Name sr ; NameOfCoef ir ; Function BF_RegionZ ;
- Support DomainB ; Entity DomainB ; }
- }
- GlobalQuantity {
- { Name Ib ; Type AliasOf ; NameOfCoef ir ; }
- { Name Ub ; Type AssociatedWith ; NameOfCoef ir ; }
- }
- Constraint {
- { NameOfCoef Ub ; EntityType Region ; NameOfConstraint Voltage_2D ; }
- { NameOfCoef Ib ; EntityType Region ; NameOfConstraint Current_2D ; }
- }
- }
-
- { Name Hregion_Z ; Type Scalar ; // Circuit equations
- BasisFunction {
- { Name sr ; NameOfCoef ir ; Function BF_Region ;
- Support DomainZt_Cir ; Entity DomainZt_Cir ; }
- }
- GlobalQuantity {
- { Name Iz ; Type AliasOf ; NameOfCoef ir ; }
- { Name Uz ; Type AssociatedWith ; NameOfCoef ir ; }
- }
- Constraint {
- { NameOfCoef Uz ; EntityType Region ; NameOfConstraint Voltage_Cir ; }
- { NameOfCoef Iz ; EntityType Region ; NameOfConstraint Current_Cir ; }
- }
- }
-
- // For use in Mechanical equation
- { Name Position ; Type Scalar ;
- BasisFunction {
- { Name sr ; NameOfCoef ir ; Function BF_Region ;
- Support DomainKin ; Entity DomainKin ; }
- }
- GlobalQuantity {
- { Name P ; Type AliasOf ; NameOfCoef ir ; }
- }
- Constraint {
- { NameOfCoef P ; EntityType Region ; NameOfConstraint CurrentPosition ; }
- }
- }
-
-
- { Name Velocity ; Type Scalar ;
- BasisFunction {
- { Name sr ; NameOfCoef ir ; Function BF_Region ;
- Support DomainKin ; Entity DomainKin ; } }
- GlobalQuantity {
- { Name V ; Type AliasOf ; NameOfCoef ir ; }
- }
- Constraint {
- { NameOfCoef V ; EntityType Region ; NameOfConstraint CurrentVelocity ; }
- }
- }
-
-}
-
-//-----------------------------------------------------------------------------------------------
-
-Formulation {
-
- { Name MagSta_a_2D ; Type FemEquation ;
- Quantity {
- { Name a ; Type Local ; NameOfSpace Hcurl_a_2D ; }
-
- { Name ir ; Type Local ; NameOfSpace Hregion_i_Mag_2D ; }
- { Name Ub ; Type Global ; NameOfSpace Hregion_i_Mag_2D [Ub] ; }
- { Name Ib ; Type Global ; NameOfSpace Hregion_i_Mag_2D [Ib] ; }
-
- { Name Uz ; Type Global ; NameOfSpace Hregion_Z [Uz] ; }
- { Name Iz ; Type Global ; NameOfSpace Hregion_Z [Iz] ; }
- }
-
- Equation {
- Galerkin { [ nu[{d a}] * Dof{d a} , {d a} ] ;
- In Domain ; Jacobian Vol ; Integration I1 ; }
- Galerkin { JacNL [ dhdb_NL[{d a}] * Dof{d a} , {d a} ] ;
- In DomainNL ; Jacobian Vol ; Integration I1 ; }
-
- Galerkin { [ 0*Dof{d a} , {d a} ] ; // DO NOT REMOVE!!! - Keeping track of Dofs in auxiliary line of MB if Symmetry=1
- In Rotor_Bnd_MBaux; Jacobian Vol; Integration I1; }
-
- Galerkin { [ -nu[] * br[] , {d a} ] ;
- In DomainM ; Jacobian Vol ; Integration I1 ; }
-
- Galerkin { [ -js[] , {a} ] ;
- In DomainS ; Jacobian Vol ; Integration I1 ; }
-
- Galerkin { [ -NbWires[]/SurfCoil[] * Dof{ir} , {a} ] ;
- In DomainB ; Jacobian Vol ; Integration I1 ; }
- Galerkin { DtDof [ AxialLength * NbWires[]/SurfCoil[] * Dof{a} , {ir} ] ;
- In DomainB ; Jacobian Vol ; Integration I1 ; }
- GlobalTerm { [ Dof{Ub}/SymmetryFactor, {Ib} ] ; In DomainB ; }
- Galerkin { [ Rb[]/SurfCoil[]* Dof{ir} , {ir} ] ;
- In DomainB ; Jacobian Vol ; Integration I1 ; }
-
- // GlobalTerm { [ Resistance[] * Dof{Ib} , {Ib} ] ; In DomainB ; }
- // The above term can replace:
- // Galerkin{ [ NbWires[]/SurfCoil[] / sigma[] * NbWires[]/SurfCoil[] * Dof{ir}, {ir} ]
- // if we have an estimation of the resistance of DomainB, via e.g. measurements
-
- If(Flag_Cir)
- GlobalTerm { NeverDt[ Dof{Uz} , {Iz} ] ; In Resistance_Cir ; }
- GlobalTerm { NeverDt[ Resistance[] * Dof{Iz} , {Iz} ] ; In Resistance_Cir ; }
-
- GlobalTerm { [ 0. * Dof{Iz} , {Iz} ] ; In DomainSource_Cir ; }
- GlobalTerm { [ 0. * Dof{Uz} , {Iz} ] ; In DomainZt_Cir ; }
-
- GlobalEquation {
- Type Network ; NameOfConstraint ElectricalCircuit ;
- { Node {Iz}; Loop {Uz}; Equation {Uz}; In DomainZt_Cir ; }
- { Node {Ib}; Loop {Ub}; Equation {Ub}; In DomainB ; }
- }
- EndIf
- }
- }
-
- { Name MagDyn_a_2D ; Type FemEquation ;
- Quantity {
- { Name a ; Type Local ; NameOfSpace Hcurl_a_2D ; }
- { Name ur ; Type Local ; NameOfSpace Hregion_u_Mag_2D ; }
- { Name I ; Type Global ; NameOfSpace Hregion_u_Mag_2D [I] ; }
- { Name U ; Type Global ; NameOfSpace Hregion_u_Mag_2D [U] ; }
-
- { Name ir ; Type Local ; NameOfSpace Hregion_i_Mag_2D ; }
- { Name Ub ; Type Global ; NameOfSpace Hregion_i_Mag_2D [Ub] ; }
- { Name Ib ; Type Global ; NameOfSpace Hregion_i_Mag_2D [Ib] ; }
-
- { Name Uz ; Type Global ; NameOfSpace Hregion_Z [Uz] ; }
- { Name Iz ; Type Global ; NameOfSpace Hregion_Z [Iz] ; }
- }
- Equation {
- Galerkin { [ nu[{d a}] * Dof{d a} , {d a} ] ;
- In Domain ; Jacobian Vol ; Integration I1 ; }
- Galerkin { JacNL [ dhdb_NL[{d a}] * Dof{d a} , {d a} ] ;
- In DomainNL ; Jacobian Vol ; Integration I1 ; }
-
- Galerkin { [ 0*Dof{d a} , {d a} ] ; // DO NOT REMOVE!!! - Keeping track of Dofs in auxiliary line of MB if Symmetry=1
- In Rotor_Bnd_MBaux; Jacobian Vol; Integration I1; }
-
- Galerkin { [ -nu[] * br[] , {d a} ] ;
- In DomainM ; Jacobian Vol ; Integration I1 ; }
-
- Galerkin { DtDof[ sigma[] * Dof{a} , {a} ] ;
- In DomainC ; Jacobian Vol ; Integration I1 ; }
- Galerkin { [ sigma[] * Dof{ur}, {a} ] ;
- In DomainC ; Jacobian Vol ; Integration I1 ; }
-
- Galerkin { [ -sigma[] * (Velocity[] *^ Dof{d a}) , {a} ] ;
- In DomainV ; Jacobian Vol ; Integration I1 ; }
-
- Galerkin { [ -js[] , {a} ] ;
- In DomainS ; Jacobian Vol ; Integration I1 ; }
-
- Galerkin { DtDof[ sigma[] * Dof{a} , {ur} ] ;
- In DomainC ; Jacobian Vol ; Integration I1 ; }
- Galerkin { [ sigma[] * Dof{ur} , {ur} ] ;
- In DomainC ; Jacobian Vol ; Integration I1 ; }
- GlobalTerm { [ Dof{I} , {U} ] ; In DomainC ; }
-
- Galerkin { [ -NbWires[]/SurfCoil[] * Dof{ir} , {a} ] ;
- In DomainB ; Jacobian Vol ; Integration I1 ; }
- Galerkin { DtDof [ AxialLength * NbWires[]/SurfCoil[] * Dof{a} , {ir} ] ;
- In DomainB ; Jacobian Vol ; Integration I1 ; }
- GlobalTerm { [ Dof{Ub}/SymmetryFactor , {Ib} ] ; In DomainB ; }
- Galerkin { [ Rb[]/SurfCoil[]* Dof{ir} , {ir} ] ;
- In DomainB ; Jacobian Vol ; Integration I1 ; } // Resistance term
-
- // GlobalTerm { [ Resistance[] * Dof{Ib} , {Ib} ] ; In DomainB ; }
- // The above term can replace the resistance term:
- // if we have an estimation of the resistance of DomainB, via e.g. measurements
- // which is better to account for the end windings...
-
- If(Flag_Cir)
- GlobalTerm { NeverDt[ Dof{Uz} , {Iz} ] ; In Resistance_Cir ; }
- GlobalTerm { NeverDt[ Resistance[] * Dof{Iz} , {Iz} ] ; In Resistance_Cir ; }
-
- GlobalTerm { [ Dof{Uz} , {Iz} ] ; In Inductance_Cir ; }
- GlobalTerm { DtDof [ Inductance[] * Dof{Iz} , {Iz} ] ; In Inductance_Cir ; }
-
- GlobalTerm { NeverDt[ Dof{Iz} , {Iz} ] ; In Capacitance_Cir ; }
- GlobalTerm { DtDof [ Capacitance[] * Dof{Uz} , {Iz} ] ; In Capacitance_Cir ; }
-
- GlobalTerm { [ 0. * Dof{Iz} , {Iz} ] ; In DomainZt_Cir ; }
- GlobalTerm { [ 0. * Dof{Uz} , {Iz} ] ; In DomainZt_Cir ; }
-
- GlobalEquation {
- Type Network ; NameOfConstraint ElectricalCircuit ;
- { Node {I}; Loop {U}; Equation {I}; In DomainC ; }
- { Node {Ib}; Loop {Ub}; Equation {Ub}; In DomainB ; }
- { Node {Iz}; Loop {Uz}; Equation {Uz}; In DomainZt_Cir ; }
- }
- EndIf
- }
- }
-
-
- //--------------------------------------------------------------------------
- // Mechanics
- //--------------------------------------------------------------------------
- { Name Mechanical ; Type FemEquation ;
- Quantity {
- { Name V ; Type Global ; NameOfSpace Velocity [V] ; } // velocity
- { Name P ; Type Global ; NameOfSpace Position [P] ; } // position
- }
- Equation {
- GlobalTerm { DtDof [ Inertia * Dof{V} , {V} ] ; In DomainKin ; }
- GlobalTerm { [ Friction[] * Dof{V} , {V} ] ; In DomainKin ; }
- GlobalTerm { [ -Fmag[] , {V} ] ; In DomainKin ; }
-
- GlobalTerm { DtDof [ Dof{P} , {P} ] ; In DomainKin ; }
- GlobalTerm { [-Dof{V} , {P} ] ; In DomainKin ; }
- }
- }
-
-}
-
-//-----------------------------------------------------------------------------------------------
-
-Resolution {
-
- { Name TimeDomain ;
- System {
- { Name A ; NameOfFormulation MagDyn_a_2D ; }
- }
- Operation {
- CreateDir["res/"];
- If[ Clean_Results==1 ]{
- DeleteFile["res/temp.dat"];
- DeleteFile["res/Tr.dat"]; DeleteFile["res/Ts.dat"]; DeleteFile["res/Tmb.dat"];
- DeleteFile["res/Ua.dat"]; DeleteFile["res/Ub.dat"]; DeleteFile["res/Uc.dat"];
- DeleteFile["res/Ia.dat"]; DeleteFile["res/Ib.dat"]; DeleteFile["res/Ic.dat"];
- DeleteFile["res/Flux_a.dat"]; DeleteFile["res/Flux_b.dat"]; DeleteFile["res/Flux_c.dat"];
- DeleteFile["res/Flux_d.dat"]; DeleteFile["res/Flux_q.dat"]; DeleteFile["res/Flux_0.dat"];
- }
- InitMovingBand2D[MB] ;
- MeshMovingBand2D[MB] ;
- InitSolution[A] ;
- If[Flag_ParkTransformation && Flag_SrcType_Stator==1]{ PostOperation[ThetaPark_IABC] ; }
- If[!Flag_NL]{
- Generate[A] ; Solve[A] ;
- }
- Else{
- //IterativeLoop[Nb_max_iter, stop_criterion, relaxation_factor]
- // { GenerateJac[A] ; SolveJac[A] ; }
- IterativeLoopN[ Nb_max_iter, relaxation_factor,
- System { {A, reltol, abstol, Solution MeanL2Norm}} ]
- { GenerateJac[A] ; SolveJac[A] ; }
- }
- SaveSolution[A] ;
- PostOperation[Get_LocalFields] ;
- PostOperation[Get_GlobalQuantities] ;
- }
- }
-
- { Name TimeDomain_Loop ;
- System {
- { Name A ; NameOfFormulation MagDyn_a_2D ; }
- }
- Operation {
- CreateDir["res/"];
- If[ Clean_Results==1 ]{
- DeleteFile["res/temp.dat"];
- DeleteFile["res/Tr.dat"]; DeleteFile["res/Ts.dat"]; DeleteFile["res/Tmb.dat"];
- DeleteFile["res/Ua.dat"]; DeleteFile["res/Ub.dat"]; DeleteFile["res/Uc.dat"];
- DeleteFile["res/Ia.dat"]; DeleteFile["res/Ib.dat"]; DeleteFile["res/Ic.dat"];
- DeleteFile["res/Flux_a.dat"]; DeleteFile["res/Flux_b.dat"]; DeleteFile["res/Flux_c.dat"];
- DeleteFile["res/Flux_d.dat"]; DeleteFile["res/Flux_q.dat"]; DeleteFile["res/Flux_0.dat"];
- }
- InitMovingBand2D[MB] ;
- MeshMovingBand2D[MB] ;
- InitSolution[A] ;
- TimeLoopTheta[time0, timemax, delta_time, 1.]{ // Euler implicit (1) -- Crank-Nicolson (0.5)
- If[Flag_ParkTransformation && Flag_SrcType_Stator==1]{ PostOperation[ThetaPark_IABC] ; }
- If[!Flag_NL]{
- Generate[A]; Solve[A];
- }
- Else{
- // IterativeLoop[Nb_max_iter, stop_criterion, relaxation_factor] {
- // GenerateJac[A] ; SolveJac[A] ; }
- IterativeLoopN[
- Nb_max_iter, relaxation_factor, System { {A, reltol, abstol, Solution MeanL2Norm}} ]{
- GenerateJac[A] ; SolveJac[A] ; }
- }
- SaveSolution[A];
-
- PostOperation[Get_LocalFields] ;
- If[ $TimeStep > 1 ]{
- PostOperation[Get_GlobalQuantities] ;
- }
- ChangeOfCoordinates[ NodesOf[Rotor_Moving], RotatePZ[delta_theta]] ;
- MeshMovingBand2D[MB] ;
- }
- }
- }
-
- { Name FrequencyDomain ;
- System {
- { Name A ; NameOfFormulation MagDyn_a_2D ; Type ComplexValue ; Frequency Freq ; }
- }
- Operation {
- If[ Clean_Results==1 && wr == 0.]{
- DeleteFile["res/Tr.dat"]; DeleteFile["res/Ts.dat"]; DeleteFile["res/Tmb.dat"];
- DeleteFile["res/Ua.dat"]; DeleteFile["res/Ub.dat"]; DeleteFile["res/Uc.dat"];
- DeleteFile["res/Ia.dat"]; DeleteFile["res/Ib.dat"]; DeleteFile["res/Ic.dat"];
- }
- SetTime[wr];
- InitMovingBand2D[MB] ;
- MeshMovingBand2D[MB] ;
- Generate[A] ; Solve[A] ; SaveSolution[A];
- PostOperation[Map_LocalFields] ;
- PostOperation[Torque_Emf_Flux] ;
- }
- }
-
- /*
- { Name MagDyn_Kin ;
- System {
- { Name A ; NameOfFormulation MagDyn_a_2D ; }
- { Name M ; NameOfFormulation Mechanical ; }
- }
- Operation {
- ChangeOfCoordinates [ NodesOf[Rotor_Moving], RotatePZ[theta0] ] ; // Initial position (supposing initial mesh with angleR=0)
- InitMovingBand2D[MB] ; MeshMovingBand2D[MB] ;
-
- InitSolution[A] ; SaveSolution[A] ;
- InitSolution[M] ; SaveSolution[M] ;
-
- TimeLoopTheta[time0, timemax, delta_time, 1.]{
- Generate[A] ; Solve[A] ; SaveSolution[A] ;
- PostOperation[MagDyn_a_2D] ;
-
- Generate[M] ; Solve[M] ; SaveSolution[M] ;
- PostOperation[Mechanical] ;
-
- ChangeOfCoordinates [ NodesOf[Rotor_Moving], RotatePZ[#77-#66] ] ;
- Evaluate[ #77#66 ] ; //Keep track of previous angular position
- MeshMovingBand2D[MB] ;
- }
- }
- }
- */
-
-}
-
-//-----------------------------------------------------------------------------------------------
-
-PostProcessing {
-
- { Name MagSta_a_2D ; NameOfFormulation MagSta_a_2D ;
- PostQuantity {
- { Name a ; Value { Term { [ {a} ] ; In Domain ; Jacobian Vol ; } } }
- { Name az ; Value { Term { [ CompZ[{a}] ] ; In Domain ; Jacobian Vol ; } } }
- { Name b ; Value { Term { [ {d a} ] ; In Domain ; Jacobian Vol ; } } }
- { Name boundary ; Value { Term { [ {d a} ] ; In Dummy ; Jacobian Vol ; } } }
- { Name br ; Value { Term { [ br[] ] ; In DomainM ; Jacobian Vol ; } } }
-
- { Name Flux ; Value { Integral { [ SymmetryFactor*AxialLength*Idir[]*NbWires[]/SurfCoil[]* CompZ[{a}] ] ;
- In Inds ; Jacobian Vol ; Integration I1 ; } } }
- { Name Force_vw ; Value {
- Integral { Type Global ; [ 0.5 * nu[] * VirtualWork [{d a}] * AxialLength ];
- In ElementsOf[Rotor_Airgap, OnOneSideOf Rotor_Bnd_MB];
- Jacobian Vol ; Integration I1 ; } } }
-
- { Name Torque_Maxwell ; Value {
- Integral {
- [ CompZ [ XYZ[] /\ (T_max[{d a}] * XYZ[]) ]*2*Pi*AxialLength/SurfaceArea[] ] ;
- In Domain ; Jacobian Vol ; Integration I1; } } }
-
- { Name Torque_vw ; Value {
- Integral { Type Global ;
- [ CompZ[ 0.5 * nu[] * XYZ[] /\ VirtualWork[{d a}] ] * AxialLength ];
- In ElementsOf[Rotor_Airgap, OnOneSideOf Rotor_Bnd_MB];
- Jacobian Vol ; Integration I1 ; } } }
-
- { Name U ; Value {
- Term { [ {Ub} ] ; In DomainB ; }
- Term { [ {Uz} ] ; In DomainZt_Cir ; }
- } }
-
- { Name I ; Value {
- Term { [ {Ib} ] ; In DomainB ; }
- Term { [ {Iz} ] ; In DomainZt_Cir ; }
- } }
-
- }
- }
-
- { Name MagDyn_a_2D ; NameOfFormulation MagDyn_a_2D ;
- PostQuantity {
- { Name a ; Value { Term { [ {a} ] ; In Domain ; Jacobian Vol ; } } }
- { Name az ; Value { Term { [ CompZ[{a}] ] ; In Domain ; Jacobian Vol ; } } }
-
- { Name b ; Value { Term { [ {d a} ] ; In Domain ; Jacobian Vol ; } } }
- { Name boundary ; Value { Term { [ 1 ] ; In Dummy ; Jacobian Vol ; } } } // Dummy quantity
- { Name b_radial ; Value { Term { [ {d a}* Vector[ Cos[AngularPosition[]#4], Sin[#4], 0.] ] ; In Domain ; Jacobian Vol ; } } }
- { Name b_tangent ; Value { Term { [ {d a}* Vector[ -Sin[AngularPosition[]#4], Cos[#4], 0.] ] ; In Domain ; Jacobian Vol ; } } }
-
- { Name js ; Value { Term { [ js[] ] ; In DomainS ; Jacobian Vol ; } } }
- { Name br ; Value { Term { [ br[] ] ; In DomainM ; Jacobian Vol ; } } }
-
- { Name j ; Value {
- Term { [ -sigma[]*(Dt[{a}]+{ur}) ] ; In DomainC ; Jacobian Vol ; }
- Term { [ sigma[]*(Velocity[] *^ {d a}) ] ; In DomainV ; Jacobian Vol ; }
- }
- }
- { Name ir ; Value { Term { [ {ir} ] ; In Inds ; Jacobian Vol ; } } }
-
- { Name jz ; Value {
- Term { [ CompZ[-sigma[]*(Dt[{a}]+{ur})] ] ; In DomainC ; Jacobian Vol ; }
- Term { [ CompZ[ sigma[]*(Velocity[]*^{d a}) ] ] ; In DomainV ; Jacobian Vol ; }
- }
- }
-
- { Name rhoj2 ;
- Value {
- Term { [ sigma[]*SquNorm[ Dt[{a}]+{ur}] ] ; In Region[{DomainC,-DomainV}] ; Jacobian Vol ; }
- Term { [ sigma[]*SquNorm[ Dt[{a}]+{ur}-Velocity[]*^{d a} ] ] ; In DomainV ; Jacobian Vol ; }
- Term { [ 1./sigma[]*SquNorm[ IA[]*{ir} ] ] ; In PhaseA ; Jacobian Vol ; }
- Term { [ 1./sigma[]*SquNorm[ IB[]*{ir} ] ] ; In PhaseB ; Jacobian Vol ; }
- Term { [ 1./sigma[]*SquNorm[ IC[]*{ir} ] ] ; In PhaseC ; Jacobian Vol ; }
- }
- }
-
- { Name JouleLosses ;
- Value {
- Integral { [ sigma[] * SquNorm[ Dt[{a}]+{ur}-Velocity[]*^{d a} ] ] ; In Region[{DomainC,-DomainV}] ; Jacobian Vol ; Integration I1 ; }
- Integral { [ sigma[] * SquNorm[ Dt[{a}]+{ur}-Velocity[]*^{d a} ] ] ; In DomainV ; Jacobian Vol ; Integration I1 ; }
- Integral { [ 1./sigma[]*SquNorm[ IA[]*{ir} ] ] ; In PhaseA ; Jacobian Vol ; Integration I1 ; }
- Integral { [ 1./sigma[]*SquNorm[ IB[]*{ir} ] ] ; In PhaseB ; Jacobian Vol ; Integration I1 ; }
- Integral { [ 1./sigma[]*SquNorm[ IC[]*{ir} ] ] ; In PhaseC ; Jacobian Vol ; Integration I1 ; }
- }
- }
-
- { Name Flux ; Value { Integral { [ SymmetryFactor*AxialLength*Idir[]*NbWires[]/SurfCoil[]* CompZ[{a}] ] ;
- In Inds ; Jacobian Vol ; Integration I1 ; } } }
-
- { Name Force_vw ; // Force computation by Virtual Works
- Value {
- Integral {
- Type Global ; [ 0.5 * nu[] * VirtualWork [{d a}] * AxialLength ];
- In ElementsOf[Rotor_Airgap, OnOneSideOf Rotor_Bnd_MB]; Jacobian Vol ; Integration I1 ; }
- }
- }
-
- { Name Torque_vw ; Value { // Torque computation via Virtual Works
- Integral { Type Global ;
- [ CompZ[ 0.5 * nu[] * XYZ[] /\ VirtualWork[{d a}] ] * AxialLength ];
- In ElementsOf[Rotor_Airgap, OnOneSideOf Rotor_Bnd_MB]; Jacobian Vol ; Integration I1 ; }
- }
- }
-
-
- { Name Torque_Maxwell ; // Torque computation via Maxwell stress tensor
- Value {
- Integral {
- [ CompZ [ XYZ[] /\ (T_max[{d a}] * XYZ[]) ] * 2*Pi*AxialLength/SurfaceArea[] ] ;
- In Domain ; Jacobian Vol ; Integration I1; }
- }
- }
-
- { Name Torque_Maxwell_cplx ; // Torque computation via Maxwell stress tensor
- Value {
- Integral {
- [ CompZ [ XYZ[] /\ (T_max_cplx[{d a}] * XYZ[]) ] * 2*Pi*AxialLength/SurfaceArea[] ] ;
- In Domain ; Jacobian Vol ; Integration I1; }
- }
- }
-
- { Name ComplexPower ; // S = P + i*Q
- Value {
- Integral { [ Complex[ sigma[]*SquNorm[Dt[{a}]+{ur}], nu[]*SquNorm[{d a}] ] ] ;
- In Region[{DomainC,-DomainV}] ; Jacobian Vol ; Integration I1 ; }
- Integral { [ Complex[ sigma[]*SquNorm[Dt[{a}]+{ur}-Velocity[]*^{d a}], nu[]*SquNorm[{d a}] ] ] ;
- In DomainV ; Jacobian Vol ; Integration I1 ; }
- }
- }
-
- { Name U ; Value {
- Term { [ {U} ] ; In DomainC ; }
- Term { [ {Ub} ] ; In DomainB ; }
- Term { [ {Uz} ] ; In DomainZt_Cir ; }
- } }
-
- { Name I ; Value {
- Term { [ {I} ] ; In DomainC ; }
- Term { [ {Ib} ] ; In DomainB ; }
- Term { [ {Iz} ] ; In DomainZt_Cir ; }
- } }
-
- { Name S ; Value {
- Term { [ {U}*Conj[{I}] ] ; In DomainC ; }
- Term { [ {Ub}*Conj[{Ib}] ] ; In DomainB ; }
- Term { [ {Uz}*Conj[{Iz}] ] ; In DomainZt_Cir ; }
- } }
-
- { Name Velocity ; Value {
- Term { [ Velocity[] ] ; In Domain ; Jacobian Vol ; }
- }
- }
-
- // For getting the value of some functions:
- { Name RotorPosition_deg ; Value { Term { Type Global; [ RotorPosition_deg[] ] ; In DomainDummy ; } } }
- { Name Theta_Park_deg ; Value { Term { Type Global; [ Theta_Park_deg[] ] ; In DomainDummy ; } } }
- { Name IA ; Value { Term { Type Global; [ IA[] ] ; In DomainDummy ; } } }
- { Name IB ; Value { Term { Type Global; [ IB[] ] ; In DomainDummy ; } } }
- { Name IC ; Value { Term { Type Global; [ IC[] ] ; In DomainDummy ; } } }
-
- { Name Flux_d ; Value { Term { Type Global; [ CompX[Flux_dq0[]] ] ; In DomainDummy ; } } }
- { Name Flux_q ; Value { Term { Type Global; [ CompY[Flux_dq0[]] ] ; In DomainDummy ; } } }
- { Name Flux_0 ; Value { Term { Type Global; [ CompZ[Flux_dq0[]] ] ; In DomainDummy ; } } }
- }
- }
-
- { Name Mechanical ; NameOfFormulation Mechanical ;
- PostQuantity {
- { Name P ; Value { Term { [ {P} ] ; In DomainKin ; } } } //Position
- { Name V ; Value { Term { [ {V} ] ; In DomainKin ; } } } //Velocity
- { Name Vrpm ; Value { Term { [ {V}*30/Pi ] ; In DomainKin ; } } } //Velocity in rpm
- }
- }
-
-}
-
-//-----------------------------------------------------------------------------------------------
-//-----------------------------------------------------------------------------------------------
-
-If (Flag_ParkTransformation)
-PostOperation ThetaPark_IABC UsingPost MagDyn_a_2D {
- Print[ RotorPosition_deg, OnRegion DomainDummy, Format Table, LastTimeStepOnly, File StrCat[Dir, StrCat["temp",ExtGnuplot]],
- SendToServer "Output/1RotorPosition", Color "LightYellow" ];
- Print[ Theta_Park_deg, OnRegion DomainDummy, Format Table, LastTimeStepOnly, File StrCat[Dir, StrCat["temp",ExtGnuplot]],
- SendToServer "Output/1Theta_Park", Color "LightYellow" ];
- Print[ IA, OnRegion DomainDummy, Format Table, LastTimeStepOnly, File StrCat[Dir, StrCat["temp",ExtGnuplot]], SendToServer "Output/2IA", Color "Pink" ];
- Print[ IB, OnRegion DomainDummy, Format Table, LastTimeStepOnly, File StrCat[Dir, StrCat["temp",ExtGnuplot]], SendToServer "Output/2IB", Color "Yellow" ];
- Print[ IC, OnRegion DomainDummy, Format Table, LastTimeStepOnly, File StrCat[Dir, StrCat["temp",ExtGnuplot]], SendToServer "Output/2IC", Color "LightGreen" ];
-}
-EndIf
-PostOperation Get_LocalFields UsingPost MagDyn_a_2D {
- Print[ ir, OnElementsOf Stator_Inds, File StrCat[Dir, StrCat["ir_stator",ExtGmsh]], LastTimeStepOnly, AppendTimeStepToFileName Flag_SaveAllSteps] ;
- Print[ ir, OnElementsOf Rotor_Inds, File StrCat[Dir, StrCat["ir_rotor",ExtGmsh]], LastTimeStepOnly, AppendTimeStepToFileName Flag_SaveAllSteps] ;
- //Print[ br, OnElementsOf #{DomainM}, File StrCat[Dir, StrCat["b",ExtGmsh]], LastTimeStepOnly, AppendTimeStepToFileName Flag_SaveAllSteps] ;
- Print[ b, OnElementsOf Domain, File StrCat[Dir, StrCat["b",ExtGmsh]], LastTimeStepOnly, AppendTimeStepToFileName Flag_SaveAllSteps] ;
- Print[ boundary, OnElementsOf Dummy, File StrCat[Dir, StrCat["bnd",ExtGmsh]], LastTimeStepOnly, AppendTimeStepToFileName Flag_SaveAllSteps] ;
- Print[ az, OnElementsOf Domain, File StrCat[Dir, StrCat["a",ExtGmsh]], LastTimeStepOnly, AppendTimeStepToFileName Flag_SaveAllSteps ] ;
-}
-
-PostOperation Get_GlobalQuantities UsingPost MagDyn_a_2D {
- If(!Flag_Cir)
- If(!Flag_ParkTransformation)
- Print[ I, OnRegion PhaseA_pos, Format Table,
- File > StrCat[Dir, StrCat["Ia",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2IA", Color "Pink" ];
- Print[ I, OnRegion PhaseB_pos, Format Table,
- File > StrCat[Dir, StrCat["Ib",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2IB", Color "Yellow" ];
- Print[ I, OnRegion PhaseC_pos, Format Table,
- File > StrCat[Dir, StrCat["Ic",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2IC", Color "LightGreen" ];
- EndIf
-
- Print[ U, OnRegion PhaseA_pos, Format Table,
- File > StrCat[Dir, StrCat["Ua",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/30UA", Color "Pink" ];
- Print[ U, OnRegion PhaseB_pos, Format Table,
- File > StrCat[Dir, StrCat["Ub",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/31UB", Color "Yellow" ];
- Print[ U, OnRegion PhaseC_pos, Format Table,
- File > StrCat[Dir, StrCat["Uc",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/32UC", Color "LightGreen" ];
- EndIf
- If(Flag_Cir && Flag_SrcType_Stator==2)
- Print[ I, OnRegion Input1, Format Table,
- File > StrCat[Dir, StrCat["Ia",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2IA", Color "Pink" ];
- Print[ I, OnRegion Input2, Format Table,
- File > StrCat[Dir, StrCat["Ib",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2IB", Color "Yellow" ];
- Print[ I, OnRegion Input3, Format Table,
- File > StrCat[Dir, StrCat["Ic",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2IC", Color "LightGreen" ];
- Print[ U, OnRegion Input1, Format Table,
- File > StrCat[Dir, StrCat["Ua",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/30UA", Color "Pink" ];
- Print[ U, OnRegion Input2, Format Table,
- File > StrCat[Dir, StrCat["Ub",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/31UB", Color "Yellow" ];
- Print[ U, OnRegion Input3, Format Table,
- File > StrCat[Dir, StrCat["Uc",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/32UC", Color "LightGreen" ];
- EndIf
- If(Flag_Cir && Flag_SrcType_Stator==0)
- Print[ I, OnRegion R1, Format Table,
- File > StrCat[Dir, StrCat["Ia",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2IA", Color "Pink" ];
- Print[ I, OnRegion R2, Format Table,
- File > StrCat[Dir, StrCat["Ib",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2IB", Color "Yellow" ];
- Print[ I, OnRegion R3, Format Table,
- File > StrCat[Dir, StrCat["Ic",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2IC", Color "LightGreen" ];
- Print[ U, OnRegion R1, Format Table,
- File > StrCat[Dir, StrCat["Ua",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/30UA", Color "Pink" ];
- Print[ U, OnRegion R2, Format Table,
- File > StrCat[Dir, StrCat["Ub",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/31UB", Color "Yellow" ];
- Print[ U, OnRegion R3, Format Table,
- File > StrCat[Dir, StrCat["Uc",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/32UC", Color "LightGreen" ];
- EndIf
-
-
- Print[ I, OnRegion RotorC, Format Table,
- File > StrCat[Dir, StrCat["Irotor",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/2Ir", Color "LightYellow" ];
-
- Print[ Torque_Maxwell[Rotor_Airgap], OnGlobal, Format TimeTable,
- File > StrCat[Dir, StrCat["Tr",ExtGnuplot]], LastTimeStepOnly, Store 54, SendToServer my_output, Color "LightYellow" ];
- Print[ Torque_Maxwell[Stator_Airgap], OnGlobal, Format TimeTable,
- File > StrCat[Dir, StrCat["Ts",ExtGnuplot]], LastTimeStepOnly, Store 55, SendToServer "Output/41T_stator", Color "LightYellow" ];
- Print[ Torque_Maxwell[MB], OnGlobal, Format TimeTable,
- File > StrCat[Dir, StrCat["Tmb",ExtGnuplot]], LastTimeStepOnly, Store 56, SendToServer "Output/42T_mb", Color "LightYellow" ];
- //Print[ Torque_vw, OnRegion NodesOf[Rotor_Bnd_MB], Format RegionValue,
- // File > StrCat[Dir, StrCat["Tr_vw",ExtGnuplot]], LastTimeStepOnly, Store 54, SendToServer "Output/1T_rotor_vw" ];
-
- If(Flag_SrcType_Stator)
- Print[ Flux[PhaseA], OnGlobal, Format TimeTable,
- File > StrCat[Dir, StrCat["Flux_a",ExtGnuplot]], LastTimeStepOnly, Store 11, SendToServer "Output/50Flux_a", Color "Pink" ];
- Print[ Flux[PhaseB], OnGlobal, Format TimeTable,
- File > StrCat[Dir, StrCat["Flux_b",ExtGnuplot]], LastTimeStepOnly, Store 22, SendToServer "Output/51Flux_b", Color "Yellow" ];
- Print[ Flux[PhaseC], OnGlobal, Format TimeTable,
- File > StrCat[Dir, StrCat["Flux_c",ExtGnuplot]], LastTimeStepOnly, Store 33, SendToServer "Output/52Flux_c", Color "LightGreen"];
-
- If(Flag_ParkTransformation && Flag_SrcType_Stator)
- Print[ Flux_d, OnRegion DomainDummy, Format TimeTable,
- File > StrCat[Dir, StrCat["Flux_d",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/60Flux_d", Color "LightYellow" ];
- Print[ Flux_q, OnRegion DomainDummy, Format TimeTable,
- File > StrCat[Dir, StrCat["Flux_q",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/61Flux_q", Color "LightYellow" ];
- Print[ Flux_0, OnRegion DomainDummy, Format TimeTable,
- File > StrCat[Dir, StrCat["Flux_0",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/62Flux_0", Color "LightYellow" ];
- EndIf
- EndIf
-}
-
-
-PostOperation Joule_Losses UsingPost MagDyn_a_2D {
- Print[ JouleLosses[Rotor], OnGlobal, Format TimeTable,
- File > StrCat[Dir, StrCat["P",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/3P_rotor" ];
- Print[ JouleLosses[Rotor_Fe], OnGlobal, Format TimeTable,
- File > StrCat[Dir, StrCat["P_Fe",ExtGnuplot]], LastTimeStepOnly, SendToServer "Output/3P_rotor_fe" ];
-}
-
-/*
-PostOperation Mechanical UsingPost Mechanical {
- Print[ P, OnRegion DomainKin, File > StrCat[Dir, StrCat["P", ExtGnuplot]],
- Format Table, Store 77, LastTimeStepOnly, SendToServer "Output/3Position"] ;
- Print[ V, OnRegion DomainKin, File > StrCat[Dir, StrCat["V", ExtGnuplot]],
- Format Table, LastTimeStepOnly, SendToServer "Output/4Velocity"] ;
-}
-*/
diff --git a/contrib/mobile/Android/res/raw/magnet_data_pro b/contrib/mobile/Android/res/raw/magnet_data_pro
deleted file mode 100644
index 3e0a76ce5234d4b1e4e68260a702de10db21ee4c..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/magnet_data_pro
+++ /dev/null
@@ -1,16 +0,0 @@
-
-DefineConstant[ Val_Rint = {0.15, Min 0.2, Max 1, Step 0.1,
- Path "Parameters/Geometry/1",
- Label "Internal shell radius (m)"} ];
-
-DefineConstant[ Val_Rext = {0.25, Min Val_Rint, Max 0.5, Step 0.1,
- Path "Parameters/Geometry/2",
- Label "External shell radius (m)"}];
-
-AIR = 100;
-AIR_INF = 101;
-AIR_GAP = 102;
-MAGNET = 103;
-CORE = 104;
-LINE_INF = 105;
-LINE_X = 106;
diff --git a/contrib/mobile/Android/res/raw/magnet_geo b/contrib/mobile/Android/res/raw/magnet_geo
deleted file mode 100644
index c0c7815711709f5b24c1a07a0057a045bb8df0c6..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/magnet_geo
+++ /dev/null
@@ -1,93 +0,0 @@
-Include "magnet_data.pro";
-
-DefineConstant[ h = {0.14, Min 0.1, Max 0.2, Step 0.01,
- Path "Parameters/Geometry",
- Label "Core height (m)"} ] ;
-
-DefineConstant[ l = {0.14, Min 0.05, Max 0.2, Step 0.01,
- Path "Parameters/Geometry",
- Label "Core width (m)"} ] ;
-
-DefineConstant[ d = {0.03, Min 0.01, Max 0.05, Step 0.002,
- Path "Parameters/Geometry",
- Label "Core tickness (m)"} ] ;
-
-DefineConstant[ e = {5e-3, Min 5e-4, Max d, Step 1e-3,
- Path "Parameters/Geometry",
- Label "Air gap (m)", Highlight "LightYellow"} ] ;
-
-DefineConstant[ ha = {0.03, Min 0.01, Max 0.1, Step 0.01,
- Path "Parameters/Geometry",
- Label "Magnet height (m)"} ] ;
-
-lc0 = d / 5 ;
-lc1 = e / 2 ;
-lc2 = (Val_Rext - Val_Rint) / 8. ;
-
-Point(1) = {0, 0, 0, lc0};
-Point(2) = {-l/2, 0, 0, lc0};
-Point(3) = {-l/2, h/2, 0, lc0};
-Point(4) = {l/2, 0, 0, lc1};
-Point(5) = {l/2, h/2, 0, lc0};
-Point(6) = {-l/2, ha/2, 0, lc0};
-Point(7) = {-l/2+d, ha/2, 0, lc0};
-Point(8) = {-l/2+d, 0, 0, lc0};
-Point(9) = {l/2-d, 0, 0, lc1};
-Point(10) = {l/2-d, h/2-d, 0, lc0};
-Point(11) = {-l/2+d, h/2-d, 0, lc0};
-Point(12) = {l/2, e/2, 0, lc1};
-Point(13) = {l/2-d, e/2, 0, lc1};
-
-Point(30) = {Val_Rint, 0, 0, lc2};
-Point(31) = {Val_Rext, 0, 0, lc2};
-Point(32) = {0, Val_Rint, 0, lc2};
-Point(33) = {0, Val_Rext, 0, lc2};
-Point(34) = {-Val_Rext, 0, 0, lc2};
-Point(35) = {-Val_Rint, 0, 0, lc2};
-
-Line(1) = {34, 35};
-Line(2) = {35, 2};
-Line(3) = {2, 8};
-Line(4) = {8, 1};
-Line(5) = {1, 9};
-Line(6) = {9, 4};
-Line(7) = {4, 30};
-Line(8) = {30, 31};
-Line(9) = {2, 6};
-Line(10) = {6, 3};
-Line(11) = {3, 5};
-Line(12) = {5, 12};
-Line(13) = {12, 4};
-Line(14) = {9, 13};
-Line(15) = {13, 10};
-Line(16) = {10, 11};
-Line(17) = {11, 7};
-Line(18) = {7, 8};
-Line(19) = {7, 6};
-Line(20) = {13, 12};
-Circle(21) = {35, 1, 32};
-Circle(22) = {32, 1, 30};
-Circle(23) = {34, 1, 33};
-Circle(24) = {33, 1, 31};
-
-Line Loop(25) = {21, 22, 8, -24, -23, 1};
-Plane Surface(26) = {25};
-Line Loop(27) = - {22, -7, -13, -12, -11, -10, -9, -2, 21};
-Plane Surface(28) = {27};
-Line Loop(29) = - {11, 12, -20, 15, 16, 17, 19, 10};
-Plane Surface(30) = {29};
-Line Loop(31) = {19, -9, 3, -18};
-Plane Surface(32) = {31};
-Line Loop(33) = - {20, 13, -6, 14};
-Plane Surface(34) = {33};
-Line Loop(35) = {15, 16, 17, 18, 4, 5, 14};
-Plane Surface(36) = {35};
-
-// physical entities (for which elements will be saved)
-Physical Surface(AIR) = {28, 36};
-Physical Surface(AIR_INF) = {26};
-Physical Surface(AIR_GAP) = {34};
-Physical Surface(MAGNET) = {32};
-Physical Surface(CORE) = {30};
-Physical Line(LINE_INF) = {23, 24};
-Physical Line(LINE_X) = {1:8};
diff --git a/contrib/mobile/Android/res/raw/magnet_pro b/contrib/mobile/Android/res/raw/magnet_pro
deleted file mode 100644
index a18c7cdf4f64bfd69453b51477cbb2e8721eccff..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/magnet_pro
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- To solve the problem
- with scalar potential, type 'getdp test -solve MagSta_phi -pos phi'
- with vector potential, type 'getdp test -solve MagSta_a -pos a'
-*/
-
-Include "magnet_data.pro";
-
-Group {
- // AIR, AIR_INF, etc. are variables defined in core.txt, and correspond to the
- // tags of physical regions in the mesh
- Air = Region[ AIR ];
- AirInf = Region[ AIR_INF ];
- Core = Region[ CORE ];
- AirGap = Region[ AIR_GAP ];
- Magnet = Region[ MAGNET ];
-
- // These are the generic group names that are used in "Magnetostatics.pro"
- Domain_S = Region[ {} ] ;
- Domain_Inf = Region[ AirInf ] ;
- Domain_M = Region[ Magnet ] ;
- Domain_Mag = Region[ {Air, Core, AirGap} ] ;
- Dirichlet_a_0 = Region[ LINE_INF ] ;
- Dirichlet_phi_0 = Region[ {LINE_X, LINE_INF} ] ;
-}
-
-Function {
- mu0 = 4.e-7 * Pi ;
-
- // DefineConstant is used to define a default value for murCore; this value
- // can be changed interactively by the ONELAB server
- DefineConstant[ murCore = {200., Min 1, Max 1000, Step 10,
- Label "Core relative permeability",
- Path "Parameters/Materials"} ];
-
- nu [ Region[{Air, AirInf, AirGap, Magnet}] ] = 1. / mu0 ;
- nu [ Core ] = 1. / (murCore * mu0) ;
-
- mu [ Region[{Air, AirInf, AirGap, Magnet}] ] = mu0 ;
- mu [ Core ] = murCore * mu0;
-
- DefineConstant[ Hc = {920000, Label "Magnet coercive field (A/m)",
- Path "Parameters/Materials"} ];
- hc [ Magnet ] = Vector[0., Hc, 0.] ;
-}
-
-Include "magnetostatics.pro"
-
-eps = 1.e-5 ;
-
-Printf[ "murCore: %f",murCore ] ;
-
-PostOperation {
- { Name phi ; NameOfPostProcessing MagSta_phi;
- Operation {
- Print[ phi, OnElementsOf Domain, File "phi.pos" ] ;
- Print[ b, OnElementsOf Domain, File "b_phi.pos" ] ;
- Print[ b, OnLine {{-0.07,eps,0}{0.09,eps,0}} {500}, File "b_phi.txt", Format Table ] ;
- }
- }
- { Name a ; NameOfPostProcessing MagSta_a;
- Operation {
- Print[ a, OnElementsOf Domain, File "a.pos"] ;
- Print[ b, OnElementsOf Domain, File "b_a.pos" ] ;
- Print[ h, OnElementsOf Domain, File "h_a.pos" ] ;
- Print[ b, OnLine {{-0.07,eps,0}{0.09,eps,0}} {500}, File "b_a.txt" , Format Table ] ;
- }
- }
-}
diff --git a/contrib/mobile/Android/res/raw/magnetostatics_pro b/contrib/mobile/Android/res/raw/magnetostatics_pro
deleted file mode 100644
index 4c9c07d5c55c12586069e061c1d6fe867fecb106..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/magnetostatics_pro
+++ /dev/null
@@ -1,209 +0,0 @@
-Group {
- // Input groups:
- DefineGroup[ Domain_M = {{}, Label "Permanent magnets",
- Path "Regions/0Sources"},
- Domain_S = {{}, Label "Inductor (imposed j_s)",
- Path "Regions/0Sources"},
- Domain_Inf = {{}, Label "Infinite domain (spherical shell)",
- Path "Regions/0Special regions", Closed "1"},
- Domain_Mag = {{}, Label "Passive magnetic regions",
- Path "Regions/Other regions"},
- Dirichlet_phi_0 = {{}, Label "h_t = 0", Closed "1",
- Path "Regions/0Boundary conditions"},
- Dirichlet_a_0 = {{}, Label "b_n = 0",
- Path "Regions/0Boundary conditions"} ];
-
- DefineGroup[ Domain = {{Domain_Mag, Domain_M, Domain_S, Domain_Inf},
- Label "Computational domain", Path "Regions", Visible 0} ];
-}
-
-Function{
- // Input constants:
- DefineConstant[ Val_Rint, Val_Rext // interior/exterior radius of Domain_Inf
- ];
-
- // Input functions:
- DefineFunction[ mu, // magnetic permeability
- nu, // magnetic reluctivity
- hc, // coercive magnetic field
- js // source current density
- ];
-
- // remove this: only for demo
- //DefineConstant[ hcx = {0, Label "Coercive field h_x", Path "Sources"}];
- //DefineConstant[ hcy = {1000, Label "Coercive field h_y", Path "Sources"}];
- //hc[] = Vector[hcx,hcy,0];
- //mu[] = 4*Pi*10^-7;
- //nu[] = 1/mu[];
-}
-
-Jacobian {
- { Name JVol ;
- Case {
- { Region Domain_Inf ; Jacobian VolSphShell{Val_Rint, Val_Rext} ; }
- { Region All ; Jacobian Vol ; }
- }
- }
-}
-
-Integration {
- { Name I1 ;
- Case {
- { Type Gauss ;
- Case {
- { GeoElement Triangle ; NumberOfPoints 4 ; }
- { GeoElement Quadrangle ; NumberOfPoints 4 ; }
- }
- }
- }
- }
-}
-
-
-/* --------------------------------------------------------------------------
- MagSta_phi : Magnetic scalar potential phi formulation
- -------------------------------------------------------------------------- */
-
-Constraint {
- { Name phi ;
- Case {
- { Region Dirichlet_phi_0 ; Value 0. ; }
- }
- }
-}
-
-FunctionSpace {
- { Name Hgrad_phi ; Type Form0 ;
- BasisFunction {
- { Name sn ; NameOfCoef phin ; Function BF_Node ;
- Support Domain ; Entity NodesOf[ All ] ; }
- }
- Constraint {
- { NameOfCoef phin ; EntityType NodesOf ; NameOfConstraint phi ; }
- }
- }
-}
-
-Formulation {
- { Name MagSta_phi ; Type FemEquation ;
- Quantity {
- { Name phi ; Type Local ; NameOfSpace Hgrad_phi ; }
- }
- Equation {
- Galerkin { [ - mu[] * Dof{d phi} , {d phi} ] ;
- In Domain ; Jacobian JVol ; Integration I1 ; }
-
- Galerkin { [ - mu[] * hc[] , {d phi} ] ;
- In Domain_M ; Jacobian JVol ; Integration I1 ; }
- }
- }
-}
-
-Resolution {
- { Name MagSta_phi ;
- System {
- { Name A ; NameOfFormulation MagSta_phi ; }
- }
- Operation {
- Generate[A] ; Solve[A] ; SaveSolution[A] ;
- }
- }
-}
-
-PostProcessing {
- { Name MagSta_phi ; NameOfFormulation MagSta_phi ;
- Quantity {
- { Name b ; Value { Local { [ - mu[] * {d phi} ] ; In Domain ; Jacobian JVol ; }
- Local { [ - mu[] * hc[] ] ; In Domain_M ; Jacobian JVol ; } } }
- { Name h ; Value { Local { [ - {d phi} ] ; In Domain ; Jacobian JVol ; } } }
- { Name phi ; Value { Local { [ {phi} ] ; In Domain ; Jacobian JVol ; } } }
- }
- }
-}
-
-PostOperation {
- { Name MagSta_phi ; NameOfPostProcessing MagSta_phi;
- Operation {
- Print[ b, OnElementsOf Domain, File "MagSta_phi_b.pos" ] ;
- Print[ h, OnElementsOf Domain, File "MagSta_phi_h.pos" ] ;
- Print[ phi, OnElementsOf Domain, File "MagSta_phi_phi.pos" ] ;
- }
- }
-}
-
-/* --------------------------------------------------------------------------
- MagSta_a : Magnetic vector potential a formulation (2D)
- -------------------------------------------------------------------------- */
-
-Constraint {
- { Name a ;
- Case {
- { Region Dirichlet_a_0 ; Value 0. ; }
- }
- }
-}
-
-FunctionSpace {
-
- { Name Hcurl_a ; Type Form1P ;
- BasisFunction {
- { Name se ; NameOfCoef ae ; Function BF_PerpendicularEdge ;
- Support Domain ; Entity NodesOf[ All ] ; }
- }
- Constraint {
- { NameOfCoef ae ; EntityType NodesOf ; NameOfConstraint a ; }
- }
- }
-
-}
-
-Formulation {
- { Name MagSta_a ; Type FemEquation ;
- Quantity {
- { Name a ; Type Local ; NameOfSpace Hcurl_a ; }
- }
- Equation {
- Galerkin { [ nu[] * Dof{d a} , {d a} ] ;
- In Domain ; Jacobian JVol ; Integration I1 ; }
-
- Galerkin { [ hc[] , {d a} ] ;
- In Domain_M ; Jacobian JVol ; Integration I1 ; }
-
- Galerkin { [ -js[] , {a} ] ;
- In Domain_S ; Jacobian JVol ; Integration I1 ; }
- }
- }
-}
-
-Resolution {
- { Name MagSta_a ;
- System {
- { Name A ; NameOfFormulation MagSta_a ; }
- }
- Operation {
- Generate[A] ; Solve[A] ; SaveSolution[A];
- }
- }
-}
-
-PostProcessing {
- { Name MagSta_a ; NameOfFormulation MagSta_a ;
- Quantity {
- { Name a ; Value { Local { [ CompZ[{a}] ] ; In Domain ; Jacobian JVol ; } } }
- { Name b ; Value { Local { [ {d a} ] ; In Domain ; Jacobian JVol ; } } }
- { Name a ; Value { Local { [ {a} ] ; In Domain ; Jacobian JVol ; } } }
- { Name h ; Value { Local { [ nu[] * {d a} ] ; In Domain ; Jacobian JVol ; }
- Local { [ hc[] ] ; In Domain_M ; Jacobian JVol ; } } }
- }
- }
-}
-
-PostOperation {
- { Name MagSta_a ; NameOfPostProcessing MagSta_a;
- Operation {
- Print[ b, OnElementsOf Domain, File "MagSta_a_b.pos" ] ;
- Print[ h, OnElementsOf Domain, File "MagSta_a_h.pos" ] ;
- Print[ a, OnElementsOf Domain, File "MagSta_a_a.pos" ] ;
- }
- }
-}
diff --git a/contrib/mobile/Android/res/raw/models.zip b/contrib/mobile/Android/res/raw/models.zip
new file mode 100644
index 0000000000000000000000000000000000000000..de8f6ff724bec17b9e76ab05fdbd88d6f17e3578
Binary files /dev/null and b/contrib/mobile/Android/res/raw/models.zip differ
diff --git a/contrib/mobile/Android/res/raw/pmsm_8p_circuit_pro b/contrib/mobile/Android/res/raw/pmsm_8p_circuit_pro
deleted file mode 100644
index 37e1ac3756b8d223e7fda6adf651dfafc861216d..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/pmsm_8p_circuit_pro
+++ /dev/null
@@ -1,123 +0,0 @@
-//
-// Circuit for Permanent Magnet Synchronous Generator - cbmag
-//
-
-Group{
- // Dummy numbers for circuit definition
- R1 = #55551 ;
- R2 = #55552 ;
- R3 = #55553 ;
-
- Input1 = #10001 ;
- Input2 = #10002 ;
- Input3 = #10003 ;
- Input4 = #10004 ;
-
- Resistance_Cir = Region[{R1, R2, R3}];
- DomainZ_Cir = Region[ {Resistance_Cir} ];
-
- DomainSource_Cir = Region[ {} ] ;
- If(Flag_SrcType_Stator>1)
- DomainSource_Cir += Region[ {Input1, Input2, Input3} ] ;
- EndIf
-
- DomainZt_Cir = Region[ {DomainZ_Cir, DomainSource_Cir} ];
-}
-
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-
-Function {
- // Open circuit - load - short circuit
- DefineConstant[ ZR = {200,
- Choices{1e-8, 200, 1e8}, Label "Load resistance", Path "Input/", Highlight "AliceBlue"} ];
- Resistance[#{R1, R2, R3}] = ZR ;
-}
-
-// --------------------------------------------------------------------------
-
-Constraint {
-
- If (SymmetryFactor<8)
- If(Flag_SrcType_Stator==0)
- { Name ElectricalCircuit ; Type Network ;
- Case Circuit1 {
- { Region Stator_Ind_Ap ; Branch {100,102} ; }
- { Region Stator_Ind_Am ; Branch {103,102} ; }
- { Region R1 ; Branch {103,100} ; }
- }
- Case Circuit2 {
- { Region Stator_Ind_Bp ; Branch {200,202} ; }
- { Region Stator_Ind_Bm ; Branch {203,202} ; }
- { Region R2 ; Branch {203,200} ; }
- }
- Case Circuit3 {
- { Region Stator_Ind_Cp ; Branch {300,302} ; }
- { Region Stator_Ind_Cm ; Branch {303,302} ; }
- { Region R3 ; Branch {303,300} ; }
- }
- }
- EndIf
- If (Flag_SrcType_Stator==2)
- { Name ElectricalCircuit ; Type Network ;
- Case Circuit1 {
- { Region Input1 ; Branch {100,101} ; }
- { Region Stator_Ind_Ap ; Branch {101,102} ; }
- { Region Stator_Ind_Am ; Branch {103,102} ; }
- { Region R1 ; Branch {103,100} ; }
- }
- Case Circuit2 {
- { Region Input2 ; Branch {200,201} ; }
- { Region Stator_Ind_Bp ; Branch {201,202} ; }
- { Region Stator_Ind_Bm ; Branch {203,202} ; }
- { Region R2 ; Branch {203,200} ; }
- }
- Case Circuit3 {
- { Region Input3 ; Branch {300,301} ; }
- { Region Stator_Ind_Cp ; Branch {301,302} ; }
- { Region Stator_Ind_Cm ; Branch {303,302} ; }
- { Region R3 ; Branch {303,300} ; }
- }
- }
- EndIf
- EndIf
-
- If(SymmetryFactor==8)
- If(Flag_SrcType_Stator==0) // Only one physical region in geo allow per branch
- { Name ElectricalCircuit ; Type Network ;
- Case Circuit1 {
- { Region PhaseA ; Branch {100,102} ; }
- { Region R1 ; Branch {102,100} ; }
- }
- Case Circuit2 {
- { Region PhaseB ; Branch {200,202} ; }
- { Region R2 ; Branch {202,200} ; }
- }
- Case Circuit3 {
- { Region PhaseC ; Branch {300,302} ; }
- { Region R3 ; Branch {302,300} ; }
- }
- }
- EndIf
- If(Flag_SrcType_Stator==2) // Only one physical region in geo allow per branch
- { Name ElectricalCircuit ; Type Network ;
- Case Circuit1 {
- { Region Input1 ; Branch {100,101} ; }
- { Region PhaseA ; Branch {101,102} ; }
- { Region R1 ; Branch {102,100} ; }
- }
- Case Circuit2 {
- { Region Input2 ; Branch {200,201} ; }
- { Region PhaseB ; Branch {201,202} ; }
- { Region R2 ; Branch {202,200} ; }
- }
- Case Circuit3 {
- { Region Input3 ; Branch {300,301} ; }
- { Region PhaseC ; Branch {302,301} ; }
- { Region R3 ; Branch {302,300} ; }
- }
- }
- EndIf
- EndIf
-}
-
diff --git a/contrib/mobile/Android/res/raw/pmsm_data_geo b/contrib/mobile/Android/res/raw/pmsm_data_geo
deleted file mode 100644
index c2760986cf88f4c497dd8c8c9257314770d99072..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/pmsm_data_geo
+++ /dev/null
@@ -1,104 +0,0 @@
-// Permanent magnet synchronous machine
-// Example of Prof. Dr. Mauricio Valencia Ferreira da Luz (Florianopolis, August 23, 2010)
-
-// Modified and customised for Onelab by Ruth V. Sabariego (February, 2013)
-
-mm = 1e-3 ;
-deg2rad = Pi/180 ;
-
-DefineConstant[ NbrPoles = { 1, Choices {1="1",
- 2="2",
- 4="4",
- 8="8"},
- Label "Number of poles in FE model",
- Path "Input/1", Highlight "Blue", Visible 1} ] ;
-
-DefineConstant[ InitialRotorAngle_deg = {7.5, Label "Start rotor angle", Path "Input/20", Highlight "AliceBlue"} ];
-
-//--------------------------------------------------------------------------------
-
-InitialRotorAngle = InitialRotorAngle_deg*deg2rad ; // initial rotor angle, 0 if aligned
-
-AxialLength = 35*mm ;
-
-//------------------------------------------------
-//------------------------------------------------
-NbrPolesTot = 8 ; // number of poles in complete cross-section
-
-SymmetryFactor = NbrPolesTot/NbrPoles ;
-Flag_Symmetry = (SymmetryFactor==1)?0:1 ;
-
-NbrSectTot = NbrPolesTot ; // number of "rotor teeth"
-NbrSect = NbrSectTot*NbrPoles/NbrPolesTot ; // number of "rotor teeth" in FE model
-//--------------------------------------------------------------------------------
-
-//------------------------------------------------
-// Stator
-//------------------------------------------------
-NbrSectTotStator = 24; // number of stator teeth
-NbrSectStator = NbrSectTotStator*NbrPoles/NbrPolesTot; // number of stator teeth in FE model
-//--------------------------------------------------------------------------------
-
-lm = 2.352*mm ; // magnet height
-Th_magnet = 32.67 *deg2rad ; // angle in degrees 0 < Th_magnet < 45
-
-//--------------------------------------------------------------------------------
-
-rRext = 25.6*mm;
-rR1 = 10.5*mm;
-rR2 = (rRext-lm); //23.243e-03;
-rR3 = (rRext-0.7389*lm); //23.862e-03;
-rR4 = (rRext-0.72278*lm); //23.9e-03;
-rR5 = rRext; //25.6e-03;
-
-rS1 = 26.02*mm;
-rS2 = 26.62*mm;
-rS3 = 26.96*mm;
-rS4 = 38.16*mm;
-rS5 = 38.27*mm;
-rS6 = 40.02*mm;
-rS7 = 46.00*mm;
-
-Gap = rS1-rR5;
-
-rB1 = rR5+Gap/3;
-rB1b = rB1;
-rB2 = rR5+Gap*2/3;
-
-
-A0 = 45 * deg2rad ; // with this choice, axis A of stator is at 30 degrees with regard to horizontal axis
-A1 = 0 * deg2rad ; // Rotor initial aligned position, current position in angRot
-
-// ----------------------------------------------------
-// Numbers for physical regions in .geo and .pro files
-// ----------------------------------------------------
-// Rotor
-ROTOR_FE = 1000 ;
-ROTOR_AIR = 1001 ;
-ROTOR_AIRGAP = 1002 ;
-ROTOR_MAGNET = 1010 ; // Index for first Magnet (1/8 model->1; full model->8)
-
-ROTOR_BND_MOVING_BAND = 1100 ; // Index for first line (1/8 model->1; full model->8)
-ROTOR_BND_A0 = 1200 ;
-ROTOR_BND_A1 = 1201 ;
-SURF_INT = 1202 ;
-
-// Stator
-STATOR_FE = 2000 ;
-STATOR_AIR = 2001 ;
-STATOR_AIRGAP = 2002 ;
-
-STATOR_BND_MOVING_BAND = 2100 ;// Index for first line (1/8 model->1; full model->8)
-STATOR_BND_A0 = 2200 ;
-STATOR_BND_A1 = 2201 ;
-
-STATOR_IND = 2300 ; //Index for first Ind (1/8 model->3; full model->24)
-STATOR_IND_AP = STATOR_IND + 1 ; STATOR_IND_BM = STATOR_IND + 2 ;STATOR_IND_CP = STATOR_IND + 3 ;
-STATOR_IND_AM = STATOR_IND + 4 ; STATOR_IND_BP = STATOR_IND + 5 ;STATOR_IND_CM = STATOR_IND + 6 ;
-
-SURF_EXT = 3000 ; // outer boundary
-
-
-MOVING_BAND = 9999 ;
-
-NICEPOS = 111111 ;
diff --git a/contrib/mobile/Android/res/raw/pmsm_geo b/contrib/mobile/Android/res/raw/pmsm_geo
deleted file mode 100644
index efade112ec7041f40cae86e572324f99da649652..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/pmsm_geo
+++ /dev/null
@@ -1,95 +0,0 @@
-Include "pmsm_data.geo";
-
-Mesh.Algorithm = 1;
-Geometry.CopyMeshingMethod = 1;
-
-Mesh.CharacteristicLengthFactor = 1.5 ;
-
-
-// Mesh characteristic lengths
-s = 0.4 ;
-pR1=(rR2-rR1)/6.*s;
-pR2=(rR2-rR1)/6.*s;
-
-pS1=(rS7-rS1)/7.*s;
-pS2=(rS7-rS1)/12.*s;
-pS3=(rS6-rS3)/10.*s;
-
-NbrDivMB = 2*Ceil[2*Pi*rRext/8/pR1]; //1/8 Moving band
-
-//--------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------
-
-cen = newp ; Point(cen)={0,0,0,pR1};
-nicepos_rotor[] = {};
-nicepos_stator[] = {};
-
-Include "pmsm_rotor.geo";
-Include "pmsm_stator.geo";
-
-
-// For nice visualisation...
-Mesh.Light = 0 ;
-//Mesh.SurfaceFaces = 1; Mesh.SurfaceEdges=0;
-
-Hide { Point{ Point '*' }; }
-Hide { Line{ Line '*' }; }
-Show { Line{ nicepos_rotor[], nicepos_stator[] }; }
-
-Physical Line(NICEPOS) = { nicepos_rotor[], nicepos_stator[] };
-
-//For post-processing...
-View[0].Light = 0;
-View[0].NbIso = 25; // Number of intervals
-View[0].IntervalsType = 1;
-
-DefineConstant[ Flag_AddInfo = {0, Choices{0,1},
- Label "Add info about phases and axis",
- Path "Input/1"} ];
-
-For i In {PostProcessing.NbViews-1 : 0 : -1}
- If(StrFind(View[i].Attributes, "tmp"))
- Delete View[i];
- EndIf
-EndFor
-
-If(Flag_AddInfo)
- rr = 1.25 * rS3 ;
- For k In {0:NbrPoles-1}
- xa[] += rr*Cos(1*Pi/24+k*Pi/4) ; ya[] += rr*Sin(1*Pi/24+k*Pi/4) ;
- xb[] += rr*Cos(3*Pi/24+k*Pi/4) ; yb[] += rr*Sin(3*Pi/24+k*Pi/4) ;
- xc[] += rr*Cos(5*Pi/24+k*Pi/4) ; yc[] += rr*Sin(5*Pi/24+k*Pi/4) ;
- EndFor
-
- // Adding some axes
- rr0 = 0.3 * rS7 ;
- rr1 = 1.3 * rS7 ;
- th_d = InitialRotorAngle ;
- th_q = th_d + 22.5 * deg2rad ;
-
- th_a = 30 * deg2rad ;
- th_b = (30 + 120/4) * deg2rad ;
- th_c = (30 + 240/4) * deg2rad ;
-
- ff = 0.9;
-
- xd[0] = rr0*Cos(th_d) ; yd[0] = rr0*Sin(th_d) ;
- xd[1] = ff*rr1*Cos(th_d) ; yd[1] = ff*rr1*Sin(th_d) ;
- xq[0] = rr0*Cos(th_q) ; yq[0] = rr0*Sin(th_q) ;
- xq[1] = ff*rr1*Cos(th_q) ; yq[1] = ff*rr1*Sin(th_q) ;
-
- xaa[0] = rr0*Cos(th_a) ; yaa[0] = rr0*Sin(th_a) ;
- xaa[1] = rr1*Cos(th_a) ; yaa[1] = rr1*Sin(th_a) ;
- xbb[0] = rr0*Cos(th_b) ; ybb[0] = rr0*Sin(th_b) ;
- xbb[1] = rr1*Cos(th_b) ; ybb[1] = rr1*Sin(th_b) ;
- xcc[0] = rr0*Cos(th_c) ; ycc[0] = rr0*Sin(th_c) ;
- xcc[1] = rr1*Cos(th_c) ; ycc[1] = rr1*Sin(th_c) ;
-
-
- Include "info_view.geo";
-
-EndIf
-
-
-
-
diff --git a/contrib/mobile/Android/res/raw/pmsm_geo_pro b/contrib/mobile/Android/res/raw/pmsm_geo_pro
deleted file mode 100644
index 225b29dd4fb482e800a1000ae94132e261b3d1e9..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/pmsm_geo_pro
+++ /dev/null
@@ -1,211 +0,0 @@
-//
-// Permanent Magnet Synchronous Generator
-//
-
-Include "pmsm_data.geo";
-
-DefineConstant[ Flag_NL = {0,
- Choices{ 0="Linear",
- 1="Nonlinear BH curve"},
- Label "Fe magnetic law",
- Path "Input/3", Highlight "Blue"} ] ;
-
-DefineConstant[ Flag_SrcType_Stator = {0,
- Choices{ 0="None",
- 1="Current" },
- Label "Source Type in Stator",
- Path "Input/4", Highlight "Blue", Visible 1} ] ;
-
-DefineConstant[ Flag_SrcType_Rotor = {0,
- Choices{ 0="None",
- 1="Current" },
- Label "Source Type in Rotor",
- Path "Input/5", Highlight "Blue", Visible 0} ] ;
-
-DefineConstant[ Flag_Cir = {!Flag_SrcType_Stator, Choices{0,1},
- Label "Use circuit in Stator", ReadOnly 1, Visible 0} ] ;
-
-Group {
- Stator_Fe = #STATOR_FE ;
- Stator_Al = #{};
- Stator_Cu = #{};
- Stator_Air = #STATOR_AIR ;
- Stator_Airgap = #STATOR_AIRGAP ;
-
- Stator_Bnd_A0 = #STATOR_BND_A0 ;
- Stator_Bnd_A1 = #STATOR_BND_A1 ;
-
- Rotor_Fe = #ROTOR_FE ;
- Rotor_Al = #{};
- Rotor_Cu = #{};
- Stator_Air = #STATOR_AIR ;
- Stator_Airgap = #STATOR_AIRGAP ;
- Stator_Bnd_MB = #STATOR_BND_MOVING_BAND ;
- Stator_Bnd_A0 = #STATOR_BND_A0 ;
- Stator_Bnd_A1 = #STATOR_BND_A1 ;
-
- Rotor_Fe = #ROTOR_FE ;
- Rotor_Air = #ROTOR_AIR ;
- Rotor_Airgap = #ROTOR_AIRGAP ;
-
- Rotor_Bnd_A0 = #ROTOR_BND_A0 ;
- Rotor_Bnd_A1 = #ROTOR_BND_A1 ;
-
- MovingBand_PhysicalNb = #MOVING_BAND ; // Fictitious number for moving band, not in the geo file
- Surf_Inf = #SURF_EXT ;
- Surf_bn0 = #SURF_INT ;
- Surf_cutA0 = #{STATOR_BND_A0, ROTOR_BND_A0};
- Surf_cutA1 = #{STATOR_BND_A1, ROTOR_BND_A1};
-
- Dummy = #NICEPOS;
-
- nbMagnets = NbrPolesTot/SymmetryFactor ;
- For k In {1:nbMagnets}
- Rotor_Magnet~{k} = Region[ (ROTOR_MAGNET+k-1) ];
- Rotor_Magnets += Region[ Rotor_Magnet~{k} ];
- EndFor
-
- nbInds = (Flag_Symmetry) ? NbrPoles*NbrSectTotStator/NbrPolesTot : NbrSectTotStator ;
- Printf("NbrPoles=%g, nbInds=%g SymmetryFactor=%g", NbrPoles, nbInds, SymmetryFactor);
-
- Stator_Ind_Ap = #{}; Stator_Ind_Am = #{STATOR_IND_AM};
- Stator_Ind_Bp = #{}; Stator_Ind_Bm = #{STATOR_IND_BM};
- Stator_Ind_Cp = #{STATOR_IND_CP}; Stator_Ind_Cm = #{};
- If(NbrPoles > 1)
- Stator_Ind_Ap += #STATOR_IND_AP;
- Stator_Ind_Bp += #STATOR_IND_BP;
- Stator_Ind_Cm += #STATOR_IND_CM;
- EndIf
-
- PhaseA = Region[{ Stator_Ind_Ap, Stator_Ind_Am }];
- PhaseB = Region[{ Stator_Ind_Bp, Stator_Ind_Bm }];
- PhaseC = Region[{ Stator_Ind_Cp, Stator_Ind_Cm }];
-
- // Provisional: Just one physical region for nice graph in Onelab
- PhaseA_pos = Region[{ Stator_Ind_Am }];
- PhaseB_pos = Region[{ Stator_Ind_Bm }];
- PhaseC_pos = Region[{ Stator_Ind_Cp }];
-
- Stator_IndsP = Region[{ Stator_Ind_Ap, Stator_Ind_Bp, Stator_Ind_Cp }];
- Stator_IndsN = Region[{ Stator_Ind_Am, Stator_Ind_Bm, Stator_Ind_Cm }];
-
- Stator_Inds = Region[ {PhaseA, PhaseB, PhaseC} ] ;
- Rotor_Inds = Region[ {} ] ;
-
- StatorC = Region[{ }] ;
- StatorCC = Region[{ Stator_Fe }] ;
- RotorC = Region[{ }] ;
- RotorCC = Region[{ Rotor_Fe, Rotor_Magnets }] ;
-
- // Moving band: with or without symmetry, these BND lines must be complete
- Stator_Bnd_MB = #STATOR_BND_MOVING_BAND;
- For k In {1:SymmetryFactor}
- Rotor_Bnd_MB~{k} = Region[ (ROTOR_BND_MOVING_BAND+k-1) ];
- Rotor_Bnd_MB += Region[ Rotor_Bnd_MB~{k} ];
- EndFor
- Rotor_Bnd_MBaux = Region[ {Rotor_Bnd_MB, -Rotor_Bnd_MB~{1}}];
-
-}
-
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-
-Function {
-
- mur_fe = 1000 ;
- sigma_fe = 0 ;
-
- NbrPhases = 3 ;
- NbrPolePairs = NbrPolesTot/2 ;
-
- DefineConstant[ b_remanent = { 1.2, Label "Remanent induction", Path "Input/3", Highlight "AliceBlue"} ] ;
- // For a radial remanent b
- For k In {1:nbMagnets}
- br[ Rotor_Magnet~{k} ] = (-1)^(k-1) * b_remanent * Vector[ Cos[Atan2[Y[],X[]]], Sin[Atan2[Y[],X[]]], 0 ];
- EndFor
-
- Inominal = 3.9 ; // Nominal current
- Tnominal = 2.5 ; // Nominal torque
-
- //Data for modeling a stranded inductor
- NbWires[] = 104 ; // Number of wires per slot
- // STATOR_IND_AM comprises all the slots in that phase, we need thus to divide by the number of slots
- nbSlots[] = Ceil[nbInds/NbrPhases/2] ;
- SurfCoil[] = SurfaceArea[]{STATOR_IND_AM}/nbSlots[] ;//All inductors have the same surface
-
- FillFactor_Winding = 0.5 ; // percentage of Cu in the surface coil side, smaller than 1
- Factor_R_3DEffects = 1.5 ; // bigger than Adding 50% of resistance
-
- DefineConstant[ rpm = { 500,
- Label "speed in rpm",
- Path "Input/7", Highlight "AliceBlue"} ]; // speed in rpm
- wr = rpm/60*2*Pi ; // speed in rad_mec/s
-
- // supply at fixed position
- DefineConstant[ Freq = {wr*NbrPolePairs/(2*Pi), ReadOnly 1,
- Path "Output/1", Highlight "LightYellow" } ];
- Omega = 2*Pi*Freq ;
- T = 1/Freq ;
-
- DefineConstant[ thetaMax_deg = { 180, Label "End rotor angle (loop)",
- Path "Input/21", Highlight "AliceBlue" } ];
-
- theta0 = InitialRotorAngle + 0. ;
- thetaMax = thetaMax_deg * deg2rad ; // end rotor angle (used in doing a loop)
-
- DefineConstant[ NbTurns = { (thetaMax-theta0)/(2*Pi), Label "Number of revolutions",
- Path "Input/24", Highlight "LightGrey", ReadOnly 1} ];
-
- DefineConstant[ delta_theta_deg = { 1., Label "step in degrees",
- Path "Input/22", Highlight "AliceBlue"} ];
-
- delta_theta = delta_theta_deg * deg2rad ;
-
- time0 = 0 ; // at initial rotor position
- delta_time = delta_theta/wr;
- timemax = thetaMax/wr;
-
- DefineConstant[ NbSteps = { Ceil[(timemax-time0)/delta_time], Label "Number of steps",
- Path "Input/23", Highlight "LightGrey", ReadOnly 1} ];
-
- RotorPosition[] = InitialRotorAngle + $Time * wr ;
- RotorPosition_deg[] = RotorPosition[]*180/Pi;
-
- Flag_ParkTransformation = 1 ;
- Theta_Park[] = ((RotorPosition[] + Pi/8) - Pi/6) * NbrPolePairs; // electrical degrees
- Theta_Park_deg[] = Theta_Park[]*180/Pi;
-
- DefineConstant[ ID = { 0, Path "Input/60", Label "Id stator current", Highlight "AliceBlue"},
- IQ = { Inominal, Path "Input/61", Label "Iq stator current", Highlight "AliceBlue"},
- I0 = { 0, Visible 0} ] ;
-
- If(Flag_SrcType_Stator==0)
- UndefineConstant["Input/60ID"];
- UndefineConstant["Input/61IQ"];
- EndIf
-}
-
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-
-Dir="res/";
-ExtGmsh = ".pos";
-ExtGnuplot = ".dat";
-
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-
-If(Flag_SrcType_Stator==1)
- UndefineConstant["Input/ZR"];
-EndIf
-
-If(Flag_Cir)
- Include "pmsm_8p_circuit.pro" ;
-EndIf
-Include "machine_magstadyn_a.pro" ;
-
-DefineConstant[ ResolutionChoices = {"TimeDomain_Loop", Path "GetDP/1"} ];
-DefineConstant[ PostOperationChoices = {"Map_LocalFields", Path "GetDP/2"} ];
-DefineConstant[ ComputeCommand = {"-solve -v 1 -v2", Path "GetDP/9"} ];
diff --git a/contrib/mobile/Android/res/raw/pmsm_pro b/contrib/mobile/Android/res/raw/pmsm_pro
deleted file mode 100644
index b9ee5ce16ab353f10ca3891a9ccb123b345922bc..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/pmsm_pro
+++ /dev/null
@@ -1,211 +0,0 @@
-//
-// Permanent Magnet Synchronous Generator
-//
-
-Include "pmsm_data.geo";
-
-DefineConstant[ Flag_NL = {0,
- Choices{ 0="Linear",
- 1="Nonlinear BH curve"},
- Label "Fe magnetic law",
- Path "Input/3", Highlight "Blue"} ] ;
-
-DefineConstant[ Flag_SrcType_Stator = {1,
- Choices{ 0="None",
- 1="Current" },
- Label "Source Type in Stator",
- Path "Input/4", Highlight "Blue", Visible 1} ] ;
-
-DefineConstant[ Flag_SrcType_Rotor = {0,
- Choices{ 0="None",
- 1="Current" },
- Label "Source Type in Rotor",
- Path "Input/5", Highlight "Blue", Visible 0} ] ;
-
-DefineConstant[ Flag_Cir = {!Flag_SrcType_Stator, Choices{0,1},
- Label "Use circuit in Stator", ReadOnly 1, Visible 0} ] ;
-
-Group {
- Stator_Fe = #STATOR_FE ;
- Stator_Al = #{};
- Stator_Cu = #{};
- Stator_Air = #STATOR_AIR ;
- Stator_Airgap = #STATOR_AIRGAP ;
-
- Stator_Bnd_A0 = #STATOR_BND_A0 ;
- Stator_Bnd_A1 = #STATOR_BND_A1 ;
-
- Rotor_Fe = #ROTOR_FE ;
- Rotor_Al = #{};
- Rotor_Cu = #{};
- Stator_Air = #STATOR_AIR ;
- Stator_Airgap = #STATOR_AIRGAP ;
- Stator_Bnd_MB = #STATOR_BND_MOVING_BAND ;
- Stator_Bnd_A0 = #STATOR_BND_A0 ;
- Stator_Bnd_A1 = #STATOR_BND_A1 ;
-
- Rotor_Fe = #ROTOR_FE ;
- Rotor_Air = #ROTOR_AIR ;
- Rotor_Airgap = #ROTOR_AIRGAP ;
-
- Rotor_Bnd_A0 = #ROTOR_BND_A0 ;
- Rotor_Bnd_A1 = #ROTOR_BND_A1 ;
-
- MovingBand_PhysicalNb = #MOVING_BAND ; // Fictitious number for moving band, not in the geo file
- Surf_Inf = #SURF_EXT ;
- Surf_bn0 = #SURF_INT ;
- Surf_cutA0 = #{STATOR_BND_A0, ROTOR_BND_A0};
- Surf_cutA1 = #{STATOR_BND_A1, ROTOR_BND_A1};
-
- Dummy = #NICEPOS;
-
- nbMagnets = NbrPolesTot/SymmetryFactor ;
- For k In {1:nbMagnets}
- Rotor_Magnet~{k} = Region[ (ROTOR_MAGNET+k-1) ];
- Rotor_Magnets += Region[ Rotor_Magnet~{k} ];
- EndFor
-
- nbInds = (Flag_Symmetry) ? NbrPoles*NbrSectTotStator/NbrPolesTot : NbrSectTotStator ;
- Printf("NbrPoles=%g, nbInds=%g SymmetryFactor=%g", NbrPoles, nbInds, SymmetryFactor);
-
- Stator_Ind_Ap = #{}; Stator_Ind_Am = #{STATOR_IND_AM};
- Stator_Ind_Bp = #{}; Stator_Ind_Bm = #{STATOR_IND_BM};
- Stator_Ind_Cp = #{STATOR_IND_CP}; Stator_Ind_Cm = #{};
- If(NbrPoles > 1)
- Stator_Ind_Ap += #STATOR_IND_AP;
- Stator_Ind_Bp += #STATOR_IND_BP;
- Stator_Ind_Cm += #STATOR_IND_CM;
- EndIf
-
- PhaseA = Region[{ Stator_Ind_Ap, Stator_Ind_Am }];
- PhaseB = Region[{ Stator_Ind_Bp, Stator_Ind_Bm }];
- PhaseC = Region[{ Stator_Ind_Cp, Stator_Ind_Cm }];
-
- // Provisional: Just one physical region for nice graph in Onelab
- PhaseA_pos = Region[{ Stator_Ind_Am }];
- PhaseB_pos = Region[{ Stator_Ind_Bm }];
- PhaseC_pos = Region[{ Stator_Ind_Cp }];
-
- Stator_IndsP = Region[{ Stator_Ind_Ap, Stator_Ind_Bp, Stator_Ind_Cp }];
- Stator_IndsN = Region[{ Stator_Ind_Am, Stator_Ind_Bm, Stator_Ind_Cm }];
-
- Stator_Inds = Region[ {PhaseA, PhaseB, PhaseC} ] ;
- Rotor_Inds = Region[ {} ] ;
-
- StatorC = Region[{ }] ;
- StatorCC = Region[{ Stator_Fe }] ;
- RotorC = Region[{ }] ;
- RotorCC = Region[{ Rotor_Fe, Rotor_Magnets }] ;
-
- // Moving band: with or without symmetry, these BND lines must be complete
- Stator_Bnd_MB = #STATOR_BND_MOVING_BAND;
- For k In {1:SymmetryFactor}
- Rotor_Bnd_MB~{k} = Region[ (ROTOR_BND_MOVING_BAND+k-1) ];
- Rotor_Bnd_MB += Region[ Rotor_Bnd_MB~{k} ];
- EndFor
- Rotor_Bnd_MBaux = Region[ {Rotor_Bnd_MB, -Rotor_Bnd_MB~{1}}];
-
-}
-
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-
-Function {
-
- mur_fe = 1000 ;
- sigma_fe = 0 ;
-
- NbrPhases = 3 ;
- NbrPolePairs = NbrPolesTot/2 ;
-
- DefineConstant[ b_remanent = { 1.2, Label "Remanent induction", Path "Input/3", Highlight "AliceBlue"} ] ;
- // For a radial remanent b
- For k In {1:nbMagnets}
- br[ Rotor_Magnet~{k} ] = (-1)^(k-1) * b_remanent * Vector[ Cos[Atan2[Y[],X[]]], Sin[Atan2[Y[],X[]]], 0 ];
- EndFor
-
- Inominal = 3.9 ; // Nominal current
- Tnominal = 2.5 ; // Nominal torque
-
- //Data for modeling a stranded inductor
- NbWires[] = 104 ; // Number of wires per slot
- // STATOR_IND_AM comprises all the slots in that phase, we need thus to divide by the number of slots
- nbSlots[] = Ceil[nbInds/NbrPhases/2] ;
- SurfCoil[] = SurfaceArea[]{STATOR_IND_AM}/nbSlots[] ;//All inductors have the same surface
-
- FillFactor_Winding = 0.5 ; // percentage of Cu in the surface coil side, smaller than 1
- Factor_R_3DEffects = 1.5 ; // bigger than Adding 50% of resistance
-
- DefineConstant[ rpm = { 500,
- Label "speed in rpm",
- Path "Input/7", Highlight "AliceBlue"} ]; // speed in rpm
- wr = rpm/60*2*Pi ; // speed in rad_mec/s
-
- // supply at fixed position
- DefineConstant[ Freq = {wr*NbrPolePairs/(2*Pi), ReadOnly 1,
- Path "Output/1", Highlight "LightYellow" } ];
- Omega = 2*Pi*Freq ;
- T = 1/Freq ;
-
- DefineConstant[ thetaMax_deg = { 180, Label "End rotor angle (loop)",
- Path "Input/21", Highlight "AliceBlue" } ];
-
- theta0 = InitialRotorAngle + 0. ;
- thetaMax = thetaMax_deg * deg2rad ; // end rotor angle (used in doing a loop)
-
- DefineConstant[ NbTurns = { (thetaMax-theta0)/(2*Pi), Label "Number of revolutions",
- Path "Input/24", Highlight "LightGrey", ReadOnly 1} ];
-
- DefineConstant[ delta_theta_deg = { 1., Label "step in degrees",
- Path "Input/22", Highlight "AliceBlue"} ];
-
- delta_theta = delta_theta_deg * deg2rad ;
-
- time0 = 0 ; // at initial rotor position
- delta_time = delta_theta/wr;
- timemax = thetaMax/wr;
-
- DefineConstant[ NbSteps = { Ceil[(timemax-time0)/delta_time], Label "Number of steps",
- Path "Input/23", Highlight "LightGrey", ReadOnly 1} ];
-
- RotorPosition[] = InitialRotorAngle + $Time * wr ;
- RotorPosition_deg[] = RotorPosition[]*180/Pi;
-
- Flag_ParkTransformation = 1 ;
- Theta_Park[] = ((RotorPosition[] + Pi/8) - Pi/6) * NbrPolePairs; // electrical degrees
- Theta_Park_deg[] = Theta_Park[]*180/Pi;
-
- DefineConstant[ ID = { 0, Path "Input/60", Label "Id stator current", Highlight "AliceBlue"},
- IQ = { Inominal, Path "Input/61", Label "Iq stator current", Highlight "AliceBlue"},
- I0 = { 0, Visible 0} ] ;
-
- If(Flag_SrcType_Stator==0)
- UndefineConstant["Input/60ID"];
- UndefineConstant["Input/61IQ"];
- EndIf
-}
-
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-
-Dir="res/";
-ExtGmsh = ".pos";
-ExtGnuplot = ".dat";
-
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-// --------------------------------------------------------------------------
-
-If(Flag_SrcType_Stator==1)
- UndefineConstant["Input/ZR"];
-EndIf
-
-If(Flag_Cir)
- Include "pmsm_8p_circuit.pro" ;
-EndIf
-Include "machine_magstadyn_a.pro" ;
-
-DefineConstant[ ResolutionChoices = {"TimeDomain_Loop", Path "GetDP/1"} ];
-DefineConstant[ PostOperationChoices = {"Map_LocalFields", Path "GetDP/2"} ];
-DefineConstant[ ComputeCommand = {"-solve -v 1 -v2", Path "GetDP/9"} ];
diff --git a/contrib/mobile/Android/res/raw/pmsm_rotor_geo b/contrib/mobile/Android/res/raw/pmsm_rotor_geo
deleted file mode 100644
index c051cf1a6da52b733f73e0548acccf70858e1fd4..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/pmsm_rotor_geo
+++ /dev/null
@@ -1,163 +0,0 @@
-//--------------------------------------------------------------------------------
-// Rotor PMSM
-//--------------------------------------------------------------------------------
-A = InitialRotorAngle-45/2*deg2rad + A1; // with Theta_Park
-
-sinA = Sin(A); cosA = Cos(A);
-pntR[]+=newp; Point(newp)={rR1*cosA, rR1*sinA, 0, pR1};
-pntR[]+=newp; Point(newp)={rR2*cosA, rR2*sinA, 0, pR1};
-pntR[]+=newp; Point(newp)={rR4*cosA, rR4*sinA, 0, pR1};
-pntR[]+=newp; Point(newp)={rR5*cosA, rR5*sinA, 0, pR1};
-pntR[]+=newp; Point(newp)={rB1*cosA, rB1*sinA, 0, pR2};
-
-For k In {0:#pntR[]-2}
- linR0[]+=newl; Line(newl) = {pntR[k], pntR[k+1]};
-EndFor
-
-Transfinite Line{linR0[0]} = Ceil[(rR2-rR1)/pR1] ;
-Transfinite Line{linR0[1]} = Ceil[(rR4-rR2)/pR1] ;
-Transfinite Line{linR0[2]} = Ceil[(rR5-rR4)/pR1] ;
-Transfinite Line{linR0[3]} = Ceil[(rB1-rR5)/pR1] ;
-
-For k In {0:#linR0[]-1}
- linR1[] += Rotate {{0, 0, 1}, {0, 0, 0}, A0+A1} { Duplicata{Line{linR0[k]};} };
-EndFor
-
-AA[] = {(A0-Th_magnet)/2+A1, Th_magnet, (A0-Th_magnet)/2+A1} ;
-
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, AA[0]} { Point{pntR[0]}; };
-cirR[]+=lin[1];
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, AA[1]} { Point{lin[0]}; };
-cirR[]+=lin[1];
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, AA[2]} { Point{lin[0]}; };
-cirR[]+=lin[1];
-
-surfint[]=cirR[{0,1,2}] ; // boundary conditions
-
-pMagnet[] = Rotate {{0, 0, 1}, {0, 0, 0}, AA[0]} { Duplicata{Point{pntR[1]};} };
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, AA[1]} { Point{pMagnet[0]}; };
-pMagnet[] += lin[0];
-cirR[] += lin[1] ;
-
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, AA[0]} { Point{pntR[2]}; };
-cirR[]+=lin[1]; pMagnet[] += lin[0];
-pMagnet[] += Rotate {{0, 0, 1}, {0, 0, 0}, AA[1]} { Duplicata{Point{lin[0]};} };
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, AA[2]} { Point{pMagnet[3]}; };
-cirR[]+=lin[1];
-
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, AA[0]} { Point{pntR[3]}; };
-cirR[]+=lin[1];
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, AA[1]} { Point{lin[0]}; };
-cirR[]+=lin[1];
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, AA[2]} { Point{lin[0]}; };
-cirR[]+=lin[1];
-
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, A0+A1} { Point{pntR[4]}; };
-cirR[]+=lin[1];
-
-linR2[] = Rotate {{0, 0, 1}, {0, 0, 0}, (A0-Th_magnet)/2+A1} { Duplicata{Line{linR0[{1,2}]};} };
-linR3[] = Rotate {{0, 0, 1}, {0, 0, 0},-(A0-Th_magnet)/2+A1} { Duplicata{Line{linR1[{1,2}]};} };
-
-// surfaces rotor
-Line Loop(newll) = {linR0[{0,1}], cirR[4], -linR2[0], cirR[3], linR3[0], cirR[5], -linR1[{1,0}], -cirR[{2,1,0}]};
-srotor[0]=news; Plane Surface(srotor[0]) = {newll-1};
-
-Line Loop(newl) = {linR2[1], cirR[7], -linR3[{1,0}], -cirR[3], linR2[0]};
-smagnet[0]=news; Plane Surface(smagnet[0]) = {newll-1};
-
-nn = #cirR[]-1 ;
-Line Loop(newll) = {cirR[{nn-5}], linR2[1], -cirR[{nn-3}], -linR0[2]};
-sairrotor[]+=news; Plane Surface(news) = {newll-1};
-Line Loop(newll) = {cirR[{nn-4}], linR1[2], -cirR[{nn-1}], -linR3[1]};
-sairrotor[]+=news; Plane Surface(news) = {newll-1};
-
-Line Loop(newll) = {linR0[3], cirR[nn], -linR1[3], -cirR[{nn-1:nn-3:-1}]};
-sairrotormb[]+=news; Plane Surface(news) = {newll-1};
-
-// -------------------------------------------------------------------------------
-// Moving band == AirGap rotor side
-// -------------------------------------------------------------------------------
-Transfinite Line{cirR[nn]} = NbrDivMB+1 ;
-
-//Filling the gap for the whole 2*Pi
-lineMBrotor[]=cirR[{nn}];
-For k In {1:NbrPolesTot-1}
- lineMBrotoraux[]+=Rotate {{0, 0, 1}, {0, 0, 0}, k*A0} { Duplicata{Line{lineMBrotor[]};} };
-EndFor
-
-// -------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------
-If(SymmetryFactor<8)
-// FULL MODEL ==> Rotation of NbrPolesTot*Pi/4
-// For simplicity: rotating first the interior and exterior boundaries
-
- If (SymmetryFactor>1)
- For k In {0:#linR1[]-1}
- linR1_[] += Rotate {{0, 0, 1}, {0, 0, 0}, 2*Pi/SymmetryFactor-Pi/4} { Duplicata{Line{linR1[k]};} };
- EndFor
- linR1[] = linR1_[];
- EndIf
-
- For k In {1:NbrPoles-1}
- surfint[] += Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Line{surfint[{0:2}]};} };
- EndFor
- For k In {1:NbrPoles-1}
- srotor[] += Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Surface{srotor[0]};} };
- smagnet[]+= Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Surface{smagnet[0]};} };
- sairrotor[] += Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Surface{sairrotor[{0,1}]};} };
- sairrotormb[]+= Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Surface{sairrotormb[0]};} };
- EndFor
-EndIf
-
-
-// -------------------------------------------------------------------------------
-// Physical regions
-// -------------------------------------------------------------------------------
-
-Physical Surface(ROTOR_FE) = {srotor[]}; // Rotor
-Physical Surface(ROTOR_AIR) = {sairrotor[]}; // AirRotor
-Physical Surface(ROTOR_AIRGAP) = {sairrotormb[]};// AirRotor for possible torque computation with Maxwell stress tensor
-
-NN = (Flag_Symmetry)?NbrPoles:NbrPolesTot;
-For k In {0:NN-1}
- Physical Surface(ROTOR_MAGNET+k) = {smagnet[k]}; // Magnets
-EndFor
-
-Physical Line(SURF_INT) = {surfint[]}; // SurfInt
-
-
-If(Flag_Symmetry) //Lines for symmetry link
- Physical Line(ROTOR_BND_A0) = linR0[];
- Physical Line(ROTOR_BND_A1) = linR1[];
-EndIf
-
-lineMBrotor[] += lineMBrotoraux[] ;
-If(!Flag_Symmetry)
- Physical Line(ROTOR_BND_MOVING_BAND) = {lineMBrotor[]};
-EndIf
-If(Flag_Symmetry)
- nr = #lineMBrotor[];
- nnp = nr/(NbrPolesTot/NbrSect) ;
- For k In {1:Floor[NbrPolesTot/NbrSect]}
- kk= ((k*nnp-1) > nr) ? nr-1 : k*nnp-1 ;
- Physical Line(ROTOR_BND_MOVING_BAND+k-1) = lineMBrotor[{(k-1)*nnp:kk}] ;
- EndFor
- k1 = Floor[NbrPolesTot/NbrSect];
- k2 = Ceil[NbrPolesTot/NbrSect];
- If (k2 > k1)
- Physical Line(ROTOR_BND_MOVING_BAND+k2-1) = lineMBrotor[{(k2-1)*nnp:#lineMBrotor[]-1}] ;
- EndIf
-EndIf
-
-// For nice visualisation...
-linRotor[] = CombinedBoundary{Surface{srotor[]};};
-linMagnet[] = Boundary{Surface{smagnet[]};};
-
-nicepos_rotor[] += { linRotor[], linMagnet[] };
-
-Color SteelBlue {Surface{srotor[]};}
-Color SkyBlue {Surface{sairrotor[], sairrotormb[]};}
-Color Orchid {Surface{smagnet[{0:#smagnet[]-1:2}]};}
-If(#smagnet[]>1)
-Color Purple {Surface{smagnet[{1:#smagnet[]-1:2}]};}
-EndIf
diff --git a/contrib/mobile/Android/res/raw/pmsm_stator_geo b/contrib/mobile/Android/res/raw/pmsm_stator_geo
deleted file mode 100644
index e928a4a055c5b8f9809365103aabcbf2046b4f96..0000000000000000000000000000000000000000
--- a/contrib/mobile/Android/res/raw/pmsm_stator_geo
+++ /dev/null
@@ -1,215 +0,0 @@
-// -------------------------------------------------------------------------------
-// Moving band == AirGap stator side
-// -------------------------------------------------------------------------------
-pntG[]+=newp; Point(newp) = {rB2, 0., 0., pS1}; // aligned with the stator
-circ[] = Extrude {{0, 0, 1}, {0, 0, 0}, A0} { Point{pntG[0]}; };
-pntG[]+=circ[0];
-lineMBstator[]=circ[1];
-Transfinite Line{lineMBstator[0]} = NbrDivMB+1 ;
-
-//Filling the gap for the whole 2*Pi
-For k In {1:NbrPolesTot-1}
- lineMBstatoraux[]+= Rotate {{0, 0, 1}, {0, 0, 0}, k*A0} { Duplicata{Line{lineMBstator[0]};} };
-EndFor
-
-// -------------------------------------------------------------------------------
-// Stator
-// -------------------------------------------------------------------------------
-
-pntS[] = newp; Point(newp)={rS1, 0, 0, pS1};
-linS[] = newl; Line(newl) = {pntG[0], pntS[0]};
-linS[]+= Rotate {{0, 0, 1}, {0, 0, 0}, A0} { Duplicata{Line{linS[0]};} };
-
-pntS[]+=newp; Point(newp)={rS7,0,0,pS2};
-points[]=Boundary{Line{linS[1]};};
-pntS[]+=points[1];
-
-lin[] = Extrude {{0, 0, 1}, {0, 0, 0}, A0} { Point{pntS[1]}; };
-cirS[]= lin[1]; pntS[]+=lin[0];
-
-linS[]+=newl; Line(newl) = {pntS[0], pntS[1]};
-linS[]+=newl; Line(newl) = {pntS[2], pntS[3]};
-
-// -------------------------------------------------------------------------------
-// Slots
-// -------------------------------------------------------------------------------
-
-A2 = 0.0;
-AA[]=deg2rad*{2.77+A2, 4.0+A2, 5.52+A2, 5.56+A2, 5.65+A2, 9.35+A2, 9.44+A2, 9.48+A2, 11+A2, 12.23+A2} ;
-
-For k In {0:#AA[]-1}
- cosAA[]+=Cos(AA[k]); sinAA[]+=Sin(AA[k]);
-EndFor
-
-pntSlot[]+=newp; Point(newp)={rS5*cosAA[0], rS5*sinAA[0], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS3*cosAA[1], rS3*sinAA[1], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS1*cosAA[2], rS1*sinAA[2], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS2*cosAA[3], rS2*sinAA[3], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS4*cosAA[3], rS4*sinAA[3], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS6*cosAA[4], rS6*sinAA[4], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS6*cosAA[5], rS6*sinAA[5], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS4*cosAA[6], rS4*sinAA[6], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS2*cosAA[6], rS2*sinAA[6], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS1*cosAA[7], rS1*sinAA[7], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS3*cosAA[8], rS3*sinAA[8], 0., pS3};
-pntSlot[]+=newp; Point(newp)={rS5*cosAA[9], rS5*sinAA[9], 0., pS3};
-
-// air slot 1
-linASlot[]+=newl ; Line(newl)={pntSlot[2], pntSlot[3]};
-linASlot[]+=newl ; Line(newl)={pntSlot[3], pntSlot[1]};
-linASlot[]+=newl ; Circle(newl)={pntSlot[1], cen, pntSlot[10]};
-linASlot[]+=newl ; Line(newl)={pntSlot[10], pntSlot[8]};
-linASlot[]+=newl ; Line(newl)={pntSlot[8], pntSlot[9]};
-linASlot[]+=newl ; Circle(newl)={pntSlot[9], cen, pntSlot[2]};
-
-Line Loop(newll) = {linASlot[]};
-sairslot[] += news ; Plane Surface(sairslot[0]) = {newll-1};
-
-// coil slot 1
-linSlot[]+=newl ; Line(newl)={pntSlot[1], pntSlot[0]};
-linSlot[]+=newl ; Circle(newl)= {pntSlot[0], pntSlot[4], pntSlot[5]};
-linSlot[]+=newl ; Line(newl)={pntSlot[5], pntSlot[6]};
-linSlot[]+=newl ; Circle(newl)={pntSlot[6], pntSlot[7],pntSlot[11]};
-linSlot[]+=newl ; Line(newl)={pntSlot[11], pntSlot[10]};
-
-Line Loop(newll) = {-linASlot[2],linSlot[]};
-sslot[] += news ; Plane Surface(sslot[0]) = {newll-1};
-
-// slots 2 and 3
-A2 = 15*deg2rad;
-
-pntSlot0[0] = pntSlot[2];
-pntSlot1[0] = pntSlot[9];
-For k In{1:2}
- pntSlot0[] += Rotate {{0, 0, 1}, {0, 0, 0}, A2} { Duplicata{Point{pntSlot0[k-1]};} };
- pntSlot1[] += Rotate {{0, 0, 1}, {0, 0, 0}, A2} { Duplicata{Point{pntSlot1[k-1]};} };
-EndFor
-
-For k In{1:2}
- sslot[] += Rotate {{0, 0, 1}, {0, 0, 0}, A2} { Duplicata{Surface{sslot[k-1]};} };
- sairslot[] += Rotate {{0, 0, 1}, {0, 0, 0}, A2} { Duplicata{Surface{sairslot[k-1]};} };
-EndFor
-
-cSlot[]+=newl; Circle(newl) = {pntS[0], cen, pntSlot[2]};
-cSlot[]+=newl; Circle(newl) = {pntSlot1[0], cen, pntSlot0[1]};
-cSlot[]+=newl; Circle(newl) = {pntSlot1[1], cen, pntSlot0[2]};
-cSlot[]+=newl; Circle(newl) = {pntSlot1[2], cen, pntS[2]};
-
-linesslot0[] = CombinedBoundary{ Surface{ sslot[0], sairslot[0] } ;};
-linesslot1[] = CombinedBoundary{ Surface{ sslot[1], sairslot[1] } ;};
-linesslot2[] = CombinedBoundary{ Surface{ sslot[2], sairslot[2] } ;};
-
-Line Loop(newll) = {-lineMBstator[0],linS[0], cSlot[0],-linesslot0[{4}],
- cSlot[1],-linesslot1[{9}],
- cSlot[2],-linesslot2[{9}], cSlot[3], -linS[1]};
-sairgapS[0]=news; Plane Surface(sairgapS[0]) = {newll-1};
-
-linesslot0[] -= linesslot0[{4}];
-linesslot1[] -= linesslot1[{9}];
-linesslot2[] -= linesslot2[{9}];
-Line Loop(newll) = { cSlot[0], linesslot0[],
- cSlot[1], linesslot1[],
- cSlot[2], linesslot2[],
- cSlot[3], linS[3], -cirS[0], -linS[2]};
-sstator[0]=news; Plane Surface(sstator[0]) = {newll-1};
-
-// -------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------
-
-auxlink[]=linS[{1,3}]; // A1
-
-If(SymmetryFactor<8)
- // FULL MODEL ==> Rotation of NbrPolesTot*Pi/4
- // For simplicity: rotating the interior and exterior boundaries
-
- If (SymmetryFactor>1)
- For k In {0:#auxlink[]-1}
- auxlink_[] += Rotate {{0, 0, 1}, {0, 0, 0}, 2*Pi/SymmetryFactor-Pi/4} { Duplicata{Line{auxlink[k]};} };
- EndFor
- auxlink[] = auxlink_[];
- EndIf
-
- For k In {1:NbrPoles-1}
- cirS[] += Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Line{cirS[{0}]};} };
- EndFor
- For k In {1:NbrPoles-1}
- sstator[]+= Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Surface{sstator[0]};} };
- sairgapS[]+= Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Surface{sairgapS[0]};} };
- sairslot[]+= Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Surface{sairslot[{0:2}]};} };
- sslot[]+= Rotate {{0, 0, 1}, {0, 0, 0}, k*Pi/4} { Duplicata{ Surface{sslot[{0:2}]};} };
- EndFor
-EndIf
-
-
-
-// -------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------
-// Physical regions
-// -------------------------------------------------------------------------------
-// -------------------------------------------------------------------------------
-
-Physical Surface(STATOR_FE) = {sstator[]}; // Stator
-Physical Surface(STATOR_AIR) = {sairslot[]}; // AirStator
-Physical Surface(STATOR_AIRGAP) = {sairgapS[]}; // AirStator for possible torque computation with Maxwell stress tensor
-
-NN = (Flag_Symmetry)?NbrSectStator:NbrSectTotStator;
-//For k In {0:NN-1}
-// Physical Surface(STATOR_IND+k) = {sslot[k]}; //Inds
-//EndFor
-
-Physical Surface(STATOR_IND_AM) = {sslot[{0:NN-1:6}]};
-Physical Surface(STATOR_IND_CP) = {sslot[{1:NN-1:6}]};
-Physical Surface(STATOR_IND_BM) = {sslot[{2:NN-1:6}]};
-If(NbrSectStator>2)
- Physical Surface(STATOR_IND_AP) = {sslot[{3:NN-1:6}]};
- Physical Surface(STATOR_IND_CM) = {sslot[{4:NN-1:6}]};
- Physical Surface(STATOR_IND_BP) = {sslot[{5:NN-1:6}]};
-EndIf
-
-Color Pink {Surface{ sslot[{0:NN-1:6}] };} // A-
-Color ForestGreen {Surface{ sslot[{1:NN-1:6}] };} // C+
-Color PaleGoldenrod{Surface{ sslot[{2:NN-1:6}] };} // B-
-If (#sslot[]>=6)
-Color Red {Surface{ sslot[{3:NN-1:6}] };} // A+
-Color SpringGreen{Surface{ sslot[{4:NN-1:6}] };} // C-
-Color Gold {Surface{ sslot[{5:NN-1:6}] };} // B+
-EndIf
-
-
-Physical Line(SURF_EXT) = {cirS[]}; // SurfExt
-
-If(Flag_Symmetry) //Lines for symmetry link
- Physical Line(STATOR_BND_A0) = linS[{0,2}];
- Physical Line(STATOR_BND_A1) = auxlink[] ;
-EndIf
-
-
-lineMBstator[] += lineMBstatoraux[] ;
-If(!Flag_Symmetry)
- Physical Line(STATOR_BND_MOVING_BAND) = {lineMBstator[]};
-EndIf
-If(Flag_Symmetry)
-ns = #lineMBstator[];
-nns = ns/SymmetryFactor ;
-For k In {1:SymmetryFactor}
- kk= ((k*nns-1) > ns) ? ns-1 : k*nns-1 ;
- Physical Line(STATOR_BND_MOVING_BAND+k-1) = {lineMBstator[{(k-1)*nns:kk}]};
-EndFor
- k1 = Floor[NbrPolesTot/NbrSect];
- k2 = Ceil[NbrPolesTot/NbrSect];
- If (k2 > k1)
- Physical Line(STATOR_BND_MOVING_BAND+k2-1) = lineMBstator[{(k2-1)*nns:#lineMBstator[]-1}] ;
- EndIf
-EndIf
-
-
-// For nice visualisation...
-linStator[] = CombinedBoundary{Surface{sstator[]};};
-linSlot[] = CombinedBoundary{Surface{sslot[]};};
-
-nicepos_stator[] += {linStator[],linSlot[] };
-
-Color SteelBlue {Surface{sstator[]};}
-Color SkyBlue {Surface{sairslot[],sairgapS[]};}
-
-
diff --git a/contrib/mobile/Android/src/org/geuz/onelab/ModelList.java b/contrib/mobile/Android/src/org/geuz/onelab/ModelList.java
index 87f177f177515eddc432daa5f499149264db51d3..1f0a1c6d81209610b946ed21018aa140b7192fd4 100644
--- a/contrib/mobile/Android/src/org/geuz/onelab/ModelList.java
+++ b/contrib/mobile/Android/src/org/geuz/onelab/ModelList.java
@@ -41,7 +41,7 @@ public class ModelList extends Activity {
ListView list = new ListView(this);
Button loadSD = new Button(this);
loadSD.setText(R.string.button_open_external_file);
- loadSD.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT,LayoutParams.WRAP_CONTENT));
+ loadSD.setLayoutParams(new ListView.LayoutParams(LayoutParams.MATCH_PARENT, ListView.LayoutParams.WRAP_CONTENT));
loadSD.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
diff --git a/contrib/mobile/Android/src/org/geuz/onelab/SplashScreen.java b/contrib/mobile/Android/src/org/geuz/onelab/SplashScreen.java
index 21c8bb726137771e248d7d0c684a4c2172a252a3..56653765f13986820805fa4574c87a1af5b7185f 100644
--- a/contrib/mobile/Android/src/org/geuz/onelab/SplashScreen.java
+++ b/contrib/mobile/Android/src/org/geuz/onelab/SplashScreen.java
@@ -1,9 +1,10 @@
package org.geuz.onelab;
+import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
-import java.io.InputStream;
-import java.lang.reflect.Field;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
import android.app.Activity;
import android.content.Context;
@@ -59,34 +60,19 @@ public class SplashScreen extends Activity{
*/
private void loadNative()
{
- for( Field f : R.raw.class.getFields()) {
- try {
- int Msh = f.getInt(null), i;
- String androidName = getResources().getResourceEntryName(Msh);
- StringBuilder tmp = new StringBuilder(androidName);
- tmp.setCharAt(androidName.lastIndexOf('_'), '.');
- String nativeName = tmp.toString();
- /*if(new File(getFilesDir().toString()+"/"+nativeName).exists()){
- //TODO check if the files are the same
- continue;
- }*/
- InputStream mshFile = getResources().openRawResource(Msh);
-
- FileOutputStream outputStream = openFileOutput(nativeName, Context.MODE_WORLD_READABLE);
- byte[] buffer = new byte[2048];
-
- while ((i = mshFile.read(buffer, 0, buffer.length)) > 0)
+ try {
+ ZipInputStream zipStream = new ZipInputStream(new BufferedInputStream(getResources().openRawResource(R.raw.models)));
+ ZipEntry entry;
+ while ((entry = zipStream.getNextEntry()) != null) {
+ FileOutputStream outputStream = openFileOutput(entry.getName(), Context.MODE_PRIVATE);
+ byte[] buffer = new byte[2048];
+ for (int i = zipStream.read(buffer, 0, buffer.length); i > 0;i = zipStream.read(buffer, 0, buffer.length))
outputStream.write(buffer,0,i);
-
- } catch (IllegalArgumentException e) {
- Log.e("Load files", "Error " + e.toString());
-
- } catch (IllegalAccessException e) {
- Log.e("Load files", "Error " + e.toString());
-
- } catch (IOException e) {
- Log.e("Load files", "Error " + e.toString());
- }
- }
+ Log.d("Load files", "Add " + entry.getName() + " from the zip file");
+ }
+ zipStream.close();
+ } catch (IOException e1) {
+ e1.printStackTrace();
+ }
}
}