Parametriserad modell av motorprototyp med Solidworks

(1)

ISRN UTH-INGUTB-EX-E-2012/11-SE

Examensarbete 15 hp September 2012

Parametriserad modell av motorprototyp med Solidworks

Parameterized model of the prototype motor with Solidworks

Daniel Gren

(2)

Sammanfattning

Syftet med denna avhandling har varit att bygga upp en parametriserad modell av en motorprototyp i programmet Solidworks, för att användas i framtida optimeringar med avseende på effektivitet och vikt. Det resulterade i två modeller. Den första modellen var en mindre del av hela konstruktionen i 2D, för att kunna optimera och studera, inför simuleringen av hela modellen. Den andra modellen var hela konstruktionen i 3D. Hela modellen gjordes med de tre programmen Solidworks, Comsol och Matlab. De tre programmen används för att kunna anpassa parametrarna och för att kunna göra framtida förlustberäkningar i Matlab. Den mindre modellen gjordes med programen Matlab och Comsol med en förlustsimulering för att beräkna förluster i materialet. Den viktigaste slutsatsen av detta projekt är att det med dessa modeller kan göras framtida studier i syftet att optimera och beräkna förluster på motorprototypen.

(3)

Teknisk- naturvetenskaplig fakultet UTH-enheten

Besöksadress:

Ångströmlaboratoriet Lägerhyddsvägen 1 Hus 4, Plan 0

Postadress:

Box 536 751 21 Uppsala

Telefon:

018 – 471 30 03

Telefax:

018 – 471 30 00

Hemsida:

http://www.teknat.uu.se/student

Abstract

Parametriserad modell av motorprototyp med Solidworks

Parameterized model of the prototype motor with Solidworks

Daniel Gren

The purpose of this thesis has been to build a parameterized model of a prototype motor in the program Solidworks, to use in future optimization of aspects of

effectiveness and weight. The result were two models. The first model were one minor part of the whole design in 2D, to be able to optimize and study the minor part with a faster loss simulation. The second model was the whole design in 3D. The whole model were done with the three programs Solidworks, Comsol and Matlab. The three programs were used to be able to adjust the parameters and to be able to do future loss calculations in Matlab. The minor part model was made with the programs Matlab and Comsol with a loss simulation to calculate losses in the material. The main conclusion of this projekt is that with these models there can be done furthermore studies in the purpose of optimization and loss calculations.

ISRN UTH-INGUTB-EX-E-2012/11-SE Examinator: Nora Masszi

Ämnesgranskare: Janaina Goncalves de Oliveira Handledare: Magnus Hedlund

(4)

Innehållsförteckning

1. Introduktion...3

1.1 Bakgrund & projektbeskrivning...3

1.2 Syfte...4

2. Teori...4

2.1 FEM...4

2.2 Modell över järnförluster...4

2.3 MatLab...5

2.4 Comsol Multiphysics...5

2.5 Solidworks...5

2.6 Livelink...5

3. Metod och Utförande...6

3.1 Litteraturstudie...6

3.2 2D-Mjukvarans uppbyggnad och utförande...7

3.2.1 Topologi...7

3.2.2 Parameterar...8

3.2.3 Simulering ...10

3.2.4 Beräkning...13

3.3 3D-modellens uppbyggnad och utförande...14

3.3.1 Solidworks...14

3.3.2 Comsol...15

3.3.3 Matlab...15

4. Resultat...16

4.1 Mjukvaran av 2D-modellen för C-bit...16

4.2 Mjukvaran av 3D-modellen för motorprototypen...18

5. Diskussion & Förbättringsförslag...20

5.1 Förlustberäkning av 3D-modellen...20

5.2 Geometriförenklingar ...20

5.3 Programekvationer...20

5.4 Dataöverföringar...20

5.5 Förbättringar av ”mesh”...21

6. Referenser...22

(5)

7. Appendix...23

7.1 P_Calk.m...23

7.2 P_Simulator...27

7.3 threeD_simulator.m...41

2

(6)

1. Introduktion

Svänghjul har sedan länge använts vid lagring av energi och kontinuerlig energitillförsel till mekaniska maskiner, till exempel en drejskiva. Svänghjul kan även tillämpas för lagring av energi för elnätet. De kan konstrueras på många olika sätt, beroende på användningsområdet. Svänghjul är en mekanisk anordning som används för att lagra rörelseenergi genom att applicera ett

accelererande vridmoment till svänghjulet. För att svänghjulet ska frigöra energi så tillkopplas en last, vilket sänker rotationshastigheten. Lasten varierar beroende på svänghjulet, och kan vara till exempelvis en mekanisk eller en resistiv last (elektrisk maskin). Svänghjulet har ett visst

tröghetsmoment vilket gör att det motstår förändringar i rotationshastigheten, däri lagras alltså energin.

En elektrisk motor/generator kan tillämpas som ett svänghjul, då det i princip sitter ett svänghjul i alla motorer. Det som gör det intressant att använda en elmotor som ett svänghjul är att den har massa, och att mer massa kan hakas på. Då motorn matas med ström tillförs vridmoment och den lagrar energi i sin rotationshastighet. Mängden kinetisk energi som maskinen kan lagra varierar, beroende på konstruktionens maximala rotationshastighet samt hur stor massa som roterar, då energimängden ökar med kvadraten på hastigheten och linjärt mot massan. Vid matning av motorn uppstår dock förluster som även påverkar effektiviteten att använda en elektrisk motor som ett svänghjul. För att undersöka dessa förluster, och optimera en konstruktion för att minimera dem, kommer en parametriserad modell av konstruktionen bra tillhands. Denna uppsats beskriver skapandet av en sådan modell.

1.1 Bakgrund & projektbeskrivning

Gruppen Kinetisk Enegilagring på avdelningen för Elektricitetslära vid Uppsala universitet utvecklar en maskin som ska användas till kinetisk energilagring för elnätet. Den elektriska maskinen fungerar som omvandlare av energi, från elektrisk till kinetisk och vice versa. Tanken med maskinen är att den ska ingå i ett roterande kinetiskt energilager (ett svänghjul), för lagring av energi på elnätet.

Examensarbetet gick ut på att skapa en parametriserad modell i Solidworks av gruppens

motorprototyp som kan kopplas till FEM-programmet Comsol samt göra några elektromagnetiska

(7)

simulationer på denna modell i Comsol. En förlustanalys gjordes även på en mindre del av statorn på motorprototypen.

1.2 Syfte

Syftet är att göra en noggrann parametrisering av motorprototypen, för att underlätta optimering.

Därför är det användbart med en modell där man kan mata in olika faktorer så som antal poler, höjd

& bredd på statorn etc för att sedan utföra dynamiska simulationer. Denna modell ska sedan användas för att optimera maskinen med avseende på effektivitet och vikt.

2. Teori

2.1 FEM

Finita Elementmetoden (FEM) är en numerisk metod för att lösa partiella differentialekvationer.

Enkelt förklarat så delas ett svårt problem upp i små element som kan lösas i relation till varandra.

FEM används för att hitta approximativa lösningar till partiella differentialekvationer (PDE) och deras system, även för integral ekvationer. FEM’s lösningar är baserade på att lösa PDE´n numeriskt.

FEM används i detta fall eftersom den kan hantera komplicerade geometrier utan större svårigheter.

Mjukvaran som används inom ramen för detta arbete är Comsol.

2.2 Modell över järnförluster

Till denna modells material förlustberäkning används följande formel[1].

̄P_V=1

T

∫

₀^T ^k¹

∣

^dBdt

∣

^α^∣^B(t)^∣^β−α^dt ^(2.1)

Där P är förlusten i watt per volym och B(t) är flux amplituden. α, β, och k är koefficienter som uppskattas empiriskt från tillverkardata.

4

(8)

2.3 MatLab

Matlab är ett högnivåspråk och interaktiv miljö för numeriska beräkningar, visualisering och programmering. Med hjälp av MATLAB kan man utveckla algoritmer, analysera data och skapa modeller och tillämpningar. [2]

2.4 Comsol Multiphysics

Comsol Multiphysics är ett simuleringsprogram som innehåller alla steg i modelleringsprocesser att definiera en geometri, specificera fysiken, lösa och sedan visualisera resultat. Comsols applikationer kan till exempel användas för elektromagnetiska analyser. [3]

2.5 Solidworks

SolidWorks är ett lätt hanterligt 3D-program verktyg för att skapa, simulera, publicera och hantera ritningar. [4]

2.6 Livelink

Livelink integrerar Solidworks och Matlab med Comsol. Comsol integrerat med Solidworks möjliggör användandet av Solidworks 3D-verktyg tillsammans med Comsols applikationer på CAD-modeller. Comsol integrerat med Matlab ger möjligheten att utöka modelleringen och kodningen med funktionerna som finns i Matlab.[5][6]

(9)

3. Metod och Utförande

Tillvägagångssättet som används för att färdigställa modellen innehåller följande moment:

1. En litteraturstudie av kinetiska energilager.

2. Färdigställande av parametriserad 2D-modell.

3. Förlustberäkning av 2D-modell samt implementering av förlustmodell.

4. Färdigställande av parametriserad 3D-modell.

6. Testning av 3D-modellen via Livelink.

3.1 Litteraturstudie

Under litteraturstudien lästes följande litteratur:

AFPM Motor/Generator Flywheel for Electric Power Stabilization

Boken beskriver en studie av en generator/motor som tillämpas som ett svänghjul för att jämna ut kraft transienter i en fordons drivlina. Svänghjulet analyseras med avseende på förluster och det gjordes simulationer på svänghjulet med FEM [7]. Denna litteratur var av intresse då det utfördes en FEM metod på den modell som parametriserades i denna avhandling, samt att studien gjordes på ett svänghjul, vilket är relevant med vad som gjordes i denna avhandling.

Power Control Systems in a Flywheel based All-Electric Driveline

Boken beskrev ett projekt där en helt elektrisk drivlina som är baserades på ett svänghjul studerades. Forskningsprojektet utfördes på Uppsala universitet [8]. Boken fokuserade på testa kontrollsystemen som ingick i en elektriska drivlinan, detta gav en inblick av tillämpningar och teori om svänghjul.

Switched Reluctance Motors and Their Constrols

Boken beskriver växelströms reluktansmaskiner, för att förstå, designa och utvärdera dem och deras kontroller [9]. Denna litteratur var av intresse då motorprototypen som parametriserades är en inductansmaskin.

Efter litteraturstudien startade examensarbetet med några olika ritningar av 2D-modellen som utvecklades av Kinetisk Energilagring på Elektricitslära. 2D-modellen skapades sedan utifrån dessa ritningar och diskussioner med gruppen Kinetisk Energilagring. 2D-modellen är intressant då den är mindre resurskrävande än en full 3D-simulation, och därför gör rimliga iterativa

6

(10)

optimeringsprocesser. 2D-modellen kommer då att kunna simulera en del av det som kommer att vara av intresse i senare studier av 3D-modellens bestämning av parametrar, vid studier av

effektivitet. 3D-modellen är intressant för att verifiera 2D-modellen. Den är inte lika förenklad, och ger därför en bild av kvaliteten på 2D-optimeringen.

3.2 2D-Mjukvarans uppbyggnad och utförande

2D-mjukvaran kan delas in i tre logiska sektioner: parametrar, simulering och beräkning.

Mjukvaran programmeras i Matlab och via Livelink styrs Comsol till att utföra skapandet av geometrin och simuleringen. Detta betyder att Matlab styr Comsol och använder dess data för att utföra beräkningar.

3.2.1 Topologi

Svänghjulet som ska parametriseras är en ny typ av reluktansmaskin, som drar runt en stålskena med hjälp av elektromagneter formade som C-bitar. Reluktansmaskinen har väldigt lovande hållfastighetsegenskaper, vilket är anledningen till att den tillämpas för svänghjulsapplikationen.

Elektromagneterna som är formade som C-bitar illustreras i Figur 1 tillsammans med en exempelmodell av reluktansmaskinen.

(11)

3.2.2 Parameterar

Mjukvaran sparar alla parametrar som används för att skapa modellen i Matlab, i en struktur som sedan används vid simuleringen. Parametrarna visas i Tabell 1. Antalet mätpunkter behöver även anges utöver modellens parametrar, för att bestämma antalet punkter av värden på modellens simulering. Högre antal mätpunkter ger bättre noggrannhet av förlustberäkningen men dock kräver mer beräkningskraft.

8

Figur 1: Markerad (blå) C-bit på exempel av motorprototypen

(12)

Variabel Beskrivning [mm]

D.I Strömmarna som ska simuleras

D.N Antalet lindningar

D.air Höjd och bredd på luftrummet

D.a Avstånd från innerkant till ytterkant

D.b Bredd på tand

D.d Höjd på rotor

D.d_2 Bredd på rotor

D.d_3 Avstånd på rotorn innanför tänderna

D.h_1 Längd på gapet mellan tänderna

D.h_2 Längd från inre tand kant till inre kant på C-bit

D.O Bredd på stator

D.l Längd på stator

D.g Luftgap

D.m_1 Förskjuten avrundning i kanterna i x-led

D.m_2 Förskjuten avrundning i kanterna i y-led

D.CUarea Kopparlindningens area

D.CU Kopplindningensradie

D.CUgap Avstånd mellan de två Lindningarna

D.e Radien på borrhålen

D.f Avstånd mellan centrum av borrhål till kanter

D.regulargridx2 Antal mätpunkter i x-led (st)

D.regulargridy2 Antal Mätpunkter i y-led (st)

Tabell 1: 2D-modellens parametrar

(13)

3.2.3 Simulering

Vid simuleringen används Comsol för att lösa de elektromagnetiska fältekvationerna med givna randvillkor. Speciellt av intresse är den magnetiska flödestätheten för beräkning av järnförlusterna och magnetiseringen i materialet, för att kunna eliminera andra förluster. Via livelink skapas geometrin med rektanglar, kvadrater och linjer med de tidigare angivna parametrarna, där dessa är beroende av varandra vid skapandet av geometrin. Sedan gjuts geometrin ihop för att underlätta definition av materialparametrar, strömtätheter och andra randvillkor. När geometrin gjuts samman betyder det att vissa geometriska grundobjekt slås ihop för att bilda någonting mer komplext.

10

Figur 2: Geometri med några markerade måttsättningar

(14)

Definieringen av olika material till geometrin och strömmarna har förvalda geometridelar, som styrs av boolska villkor beroende på vilka ”tillägg” som är aktiva samt beroende på parametrarnas

storhetsskillnader.

Vid skapandet av beräkningsnätet (den s.k meshen) för geometrin har luften mindre noggrannhet än materialet, då den inte att tas med i förlustberäkningen. När beräkningsnätet skapas delas geometrin upp i små element för att tillämpa FEM. Högre noggrannhet vid luftgapen används för att förbättra simulering och beräkningen av förluster, då det sker en väldigt stor förändring av den magnetiska flödestätheten nära kanterna vid luftgapen.

Figur 3: Exempel på geometri innan (vänster) och efter (höger) gjutning

(15)

Därefter beräknades studien av geometrin. För att beräkna denna studie valdes ”Magnetic fields”

mode i Comsol, eftersom ”Magnetic fields” löser den magnetiska vektorpotentialen.

12 Figur 5: Exempel på studie av den magnetiska flödestätheten Figur 4: Exempel på geometri efter skapande av

beräkningsnätet

(16)

Efter att modellerna har simulerats så exporteras mätdata till Matlab. Mätpunktsdata sparas i txt- format och importeras till Matlab, för att användas vid beräkningar av förluster.

3.2.4 Beräkning

Efter importeringen används mätpunktsdatan som visar magnetiseringen för att eliminera alla förluster som sker i luften, detta för att enbart kunna beräkna materialets förluster med formel 2.1.

Elimineringen sker genom att bara ta de punkter som har magnetisering utifrån den data som visar den magnetiska flödestätheten. För att hitta dessa punkter används en boolsk operation i Matlab på datan ifrån magnetisering för att hitta alla värden som är större än noll.

M =(Magnetisering )> 0 ;

Magnetisk flödestäthet i materialet =M .∗Magnetisk flödestäthet ; Sist sparas geometrin för vidare studier i Comsol.

Figur 6: Exempel på studie av magnetiseringen

(17)

3.3 3D-modellens uppbyggnad och utförande

Den parametriserade 3D-modellen använder sig av tre program i samarbete: Solidworks, Comsol och Matlab.

3.3.1 Solidworks

I Solidworks finns geometrin, vars ekvationer innehåller parametrar som styrs från Matlab. Av hela geometrin simuleras en tredjedel i Comsol, för att spara beräkningskraft, då maskinen är

symmetrisk.

14 Figur 7: Exempel på en tredjedel av geometrin

(18)

Enligt prototypen ska C-bitarna i modellen ligga intill varandras kanter och för att lättare uppnå detta så kan inte kärnornas tjocklek variera. Istället varieras antalet C-bitar som är utspridda på ett visst antal grader runt rotorns mittenrör. Det antal grader som C-bitarna är bestämda att vara utsprida på är för att försäkra sig om att kopparlindningen runt C-bitarna ska kunna böjas runt kanterna, med det mellanrum som bildas mellan varje tredjedel av hela geometrin. Modellen har även en lindning runt kärnorna, istället för flera lindningar för att underlätta skapandet av

beräkningsnätet och definieringen av strömmarna samt för att förbättra simuleringen. Modellen och parametrarna som kan varieras visas i Tabell 2.

Variabel Beteckning

Pipe_l Längd på Mittenröret

E_Bit_a C-bits innerkant till ytterkant

E_Bit_b Bredden på C-bitens tänder

E_Bit_h_1 Avstånd mellan C-bitens tänder

E_Bit_h_2 Längd på C-bits tänderna

E_Bit_l Längd på C-biten

E_Bit_O Bredden på C-bitens rygg

E_Bit_CU_r Radien på kopparlindningen

E_Bit_CUgap Avstånd mellan de två Lindningarna utskärningar

E_Bit_g Luftgapet

r Radie på mittenröret

Ant Antalet C-bitar

Rotor_d_2 Tjocklek på rotorn

Block_deg Sätt antalet grader C-bitarna är utspridda på

Tabell 2: Parametrar för 3D-modellen 3.3.2 Comsol

Comsol hanterar simuleringen av geometrin, som importeras från Solidworks, och därefter

manipuleras modellens parametrar via Comsol av Matlab. Matlab styr simuleringen för att definiera materialet, skapa beräkningsnät för modellen, utföra två studier av magnetiseringen och den

magnetiska flödestätheten samt exportera mätdata i txt-fil som Matlab därefter importerar.

3.3.3 Matlab

Matlab fungerar som den styrande delen, då programmet har mer funktionalitet att beräkna ut förlusterna i materialet. Matlab ger alla kommandon som styr Solidworks och Comsol under parametriseringen och simuleringen.

(19)

4. Resultat

4.1 Mjukvaran av 2D-modellen för C-bit

Modellen i 2D skapas efter satta mått och kan även ta med eller ta bort features med boolska vilkor, som monteringshål, avrundningar på C-bitens innersida och om rotorn ska vara med i modellen. För att kunna förenkla modellen kan monteringshålen tas bort då i CAD-ritningarna för maskinen, då det finns monteringshål som bortses ifrån för att förenkla och spara beräkningskraft.

16

Figur 8: Exempel på modell med parametrar

(20)

Förlustberäkningar kan utföras på den skapade modellen och i materialet kan antalet mätpunkter regleras på de två axlarna för att antigen effektivisera eller göra en noggrannare beräkning. I exemplen ovan (Figur 8 & Figur 9) utfördes två förlustberäkningar: för Figur 8 beräknades förlusten till 3.5673 watt och för Figur 9 beräknades förlusten till 2.8278 watt.

Figur 10: Exempel plot på den magnetiska flödestätheten på tidigare exempel modeler Figur 9: Exempel på modell med parametrar, utan

kantavrundningar

(21)

4.2 Mjukvaran av 3D-modellen för motorprototypen

Modellen i 3D skapas inte på nytt vid varje simulering utan det finns en modell som manipuleras med parametrarna angivna i Matlab. Många av de relevanta parametrarna har automatiserats för att skapa förutsättningar för diverse optimeringsarbete med denna topologi.

18

Figur 11: Exempel på modell med parametrar

(22)

Figur 12: Exempel på plot över magnetisering (vänster) och den magnetiska flödestätheten (höger)

(23)

5. Diskussion & Förbättringsförslag

5.1 Förlustberäkning av 3D-modellen

Förlustberäkningen på modellen i 3D blev inte helt funktionell då skapandet av beräkningsnätet på modellen i Comsol kräver en bättre anpassning av noggrannhet på geometrin för att kunna skapa ett funktionellt beräkningsnät.

5.2 Geometriförenklingar

Designen på geometrierna mellan C-bitarna förenklades från att vara fyrkantiga block till att ha en kontur som även följde järnkärnans inre kanter för att underlätta beräkningsnätet och få mindre kantförluster. Detta underlättade skapandet av beräkningsnätet då det uppstod färre små områden som var svåra att skapa beräkningsnät på.

Borrhål för fasthållning togs bort i modellen, för att skapa färre element i beräkningsnätet och underlätta simulering. Kopparlindningens geometri förenklades från att ha flera lindningar runt C- bitarna till att ha endast en lindning för definiering av strömmarna. Detta förenklade

beräkningsnätet på kopparlindningen och gjorde det lättare att kunna parametrisera modellen.

5.3 Programekvationer

En inkompatibilitet mellan programmen begränsade parametriseringen för modellen i 3D. För att kunna utföra geometriekvationer var det nödvändigt att ekvationerna utfördes i Solidworks, då det uppstod decimalfel mellan programmen. Decimalfelen medförde att geometrin inte kunde lösas i Solidworks.

5.4 Dataöverföringar

Mätdatan efter simuleringarna i Comsol testades först att överföras via Livelink till Matlab. Detta resulterade i att Livelinks minne överbelastades, då det vid överföring av de olika värdena sparades data i ett temporärt minne som aldrig tömdes under överföringen. För att inte överbelasta minne sparades mätdatan i txt-format som sedan importerades till Matlab.

20

(24)

5.5 Förbättringar av ”mesh”

För att mjukvaran i 3D även ska kunna göra en förlustsimulering behöver den förbättras när den ska skapa beräkningsnätet för modellen. Vid vissa parameterar kan inte beräkningsnätet (s.k. mesh) lösas effektivt, då manuella justeringar behövs för att hitta en funktionell ”mesh” som inte innehåller för många element.

5.6 Geometri i 3D utan ”mates”

Geometrin i 3D i Solidworks kan förbättras genom att skapa geometrin utan s.k. ”mates” och istället skulle geometrins delar bli skapta i specifika koordinater. Detta skulle underlätta manipulerandet av geometrin och den skulle bli lättare att skapa i Solidworks och troligtvis även effektivare.

(25)

6. Referenser

[1] Jieli Li, T. Abdallah, C. R. Sullivan. Improved Calculation of Core Loss With Nonsinusoidal Waveforms, Found in IEEE Industry Applications Society Annual Meeting, Oct. 2001, pp. 2203–

2210.

[2] http://www.mathworks.se/products/matlab/ (2012-09-17)

[3] http://www.comsol.se/products/multiphysics/ (2012-09-17)

[4] http://www.solidworks.se/sw/6453_SVE_HTML.htm (2012-09-17)

[5] http://www.comsol.com/products/livelink-solidworks/ (2012-09-17)

[6] http://www.comsol.com/products/livelink-matlab/ (2012-09-17)

[7] Juan de Santiago Ochoa, "AFPM Motor/Generator Flywheel for Electric Power Stabilization", UURIE 314-09L, ISSN 0349-8352, Uppsala 2009.

[8] Janaína Gonçalves de Oliveira, "Power Control Systems in a Flywheel based All-Electric Driveline", Digital Comprehensive Summaries of Uppsala Dissertations from the Faculty of Science and Technology, ISSN 1651-6214. (ISBN 978-91-554-8133-9)

[9] T. J. E. Miller, Switched Reluctance Motors and Their Controls, Oxford University Press.

( ISBN 1-881855-02-3)

22

(26)

7. Appendix

7.1 P_Calk.m

clc clear

D.I = linspace(-50,50,50); % Strömmen D.N = 100; % Antalet lindningar

D.air = 250; % Höjd och bredd på luftrummet

D.a = 31; % avstånd från innerkant till ytterkant D.b = 15; % bredd på tand

D.d = 101; % höjd på rotor D.d_2 = 15; % bredd på rotor

D.d_3 = 0; % Avstånd innanför tänder

D.h_1 = 103; % längd på gapet mellan tänderna D.h_2 = 10; % från tand kant till inre kant D.O = 20; % bredd på stator

D.l = 169; % längd på stator D.g = 1; % luftgap

D.spline_active = 1; % activering av arundade kanter D.m_1 = 0; % försjuten avrunding i x-led

D.m_2 = 0; % försjuten avrunding i y-led

D.CUarea = 5; % kopparlindningens area D.CUr = 2; % kopparlindingensradie

D.CUgap = 10; % Avstånd mellan lindningar

D.active_holes = 0; %activering av borrhål

(27)

D.e = 2; % radien på borrhålen

D.f = 7; % avstånd mellan centrum av borrhål kanter samt andra borrhål

D.regulargridx2 = 100;

D.regulargridy2 = 100;

DATA = P_Simulator(D, 1);

%figure(1)

%imagesc(reshape(DATA(1:

(D.regulargridx2*D.regulargridy2),5),D.regulargridx2,D.regulargridy2)');

%% Loss calculation ant_I = length(D.I);

B = DATA(:,3:end);

B = reshape(B,D.regulargridx2,D.regulargridy2, ant_I);

%dB = B(:,:,2:end)-B(:,:,1:end-1);

%B = sum(DATA(1:(D.regulargridx2*D.regulargridy2), 3:(ant_I(2)+2)), 1);

%dB = B(1+1) - B(1);

%ant_point = sum(DATA(1:(D.regulargridx2*D.regulargridy2), 1) > 0);

dI = D.I(2)-D.I(1);

t = linspace(0,10e-3,500);

dt = (t(2)-t(1));

I_max = 50;

w = 2*pi*300;

I = I_max*sin(w*t);

%B_t = B(:,:,I);

[x,y,z]=meshgrid(1:D.regulargridx2,1:D.regulargridy2,I);

B_t = interp3(1:D.regulargridx2,1:D.regulargridy2,D.I,B,x,y,z);

%dBdt = B_t(

%dI_dt = I_max*w*cos(w*t);

[x,y,z] = meshgrid(ones(1,D.regulargridx2),ones(1,D.regulargridy2), t);

dBdt = (B_t(:,:,2:end)-B_t(:,:,1:end-1))./(z(:,:,2:end)-z(:,:,1:end-1));

%dB_dI = dB/dI;

24

(28)

%dB_dt = dB_dI.*dI_dt(1:49);

%B_t = dB_dt*dt;

k_1 = 0.0061;

alfa = 1.3606;

beta = 1.7695;

P_t = k_1*abs(dBdt).^alfa.*abs(B_t(:,:,1:end-1)).^beta; %end-1 implies forward differentiation

P = sum(sum(sum(P_t*(((D.air/1000)*(D.air/1000)*(0.01))/(D.regulargridx2*D.regulargridy2)))))

%minnes sparing

%asdf = importdata('C:\Users\gren\Documents\Backup\mätpunkter_data\asdf.txt')

%asdf_2 = (asdf(1:10000,3) == 2) + (asdf(1:10000,3) == 7);

%asdf_2(1:10000).*asdf(1:10000,3)

%B_inactive = P_Simulator(D, 0);

clc clear

D.I = linspace(-50,50,50); % Strömmen D.N = 100; % Antalet lindningar

D.air = 250;

D.a = 31; % avstånd från innerkant till ytterkant D.b = 15; % bredd på tand

D.d = 101; % höjd på rotor D.d_2 = 15; % bredd på rotor

D.d_3 = 0; % Avstånd innanför tänder

D.h_1 = 103; % längd på gapet mellan tänderna D.h_2 = 10; % från tand kant till inre kant

(29)

D.O = 20; % bredd på stator D.l = 169; % längd på stator D.g = 1; % luftgap

D.spline_active = 1; % activering av arundade kanter D.m_1 = 0; % försjuten avrunding i x-led

D.m_2 = 0; % försjuten avrunding i y-led

D.CUarea = 5; % kopparlindningens area D.CUr = 2; % kopparlindingensradie

D.CUgap = 10; % Avstånd mellan lindningar

D.active_holes = 0; %activering av borrhål D.e = 2; % radien på borrhålen

D.f = 7; % avstånd mellan centrum av borrhål kanter samt andra borrhål

D.regulargridx2 = 100;

D.regulargridy2 = 100;

DATA = P_Simulator(D, 1);

%figure(1)

%imagesc(reshape(DATA(1:

(D.regulargridx2*D.regulargridy2),5),D.regulargridx2,D.regulargridy2)');

%% Loss calculation ant_I = length(D.I);

B = DATA(:,3:end);

B = reshape(B,D.regulargridx2,D.regulargridy2, ant_I);

%dB = B(:,:,2:end)-B(:,:,1:end-1);

%B = sum(DATA(1:(D.regulargridx2*D.regulargridy2), 3:(ant_I(2)+2)), 1);

%dB = B(1+1) - B(1);

%ant_point = sum(DATA(1:(D.regulargridx2*D.regulargridy2), 1) > 0);

dI = D.I(2)-D.I(1);

26

(30)

t = linspace(0,10e-3,500);

dt = (t(2)-t(1));

I_max = 50;

w = 2*pi*300;

I = I_max*sin(w*t);

%B_t = B(:,:,I);

[x,y,z]=meshgrid(1:D.regulargridx2,1:D.regulargridy2,I);

B_t = interp3(1:D.regulargridx2,1:D.regulargridy2,D.I,B,x,y,z);

%dBdt = B_t(

%dI_dt = I_max*w*cos(w*t);

[x,y,z] = meshgrid(ones(1,D.regulargridx2),ones(1,D.regulargridy2), t);

dBdt = (B_t(:,:,2:end)-B_t(:,:,1:end-1))./(z(:,:,2:end)-z(:,:,1:end-1));

%dB_dI = dB/dI;

%dB_dt = dB_dI.*dI_dt(1:49);

%B_t = dB_dt*dt;

k_1 = 0.0061;

alfa = 1.3606;

beta = 1.7695;

P_t = k_1*abs(dBdt).^alfa.*abs(B_t(:,:,1:end-1)).^beta; %end-1 implies forward differentiation

P = sum(sum(sum(P_t*(((D.air/1000)*(D.air/1000)*(0.01))/(D.regulargridx2*D.regulargridy2)))))

%minnes sparing

%asdf = importdata('C:\Users\gren\Documents\Backup\mätpunkter_data\asdf.txt')

%asdf_2 = (asdf(1:10000,3) == 2) + (asdf(1:10000,3) == 7);

%asdf_2(1:10000).*asdf(1:10000,3)

%B_inactive = P_Simulator(D, 0);

7.2 P_Simulator

function [DATA Model] = P_Simulator(D, Rotor_active)

(31)

%% Skapar en model och kan simulerar en parametic sweep för förlustberäkning och kan spara en avi fil (parametrar)

% P_Simulator.m

%

% Model exported on Apr 10 2012, 18:28 by COMSOL 4.2.1.166.

import com.comsol.model.*

import com.comsol.model.util.*

model = ModelUtil.create('Model');

pause(2) % some time to start the showProgress command peacefully...

ModelUtil.showProgress(true); % display the progress bar

model.modelPath('C:\Users\gren\Documents\Backup\MATLAB');

model.modelNode.create('mod1');

model.geom.create('geom1', 2);

model.physics.create('mf', 'InductionCurrents', 'geom1');

model.study.create('std1');

model.study('std1').feature.create('stat', 'Stationary');

model.geom('geom1').lengthUnit('mm');

model.param.set('I', '20 [A]');

model.param.set('N', D.N);

model.param.set('a', D.a);

model.param.set('b', D.b);

model.param.set('d', D.d);

model.param.set('d_2', D.d_2);

28

(32)

model.param.set('d_3', D.d_3);

model.param.set('h_1', D.h_1);

model.param.set('O', D.O);

model.param.set('l', D.l);

model.param.set('h_2', D.h_2);

model.param.set('g', D.g);

model.param.set('m_1', D.m_1);

model.param.set('m_2', D.m_2);

model.param.set('CUarea', D.CUarea);

model.param.set('CUr', D.CUr);

model.param.set('CUgap', D.CUgap);

model.param.set('e', D.e);

model.param.set('f', D.f);

model.param.set('D.air', D.air);

model.geom('geom1').run;

model.geom('geom1').feature.create('r1', 'Rectangle');

model.geom('geom1').feature('r1').setIndex('size', 'O', 0);

model.geom('geom1').feature('r1').setIndex('size', 'l', 1);

model.geom('geom1').run('r1');

model.geom('geom1').feature('r2').setIndex('size', 'a-b', 0);

model.geom('geom1').feature('r2').setIndex('size', '(l-h_1-h_2*2)/2', 1);

model.geom('geom1').feature('r2').setIndex('pos', 'O', 0);

model.geom('geom1').feature('r3').setIndex('size', 'a-b', 0);

model.geom('geom1').feature('r3').setIndex('size', '(l-h_1-h_2*2)/2', 1);

model.geom('geom1').feature('r3').setIndex('pos', 'l-(l-h_1-h_2*2)/2', 1);

model.geom('geom1').feature('r4').setIndex('size', 'b', 0);

model.geom('geom1').feature('r4').setIndex('size', '(l-d-(g*2))/2', 1);

(33)

model.geom('geom1').feature('r4').setIndex('pos', 'O+a-b', 0);

model.geom('geom1').feature('r5').setIndex('size', 'b', 0);

model.geom('geom1').feature('r5').setIndex('size', '(l-d-(g*2))/2', 1);

model.geom('geom1').feature('r5').setIndex('pos', 'O+a-b', 0);

model.geom('geom1').feature('r5').setIndex('pos', 'l-(l-d-(g*2))/2', 1);

%kontrollera om man vill ha rotor if Rotor_active

model.geom('geom1').feature('r6').setIndex('size', 'd_2', 0);

model.geom('geom1').feature('r6').setIndex('size', 'd', 1);

model.geom('geom1').feature('r6').setIndex('pos', 'O+a-b-d_3', 0);

model.geom('geom1').feature('r6').setIndex('pos', '(l-d-(g*2))/2+g', 1);

end

model.geom('geom1').feature('r7').setIndex('size', 'CUr*2', 0);

model.geom('geom1').feature('r7').setIndex('size', '(h_1-CUgap)/2', 1);

model.geom('geom1').feature('r7').setIndex('pos', '(l-h_1-h_2*2)/2+h_2', 1);

model.geom('geom1').feature('r8').setIndex('size', 'CUr*2', 0);

model.geom('geom1').feature('r8').setIndex('size', '(h_1-CUgap)/2', 1);

model.geom('geom1').feature('r8').setIndex('pos', '0', 0);

model.geom('geom1').feature('r8').setIndex('pos', '(l-h_1-h_2*2)/2+h_2', 1);

model.geom('geom1').feature('r9').setIndex('size', 'D.air', 0);

model.geom('geom1').feature('r9').setIndex('size', 'D.air', 1);

30

(34)

model.geom('geom1').feature('r9').set('base', 'center');

model.geom('geom1').feature('r9').setIndex('pos', 'l/2', 1);

%kontrollera om man vill ha splines if D.spline_active

model.geom('geom1').feature.create('b1', 'BezierPolygon');

model.geom('geom1').feature('b1').set('degree', [2]);

model.geom('geom1').feature('b1').set('p', {'0' '0' '0'; '0' '0' '0'});

model.geom('geom1').feature('b1').set('w', {'1' '1/sqrt(2)' '1'});

model.geom('geom1').feature('b1').setIndex('p', 'O+(a-b)/2+m_1', 0, 0);

model.geom('geom1').feature('b1').setIndex('p', 'O', 0, 1);

model.geom('geom1').feature('b1').setIndex('p', 'O', 0, 2);

model.geom('geom1').feature('b1').setIndex('p', '(l-h_1-h_2*2)/2', 1, 0);

model.geom('geom1').feature('b1').setIndex('p', '(l-d-(g*2))/2+m_2', 1, 2);

model.geom('geom1').feature('b1').set('degree', [2 1]);

model.geom('geom1').feature('b1').set('p', {'O+(a-b)/2+m_1' 'O' 'O' 'O'; '(l-h_1-h_2*2)/2' '(l-h_1- h_2*2)/2' '(l-d-(g*2))/2+m_2' '(l-d-(g*2))/2+m_2'});

model.geom('geom1').feature('b1').set('w', {'1' '1/sqrt(2)' '1' '1' '1'});

model.geom('geom1').feature('b1').set('degree', [2 1 1]);

model.geom('geom1').feature('b1').set('p', {'O+(a-b)/2+m_1' 'O' 'O' 'O' 'O'; '(l-h_1-h_2*2)/2' '(l- h_1-h_2*2)/2' '(l-d-(g*2))/2+m_2' '(l-h_1-h_2*2)/2' '(l-h_1-h_2*2)/2'});

model.geom('geom1').feature('b1').set('w', {'1' '1/sqrt(2)' '1' '1' '1' '1' '1'});

model.geom('geom1').run('b1');

model.geom('geom1').feature.create('b2', 'BezierPolygon');

model.geom('geom1').feature('b2').set('degree', [2]);

model.geom('geom1').feature('b2').set('p', {'0' '0' '0'; '0' '0' '0'});

model.geom('geom1').feature('b2').set('w', {'1' '1/sqrt(2)' '1'});

(35)

model.geom('geom1').feature('b2').setIndex('p', '0', 0, 1);

model.geom('geom1').feature('b2').setIndex('p', 'O+a-b', 0, 0);

model.geom('geom1').feature('b2').set('degree', [2 1]);

model.geom('geom1').feature('b2').set('p', {'O+a-b' 'O+a-b' 'O+(a-b)/2+m_1' 'O+(a-b)/2+m_1'; '(l- d-(g*2))/2+m_2' '(l-h_1-h_2*2)/2' '(l-h_1-h_2*2)/2' '(l-h_1-h_2*2)/2'});

model.geom('geom1').feature('b2').set('w', {'1' '1/sqrt(2)' '1' '1' '1'});

model.geom('geom1').feature('b2').set('degree', [2 1 1]);

model.geom('geom1').feature('b2').set('p', {'O+a-b' 'O+a-b' 'O+(a-b)/2+m_1' 'O+a-b' 'O+a-b'; '(l- d-(g*2))/2+m_2' '(l-h_1-h_2*2)/2' '(l-h_1-h_2*2)/2' '(l-h_1-h_2*2)/2' '(l-h_1-h_2*2)/2'});

model.geom('geom1').feature('b2').set('w', {'1' '1/sqrt(2)' '1' '1' '1' '1' '1'});

model.geom('geom1').feature.create('mir2', 'Mirror');

model.geom('geom1').feature('mir2').selection('input').set({'b1' 'b2'});

model.geom('geom1').feature('mir2').set('keep', 'on');

model.geom('geom1').feature('mir2').setIndex('pos', 'O+(a-b)/2', 0);

model.geom('geom1').feature('mir2').setIndex('pos', 'l/2', 1);

model.geom('geom1').feature('mir2').setIndex('axis', '0', 0);

model.geom('geom1').feature.create('uni1', 'Union');

model.geom('geom1').feature.remove('uni1');

model.geom('geom1').run('mir2');

32

(36)

end

model.geom('geom1').feature.create('mir3', 'Mirror');

model.geom('geom1').feature('mir3').selection('input').set({'r7' 'r8'});

model.geom('geom1').feature('mir3').setIndex('pos', 'O/2', 0);

model.geom('geom1').feature('mir3').setIndex('pos', 'l/2', 1);

model.geom('geom1').feature('mir3').set('keep', 'on');

model.geom('geom1').run('mir3');

%olika unions beroende på Spline_active villkoret if D.spline_active

model.geom('geom1').feature('uni1').selection('input').set({'b1' 'b2' 'mir2(1)' 'mir2(2)' 'r1' 'r2' 'r3' 'r4' 'r5'});

model.geom('geom1').feature('uni1').set('intbnd', 'off');

else

model.geom('geom1').feature('uni1').selection('input').set({'r1' 'r2' 'r3' 'r4' 'r5'});

model.geom('geom1').feature('uni1').set('intbnd', 'off');

end

if D.active_holes

model.geom('geom1').feature.create('c1', 'Circle');

model.geom('geom1').feature('c1').set('r', 'e');

model.geom('geom1').feature('c1').setIndex('pos', 'f', 0);

model.geom('geom1').feature('c1').setIndex('pos', 'l-f', 1);

model.geom('geom1').run('c1');

model.geom('geom1').feature('c2').setIndex('pos', 'O+a-f', 0);

(37)

model.geom('geom1').feature('c3').setIndex('pos', 'O+a-f', 0);

model.geom('geom1').feature('c5').setIndex('pos', 'f*2', 0);

end

%definerar material

model.material.create('mat1');

model.material('mat1').name('Air');

model.material('mat1').set('family', 'air');

model.material('mat1').propertyGroup('def').set('relpermeability', '1');

model.material('mat1').propertyGroup('def').set('relpermittivity', '1');

model.material('mat1').propertyGroup('def').set('dynamicviscosity', 'eta(T[1/K])[Pa*s]');

model.material('mat1').propertyGroup('def').set('ratioofspecificheat', '1.4');

model.material('mat1').propertyGroup('def').set('electricconductivity', '0[S/m]');

model.material('mat1').propertyGroup('def').set('heatcapacity', 'Cp(T[1/K])[J/(kg*K)]');

model.material('mat1').propertyGroup('def').set('density', 'rho(pA[1/Pa],T[1/K])[kg/m^3]');

model.material('mat1').propertyGroup('def').set('thermalconductivity', 'k(T[1/K])[W/(m*K)]');

model.material('mat1').propertyGroup('def').set('soundspeed', 'cs(T[1/K])[m/s]');

model.material('mat1').propertyGroup('def').func.create('eta', 'Piecewise');

model.material('mat1').propertyGroup('def').func('eta').set('funcname', 'eta');

model.material('mat1').propertyGroup('def').func('eta').set('arg', 'T');

34

(38)

model.material('mat1').propertyGroup('def').func('eta').set('extrap', 'constant');

model.material('mat1').propertyGroup('def').func('eta').set('pieces', {'200.0' '1600.0' '-8.38278E- 7+8.35717342E-8*T^1-7.69429583E-11*T^2+4.6437266E-14*T^3-1.06585607E-17*T^4'});

model.material('mat1').propertyGroup('def').func.create('Cp', 'Piecewise');

model.material('mat1').propertyGroup('def').func('Cp').set('funcname', 'Cp');

model.material('mat1').propertyGroup('def').func('Cp').set('arg', 'T');

model.material('mat1').propertyGroup('def').func('Cp').set('extrap', 'constant');

model.material('mat1').propertyGroup('def').func('Cp').set('pieces', {'200.0' '1600.0' '1047.63657- 0.372589265*T^1+9.45304214E-4*T^2-6.02409443E-7*T^3+1.2858961E-10*T^4'});

model.material('mat1').propertyGroup('def').func.create('rho', 'Analytic');

model.material('mat1').propertyGroup('def').func('rho').set('funcname', 'rho');

model.material('mat1').propertyGroup('def').func('rho').set('args', {'pA' 'T'});

model.material('mat1').propertyGroup('def').func('rho').set('expr', 'pA*0.02897/8.314/T');

model.material('mat1').propertyGroup('def').func('rho').set('dermethod', 'manual');

model.material('mat1').propertyGroup('def').func('rho').set('argders', {'pA' 'd(pA*0.02897/8.314/T,pA)'; 'T' 'd(pA*0.02897/8.314/T,T)'});

model.material('mat1').propertyGroup('def').func.create('k', 'Piecewise');

model.material('mat1').propertyGroup('def').func('k').set('funcname', 'k');

model.material('mat1').propertyGroup('def').func('k').set('arg', 'T');

model.material('mat1').propertyGroup('def').func('k').set('extrap', 'constant');

model.material('mat1').propertyGroup('def').func('k').set('pieces', {'200.0' '1600.0' '-

0.00227583562+1.15480022E-4*T^1-7.90252856E-8*T^2+4.11702505E-11*T^3-7.43864331E- 15*T^4'});

model.material('mat1').propertyGroup('def').func.create('cs', 'Analytic');

model.material('mat1').propertyGroup('def').func('cs').set('funcname', 'cs');

model.material('mat1').propertyGroup('def').func('cs').set('args', {'T'});

model.material('mat1').propertyGroup('def').func('cs').set('expr', 'sqrt(1.4*287*T)');

model.material('mat1').propertyGroup('def').func('cs').set('dermethod', 'manual');

model.material('mat1').propertyGroup('def').func('cs').set('argders', {'T' 'd(sqrt(1.4*287*T),T)'});

model.material('mat1').propertyGroup('def').addInput('temperature');

model.material('mat1').propertyGroup('def').addInput('pressure');

(39)

model.material('mat2').name('Soft Iron (without losses)');

model.material('mat2').set('family', 'iron');

model.material('mat2').propertyGroup('def').set('relpermittivity', '1');

model.material('mat2').propertyGroup.create('BHCurve', 'BH curve');

model.material('mat2').propertyGroup('BHCurve').set('normB', 'BH(normH[m/A])[T]');

model.material('mat2').propertyGroup('BHCurve').func.create('BH', 'Interpolation');

model.material('mat2').propertyGroup('BHCurve').func('BH').set('funcname', 'BH');

model.material('mat2').propertyGroup('BHCurve').func('BH').set('interp', 'linear');

model.material('mat2').propertyGroup('BHCurve').func('BH').set('extrap', 'linear');

model.material('mat2').propertyGroup('BHCurve').func('BH').set('table', {'0' '0'; '663.146' '1';

'1067.5' '1.1'; '1705.23' '1.2'; '2463.11' '1.3'; '3841.67' '1.4'; '5425.74' '1.5'; '7957.75' '1.6'; '12298.3' '1.7'; '20462.8' '1.8'; '32169.6' '1.9'; '61213.4' '2.0'; '111408' '2.1'; '175070' '2.2'; '261469' '2.3';

'318310' '2.4'});

model.material('mat2').propertyGroup.create('HBCurve', 'HB curve');

model.material('mat2').propertyGroup('HBCurve').set('normH', 'HB(normB[1/T])[A/m]');

model.material('mat2').propertyGroup('HBCurve').func.create('HB', 'Interpolation');

model.material('mat2').propertyGroup('HBCurve').func('HB').set('funcname', 'HB');

model.material('mat2').propertyGroup('HBCurve').func('HB').set('interp', 'linear');

model.material('mat2').propertyGroup('HBCurve').func('HB').set('extrap', 'linear');

model.material('mat2').propertyGroup('HBCurve').func('HB').set('table', {'0' '0'; '1' '663.146'; '1.1' '1067.5'; '1.2' '1705.23'; '1.3' '2463.11'; '1.4' '3841.67'; '1.5' '5425.74'; '1.6' '7957.75'; '1.7' '12298.3';

'1.8' '20462.8'; '1.9' '32169.6'; '2.0' '61213.4'; '2.1' '111408'; '2.2' '175070'; '2.3' '261469'; '2.4' '318310'});

model.material('mat2').set('family', 'iron');

%kontroll av selections för material if Rotor_active

model.material('mat2').selection.set([2 7]);

else

model.material('mat2').selection.set([2]);

end

model.material('mat2').propertyGroup('def').set('relpermeability', {'1'});

36

(40)

model.physics('mf').feature.create('al2', 'AmperesLaw', 2);

if Rotor_active

model.physics('mf').feature('al2').selection.set([2 7]);

else

model.physics('mf').feature('al2').selection.set([2]);

end

model.physics('mf').feature('al2').set('ConstitutiveRelationH', 1, 'HBCurve');

model.physics('mf').feature.create('mtcd1', 'MultiTurnCoilDomain', 2);

model.physics('mf').feature('mtcd1').selection.set([3]);

model.physics('mf').feature('mtcd1').set('N', 1, 'N/2');

model.physics('mf').feature('mtcd1').set('coilWindArea', 1, 'CUarea');

model.physics('mf').feature('mtcd1').set('ICoil', 1, 'I');

model.physics('mf').feature('al2').set('ConstitutiveRelationH', 1, 'HBCurve');

model.physics('mf').feature('mtcd2').set('ICoil', 1, 'I');

model.physics('mf').feature('mtcd3').set('ICoil', 1, '-I');

model.physics('mf').feature('mtcd4').set('ICoil', 1, '-I');

model.physics('mf').prop('d').set('d', 1, '0.001');

model.name('Matlab_design.mph');

(41)

model.save('C:\Users\gren\Documents\Backup/model_vertifiering_2');

ModelUtil.remove('model');

model = mphload('C:\Users\gren\Documents\Backup/model_vertifiering_2.mph');

model.mesh.create('mesh1', 'geom1');

model.mesh('mesh1').automatic(false);

model.mesh('mesh1').feature.create('edg1', 'Edge');

model.mesh('mesh1').feature.move('edg1', 1);

%kontroll av selections för mech if Rotor_active*D.spline_active if (D.d_3 > 0)

model.mesh('mesh1').feature('edg1').selection.set([29 30 32 33]);

else

model.mesh('mesh1').feature('edg1').selection.set([32 34 35 37]);

end

elseif D.spline_active

model.mesh('mesh1').feature('edg1').selection.set([32 34]);

elseif Rotor_active if D.d_3>0

model.mesh('mesh1').feature('edg1').selection.set([18 19 22 26 28 33 34 36 37 38 39]);

else

model.mesh('mesh1').feature('edg1').selection.set([24 25 27 29 30 33 34 36 37 38 39]);

end else

model.mesh('mesh1').feature('edg1').selection.set([24 25 27 29 30 33 34 35 36]);

end

model.mesh('mesh1').feature('edg1').feature.create('size1', 'Size');

model.mesh('mesh1').feature('edg1').feature('size1').set('custom', 'on');

model.mesh('mesh1').feature('edg1').feature('size1').set('hmaxactive', 'on');

model.mesh('mesh1').feature('edg1').feature('size1').set('hmax', '0.8');

model.mesh('mesh1').feature('ftri1').feature.create('size1', 'Size');

38

(42)

%eventuell extra fin mech för rotor %if Rotor_active

%model.mesh('mesh1').feature.create('ftri2', 'FreeTri');

%model.mesh('mesh1').feature.move('ftri2', 2);

%model.mesh('mesh1').feature('ftri2').selection.geom('geom1', 2);

%model.mesh('mesh1').feature('ftri2').selection.set([7]);

%model.mesh('mesh1').feature('ftri2').feature.create('size1', 'Size');

%model.mesh('mesh1').feature('ftri2').feature('size1').set('hauto', '3');

%end

model.mesh('mesh1').feature('ftri1').feature('size1').set('hauto', '5');

model.mesh('mesh1').run;

model.study('std1').feature.create('param', 'Parametric');

model.study('std1').feature('param').set('plist', num2str(D.I));

model.study('std1').feature('param').set('pname', {'I'});

model.sol.create('sol1');

model.sol('sol1').study('std1');

model.sol('sol1').feature.create('st1', 'StudyStep');

model.sol('sol1').feature('st1').set('study', 'std1');

model.sol('sol1').feature('st1').set('studystep', 'stat');

model.sol('sol1').feature.create('v1', 'Variables');

model.sol('sol1').feature.create('s1', 'Stationary');

model.sol('sol1').feature('s1').feature.create('p1', 'Parametric');

model.sol('sol1').feature('s1').feature('p1').set('pname', {'I'});

model.sol('sol1').feature('s1').feature('p1').set('plist', num2str(D.I));

model.sol('sol1').feature('s1').feature('p1').set('plot', 'off');

model.sol('sol1').feature('s1').feature('p1').set('probesel', 'all');

model.sol('sol1').feature('s1').feature('p1').set('probes', {});

model.sol('sol1').feature('s1').feature('p1').set('control', 'param');

model.sol('sol1').feature('s1').set('control', 'stat');

model.sol('sol1').feature('s1').feature.create('fc1', 'FullyCoupled');

model.sol('sol1').feature('s1').feature.remove('fcDef');

model.sol('sol1').feature('s1').set('stol', '0.00001');

(43)

model.sol('sol1').attach('std1');

model.result.create('pg1', 2);

model.result('pg1').set('data', 'dset1');

model.result('pg1').feature.create('surf1', 'Surface');

model.result('pg1').feature('surf1').set('expr', {'mf.normB'});

model.result('pg1').name('Magnetic Flux Density (mf)');

model.result('pg1').feature('surf1').set('rangecoloractive', 'on');

model.result('pg1').feature('surf1').set('rangecolormin', '0');

model.result('pg1').feature('surf1').set('rangecolormax', '2.2');

model.sol('sol1').runAll;

model.result('pg1').run;

model.result.export.create('data1', 'Data');

%notera solution 50

model.result.export('data1').set('solnum', {num2str(1:length(D.I))});

model.result.export('data1').set('expr', {'mf.normB'});

model.result.export('data1').set('descr', {'Magnetic flux density norm'});

model.result.export('data1').set('unit', {'T'});

model.result.export('data1').set('filename', ['C:\Users\gren\Documents\Backup\m' native2unicode(hex2dec('00e4'), 'Cp1252') 'tpunkter_data\qwer.txt']);

model.result.export('data1').set('location', 'regulargrid');

model.result.export('data1').set('regulargridx2', num2str(D.regulargridx2));

model.result.export('data1').set('regulargridy2', num2str(D.regulargridy2));

model.result.export('data1').set('header', 'off');

model.result.export('data1').run;

model.result.export.create('data2', 'Data');

model.result.export('data2').set('expr', {'mf.normM'});

model.result.export('data2').set('descr', {'magnetization'});

model.result.export('data2').set('unit', {'A/m'});

model.result.export('data2').set('solnum', {num2str(1:length(D.I))});

model.result.export('data2').set('location', 'regulargrid');

40

(44)

model.result.export('data2').set('regulargridx2', num2str(D.regulargridx2));

model.result.export('data2').set('regulargridy2', num2str(D.regulargridy2));

model.result.export('data2').set('filename', ['C:\Users\gren\Documents\Backup\m' native2unicode(hex2dec('00e4'), 'Cp1252') 'tpunkter_data\asdf.txt']);

model.result.export('data2').set('header', 'off');

model.result.export('data2').run;

ant_I = size(D.I);

DATA = zeros((D.regulargridx2*D.regulargridy2), 2+ant_I(2));

asdf = importdata('C:\Users\gren\Documents\Backup\mätpunkter_data\asdf.txt');

qwer = importdata('C:\Users\gren\Documents\Backup\mätpunkter_data\qwer.txt');

DATA(1:(D.regulargridx2*D.regulargridy2), 1:2+ant_I(2)) =

importdata('C:\Users\gren\Documents\Backup\mätpunkter_data\qwer.txt');

M = asdf(1:(D.regulargridx2*D.regulargridy2), 3:2+ant_I(2)) > 0;

DATA(1:(D.regulargridx2*D.regulargridy2), 3:2+ant_I(2)) = M.*qwer(1:

(D.regulargridx2*D.regulargridy2),3:2+ant_I(2));

model.save('C:\Users\gren\Documents\Backup/model_vertifiering_2');

model.mesh('mesh1').export('C:\Users\gren\Documents\Backup/Model_2d.mphbin');

Model = model;

7.3 threeD_simulator.m

%clc

%clear

%% Synkronisering

%starta Solidworks & öppna modellen Stator_3

import com.comsol.model.*

import com.comsol.model.util.*

model = ModelUtil.create('Model');

(45)

model.modelPath('C:\Users\gren\Documents\Backup');

model.modelNode.create('mod1');

model.geom.create('geom1', 3);

model.mesh.create('mesh1', 'geom1');

model.physics.create('mf', 'InductionCurrents', 'geom1');

model.study.create('std1');

model.study('std1').feature.create('stat', 'Stationary');

model.geom('geom1').lengthUnit('mm');

model.geom('geom1').feature.create('cad1', 'LiveLinkSolidWorks');

%%Progress bar

ModelUtil.showProgress(true); % display the progress bar

%%Parametrisering

Pipe_l = 240;

E_Bit_a = 34;

E_Bit_b = 20;

E_Bit_h_1 = 101;

E_Bit_h_2 = 10;

E_Bit_l = 169;

E_Bit_O = 20;

E_Bit_CU_r = 1;

E_Bit_Hole = 4;

E_Bit_Hole_a = 7;

42

(46)

E_Bit_CUgap = 10;

E_Bit_g = 1;

Rotor_d_2 = 20;

Block_deg = 80; % Max 80 för att få plats med kopparlindningen mellan C-bitarna dy = 36;

r = 37;

Ant = 6;

CU_gap = (4.5+1)*2;

CU_gap_deg=40;

ExternalCurrentDensity = 100000;

ExternalCurrentDensity_2 = linspace(-31250,31250,50);

Ant_2 = Ant -1;

deg_3 = Block_deg / Ant_2;

deg = deg_3;

r_2 = dy + r;

DataGridx = 50;

DataGridy = 50;

DataGridz = 50;

%x = tan((deg*pi/180)/2)*r;

%alfa = (180/pi)*atan(x/r);

%deg_2 = (asin(CU_gap/(2*sqrt(r^2+x^2)))+alfa)*2;

%r_3 = sqrt(r^2 + x^2);

model.geom('geom1').feature('cad1').importData;

pause(2)

model.geom('geom1').feature('cad1').setIndex('param', 'D3@innerkilar', 0);

model.geom('geom1').feature('cad1').setIndex('paramvalue', '120', 0);

model.geom('geom1').feature('cad1').setIndex('param', 'Pipe_l', 1);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(Pipe_l), 1);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_a', 2);

(47)

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_a), 2);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_b', 3);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_b), 3);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_h_1', 4);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_h_1), 4);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_h_2', 5);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_h_2), 5);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_l', 6);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_l), 6);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_O', 7);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_O), 7);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_CU_r', 8);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_CU_r), 8);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_Hole', 9);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_Hole), 9);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_Hole_a', 10);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_Hole_a), 10);

model.geom('geom1').feature('cad1').setIndex('param', 'E_Bit_CUgap', 11);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(E_Bit_CUgap), 11);

model.geom('geom1').feature('cad1').setIndex('param', 'Ant', 12);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(Ant), 12);

%ekvation Ant - 1

model.geom('geom1').feature('cad1').setIndex('param', 'Ant_2', 13);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(Ant_2), 13);

model.geom('geom1').feature('cad1').setIndex('param', 'Block_deg', 14);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(Block_deg), 14);

%ekvation "Block_deg" / "Ant_2"

model.geom('geom1').feature('cad1').setIndex('param', 'deg_3', 15);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(deg_3), 15);

%"deg_3"= "Block_deg" / "Ant_2"

model.geom('geom1').feature('cad1').setIndex('param', 'dy', 16);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(dy), 16);

model.geom('geom1').feature('cad1').setIndex('param', 'r', 17);

44

(48)

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(r), 17);

%"r_2"= "dy" + "r"

model.geom('geom1').feature('cad1').setIndex('param', 'r_2', 18);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(r_2), 18);

% "CU-gap"= (4.5+1)*2

model.geom('geom1').feature('cad1').setIndex('param', 'CU-gap', 19);

model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(CU_gap), 19);

%"deg"= "deg_3"

%model.geom('geom1').feature('cad1').setIndex('param', 'deg', 21);

%model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(deg), 21);

%x = tan("deg"/2)*"r"

%model.geom('geom1').feature('cad1').setIndex('param', 'x', 22);

%model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(x), 22);

%"alfa"= (atn("x"/"r"))

%model.geom('geom1').feature('cad1').setIndex('param', 'alfa', 23);

%model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(alfa), 23);

%model.geom('geom1').feature('cad1').setIndex('param', 'CU_gap_deg',24);%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%

%model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(CU_gap_deg), 24);

%"deg_2"= (arcsin("CU-gap"/(2*sqr("r"^2+"x"^2)))+"alfa")*2

%model.geom('geom1').feature('cad1').setIndex('param', 'deg_2', 25);

%model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(deg_2), 25);

%"D3@3C-block" = "Block_deg"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%

%model.geom('geom1').feature('cad1').setIndex('param', 'D3@3C-block', 26);

%model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(Block_deg), 26);

%"D3@ytterkilar_2" = "deg"

%model.geom('geom1').feature('cad1').setIndex('param', 'D3@ytterkilar_2', 27);

%"D3@3C-block_2" = "deg"

(49)

%model.geom('geom1').feature('cad1').setIndex('param', 'D3@3C-block_2', 28);

%"D3@3C-block_3" = "deg"

%"D3@ytterkilar_4" = "deg"

%"D2@CirPattern2" = "deg"

%model.geom('geom1').feature('cad1').setIndex('param', 'D2@CirPattern2', 31);

%"D3@innerkilar_2" = "deg"

%model.geom('geom1').feature('cad1').setIndex('param', 'D3@innerkilar_2', 32);

%"D1@3C-block" = "Ant"

%model.geom('geom1').feature('cad1').setIndex('param', 'D1@3C-block', 33);

%model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(Ant), 33);

%"D1@3C-block_2" = "Ant"

%"D1@3C-block_3" = "Ant"

%"D1@innerkilar_2" = "Ant_2"

%model.geom('geom1').feature('cad1').setIndex('param', 'D1@innerkilar_2', 36);

%model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(Ant_2), 36);

%"D1@ytterkilar_4" = "Ant_2"

%"D1@CirPattern2" = "Ant_2"

%model.geom('geom1').feature('cad1').setIndex('param', 'D1@CirPattern2', 38);

%"D1@ytterkilar_2" = "Ant_2"

46

(50)

%"r_3"= sqr( "r"^2 + "x"^2 )

%model.geom('geom1').feature('cad1').setIndex('param', 'r_3', 40);

%model.geom('geom1').feature('cad1').setIndex('paramvalue', num2str(r_3), 40);

model.geom('geom1').feature('cad1').importData;

model.name('model_vertifiering_7.mph');

model.geom('geom1').runAll;

%Roterar geometrin för lättare val av selections for n = 1:(7+Ant+2*Ant_2)

s = ['cad1(' num2str(n) ')'];

s_2 = ['rot' num2str(n)];

model.geom('geom1').feature.create(s_2, 'Rotate');

model.geom('geom1').feature(s_2).selection('input').set({s});

model.geom('geom1').feature(s_2).setIndex('ax3', '1', 1);

model.geom('geom1').feature(s_2).setIndex('ax3', '0', 2);

model.geom('geom1').feature(s_2).set('rot', '40');

end

model.geom('geom1').runAll;

%%Material definering

%Air material

model.material('mat1').name('Air');

model.material('mat1').propertyGroup('def').set('dynamicviscosity', 'eta(T[1/K])[Pa*s]');

model.material('mat1').propertyGroup('def').set('ratioofspecificheat', '1.4');

model.material('mat1').propertyGroup('def').set('heatcapacity', 'Cp(T[1/K])[J/(kg*K)]');

model.material('mat1').propertyGroup('def').set('density', 'rho(pA[1/Pa],T[1/K])[kg/m^3]');

model.material('mat1').propertyGroup('def').set('thermalconductivity', 'k(T[1/K])[W/(m*K)]');

model.material('mat1').propertyGroup('def').set('soundspeed', 'cs(T[1/K])[m/s]');

(51)