Skip to content
Snippets Groups Projects
Commit 24b7d828 authored by Maxime Graulich's avatar Maxime Graulich
Browse files

Files used in native code are now in a zip file

parent 2459ddb3
Branches
Tags
No related merge requests found
Showing
with 17 additions and 2537 deletions
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] ;
}
This diff is collapsed.
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;
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};
/*
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 ] ;
}
}
}
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" ] ;
}
}
}
File added
//
// 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
}
// 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 ;
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
//
// 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"} ];
//
// 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"} ];
//--------------------------------------------------------------------------------
// 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
// -------------------------------------------------------------------------------
// 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[]};}
...@@ -41,7 +41,7 @@ public class ModelList extends Activity { ...@@ -41,7 +41,7 @@ public class ModelList extends Activity {
ListView list = new ListView(this); ListView list = new ListView(this);
Button loadSD = new Button(this); Button loadSD = new Button(this);
loadSD.setText(R.string.button_open_external_file); 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() { loadSD.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) { public void onClick(View v) {
......
package org.geuz.onelab; package org.geuz.onelab;
import java.io.BufferedInputStream;
import java.io.FileOutputStream; import java.io.FileOutputStream;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.util.zip.ZipEntry;
import java.lang.reflect.Field; import java.util.zip.ZipInputStream;
import android.app.Activity; import android.app.Activity;
import android.content.Context; import android.content.Context;
...@@ -59,34 +60,19 @@ public class SplashScreen extends Activity{ ...@@ -59,34 +60,19 @@ public class SplashScreen extends Activity{
*/ */
private void loadNative() private void loadNative()
{ {
for( Field f : R.raw.class.getFields()) {
try { try {
int Msh = f.getInt(null), i; ZipInputStream zipStream = new ZipInputStream(new BufferedInputStream(getResources().openRawResource(R.raw.models)));
String androidName = getResources().getResourceEntryName(Msh); ZipEntry entry;
StringBuilder tmp = new StringBuilder(androidName); while ((entry = zipStream.getNextEntry()) != null) {
tmp.setCharAt(androidName.lastIndexOf('_'), '.'); FileOutputStream outputStream = openFileOutput(entry.getName(), Context.MODE_PRIVATE);
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]; byte[] buffer = new byte[2048];
for (int i = zipStream.read(buffer, 0, buffer.length); i > 0;i = zipStream.read(buffer, 0, buffer.length))
while ((i = mshFile.read(buffer, 0, buffer.length)) > 0)
outputStream.write(buffer,0,i); outputStream.write(buffer,0,i);
Log.d("Load files", "Add " + entry.getName() + " from the zip file");
} 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());
} }
zipStream.close();
} catch (IOException e1) {
e1.printStackTrace();
} }
} }
} }
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment