Download - Modelowanie i analiza przetworników elektromechanicznych z ... · Modelowanie i analiza przetworników elektromechanicznych z wykorzystaniem MES 4 1 Program Flux2D FLUX2D jest programem

Modelowanie i analiza przetworników

elektromechanicznych z wykorzystaniem

MES

dr inż Michał Michna

dr inż Grzegorz Kostro

Politechnika Gdańska, Gdańsk 2011

Publikacja jest dystrybuowana bezpłatnie.

Materiały zostały przygotowane w związku z realizacją projektu pt. „Zamawianie

kształcenia na kierunkach technicznych, matematycznych i przyrodniczych – pilotaż”

współfinansowanego ze środków Unii Europejskiej w ramach Europejskiego Funduszu

Społecznego Nr umowy: 46/DSW/4.1.2/2008 – zadanie 018240

w okresie od 21.08.2008 – 15.03.2012

Modelowanie i analiza przetworników elektromechanicznych z wykorzystaniem MES

2

Spis treści

1 Program Flux2D ............................................................................................................................ 4

1.1 Instalacja programu ................................................................................................................. 4

1.2 Algorytm obliczeń ................................................................................................................... 5

1.3 Prototyp silnika ........................................................................................................................ 6

2 Rozpoczęcie pracy z programem Flux2D ........................................................................................ 8

2.1 Program Flux Supervisor ......................................................................................................... 8

3 Model geometryczny ...................................................................................................................... 10

3.1 Projekt SBMT ........................................................................................................................ 10

3.2 Proces definiowania modelu geometrycznego ...................................................................... 12

3.3 Parametry modelu geometrycznego silnika ........................................................................... 12

3.3.1 Definicja parametru ........................................................................................................... 14

3.4 Układy współrzędnych .......................................................................................................... 15

3.5 Wirnik .................................................................................................................................... 16

3.5.1 Układy współrzędnych ...................................................................................................... 16

3.5.2 Punkty wirnika .................................................................................................................. 17

3.5.3 Zarys wirnika ..................................................................................................................... 19

3.5.4 Powierzchnie wirnika ........................................................................................................ 21

3.5.5 Regiony ............................................................................................................................. 21

3.6 Stojan i żłobek ....................................................................................................................... 23

3.6.1 Układy współrzędnych ...................................................................................................... 23

3.6.2 Punkty stojana i żłobka ...................................................................................................... 23

3.6.3 Zarys stojana ...................................................................................................................... 25

3.6.4 Powierzchnie stojana ......................................................................................................... 26

3.6.5 Regiony ............................................................................................................................. 26

3.6.6 Transformacje .................................................................................................................... 26

3.7 Szczelina powietrzna ............................................................................................................. 28

3.7.1 Układ współrzędnych ........................................................................................................ 28

3.7.2 Punkty szczeliny powietrznej ............................................................................................ 28

3.7.3 Zarys szczeliny powietrznej .............................................................................................. 29

3.7.4 Powierzchnie szczeliny powietrznej .................................................................................. 29

3.7.5 Regiony ............................................................................................................................. 29

3.8 Sprawdzenie poprawności modelu geometrycznego ............................................................. 30


3

4 Dyskretyzacja modelu .................................................................................................................... 31

4.1 Ogólny algorytm dyskretyzacji automatycznej ..................................................................... 31

4.2 Automatyczna dyskretyzacja modelu .................................................................................... 32

4.3 Przydział pamięci dla programu flux2D ................................................................................ 33

4.4 Dyskretyzacja szczeliny obrotowej ....................................................................................... 34

4.5 Parametry kontroli gęstości siatki ......................................................................................... 35

4.5.1 Gęstość podział Linii – Mesh Line .................................................................................... 35

4.5.2 Gęstość siatki wokół punktu – Mesh Point ....................................................................... 36

4.5.3 Generator siatki ................................................................................................................. 37

4.6 Przyporządkowanie parametrów gęstości siatki do elementów modelu ............................... 37

4.7 Ponowna dyskretyzacja modelu .......................................................................................... 43

4.8 Weryfikacja dyskretyzacji modelu ..................................................................................... 43

5 Model fizyczny .............................................................................................................................. 44

5.1 Moduł obliczeniowy .............................................................................................................. 44

5.2 Warunki symetrii ................................................................................................................... 45

5.3 Warunki brzegowe ................................................................................................................ 45

5.4 Materiały ............................................................................................................................... 47

5.4.1 Magnesy trwałe ................................................................................................................. 47

5.4.2 Blacha prądnicowa ............................................................................................................ 48

5.4.3 Baza materiałów ................................................................................................................ 49

5.4.4 Przyporządkowanie materiałów do regionów ................................................................... 51

5.4.5 Właściwości mechaniczne ................................................................................................. 52

5.4.6 Sprawdzenie poprawności modelu fizycznego .................................................................. 54

5.5 Zapisanie modelu numerycznego .......................................................................................... 55

6 Obliczenia w programie polowym ................................................................................................. 56

6.1 Obliczenia parametryczne ..................................................................................................... 56

6.2 Warunki obliczeń .................................................................................................................. 58

6.3 Bieg jałowy............................................................................................................................ 58

6.3.1 Rozkład indukcji ................................................................................................................ 58

6.3.2 Strumień sprzężony z uzwojeniem w funkcji położenia wirnika ...................................... 70

6.3.3 Napięcie indukowane rotacji ............................................................................................. 72

6.3.4 Moment zaczepowy ........................................................................................................... 73

7 Bibliografia .................................................................................................................................... 75

8 Skrypt ............................................................................................................................................. 76


4

1 Program Flux2D FLUX2D jest programem CAD (1), umożliwiającym między innymi obliczanie pól magnetycznych

oraz ich analizę. Obliczenia wykonywane są z wykorzystaniem metody elementów skończonych.

Program Flux 2D służy do analizy zagadnień, których modele obliczeniowe mogą być przekrojami

płaskimi rzeczywistych obiektów (obiekty które można utworzyć poprzez wyciagnięcie proste ich

przekroju poprzecznego albo obrót odpowiedniego przekroju wokół osi symetrii - problemy z symetrią

obrotową). Program zawiera moduły do analizy pól magnetycznych, elektrycznych i cieplnych.

Analiza tych pól pozwala na obliczanie wielu wielkości globalnych i lokalnych, takich jak indukcja,

potencjał, strumień, energia, siła, itd (2). Flux posiada cechy wyróżniające go z pośród innych

programów do obliczeń polowych (3). Program ten umożliwia:

analizę pola magnetycznego, elektrycznego i termicznego,

analizę stanów statycznych, nieustalonych i harmonicznych,

analizę wieloparametryczną zarówno na etapie obliczeń jak i obróbki wyników,

analizę sprzężonych zagadnień magnetyczno-termicznych i dielektryczno-termicznych,

obliczenia pól sprzężonych z ruchem liniowym i obrotowym,

sprzężenie modelu polowego z zewnętrznym obwodem elektrycznym (schematem

elektrycznym),

wykorzystanie komend opartych na języku Python,

tworzenie nowego programu wykonawczego poprzez dołożenie własnych procedur,

budowę modeli maszyn elektrycznych z wykorzystaniem dedykowanego interfejsu,

zaawansowaną prezentację wyników obliczeń.

1.1 Instalacja programu

Na stronie domowej firmy CEDRAT(1) dostępna jest 60-dniowa wersja programu Flux2D (rys. 1.1).

Klucz licencji oraz link do wersji instalacyjnej jest wysyłany emailem po wypełnieniu odpowiedniego

formularza. W formularzu oprócz podstawowych danych osobowych studenta konieczne jest podanie

nazwiska osoby prowadzącej zajęcia (Teacher's name) oraz MAC adresu karty sieciowej komputera,

na którym planowana jest instalacja programu.

http://www.cedrat.com/


5

Rys. 1.1 Strona domowa programu Flux2D (1)

W laboratorium EM02 zainstalowany jest program Flux2D w wersji 10.2 (wersja edukacyjna) –

licencja sieciowa umożliwia uruchomienie go na 15 stanowiskach. Różnice pomiędzy wersją

demonstracyjną a wersją edukacyjną (zainstalowaną w laboratorium EM02) zestawiono w poniższej

tabeli. Najważniejszym ograniczeniem wersji edukacyjnej programu jest maksymalna liczba węzłów.

Rys. 1.2. Porównanie cech pakietów symulacyjnych FLUX 2D, 3D (1)

DEMO VERSION FULL VERSION

2D 3D 2D 3D

Magnetic applications

- static x x x

- steady AC x x

- transient x x

- coupling with circuit equations x x

- movement (rotation & translation) x x

Electric applications

- static x x x

- steady AC x x

- electric conduction x x

Thermal applications

- steady thermal x x x

- transient thermal x x

- magneto thermal x x

- electro thermal x x

Other features

- Coupling with Simulink x

- Multiphysics x

- Motor Overlays (BPM, IM, DCM, SRM) 1 x

- Advanced CAD Import / Export x x

- Superconductivity x

1.2 Algorytm obliczeń

Proces obliczeń w programie Flux2D składa się z następujących etapów(rys. 1.3):

opracowanie modelu geometrycznego – układy współrzędnych, wprowadzenie punktów, linii,

powierzchni, parametrów, dyskretyzacja modelu (generacja siatki);

zdefiniowanie modelu fizycznego – właściwości fizyczne (materiały), warunki brzegowe,

wymuszenia pola;

wykonanie obliczeń (procesor/solver)– ustawienia opcji obliczeń, obliczenia parametryczne;

analiza wyników obliczeń – postprocesor.


6

Istotną zaletą programu jest możliwość wykonywania obliczeń w funkcji określonych parametrów

geometrycznych, właściwości materiałów lub wartości wymuszeń pola. Wyniki obliczeń można

analizować w postprocesorze programu Flux2D lub eksportować do plików tekstowych.

W instrukcji używa się następujących pojęć:

model numeryczny (rys.1.3) – kompletny model obliczeniowy urządzenia wprowadzony do

programu Flux obejmujący:

o model geometryczny – rysunek, zarys urządzenia (zbiór parametrów, punktów, linii,

powierzchni) wraz z siatką dyskretyzującą model

o model fizyczny – właściwości fizyczne, wymuszenia pola, warunki brzegowe.

Otwracie

projektu

model.tra

Import modelu

CAD

Zakończenie

Model numeryczny w programie Flux2D

Model

geometryczny

Genracja siatki

Właściwości

fizyczne

Import modelu

Flux

Definicja

materiałówmateri.dat

Obliczenia

Analiza wyników

obliczeń

Definicja

obwodu

elektrycznego

Pre

pro

ce

so

rP

ostp

roce

so

rso

lve

r

Rys. 1.3. Ogólny algorytm obliczeń w programie Flux2D

1.3 Prototyp silnika

W instrukcji opisano sposób definiowania modelu numerycznego i analizę silnika bezszczotkowego

z magnesami trwałymi. Dane wejściowe do projektu (wymiary, materiały, uzwojenie) opracowano na


7

podstawie zmodyfikowanego silnika Sg100L4A firmy Tamel. Stojan i uzwojenie silnika pozostawiono

bez zmian. Wykonano nowy wirnik z magnesami mocowanymi powierzchniowo.

Rys. 1.4 Prototyp Silnika z magnesami trwałymi wykonany na bazie silnika Tamesl Sg100L4a


8

2 Rozpoczęcie pracy z programem Flux2D

2.1 Program Flux Supervisor

W celu uruchomienia programu należy wybrać nazwę programu z menu start lub kliknąć odpowiednią

ikonę na pulpicie (rys.2.1).

Rys. 2.1 Uruchomienie programu FLux2D

Główne okno Flux Supervisor (rys.2.2) składa się z sekcji wyboru modułu programu, okna z drzewem

katalogów wskazującego położenie katalogu roboczego oraz okna z plikami projektu. Zaleca się by

każdy nowy projekt zapisywać w osobnym katalogu.

Rys. 2.2. Główne okno programu Flux Supervisor

Po wybraniu opcji Tools w menu górnym mamy dostęp do ustawień programu (Option) (rys. 2.3). Na

zakładce General można określić miejsce zapisu pliku z danymi materiałów (katalog roboczy, plik

współdzielony, użytkownika). Informacja na temat lokalizacji pliku z materiałami jest o tyle istotna,

że w czasie opracowywania nowych modeli obliczeniowych można wykorzystywać wcześniej

opracowywane modele materiałów (opcja Shared).


9

Rys. 2.3 Okno ustawieo ogólnych programu Flux2D


10

3 Model geometryczny

Model geometryczny silnika (rys. 3.1) zostanie wykonany w następujących krokach:

- Definicja układów współrzędnych,

- Definicja parametrów modelu geometrycznego,

- Wprowadzenie punktów charakterystycznych modelu,

- Połączenie punktów liniami,

- Definicja powierzchni,

- Definicja transformacji,

- Powielenie elementów modelu z wykorzystaniem transformacji.

Proces ten jest uniwersalny i może być wykorzystany do opracowywania modeli geometrycznych

innych maszyn elektrycznych.

Rys. 3.1. Model geometryczny silnika

3.1 Projekt SBMT

Należy utworzyć katalog SBMT i wskazać go w drzewie katalogów programu FluxSupervisor. Model

geometryczny silnika wykonuje się z wykorzystaniem podprogramu Preflu2D. W celu jego

uruchomienia należy wybrać w kategorii Construction moduł Geometry & Physics (rys. 3.2).

Rys. 3.2. Uruchomienie modułu Preflu2D


11

W menu górnym programu Preflu2D należy wybrać opcję Project->New lub wybrać odpowiednią

ikonę z paska narzędzi (rys. 3.3).

Rys. 3.3. Utworzenie i zapisanie nowego projektu

Dostęp do narzędzi rysunkowych jest możliwy poprzez wybranie odpowiedniego polecenia z menu

górnego, pasków narzędzi lub drzewa projektów(rys. 3.4). Narzędzia dostępne na paskach narzędzi

zmieniają się w zależności od aktualnie wybranego trybu pracy (model geometryczny, model

fizyczny, dyskretyzacja).

Rys. 3.4. Okno projektu

Po lewej stronie okna znajduje się drzewo projektu, w którym można przeglądać wszystkie zmiany

wprowadzone w bieżącym projekcie. Elementy projektu pogrupowane są w kategorie:

- model geometryczny,

- siatka – dyskretyzacja modelu,

- model fizyczny,

- narzędzia,

Linia poleceń

Obszar rysunku

Drzewo projektu

Paski narzędzi Menu główne


12

- rozszerzenia.

3.2 Proces definiowania modelu geometrycznego

Definicja modelu geometrycznego w programie preflu2D wymaga zdefiniowania kolejno:

punktów charakterystycznych geometrii,

linii: odcinków prostych i łuków,

powierzchni (face).

Program preflu2D posiada wiele narzędzi ułatwiających definiowanie modelu geometrycznego, z

których najbardziej interesujące to:

możliwość parametryzowania geometrii,

definiowanie lokalnych układów współrzędnych,

powielanie elementów modelu geometrycznego z wykorzystaniem transformacji, kopiowanie

punktów i linii.

Model silnika zostanie zdefiniowany jako model parametryczny.

3.3 Parametry modelu geometrycznego silnika

Poniżej przedstawiono oznaczenia parametrów modelu geometrycznego silnika bezszczotkowego z

magnesami trwałymi. Przyjęto jedną z najprostszych i najczęściej stosowanych konstrukcji wirników

maszyn z magnesami trwałymi. Magnesy trwałe w kształcie wycinków pierścienia zamocowano na

wirniku (rys. 3.5).

Parametry Układy

współrzędnych Transformacje

Punkty

Linie

Powierzchnie


13

DRD

M

DS

HMDELTA

ALFA

M

DRI

Rys. 3.5 Parametry modelu geometrycznego – wirnik

Przyjęty kształt przekroju żłobka stojana jest odpowiedni do uzwojeń wykonanych z drutu okrągłego.

Kształt żłobka i oznaczenia wymiarów (parametrów) blachy stojana przedstawiono na rys. 3.6.

HS1

HS2

HS3

BS

2

BS

1

BS

3

DSE

DS

Rys. 3.6 Parametry modelu geometrycznego – stojan

Zastosowane wartości parametrów modelu geometrycznego silnika zestawiono w tabela 3.1.

Tabela 3.1. Wartości parametrów modelu geometrycznego silnika

oznaczenie (name)

wyrażenie (expression)

wartośd (value)

Jednostka (unit)

opis (comment)

NPH =3 3 ul liczba faz (number of phase)

P =2 4 ul liczba par biegunów (number of pole pairs)

Q =3 3 ul liczba żłobków na biegun i fazę (number of slots for one phase and one pole)

NS =2*NPH*P*Q 36 ul liczba żłobków (number of slots)

TAUS =360/NS 6.667 ul podziałka żłobkowa (slote pitch)

TAUP =360/P/2 45 ul Podziałka biegunowa (pole pitch)

DRI =38 38 mm średnica wewnętrzna wirnika (inner diameter of rotor = diameter of shaft)

DELTA =1 1 mm grubośd szczeliny powietrznej (width of airgap)

HM =5 5 mm wysokośd magnesu (high of magnet)

ALFAM =0.6 0.6 ul wsp. zapełnienia podziałki biegunowej wirnika


14

DSE =155,1 155,1 mm średnica zewnętrzna stojana (outer diameter of stator)

DS =94 94 mm średnica wewnętrzna stojana (inner diameter of stator)

LES =100 100 mm długośd stojana (stator length)

BS1 =2,6 2,6 mm szerokośd otwarcia żłobka (width of slot opening)

BS2 =3,6 3,6 mm szerokośd klina (width of stator slot wedge)

BS3 =5,9 5,9 mm szerokośd żłobka (width of stator slot)

HS1 =0.7 0.7 mm wysokośd otwarcia żłobka (high of slot opening)

HS2 =0.2 0.2 mm wysokośd klina (hight of stator slot wedge)

HS3 =13,1 13,1 mm wysokośd żłobka (high of stator slot)

DM =DS-2*DELTA 92 mm średnica zewnętrzna magnesu (diameter of magnet)

DR =DM-2*HM 86 mm średnica zewnętrzna wirnika (outer diameter of rotor)

TAUM =ALFAM*TAUP 7.5 deg Rozpiętośd magnesu (magnet span)

3.3.1 Definicja parametru

Dodanie nowego parametru rozpoczyna się od wybrania odpowiedniej funkcji z menu górnego (rys.

3.7), drzewa projektu (rys. 3.8) lub wybrania ikony na pasku narzędzi (rys. 3.9).

Rys. 3.7 Wprowadzenie nowego parametru z menu górnego

Rys. 3.8 Wprowadzenie nowego parametru - drzewo projektu

Rys. 3.9. Wprowadzenie nowego parametru - pasek narzędzi

W oknie właściwości parametru należy podać unikalną nazwę parametru, komentarz i wartość

liczbową lub wyrażenie matematyczne wyznaczające wartość parametru (rys. 3.10), zachowując

zasady:

nazwa – 12 znaków, rozpoczyna się od litery

komentarz – 80 znaków

wyrażenie matematyczne – nie może zawierać spacji


15

Rys. 3.10 Definicja parametrów modelu geometrycznego – dri, dr, hqr

Wprowadzone parametry widoczne są w drzewie projektu(rys. 3.11). Wskazując parametr na liście

można z menu kontekstowego wybrać opcje edycji właściwości parametru lub usunąć dany parametr

z bazy rysunku (drzewa projektu).

Rys. 3.11 Sprawdzenie i edycja wartości parametrów

Kod w języku PYTHON definiujący parametry silnika

ParameterGeom(name='NPH : number of phase', expression=str(Nph)); ParameterGeom(name='P : number of pole pairs', expression=str(p)); ParameterGeom(name='Q : number of slots for one phase and one pole',expression=str(q)); ParameterGeom(name='NS : number of slots',expression='2*Nph*p*q'); ParameterGeom(name='TAUS : slot pitch',expression='360/NS'); ParameterGeom(name='TAUP : pole pitch',expression='360/2/P'); ParameterGeom(name='DRI : inner diameter of rotor = diameter of shaft', expression=str(dri)); ParameterGeom(name='DELTA : width of airgap',expression=str(delta)); ParameterGeom(name='HM : high of magnet',expression=str(hm)); ParameterGeom(name='ALFAM : magnet span',expression=str(alfam)); ParameterGeom(name='LES : stator length',expression=str(les)); ParameterGeom(name='DS : inner diameter of stator',expression=str(ds)); ParameterGeom(name='DSE : outer diameter of stator',expression=str(dse)); ParameterGeom(name='BS1 : width of slot opening',expression=str(bs1)); ParameterGeom(name='BS2 : width of stator slot wedge',expression=str(bs2)); ParameterGeom(name='BS3 : width of slot opening',expression=str(bs3)); ParameterGeom(name='HS1 : hight of slot opening',expression=str(hs1)); ParameterGeom(name='HS2 : hight of slot wedge',expression=str(hs2)); ParameterGeom(name='HS3 : hight of stator slot',expression=str(hs3)); ParameterGeom(name='DM : diameter of magnet',expression='DS-2*DELTA'); ParameterGeom(name='DR : outer diameter of rotor',expression='DM-2*HM'); ParameterGeom(name='TAUM : MAGNET SPAN',expression='ALFAM*TAUP'); ParameterGeom(name='MESH : MESH DENSIT COEFICIENT',expression=str(mesh));

3.4 Układy współrzędnych

Odpowiednio zdefiniowane układy współrzędnych upraszczają proces modelowania (wprowadzania

współrzędnych, transformacji). Przy modelowaniu silników elektrycznych bardzo często wykorzystuje

się układy współrzędnych biegunowych, oraz lokalne układy współrzędnych np.: związane ze

żłobkami/magnesami.


16

Układ współrzędnych prostokątnych o nazwie XY1 jest układem domyślnym w programie Flux.

Układy współrzędne definiowane przez użytkownika mogą być układami globalnymi (niezależnymi)

lub układami lokalnymi (określonymi względem innych układów współrzędnych).

W procesie opracowywania modelu geometrycznego silnika zostaną zdefiniowane następujące układy

współrzędnych:

globalny układ współrzędnych cylindrycznych (MAIN),

lokalny układ współrzędnych do definicji geometrii wirnika (ROTOR),

lokalny układ współrzędnych do definicji geometrii szczeliny roboczej maszyny (AIRGAP),

lokalny układ współrzędnych do definicji geometrii stojana (STATOR),

lokalny układ współrzędnych do definicji geometrii żłobka stojana (STATORSLOT).

W projekcie silnika zostanie zdefiniowany jeden globalny układ współrzędnych o nazwie MAIN (rys.

3.12). Pozostałe układy (lokalne) zostaną określone w odniesieniu do układu MAIN. Układ ten będzie

definiował położenie całego silnika.

Rys. 3.12 Układy współrzędnych

Kod w języku Python definiujący główny układ współrzędnych (MAIN).

CoordSysCylindrical(name='MAIN : MAIN COORDINATE SYSTEM', parentCoordSys=GlobalUnits( lengthUnit=LengthUnit['MILLIMETER'], angleUnit=AngleUnit['DEGREE']), origin=['0','0','0'], rotationAngles=RotationAngles(angleX='0',angleY='0',angleZ='0'));

3.5 Wirnik

Współrzędne punktów silnika o budowie cylindrycznej dogodnie jest wprowadzać używając

biegunowego układu współrzędnych. Współrzędne zostaną określone przy pomocy parametrów i

odpowiednich wyrażeń algebraicznych. Pozwoli to w łatwy sposób wprowadzać modyfikację

geometrii, bez konieczności definiowania na nowo wszystkich punktów.

3.5.1 Układy współrzędnych

Nowy lokalny układ współrzędnych definiuje się przez podanie nazwy oraz ustalenia jego typu

(prostokątny, biegunowy) (rys. 3.13).


17

Rys. 3.13 Dodanie lokalnego układu współrzędnych ROTOR

Układ współrzędnych wirnika o nazwie ROTOR zdefiniowano jako układ biegunowy o środku w

punkcie [0,0], którego kąt początkowy jest przesunięty o połowę podziałki biegunowej względem

układu globalnego MAIN.

Kod w języku PYTHON definiujący lokalny układ współrzędnych ROTOR

CoordSysCylindrical(name='ROTOR : Rotor coordinate system', parentCoordSys=Local(coordSys=CoordSys['MAIN']), origin=['0','0'], rotationAngles=RotationAngles(angleZ='TAUP/2'));

3.5.2 Punkty wirnika

Współrzędne punktów charakterystycznych wirnika (rys. 3.14) wprowadzone zostaną z

wykorzystaniem parametrów; ich wartości zestawiono w tabela 3.2. Należy zdefiniować taką liczbę

punktów geometrii by utworzone za ich pomocą linie/łuki nie przecinały się. Punkty

charakterystyczne jednego bieguna wirnika silnika bezszczotkowego z magnesami trwałymi

przedstawiono na (rys. 3.14).

P2

P3

P4

P5

P6

P7

P8

P9

P11

P1

P10

Rys. 3.14 Oznaczenie punktów charakterystycznych wirnika

Proces definicji współrzędnych punktów wymaga określenia odpowiedniego układu współrzędnych

oraz wartości współrzędnych (można używać formuł matematycznych i parametrów).


18

Rys. 3.15 Współrzędne punktu P1

Współrzędne punktów wirnika określone są przez podanie promienia i kąta położenia (w

stopniach)(tabela 3.2).

Tabela 3.2 Współrzędne punktów charakterystycznych geometrii wirnika oznaczonych na Rys. 3.14

r [mm] [] r [mm] []

P1 0 0 P7 DR/2 TAUP/2

P2 DRI/2 - TAUP/2 P8 DM/2 - TAUP/2

P3 DRI/2 TAUP/2 P9 DM/2 - TAUM/2

P4 DR/2 - TAUP/2 P10 DM/2 TAUM/2

P5 DR/2 - TAUM/2 P11 DM/2 TAUP/2

P6 DR/2 TAUM/2

Formuły matematyczne wyznaczające wartości współrzędnych można wprowadzać przy użyciu

kalkulatora (rys. 3.16).

Rys. 3.16 Wprowadzanie formuły matematycznej oraz współrzędne punktu P6

Kod w języku PYTHON definiujący współrzędne punktów wirnika

PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['MAIN'], uvw=['0','0','0'], nature=Nature['STANDARD']); #P1 PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DRI/2','-TAUP/2','0'], nature=Nature['STANDARD']); #P2 PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DRI/2','TAUP/2','0'], nature=Nature['STANDARD']); #P3


19

PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DR/2','-TAUP/2','0'], nature=Nature['STANDARD']); #P4 PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DR/2','-TAUM/2','0'], nature=Nature['STANDARD']) ; #P5 PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DR/2','TAUM/2','0'], nature=Nature['STANDARD']); #P6 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DR/2','TAUP/2','0'], nature=Nature['STANDARD']); #P7 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DM/2','-TAUP/2','0'], nature=Nature['STANDARD']); #P8 PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DM/2','-TAUM/2','0'], nature=Nature['STANDARD']) ; #P9 PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DM/2','TAUM/2','0'], nature=Nature['STANDARD']); #P10 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], uvw=['DM/2','TAUP/2','0'], nature=Nature['STANDARD']); #P11

Po wprowadzeniu wszystkich punktów można ustawić widok prezentujący wszystkie wprowadzone

punkty – wybierając funkcję „zoom all” (rys. 3.17).

Rys. 3.17 Powiększenie rysunku

3.5.3 Zarys wirnika

Zarys wirnika powstanie poprzez odpowiednie połączenie punktów odcinkami prostymi i łukami (w

programie Flux2D nie ma możliwości definiowania okręgu). Linie definiuje się przez podanie punktu

początkowego i końcowego odcinka. Łuk można zdefiniować na kilka różnych sposobów –

wykorzystano definicję łuku przez określenie punktu początkowego, końcowego i środkowego (rys.

3.18). Przy definiowaniu łuku istotny jest również wybór odpowiedniego układu współrzędnych.


20

Rys. 3.18 Definicja Łuku określonego przez Trzy punkty (początkowy, końcowy i środek )

Kod w języku PYTHON definiujący linie zarysu wirnika

LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[1],Point[2]], nature=Nature['STANDARD']); #L1 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[2],Point[4]], nature=Nature['STANDARD']); #L2 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[4],Point[8]], nature=Nature['STANDARD']); #L3 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[5],Point[9]], nature=Nature['STANDARD']); #L4 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[6],Point[10]], nature=Nature['STANDARD']) ; #L5 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[1],Point[3]], nature=Nature['STANDARD']) ; #L6 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[3],Point[7]], nature=Nature['STANDARD']); #L7 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[7],Point[11]], nature=Nature['STANDARD']); #L8 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], defPoint=[Point[2],Point[3],Point[1]], nature=Nature['STANDARD']); #L9 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], defPoint=[Point[4],Point[5],Point[1]], nature=Nature['STANDARD']); #L10 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], defPoint=[Point[5],Point[6],Point[1]], nature=Nature['STANDARD']); #L11 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], defPoint=[Point[6],Point[7],Point[1]], nature=Nature['STANDARD']); #L12 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], defPoint=[Point[8],Point[9],Point[1]], nature=Nature['STANDARD']); #L13 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], defPoint=[Point[9],Point[10],Point[1]],


21

nature=Nature['STANDARD']); #L14 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['ROTOR'], defPoint=[Point[10],Point[11],Point[1]], nature=Nature['STANDARD']); #L15

3.5.4 Powierzchnie wirnika

Pola ograniczone przez linie (zamknięte) wyznaczają powierzchnie (faces). Powierzchnie w programie

Flux2D tworzone są automatycznie po wybraniu funkcji z menu Geometry, Face, Build Faces lub po

wybraniu odpowiednich ikon z menu narzędziowego lub drzewa projektu (zakładka geometry) (Rys.

3.19).

Rys. 3.19. Utworzenie powierzchni

Kod w języku PYTHON uruchamiający funkcję BuildFaces

buildFaces(); # 1 - shaft, 2 - rotor yoke, 3 - rotor air, 4 - magnet, 5 - rotor air

3.5.5 Regiony

Regiony stanowią część opisu modelu fizycznego silnika i mogą reprezentować różne jego części –

takie jak stojan, żłobek, szczelina powietrzna itd. W późniejszej części projektu do regionów zostaną

przyporządkowane odpowiednie właściwości fizyczne lub źródła pola magnetycznego. Nazwy

regionów powinny być unikalne oraz powinny ułatwiać identyfikację części silnika. W projekcie

przyjęto nazwy regionów pochodzące od angielskich nazw części silnika (rys. 3.20).

Należy rozróżnić pojęcia powierzchnia i region. Powierzchnia jest elementem modelu

geometrycznego – definiuje zamknięty obszar ograniczony przez linie lub łuki. Region jest elementem

modelu fizycznego – może składać się z jednej lub kilu powierzchni (nawet nie przylegających do

siebie). Elementem wspólnym powierzchni przyporządkowanych do regionów są takie same

własności fizyczne.


22

Rys. 3.20 Przyjęte nazwy regionów silnika

Nowy region tworzymy wybierając funkcję: Physic, Face Region, New (Rys. 3.21).

Rys. 3.21 Utworzenie nowych regionów

W oknie definicji nowego regionu należy wprowadzić nazwę, komentarz, kolor oraz określić

widoczność regionu (Rys. 3.22).

Rys. 3.22. Definicja nowego regionu

Do zdefiniowania modelu fizycznego wirnika potrzebne jest utworzenie następujących regionów

fizycznych:

- SHAFT – wałek,

- ROTOR – wirnik,

- MAGNET – magnes.

Powiązanie regionów fizycznych z odpowiadającymi im powierzchniami modelu geometrycznego

uzyskuje się przez wybranie funkcji Assign regions to faces. W oknie dialogowym wskazujemy jedną

SHAFT

ROTOR

MAGNET

ROTOR_AIR

AIRGAP STATOR_AIR

STATOR

SLOT_1

SLOT_2

SLOT_3

SLOT_4

SLOT_5

SLOT_6

SLOT_7

SLOT_8SLOT_9

MAGNET

ROTOR_AIR

AIRGAP

STATOR_AIR

SLOT_OPENING

SLOT_WEDGE

STATOR

SLOT_1


23

lub więcej powierzchni oraz nazwę regionu, do którego przyporządkowujmy owe powierzchnie (Rys.

3.23).

Rys. 3.23 Powiązanie regionu z powierzchnią

assignRegionToFaces(face=[Face[1]], region=RegionFace['SHAFT']); assignRegionToFaces(face=[Face[2], Face[3],Face[5]], region=RegionFace['ROTOR']); assignRegionToFaces(face=[Face[4]], region=RegionFace['MAGNET']);

3.6 Stojan i żłobek

W pierwszym kroku zostanie narysowana połowa podziałki żłobkowej stojana (połowa żłobka i

fragment blachy stojana) - zdefiniowane układy współrzędnych, punkty, linie, powierzchnie i regiony.

Następnie regiony zostaną powielone za pomocą transformacji, tak by w rezultacie otrzymać jeden

biegun silnika.

3.6.1 Układy współrzędnych

Do zdefiniowania punktów charakterystycznych geometrii stojana wykorzystane zostaną dwa lokalne

układy współrzędnych:

- cylindryczny (biegunowy) – do zarysu zewnętrznego,

- kartezjański (prostokątny) – do żłobka stojana.

CoordSysCylindrical(name='STATOR : STATOR COORDINATE SYSTEM', parentCoordSys=Local(coordSys=CoordSys['MAIN']), origin=['0','TAUS/2','0'], rotationAngles=RotationAngles(angleZ='TAUS/2')) ; CoordSysCartesian(name='STATORSLOT : STATOR COORDINATE SYSTEM', parentCoordSys=Local(coordSys=CoordSys['STATOR']), origin=['DS/2','0','0'], rotationAngles=RotationAngles(angleZ='0'));

3.6.2 Punkty stojana i żłobka

Oznaczenia punktów charakterystycznych fragmentu stojana przedstawiono na rys. 3.24.

P12

P13

P14

P15

P16

P18

P17 P19

P20

P21

P22 P23

Rys. 3.24. Oznaczenie punktów charakterystycznych stojana i żłobka


24

Punkty P12-P16, ulokowane na łukach wewnętrznym i zewnętrznym stojana, określone są w układzie

biegunowym współrzędnych STATOR przez podanie promienia i kąta (tabela 3.3).

Tabela 3.3 Współrzędne stojana zdefiniowane względem układu STATOR

r [mm] [] r [mm] []

P12 DS/2 -TAUS/2

P13 DS/2 -

ATAN2D(BS1/2,DS/2)

P14 DS/2 0 P15 DSE/2 -TAUS/2

P16 DSE/2 0

Punkty P17-P23 dogodniej jest zdefiniowad w prostokątnym układzie współrzędnych (STATORSLOT)

podając wartości (formuły) współrzędnych X i Y (tabela 3.4)

Tabela 3.4 Współrzędne żłobka stojana zdefiniowane względem układu STATORSLOT

x [mm] y [mm] x [mm] y [mm]

P17 HS1 -BS1/2 P18 HS1 0

P19 HS1+HS2 -BS2/2 P20 HS1+HS2 0

P21 HS1+HS2+HS3 -BS2/2 P22 HS1+HS2+HS3 0

P23 HS1+HS2+HS3+BS3/2 0

Kod w języku PYTHON definiujący punkty na łukach wewnętrznym i zewnętrznym stojana.

PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATOR'], uvw=['DS/2','-TAUS/2','0'], nature=Nature['STANDARD']); #P12 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATOR'], uvw=['DS/2','-Atan2d(BS1/2,DS/2)','0'], nature=Nature['STANDARD']); #P13 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATOR'], uvw=['DS/2','0','0'],

nature=Nature['STANDARD']); #P14 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATOR'], uvw=['DSE/2','-TAUS/2','0'], nature=Nature['STANDARD']); #P15 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATOR'], uvw=['DSE/2','0','0'], nature=Nature['STANDARD']) ; #P16

Kod w języku PYTHON definiujący punkty żłobka stojana

PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATORSLOT'], uvw=['HS1','-BS1/2','0'], nature=Nature['STANDARD']); #P17 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATORSLOT'], .uvw=['HS1','0','0'], nature=Nature['STANDARD']) ; #P18 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'],


25

coordSys=CoordSys['STATORSLOT'], uvw=['HS1+HS2','-BS2/2','0'], nature=Nature['STANDARD']) ; #P19 PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATORSLOT'], uvw=['HS1+HS2','0','0'], nature=Nature['STANDARD']); #P20 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATORSLOT'], uvw=['HS1+HS2+HS3','-BS3/2','0'], nature=Nature['STANDARD']) ; #P21 PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATORSLOT'], uvw=['HS1+HS2+HS3','0','0'], nature=Nature['STANDARD']); #P22 PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATORSLOT'], uvw=['HS1+HS2+HS3+BS3/2','0','0'], nature=Nature['STANDARD']); #P23

3.6.3 Zarys stojana

Odpowiednio łącząc punkty liniami prostymi i łukami otrzymamy zarys połowy podziałki żłobkowej

stojana.

LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATOR'], defPoint=[Point[12],Point[13],Point[1]], nature=Nature['STANDARD']); #L16 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATOR'], defPoint=[Point[13],Point[14],Point[1]], nature=Nature['STANDARD']); #L17 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATOR'], defPoint=[Point[15],Point[16],Point[1]], nature=Nature['STANDARD']); #L18

Linie tworzące zarys żłobka stojana.

LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[13],Point[17]], nature=Nature['STANDARD']); #L19 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[17],Point[19]], nature=Nature['STANDARD']); #L20 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[19],Point[21]], nature=Nature['STANDARD']); #L21 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[17],Point[18]], nature=Nature['STANDARD']); #L22 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[19],Point[20]], nature=Nature['STANDARD']); #L23 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[14],Point[18]], nature=Nature['STANDARD']) ; #L24 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[18],Point[20]], nature=Nature['STANDARD']); #L25 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'],


26

defPoint=[Point[20],Point[22]], nature=Nature['STANDARD']); #L26 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[22],Point[23]], nature=Nature['STANDARD']); #L27 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[21],Point[22]], nature=Nature['STANDARD']); #L28 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['STATORSLOT'], defPoint=[Point[21],Point[23],Point[22]], nature=Nature['STANDARD']); #L29 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[12],Point[15]], nature=Nature['STANDARD']); #L30 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[23],Point[16]], nature=Nature['STANDARD']); #L31

3.6.4 Powierzchnie stojana

W kolejnym kroku wygenerowano powierzchnie wyznaczone przez zarys podziałki żłobkowej stojana

(wybieramy z menu górnego Geometry, Face, Build Faces).

buildFaces(); # 6-stator yoke, 7-slot opennig, 8-slot wedge, 9,10-slot

3.6.5 Regiony

W celu określenia właściwości fizycznych stojana zostały utworzone następujące regiony:

- 'SLOT_OPENING' – powierzchnia otwarcia żłobka – powietrze;

- 'SLOT_WEDGE' – klin żłobkowy, przytrzymujący uzwojenie w żłobku;

- 'STATOR' – stojan, blacha prądnicowa;

- 'SLOT_1' – żłobek, miejsce na uzwojenie.

RegionFace(name='SLOT_OPENING', color=Color['Turquoise'], visibility=Visibility['VISIBLE']); RegionFace(name='SLOT_WEDGE', color=Color['Turquoise'], visibility=Visibility['VISIBLE']); RegionFace(name='STATOR', color=Color['Cyan'], visibility=Visibility['VISIBLE']); RegionFace(name='SLOT_1', color=Color['Cyan'], visibility=Visibility['VISIBLE']);

assignRegionToFaces(face=[Face[6]], region=RegionFace['STATOR']); assignRegionToFaces(face=[Face[7]], region=RegionFace['SLOT_OPENING']); assignRegionToFaces(face=[Face[8]], region=RegionFace['SLOT_WEDGE']); assignRegionToFaces(face=[Face[9],Face[10]], region=RegionFace['SLOT_1']);

3.6.6 Transformacje

W programie Flux możliwe jest powielenie (skopiowanie) elementów geometrii (punktów, linii ,

powierzchni, regionów) z wykorzystaniem transformacji. Zostaną wykorzystane dwa typy

transformacji: odbicie lustrzane oraz kopiowanie elementów w szyku kołowym.

Transformację definiuje się podając jej nazwę, komentarz oraz sposób kopiowania elementów. W celu

określenia operacji kopiowania elementów w szyku kołowym (kopiowanie przez obrót) wybieramy


27

opcję Rotation defined by Angles and existing Pivot Point , odpowiedni układ współrzędnych

(STATOR), indeks (numer) punktu środkowego oraz wprowadzamy kąt obrotu (TAUS) (rys. 3.25) .

Rys. 3.25 Definicja Transformacja

Transformacja typu odbicie lustrzane (Affine transformation with respect to line defined by 2 points )

wymaga zdefiniowania linii symetrii/odbicia (wskazanej przez dwa punkty) oraz podania

współczynnika transformacjami.

TransfAffineLine2PT(name='SLOTMIRROR : mirror of stator slot', point=[Point[1],Point[16]], factor='-1') TransfRotation3AnglesPivotPoint(name='SLOTROTATION : rotation of the stator slots', coordSys=CoordSys['STATOR'], pivotPoint=Point[1], rotationAngles=RotationAngles(angleZ='taus'))

Najpierw zostanie utworzona pełna podziałka żłobkowa stojana przy wykorzystaniu transformacji

SLOTMIRROR. Należy wybrać powierzchnie tworzące podziałkę żłobkową stojana, a następnie z

menu kontekstowego opcję Propagate faces. W oknie należy podać rodzaj transformacji

('SLOTMIRROR') oraz liczbę powtórzeń (1). Wybranie opcji 'ADD FACES AND ASSOCIATED LINKED MESH

GENERATOR' umożliwia kopiowanie ustawieo dyskretyzacji powierzchni. W przypadku opcji 'WITH THE

SAME REGION' powierzchnie, powstałe w wyniku transformacji, zostaną przyporządkowane do tych

samych regionów fizycznych.

FaceAutomatic[6,7,8,9,10].propagate(transformation=Transf['SLOTMIRROR'], repetitionNumber=1, buildingOption='ADD FACES AND ASSOCIATED LINKED MESH GENERATOR', regionPropagation='WITH THE SAME REGION')

W kolejnych dwóch krokach zostanie wykorzystana transformacja 'SLOTROTATION'.

Najpierw zostaną skopiowane elementy blachy (jarzma) stojana i połączone w jeden region fizyczny.

FaceAutomatic[6,7,8,11,12,13].propagate(transformation=Transf['SLOTROTATION'], repetitionNumber=str(Nph*q-1), buildingOption='ADD FACES AND ASSOCIATED LINKED MESH GENERATOR', regionPropagation='WITH THE SAME REGION')


28

Następnie zostaną skopiowane powierzchnie tworzącą żłobki stojana, przy czym będą one

przyporządkowane do kolejnych regionów fizycznych (tworzonych automatycznie poprzez ustawienie

regionPropagation=’WITH INCREMENT’).

FaceAutomatic[9,10,14,15].propagate(transformation=Transf['SLOTROTATION'], repetitionNumber=str(Nph*q-1), buildingOption=’ADD FACES AND ASSOCIATED LINKED MESH GENERATOR', regionPropagation='WITH INCREMENT')

3.7 Szczelina powietrzna

Z punktu widzenia analizy pola magnetycznego szczelina powietrzna jest najistotniejszym elementem

każdego silnika elektrycznego. Dokładnośd obliczeo jest zależna od gęstości i jakości siatki

dyskretyzującej ten element oraz regionów położonych w bezpośrednim jej sąsiedztwie. Minimalny

rozmiar siatki dyskretyzującej zależy od wymiarów szczeliny. Wykonanie obliczeo z uwzględnieniem

obrotu wirnika (funkcji kąta położenia wirnika) wymaga zdefiniowania tzw. szczeliny/warstwy

obrotowej. Powierzchnia ta powinna byd regularna – ograniczona przez dwa współśrodkowe łuki,

ponadto powinna ona sąsiadowad z regionami o właściwościach fizycznych powietrza.

W celu zdefiniowania warstwy obrotowej szczelina powietrzna silnika zostanie podzielona na trzy

warstwy. Warstwa środkowa stanowić będzie szczelinę obrotową. W celu uzyskania równomiernej

szczeliny dodano do modelu odpowiednie łuki wyznaczające warstwę obrotową szczeliny powietrznej

, dzieląc w ten sposób szczelinę na 3 warstwy. W konsekwencji powinno to ułatwić dyskretyzację

modelu silnika.

3.7.1 Układ współrzędnych

Szczelina powietrzna zostanie zdefiniowana w biegunowym układzie współrzędnych, którego środek

wyznaczony jest przez oś symetrii bieguna silnika.

CoordSysCylindrical(name='AIRGAP : Air-gap coordinate system', parentCoordSys=Local(coordSys=CoordSys['MAIN']), origin=['0','TAUP/2','0'], rotationAngles=RotationAngles(angleZ='TAUP/2'));

3.7.2 Punkty szczeliny powietrznej

Współrzędne punktów początkowych i koocowych łuków ograniczających warstwy szczeliny

obrotowej wprowadzono z wykorzystaniem parametrów. Podstawę obliczeo stanowi wysokośd

szczeliny powietrznej, którą podzielono na trzy równe części. Współrzędne punktów definiujących

początki i kooce łuków zestawiono w tab.3.5.

Tabela 3.5 Współrzędne punktów szczeliny powietrznej

r [mm] [] r [mm] []

P.. DS/2-

2/3*DELTA -TAUP/2

P..

DS/2-

1/3*DELTA -TAUP/2

P.. DS/2-

2/3*DELTA TAUP/2

P..

DS/2-

1/3*DELTA TAUP/2

PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['AIRGAP'], uvw=['DS/2-2/3*DELTA','-TAUP/2','0'], nature=Nature['STANDARD']); #P85 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['AIRGAP'],


29

uvw=['DS/2-2/3*DELTA','TAUP/2','0'], nature=Nature['STANDARD']); #P86 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['AIRGAP'], uvw=['DS/2-1/3*DELTA','-TAUP/2','0'], nature=Nature['STANDARD']) ; #P87 PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'], coordSys=CoordSys['AIRGAP'], uvw=['DS/2-1/3*DELTA','TAUP/2','0'], nature=Nature['STANDARD']); #P88

3.7.3 Zarys szczeliny powietrznej

Odpowiednio łącząc punkty liniami prostymi i łukami otrzymamy zarys szczeliny powietrznej.

LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['AIRGAP'], defPoint=[Point[index+1],Point[index+2],Point[1]], nature=Nature['STANDARD']); #L155 LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'], coordSys=CoordSys['AIRGAP'], defPoint=[Point[index+3],Point[index+4],Point[1]], nature=Nature['STANDARD']); #L156 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[8],Point[index+1]], nature=Nature['STANDARD']) ; #L157 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[index+1],Point[index+3]], nature=Nature['STANDARD']) ; #L158 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[index+3],Point[12]], nature=Nature['STANDARD']) ; #L159 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[11],Point[index+2]], nature=Nature['STANDARD']) ; #L160 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[index+2],Point[index+4]], nature=Nature['STANDARD']) ; #L161 LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'], defPoint=[Point[index+4],Point[145]], nature=Nature['STANDARD']) ; #L161

3.7.4 Powierzchnie szczeliny powietrznej

W kolejnym kroku wygenerowano powierzchnie wyznaczone przez zarys szczeliny powietrznej

(wybieramy z menu górnego Geometry, Face, Build Faces).

buildFaces(); #

3.7.5 Regiony

Szczelina powietrzna została podzielona na trzy warstwy przyporządkowane do trzech regionów:

- ROTOR_AIR – warstwa szczeliny powietrznej pomiędzy wirnikiem a szczeliną obrotową,

- AIRGAP –szczelina obrotowa,

- 'STATOR_AIR' – warstwa szczeliny powietrznej pomiędzy stojanem a szczeliną obrotową.

RegionFace(name='ROTOR_AIR', color=Color['Turquoise'], visibility=Visibility['VISIBLE']); RegionFace(name='AIRGAP', color=Color['Yellow'], visibility=Visibility['VISIBLE']); RegionFace(name='STATOR_AIR', color=Color['Turquoise'], visibility=Visibility['VISIBLE']);


30

assignRegionToFaces(face=[Face[98]], region=RegionFace['AIRGAP']); assignRegionToFaces(face=[Face[97]], region=RegionFace['STATOR_AIR']); assignRegionToFaces(face=[Face[96]], region=RegionFace['ROTOR_AIR']);

3.8 Sprawdzenie poprawności modelu geometrycznego

Poprawnie zdefiniowany model geometryczny składa się z nieprzecinających się odcinków, które

wyznaczają powierzchnie. Powierzchnie mogą być interpretowane jako fizyczne części

maszyny/urządzenia lub stanowić obszary upraszczające geometrię (szczelina powietrzna).

Poprawność modelu sprawdzamy funkcją Check geometry z menu górnego Geometry (rys. 3.26).

Rys. 3.26. Sprawdzenie poprawności modelu geometrycznego


31

4 Dyskretyzacja modelu Jednym z najbardziej istotnych zagadnień opracowywania modelu numerycznego maszyn wirujących

jest utworzenie odpowiedniego podziału na elementy skończone (dyskretyzacja modelu). Poprawnie

wygenerowana siatka dyskretyzująca model silnika powinna spełniać następujące cechy:

równomierny i dokładny podział szczeliny powietrznej,

podział w szczelinie powietrznej powinien być związany z krokiem analizy lub kątem obrotu,

zwiększony podział w częściach maszyny w których spodziewamy się zagęszczenia linii pola

(nasycenia)

4.1 Ogólny algorytm dyskretyzacji automatycznej

Program Flux2D wyposażony jest w automatyczne generatory siatki dyskretyzacyjnej. Jedną z metod

używanych do podziału modelu na elementy skończone jest metoda bąbelkowego (bubble packing

method). Algorytm tej metody przedstawiony jest w sposób graficzny na rys. 4.1.

Rys. 4.1. Algorytm generacji siatki metodą bąbelkową

Rezultat działania automatycznego generatora siatki może byd niesatysfakcjonujący. Możliwa jest

wówczas ingerencja w dokładnośd generacji siatki poprzez zdefiniowanie oczekiwanej gęstości siatki

w punktach (mesh points) lub liczby węzłów siatki wzdłuż linii (mesh lines). Ogólny algorytm

postępowania w przypadku modyfikacji siatki przez użytkownika przedstawiono na rys. 4.2.

Parametry siatki przyporządkowane funkcjami mesh points i mesh lines mogą byd kopiowane w

trakcie kopiowanie powierzchni.


32

Rys. 4.2 Algorytm dyskretyzacji modelu

4.2 Automatyczna dyskretyzacja modelu

Należy przełączyć interfejs użytkownika w opcję „mesh”. Wygenerowanie automatycznej siatki

uzyskujemy wybierając najpierw funkcję mesh lines, a następnie mesh faces (rys. 4.3).

Rys. 4.3. Dyskretyzacja modelu

Wygenerowany w ten sposób podział na elementy skończone jest nieodpowiedni, siatka jest zbyt

rzadka i posiada wiele nieprawidłowych elementów (abnormal elements). Ocenę jakości dyskretyzacji

można przeprowadzić w oparciu o raport wyświetlany automatycznie przez program Flux w linii

poleceń (rys. 4.4).


33

Rys. 4.4 Automatyczna generacja siatki

Najprostszym sposobem poprawy jakości siatki jest zmiana domyślnych wartości parametrów

mesh_point generowanych automatycznie przez program (LARGE, MEDIUM, SMALL). W

przypadku maszyn elektrycznych ze szczeliną obrotową skuteczną kontrolę nad jakością siatki można

uzyskać wprowadzając gęstości podziału linii mesh line.

4.3 Przydział pamięci dla programu flux2D Często okazuje się że proces generowania siatki wymaga zwiększenia pamięci zarezerwowanej dla

programu. W tym celu z poziomu FluxSupervisor wybieramy opcję Tools->Options… Można

powiększyd dwukrotnie domyślne wartości pamięci przydzielonej do programu preflu2D 32 bits.

Rys. 4.5 Przydział pamięci dla programu Flux2D


34

W pamięci systemu uruchomione są trzy procesy związane z programem Flux2D

moduł obliczeniowy – napisany w Fortranie,

moduł interfejsu użytkownika – napisany w Javie,

moduł pośredniczący. Numerical memory – pamięd zarezerwowana dla procesów modelowania, dyskretyzacji i obliczeo.

Wielkośd tego rodzaju pamięci jest ściśle związana z gęstością siatki dyskretyzującej (20 000 węzłów

to około 200MB).

Character memory – pamięd wykorzystywana do przechowywania entity names (parametrów,

transformacji, regionów) oraz nazw projektów

GUI memory – pamięd wykorzystywana w procesach związanych z obsługą interfejsu użytkownika.

W systemach 32bitowych maksymalny zakres pamięci jest ograniczony do 3GB.

4.4 Dyskretyzacja szczeliny obrotowej Program Flux2D pozwala na przeprowadzenie obliczeo maszyn wirujących z uwzględnieniem ruchu

wirnika. Model maszyny podzielony jest na dwie części: nieruchomą (np. stojan) i ruchomą (np.

wirnik). Rozdzielone są one warstwą wirującej szczeliny obrotowej (warstwa poślizgowa). Podczas

rozwiązywania problemu, przy obrocie wirnika o zadany kąt – siatka warstwy poślizgowej musi zostad

przebudowana. W przypadku programu Flux2D zalecane jest by szczelina powietrzna zbudowana była

z pojedynczej warstwy elementów trójkątowych, które powinny byd możliwie zbliżone do

równobocznych. W przypadku maszyn elektrycznych szczelina powietrzna może nie byd symetryczna

(maszyny wydatnobiegunowe), należy wówczas rozważyd możliwośd podzielenia szczeliny na kilka

obszarów wprowadzając jedną lub trzy warstwy cylindryczne.

Poniżej przedstawiono dwa sposoby podziału obszaru szczeliny powietrznej. W pierwszym przypadku

szczelina powietrzna składa się z jednej warstwy, w której gęstośd siatki jest kontrolowana za pomocą

podziału punktów („mesh point”). Taki podział można zastosowad do analizy rozkładu pola w

problemach analizy statycznej. W przypadku uwzględnienia ruchu wirnika szczelinę powietrzną

należy podzielid na trzy warstwy. Gęstośd siatki w warstwie środkowej jest kontrolowana za pomocą

podziału linii („mesh line”). Można wówczas powiązad gęstośd siatki z krokiem obrotu wirnika.

Rys. 4.6 Podział siatki w obszarze szczeliny powietrznej


35

4.5 Parametry kontroli gęstości siatki W celu poprawy jakości podziału na elementy skończone należy utworzyć odpowiednie parametry

kontroli gęstości siatki mesh point lub mesh line, a następnie przyporządkować je do elementów

modelu geometrycznego.

W przypadku dodawania parametru gęstości siatki wokół punktu („mesh point”) definiuje się

odległość pomiędzy węzłami siatki (długość elementów) wokół punktu (rys. 4.7 a). Dodanie

parametru gęstości podziału linii („mesh line”) umożliwia podział odcinka na określoną liczbę

elementów (opcja Arithmetic) lub podanie maksymalnych długości odcinków na początku i końcu

linii. (rys. 4.7 b).

Rys. 4.7. Okna dodania nowych gęstości siatki

4.5.1 Gęstość podział Linii – Mesh Line

Zostaną dodane parametry gęstości podziału linii, które ułatwią kontrolę dokładności siatki w

szczelinie powietrznej (ML_AIRGAP) oraz na łukach tworzących wał wirnika, jarzmo wirnika, magnes

trwały oraz stojan.

Założono, że obliczenia uwzględniające ruch wirnika, będą wykonywane z obrotem wirnika o 1

stopieo w każdym kroku obliczeniowym. W związku z tym łuki wyznaczające obrotową szczelinę

powietrzną zostaną podzielone na odcinki wyznaczone przez łuk o rozpiętości 1 stopieo (360/p/2) .

Kontrolę gęstości siatki w pozostałych elementach modelu zapewnia parametr MESH, którego

wartośd definiuje się w ogólnych parametrach modelu.

Dodanie nowego parametru gęstości podziału linii wywołujemy wybierając opcję Mesh -> Mesh Line -

> New (rys. 4.8).

Rys. 4.8. Dodanie parametru kontroli gęstości siatki – mesh line

Do modelu geometrycznego silnika należy dodad (rys. 4.9) parametry kontroli gęstości podziału linii

zestawione w Tabela 4.1.


36

Rys. 4.9 Edycja parametrów kontroli gęstości podziału linii

Tabela 4.1 Parametry kontroli gęstości podziału linii

nazwa typ wartośd 1 wartośd 2 ML_AIRGAP Arithmetic 360/2/p ML_SHAFT Lengths [mm] MESH*PI()*DRI/2/P/15' MESH*PI()*DRI/2/P/15' ML_ROTOR_YOKE Lengths [mm] MESH*PI()*DRI/2/P/15' MESH*PI()*DR/2/P/45' ML_ROTOR Lengths [mm] MESH*Pi()*DR/2/P/45' MESH*Pi()*DR/2/P/45' ML_MAGNET Lengths [mm] Pi()*DM/2/P/90' Pi()*DM/2/P/90' ML_STATOR Lengths [mm] Pi()*DS/2/P/90' Pi()*DS/2/P/90' ML_STATOREX Lengths [mm] MESH*Pi()*DSE/2/P/45' MESH*Pi()*DSE/2/P/45'

Kod w języku Python dodający odpowiednie parametry kontroli gęstości linii.

airgap = int(360/(2*p)) MeshLineArithmetic(name='ML_AIRGAP : air gap line density', color=Color['White'], number=str(airgap)); MeshLineLengths(name='ML_SHAFT : GESTOSC SIATKI NA KRAWEDZIACH WALKA', color=Color['White'], lengthUnit=LengthUnit['MILLIMETER'], lengths=['MESH*PI()*DRI/2/P/15','MESH*PI()*DRI/2/P/15']) MeshLineLengths(name='ML_ROTOR_YOKE : GESTOSC SIATKI NA KRAWEDZIACH JARZMA WIRNIKA', color=Color['White'], lengthUnit=LengthUnit['MILLIMETER'], lengths=['MESH*PI()*DRI/2/P/15','MESH*PI()*DR/2/P/45']) MeshLineLengths(name='ML_ROTOR : GESTOSC SIATKI NA KRAWEDZIACH WIRNIKA', color=Color['White'], lengthUnit=LengthUnit['MILLIMETER'], lengths=['MESH*Pi()*DR/2/P/45','MESH*Pi()*DR/2/P/45']) MeshLineLengths(name='ML_MAGNET : GESTOSC SIATKI NA KRAWEDZIACH MAGNESU', color=Color['White'], lengthUnit=LengthUnit['MILLIMETER'], lengths=['Pi()*DM/2/P/90','Pi()*DM/2/P/90']) MeshLineLengths(name='ML_STATOR : GESTOSC SIATKI NA KRAWEDZI WEWNETRZNEJ STOJANA', color=Color['White'], lengthUnit=LengthUnit['MILLIMETER'], lengths=['Pi()*DS/2/P/90','Pi()*DS/2/P/90']) MeshLineLengths(name='ML_STATOREX : GESTOSC SIATKI NA KRAWEDZI ZEWNETRZNEJ STOJANA', color=Color['White'], lengthUnit=LengthUnit['MILLIMETER'], lengths=['MESH*Pi()*DSE/2/P/45','MESH*Pi()*DSE/2/P/45'])

4.5.2 Gęstość siatki wokół punktu – Mesh Point

Zostaną dodane parametry kontroli gęstości siatki wokół punktów/wierzchołków opisujących

rozwarcie żłobka oraz klin żłobkowy. Dodanie parametru kontroli gęstości siatki wokół punktu

następuje po wybraniu opcji Mesh -> Mesh point -> New (rys. 4.10).


37

Rys. 4.10. Dodanie parametru kontroli gęstości siatki – mesh point

Należy dodad dwa nowe parametry typu mesh point – MP_SLOT oraz MP_WEDGE (rys. 4.11).

Rys. 4.11 Parametry kontroli gęstości siatki wokół punktów

Kod w języku Python dodający odpowiednie parametry kontroli gęstości siatki wokół punktów.

# mesh points MeshPoint(name='MP_SLOT', lengthUnit=LengthUnit['MILLIMETER'], color=Color['Red'], value='MESH*BS3/5'); MeshPoint(name='MP_WEDGE', lengthUnit=LengthUnit['MILLIMETER'], color=Color['Red'], value='MESH*2*HS2');

4.5.3 Generator siatki

Domyślny generator siatki tworzy elementy trójkątne. W niektórych regularnych powierzchniach

lepiej sprawdzają się generatory siatki prostokątnej. Typ MAPPED siatki zostanie przyporządkowany

do obszaru powierzchni żłobka.

4.6 Przyporządkowanie parametrów gęstości siatki do elementów modelu Przyporządkowanie (powiązanie) zdefiniowanych wcześniej parametrów siatki do elementów modelu

geometrycznego następuje po wybraniu jednej z funkcji assignMeshLine lub assignMeshPoint (rys.

4.132). Parametry gęstości podziału linii zostaną przyporządkowane do linii modelu

geometrycznego silnika (rys. 4.13).


38

Rys. 4.12 Przyporządkowanie parametrów siatki – wywołanie funkcji


39

Rys. 4.13 Numery linii modelu geometrycznego silnika: a) wirnika, b) stojana

Numery linii i odpowiadające im parametry kontroli gęstości siatki zestawiono w tabela 4.2.

Tabela 4.2 Parametry gęstości siatki i odpowiadające im numery linii

Gęstośd siatki Numer linii 'ML_AIRGAP' 251,252 'ML_SHAFT' 1,6,9 'ML_ROTOR_YOKE' 2,7 'ML_ROTOR' 10,11,12 'ML_MAGNET' 13,14,15 'ML_STATOR' 16,17

1 2 3

4

5

6

7

8

9

10

11

12

13

14

15

251 252

13

16

17 18


40

'ML_STATOREX' 18

Procedura przyporządkowania gęstości siatki do linii rozpoczyna się od wskazania linii (jednej lub

wielu). Program Flux2D udostępnia funkcje ułatwiające wskazania linii poprzez wybranie jednego z

kryteriów (np. przez wskazanie powierzchni, przez wskazanie regionów… ) (rys. 4.14). W celu

przyporządkowania odpowiedniej gęstości siatki do szczeliny obrotowej wskazano linie przez

wybranie regionu AIRGAP (rys. 4.14).

Rys. 4.14 Wskazanie linii przez wybranie regionu

W kolejnym kroku do linii ograniczających szczelinę powietrzną przyporządkowano odpowiednią

gęstośd siatki (ML_AIRGAP) (rys. 4.15).

Rys. 4.15 Przyporządkowanie gęstości siatki do łuków ograniczających szczelinę obrotową

Poniżej przedstawiono kod w języku Python przyporządkowujący parametry gęstości siatki do

odpowiednich linii i łuków modelu geometrycznego silnika.

#Assign mesh density LineArcPivotPoint[251,252].assignMeshLine(meshLine=MeshLine['ML_AIRGAP']); LineArcPivotPoint[1,6,9].assignMeshLine(meshLine=MeshLine['ML_SHAFT']); LineArcPivotPoint[2,7].assignMeshLine(meshLine=MeshLine['ML_ROTOR_YOKE']); LineArcPivotPoint[10,11,12].assignMeshLine(meshLine=MeshLine['ML_ROTOR']); LineArcPivotPoint[13,14,15].assignMeshLine(meshLine=MeshLine['ML_MAGNET']); LineArcPivotPoint[16,17].assignMeshLine(meshLine=MeshLine['ML_STATOR']); LineArcPivotPoint[18].assignMeshLine(meshLine=MeshLine['ML_STATOREX']);


41

Parametry gęstości siatki wokół punktu pomogą kontrolować dokładność siatki generowanej na

powierzchni otwarcia żłobka oraz klina żłobkowego. Numery punktów modelu wykorzystywane do

kontroli gęstości siatki zostały przedstawione na rys. 4.16 a odpowiadające im parametry gęstości

siatki zestawione w tabela 4.3.

Rys. 4.16 Numery punktów modelu geometrycznego żłobka stojana

Tabela 4.3 Parametry gęstości siatki i odpowiadające im numery punktów

Gęstośd siatki Numer punktu 'MP_WEDGE' 17,18,19,20 'MP_SLOT' 21,22,23

Procedura wybierania punktów jest podobna jak w przypadku linii – tym razem wybrano opcję

wyboru punktów przez wskazanie powierzchni (Selection by face) (rys. 4.17).

Rys. 4.17 Wybór punktów do kontroli gęstości siatki

Do wybranych punktów rozwarcia żłobka przyporządkowano parametr gęstość siatki MP_WEDGE

(rys. 4.18).

17

18

19

20

22

21

23


42

Rys. 4.18 Przyporządkowanie gęstości siatki do punktów

Poniżej przedstawiono kod w języku Python przyporządkowujący parametry gęstości siatki do

odpowiednich punktów modelu geometrycznego silnika.

Point[17,18,19,20].assignMeshPoint(meshPoint=MeshPoint['MP_WEDGE']); Point[21,22,23].assignMeshPoint(meshPoint=MeshPoint['MP_SLOT']);

Powierzchnia żłobka stojana zostanie podzielona na elementy skończone przy użyciu generatora siatki

prostokątnej. W tym celu należy wybrać opcję Assign mesh generator to face a następnie wskazać

odpowiednią powierzchnię (żłobek) oraz wybrać rodzaj genereatora (MAPPED) (rys. 4.19).

Rys. 4.19 Przyporządkowanie generatora siatki do powierzchni żłobka

Poniżej przedstawiono kod w języku Python przyporządkowujący generator siatki do powierzchni

żłobka


43

assignMeshGeneratorToFace(face=[Face[9]], meshGenerator=MeshGenerator['MAPPED']);

4.7 Ponowna dyskretyzacja modelu Wprowadzone przez użytkownika parametry sterujące dokładnością siatki wymagają ponownego

uruchomienia procesu dyskretyzacji.

meshLines() meshFaces()

4.8 Weryfikacja dyskretyzacji modelu Poprawnośd dyskretyzacji sprawdzamy poleceniem Mesh -> Check mesh (rys. 4.20). Należy tak

dobrad parametry kontroli gęstości siatki by uzyskad siatkę bez elementów typu abnormal.

Rys. 4.20 Weryfikacja poprawności podziału siatki


44

5 Model fizyczny

5.1 Moduł obliczeniowy Program Flux2D posiada wiele modułów obliczeniowych – wybór odpowiedniego zależy od rodzaju

analizowanego problemu. Przed przystąpieniem do definiowania materiałów należy wybrad moduł,

który będzie wykorzystany do obliczeo budowanego modelu. Na rys. 5.1 pokazano sposób wyboru

modułu do obliczeo pola magnetycznego w analizowanym obiekcie.

Rys. 5.1. Definiowanie modułu obliczeniowego

Definiowanie modułu obliczeniowego oraz jego parametrów z zastosowaniem języka PHYTON

przedstawiono na poniższym listingu:

#Applicationdefinition ApplicationMagneticDC2D(domain2D=Domain2DPlane(lengthUnit=LengthUnit['MILLIMETER'], depth=str(les)),solverFE=SolverFEAutomatic(),coilCoefficient=CoilCoefficientAutomatic());

Po zdefiniowaniu modułu obliczeniowego i jego parametrów w drzewie projektu pojawiają się dwie

dodatkowe kategorie: MATERIAL oraz MECHANICAL SET (rys. 5.2).

Rys. 5.2. drzewo projektu po zdefiniowaniu modułu obliczeniowego


45

5.2 Warunki symetrii W przypadku definiowania modeli numerycznych silników elektrycznych wykorzystuje się ich

symetrię magnetyczną i geometryczną w celu ograniczenia powierzchni analizowanego modelu.

Pozwala to na skrócenie czasu obliczeo, a w przypadku licencji edukacyjnych na ominięcie

ograniczenia maksymalnej liczby węzłów modelu.

Silnik elektryczny wykazuje symetrię magnetyczną i geometryczną dla każdego bieguna, przy czym

zwrot wektora indukcji jest przeciwny w biegunach różnoimiennych. Do określenia tych właściwości

silnika zostanie wykorzystany warunek symetrii (powtarzalności modelu – periodicity) wokół osi Z o

nazwie antycyclic. Sposób wprowadzenia warunków symetrii pokazano na rys. 5.3. Do określenia

liczby oraz kąta powtórzeo wykorzystano liczbą par biegunów (p) .

Rys. 5.3. definiowanie warunków symetrii modelu

Definiowanie warunków symetrii oraz jej parametrów z zastosowaniem języka PHYTON

przedstawiono na poniższym listingu:

# PERIODICITY

PeriodicityNumberZaxis(physicalType=PeriodicityAnticyclicType(),

repetitionNumber='2*P', domainOriginAngle='360/2/P');

5.3 Warunki brzegowe Warunki brzegowe określają sposób zachowywania się pola na brzegach modelu. Określenie

warunków symetrii powoduje automatyczne wygenerowanie warunków brzegowych dla

odpowiednich krawędziach modelu. W gestii użytkownika pozostaje określenie warunków

brzegowych na powierzchni zewnętrznej silnika.

Przed określeniem warunków brzegowych dla silnika należy zdefiniowad nowy element modelu

fizycznego - region liniowy (LINE REGION) o nazwie „EXT” (rys. 5.5).


46

Rys. 5.4. Definiowanie regionu liniowego LINE REGION

Następnie region ten należy przyporządkowad do odpowiednich linii modelu geometrycznego (rys.

5.6) to znaczy do linii stanowiących zewnętrzny łuk zarysu stojana maszyny, rys. 5.8.

Rys. 5.5. przyporządkowanie regionu do linii modelu


47

Rys. 5.6. Model maszyny z zaznaczoną linią zewnętrzną zarysu stojana

Na kolejnych listingach przedstawiono odpowiedni kod w języku PYTHON do utworzenia „LINE

REGION” o nazwie „EXT” i jego przyporządkowania do odpowiednich linii modelu.

#Boundary condition

RegionLine(name='EXT : EXTERNAL LINE OF THE STATOR',

magneticDC2D=MagneticDC2DLineImposedFluxConstant(value='0'),

color=Color['Turquoise'], visibility=Visibility['VISIBLE']);

#Assign the boundary condition to stator external line

Line[18,37,49,146,51,152,59,158,67,164,75,170,83,176,91,182,99,188].assignRegion(region=Reg

ionLine['EXT']);

5.4 Materiały

5.4.1 Magnesy trwałe

Do analizy badanej maszyny proponuje się zastosowanie magnesów trwałych neodymowych lub

samarowo-kobaltowych. Parametry wyżej wymienionych magnesów można odnaleźd na stronach

producentów:

Arnold Magnetics

Bakker Magnetics

Ningbo Zhao Bao Magnet Co.,Ltd.

W tabeli 5.1 zestawiono dane trzech rodzajów magnesów trwałych.

Tabela 5.1. dane magnesów

Temp Br Hcj r Hcb BHm Bd Hd Hk

C T kA/m - kA/m kJ/m^3 T kA/m kA/m

NdFeB-N35

20 1,20 996,31 1,06 902,41 271,84 0,60 456,77 965,27

40 1,17 840,34 1,14 817,26 262,92 0,59 448,02 815,67

60 1,15 705,85 1,32 691,53 245,26 0,58 423,35 684,37

80 1,11 572,96 1,57 563,41 230,30 0,56 411,42 556,25


48

NdFeB-N40

20 1,29 1011,43 1,06 965,27 315,37 0,64 491,79 981,99

40 1,26 866,60 1,19 844,32 301,60 0,63 478,26 841,13

60 1,23 729,73 1,36 715,40 287,43 0,62 465,53 708,24

80 1,19 596,04 1,62 586,49 269,93 0,60 452,00 578,53

NdFeB-N50

20 1,43 970,85 1,20 946,18 390,57 0,72 545,11 942,20

40 1,40 829,99 1,36 814,08 374,09 0,71 529,99 806,12

60 1,36 706,65 1,56 694,71 355,63 0,68 521,23 685,96

80 1,32 592,85 1,80 584,10 332,79 0,67 497,36 576,14

5.4.2 Blacha prądnicowa

Do budowy rdzenia magnetycznego maszyn stosowane są blachy elektrotechniczne. W

analizowanym przypadku przyjęto, że jarzmo wirnika i stojana zostanie wykonane z materiału,

którego krzywa magnesowania została przedstawiona na poniższym rysunku

Rys. 5.7.charakterystyka magnesowania

Tabela 5.2.CHARAKTERYSTYKA MAGNESOWANIA BLACHY PRĄDNICOWEJ

H B mr H B mr

A/m T - A/m T -

1 0,0 0,00 0,0 15 4774,6 1,70 283,3

2 79,6 0,64 6400,0 16 6525,4 1,75 213,4

3 135,3 0,92 5411,8 17 9151,4 1,80 156,5

4 159,2 1,01 5050,0 18 11936,6 1,85 123,3

5 191,0 1,10 4583,3 19 15119,7 1,90 100,0

6 238,7 1,20 4000,0 20 18541,6 1,95 83,7

7 318,3 1,30 3250,0 21 22281,7 2,00 71,4

8 493,4 1,40 2258,1 22 27454,2 2,05 59,4

0,0

1000,0

2000,0

3000,0

4000,0

5000,0

6000,0

7000,0

0,00

0,50

1,00

1,50

2,00

2,50

0,0 20,0 40,0 60,0 80,0 100,0 120,0 140,0

r

B [T

]

H [A/m]

Tysiące

Charakterystyka mangesowania


49

9 644,6 1,45 1790,1 23 35809,9 2,10 46,7

10 875,4 1,50 1363,6 24 47746,5 2,15 35,8

11 1273,2 1,55 968,8 25 63662,0 2,20 27,5

12 1591,5 1,58 787,5 26 93901,4 2,25 19,1

13 2148,6 1,60 592,6 27 127324,0 2,30 14,4

14 3342,3 1,65 392,9

5.4.3 Baza materiałów

Po zdefiniowaniu parametrów aplikacji, warunków brzegowych oraz warunków symetrii budowanego

modelu maszyny kolejnym krokiem jest definicja właściwości materiałowych poszczególnych

obszarów. Baza programu Flux zawiera definicje różnych materiałów. Zastosowanie jakiegokolwiek z

nich wymaga jednak dołączenia wybranego materiału do projektu. Sposób dołączenia materiału do

projektu pokazano na Rys. 5.8.

Rys. 5.8. Import materiału z bazy programu flux

Sposób importu danych materiału z bazy danych programu Flux w języku PYTHON pokazano na

listingu:

importMaterial(fileName='C:/Cedrat/Materials/FLUX_101_MATERI.DAT',materialNames=['FLU_COPPE

R :'])

W programie możliwe jest wykorzystanie materiałów zdefiniowanych przez użytkownika. Sposób

wprowadzenia danych materiału o nieliniowej charakterystyce magnesowania pokazano na Rys. 5.9.


50

Rys. 5.9. Definiowanie nowego materiału o nieliniowej charakterystyce magnesowania

Niżej zamieszczony listing przedstawia sposób zdefiniowania materiałów użytkownika z

zastosowaniem języka PYTHON.

# DEFINE MATERIALS Material(name='STEEL_SP : nonlinear steel', propertyBH=PropertyBhNonlinearSpline (splinePoints=[ BHPoint(h=0.0, b=0.0), BHPoint(h=79.58, b=0.64), BHPoint(h=135.3, b=0.92), BHPoint(h=159.2, b=1.01), BHPoint(h=191.0, b=1.1), BHPoint(h=238.7, b=1.2), BHPoint(h=318.3, b=1.3), BHPoint(h=493.4, b=1.4), BHPoint(h=644.6, b=1.45), BHPoint(h=875.4, b=1.5), BHPoint(h=1273.2, b=1.55), BHPoint(h=1591.5, b=1.58), BHPoint(h=2148.6, b=1.6), BHPoint(h=3342.3, b=1.65), BHPoint(h=4774.6, b=1.7), BHPoint(h=6525.4, b=1.75), BHPoint(h=9151.4, b=1.8), BHPoint(h=11936.3, b=1.85), BHPoint(h=15119.7, b=1.9), BHPoint(h=18541.6, b=1.95), BHPoint(h=22281.7, b=2.0), BHPoint(h=27454.2, b=2.05), BHPoint(h=35809.9, b=2.1), BHPoint(h=47746.5, b=2.15), BHPoint(h=63662.0, b=2.2), BHPoint(h=93901.4, b=2.25), BHPoint(h=127324.0, b=2.3)]));

# Magnets from BakkerMagnetics www.bakkermagnetics.com Material(name='BM_N35: Sintered NdFeB permanent magnet', propertyBH = PropertyBhMagnetOneDirection(br='1.2', mur='1.10'));


51

Material(name='BM_N40: Sintered NdFeB permanent magnet', propertyBH = PropertyBhMagnetOneDirection(br='1.28', mur='1.18')); Material(name='BM_N50: Sintered NdFeB permanent magnet', propertyBH = PropertyBhMagnetOneDirection(br='1.43', mur='1.36'));

Na rys. 5.10. pokazano sposób definiowania magnesu trwałego.

Rys. 5.10. Definiowanie właściwości magnesu trwałego

5.4.4 Przyporządkowanie materiałów do regionów

Po zdefiniowaniu wszystkich niezbędnych materiałów w kolejnym kroku należy dołączyd materiały do odpowiednich regionów budowanego modelu maszyny. Sposób dołączenia materiału o nazwie STEEL_SP do regionów o nazwie STATOR i ROTOR przedstawiono na rys. 5.11.

Rys. 5.11. Dołączenie materiału do odpowiedniego regionu modelu

Zastosowanie magnesów trwałych w modelu obliczeniowym maszyny oprócz dołączenia materiału do odpowiedniego regionu wymaga ustawienia kierunku namagnesowania. Sposób zdefiniowania


52

kierunku wektora indukcji dla magnesu w programie Flux z wykorzystaniem GUI przedstawiono na rys. 5.12.

Rys. 5.12. Ustawienie kierunku wektora indukcji magnetycznej dla magnesu trwałego

5.4.5 Właściwości mechaniczne

Przeprowadzenie obliczeo rozkładu indukcji magnetycznej z uwzględnieniem ruchu wirnika (w funkcji

kąta obrotu wirnika) wymaga zdefiniowania właściwości mechanicznych. Program Flux wprowadza

trzy typy właściwości mechanicznych modelu numerycznego:

Fixed – definiuje nieruchome elementy modelu – np. stojan

Moving – definiuje ruchome elementy modelu (wirujące i przesuwające się) - np. wirnik

Compressible – definiuje regiony pomiędzy elementami ruchomymi i nieruchomymi –

szczelina oborotwa

Podobnie jak w przypadku materiałów magnetycznych przygotowuje się bazę z nazwanymi

zestawami właściwości fizycznych. Należy zdefiniowad zestaw właściwości mechanicznych ruchomych

„ROTOR” i nieruchomych „STATOR”, oraz warstwę poślizgową „AIR_GAP”. W kolejnym kroku należy

dołączyd zestawy właściwości mechanicznych do odpowiednich regionów maszyny. Sposób

definiowania poszczególnych zestawów właściwości mechanicznych pokazano na rys. 5.13.


53

Rys. 5.13. Definiowanie Zestawu właściwości mechanicznych

Kod programu PYTHON do definiowania zestawów właściwości mechanicznych przedstawiono na

poniższym listingu:

# DEFINE MECHANICAL PROPERTIS MechanicalSetCompressibleRemeshing(name='AIRGAP : Rotating airgap'); MechanicalSetFixed(name='STATOR : Static part of the motor'); MechanicalSetRotation1Axis(name='ROTOR : rotating part of the motor', kinematics=RotatingMultiStatic(), rotationAxis=RotationZAxis(coordSys=CoordSys['ROTOR'], pivot=['0','0']));

Sposób przyporządkowania właściwości mechanicznych „ROTOR” do odpowiednich regionów

budowanego modelu z wykorzystaniem GUI pokazano na rys. 5.14.


54

Rys. 5.14. Przyporządkowanie zestawu właściwości mechanicznych „rotor” do odpowiednich regionów modelu

Kod programu PYTHON do przyporządkowania zestawu właściwości mechanicznych do odpowiednich

obszarów modelu przedstawiono na poniższym listingu:

RegionFace['MAGNET','ROTOR','ROTOR_AIR','SHAFT'].mechanicalSet=MechanicalSet['ROTOR']; RegionFace['STATOR','STATOR_AIR','SLOT_WEDGE','SLOT_OPENING'].mechanicalSet=MechanicalSet['STATOR']; RegionFace['SLOT_1','SLOT_2','SLOT_3','SLOT_4','SLOT_5','SLOT_6','SLOT_7','SLOT_8','SLOT_9'].mechanicalSet=MechanicalSet['STATOR']; RegionFace['AIRGAP'].mechanicalSet=MechanicalSet['AIRGAP'];

5.4.6 Sprawdzenie poprawności modelu fizycznego

Po wykonaniu wszystkich wyżej opisanych czynności należy dokonad sprawdzenia poprawności

definicji właściwości fizycznych modelu (Physics – Check physics) (rys.5.15).

Rys. 5.15 Sprawdzenie poprawności modelu fizycznego


55

5.5 Zapisanie modelu numerycznego Jeśli sprawdzenie zakooczy się wynikiem pozytywnym należy zapisad tak zdefiniowany model w

odpowiednim folderze na dysku twardym komputera. Poprawne wykonanie wyżej opisanych

czynności pozwoli na wykonanie obliczeo rozkładu indukcji magnetycznej w opracowanym modelu.

Opracowany model numeryczny silnika powinien zostad wyeksportowany do pliku TRA, który

zostanie podjęty przez procesor obliczeniowy programu Flux2D. W tym celu należy wybrad opcję

Project->Export->Export physics -> Export physics to a TRA file (rys.5.16).

Rys. 5.16 Eksport modelu numerycznego


56

6 Obliczenia w programie polowym Moduł obliczeniowy (solver) uruchamia się w sekcji Solving Process wybierając opcję Direct (rys. 6.1).

Po wyświetleniu okna Solver’a można uruchomid obliczenia dla warunków zdefiniowanych w modelu

numerycznym .

Rys. 6.1 Uruchomienie obliczeo

6.1 Obliczenia parametryczne W programie Flux2D można wykonad obliczenia parametryczne, czyli dokonad analizy wpływu

wartości wybranego parametru na rozkład pola oraz wielkości całkowe. Definicję parametrów

rozpoczyna się od wybrania opcji Parametrisation -> Parameter… (rys. 6.2).

Rys. 6.2 Obliczenia parametryczne

Poniżej zostanie zaprezentowana procedura definicji parametru w celu wykonania obliczeo dla

różnych położeo wirnika. Należy zdefiniowad wartości jakie ma przyjąd parametr położenie wirnika

(initial position of rotor) z sekcji others (rys. 6.3).


57

Rys. 6.3 Definicja parametru – kąta obrotu wirnika

Wartości parametrów można definiowad podając zakres zmian oraz wartośd kroku, liczbę kroków lub

po prostu listę wartości parametrów (rys. 6.4). Zdefiniowane wartości parametrów można wyświetlid

po wybraniu funkcji display. W omawianym przypadku wprowadzono zmianę położenia

początkowego wirnika od 0 do 180 stopni z krokiem co 1 stopieo.

Rys. 6.4 Definicja wartości kąta obrotu wirnika

Po zdefiniowaniu zmian wartości wybranego parametru (lub parametrów) należy uruchomid

obliczenia (rys. 6.5).

Rys. 6.5 Uruchomienie obliczeo parametrycznych

Obliczenia wykonywane są dla każdej ustawionej wartości parametru (rys. 6.6).


58

Rys. 6.6 Obliczenia parametryczne

6.2 Warunki obliczeń W zależności od celu przeprowadzania obliczeo należy zdefiniowad różne wymuszenia pola (magnesy

trwałe, prądy). Poniżej zestawiono przykładowe parametry modelu fizycznego w zależności od

rodzaju analizowanego problemu.

Tabela 6.1 Warunki przeprowadzenia obliczeo

Nazwa magnesy ias ibs ics

bieg jałowy tak 0 0 0

indukcyjności nie Ismx 0 0

moment elektromagnetyczny tak Ismx -1/2Ismx -1/2Ismx

6.3 Bieg jałowy Bieg jałowy określa stan pracy maszyny nie obciążonej – maszyna jest wzbudzona (magnesy trwałe),

obraca się z ustaloną prędkością, brak jest prądów w uzwojeniach stojana.

6.3.1 Rozkład indukcji

Rozkład indukcji może zostad użyty do oceny poprawności zaprojektowania obwodu magnetycznego

silnika.

Obliczenia wykonane zostały dla modelu numerycznego dla ustalonych warunków brzegowych oraz z

wykorzystaniem warunków symetrii. Istnieje możliwośd wyświetlenia całego modelu silnika,

wygenerowanego w oparciu o warunki symetrii. W tym celu z menu Geometry należy wybrad opcję

Full Geometry (rys. 6.7).


59

Rys. 6.7 Model silnika z magnesami trwałymi wygenerowany w oparciu o warunki symetrii

Wyświetlenie linii stałego potencjału (izolinii) pozwala na weryfikację poprawności definicji

warunków brzegowych i warunków symetrii. Izolinie zostają wyświetlone po wybraniu opcji Results -

> Isovalues (Rys. 6.8).


60

Rys. 6.8 Rozkład indukcji - linie stałego potencjału

Domyślnie wyświetlanych jest 11 izolinii – zmiana tej liczby wymaga wyświetlenie okna parametrów

wyświetlania wyników – Results -> Propertis … (rys. 6.9).

Rys. 6.9 Ustwienie sposobu wyświetlania izolinii

Obraz rozkładu pola w postaci mapy kolorów (Results -> Colour shade) może wskazad najbardziej

nasycone elementy maszyny, które mogą stanowid źródła potencjalnych strat (rys. 6.10).

Isovalues ResultsQuantity : Equi flux Weber TETAINI(AIRGAP) (degrees) : 0 Pos (deg): 0Line / Value 1 / -2,02781E-3 2 / -1,82503E-3 3 / -1,62225E-3 4 / -1,41947E-3 5 / -1,21669E-3 6 / -1,0139E-3 7 / -811,1237E-6 8 / -608,34276E-6 9 / -405,56185E-6 10 / -202,78092E-6 11 / 0 12 / 202,78092E-6 13 / 405,56185E-6 14 / 608,34276E-6 15 / 811,1237E-6 16 / 1,0139E-3 17 / 1,21669E-3 18 / 1,41947E-3 19 / 1,62225E-3 20 / 1,82503E-3 21 / 2,02781E-3


61

Rys. 6.10 Rozkład indukcji – mapa kolorów

Parametr fizyczna oraz jakośd wyświetlanego obrazu jest również sterowany w oknie parametrów

wyświetlania wyników obliczeo.

Rys. 6.11 Ustawienia sposobu wyświetlania mapy kolorów (color shade)

Postprocesor programu Flux2D posiada opcję przygotowania animacji – zmiany wyników obliczeo w

funkcji zmian wartości wcześniej ustawionych parametrów. W przypadku maszyn elektrycznych

Color Shade ResultsQuantity : |Flux density| Tesla

TETAINI(AIRGAP) (degrees) : 0 Pos (deg): 0

Scale / Color

21,44314E-9 / 138,97306E-3

138,97306E-3 / 277,94608E-3

277,94608E-3 / 416,91908E-3

416,91908E-3 / 555,89211E-3

555,89211E-3 / 694,86511E-3

694,86511E-3 / 833,83822E-3

833,83822E-3 / 972,81122E-3

972,81122E-3 / 1,11178

1,11178 / 1,25076

1,25076 / 1,38973

1,38973 / 1,5287

1,5287 / 1,66768

1,66768 / 1,80665

1,80665 / 1,94562

1,94562 / 2,0846

2,0846 / 2,22357


62

interesujące jest zobrazowanie zmian rozkładu pola magnetycznego w czasie obrotu wirnika.

Animację uruchamia się opcją Parameters -> Manager.. (rys. 6.12). Następnie rozwijamy okno

Parameters przyciskiem Animation >> i ustawiamy żądny zakres zmian parametru. Animację można

zapisad na dysku w formacie avi wybierając opcję Record as..

Rys. 6.12 Animacja zmian wyników obliczeo w funkcji w funkcji zmian wartości parametru

Rozkład indukcji w szczelnie i analiza zawartości harmonicznych pozwala na ocenę poprawności

projektu wirnika, mocowania magnesów i kierunku ich namagnesowania.

W celu wyświetlania rozkładu indukcji w szczelnie należy najpierw zdefiniowad łuk/okrąg

przechodzący przez środek szczeliny. W tym celu wybieramy opcję Support -> Path manager… . W

sekcji Path definiuje się nazwę ścieżki (AIR_GAP) oraz gęstośd jej podziału (180), a w sekcji Graphic

Section należy wybrad opcję Arc (łuk) i potwierdzid przyciskiem New Section. W oknie Section Editing

wybiera się sposób definiowania ścieżki (Arc radius angles) i wprowadza odpowiednie jej parametry

(rys. 6.13).


63

Rys. 6.13 Definicja ścieżki przechodzącej przez środek szczeliny

Poprawnie zdefiniowana ścieżka zostanie wyświetlona na ekranie (rys. 6.14).

Rys. 6.14 Ścieżka przechodząca przez środek szczeliny powietrznej

W kolejnym kroku należy uruchomid menadżera wykresów 2-wymiarowych (2D curves manager) w

celu zdefiniowania rozkładu indukcji w szczelnie (rys. 6.15).


64

Rys. 6.15 Uruchomienie menadżera wykresów 2D

W oknie menadżera definiuje się nazwę wykresu, wybiera opcję wyświetlanie wyników wzdłuż ścieżki

(Path) i wskazuje nazwę ścieżki (Airgap). Rozkład składowej normalnej indukcji w szczelnie uzyskuje

się po wybraniu z listy rozwijanej Quantity opcji Flux density oraz składowej (Components) – Normal

component (rys. 6.16).

Rys. 6.16 Definicja rozkładu indukcji w szczelnie

Wyświetlenie zdefiniowanego wykresu wymaga przygotowania nowej karty z wykresami 2D (rys.

6.17) .

Rys. 6.17 Otwarcie nowej karty z wykresami 2D

Na nowej karcie z menu kontekstowego wybieramy opcję Properties… i wybieramy odpowiednie

wykresy do wyświetlenia (rys. 6.18).


65

Rys. 6.18 Wybranie wykresów do wyświetlenia

Wybrane wykresy mogą byd wyświetlone w osobnych układach współrzędnych (rys. 6.19) lub w

jednym po wybraniu opcji (Supermiposed) (rys. 6.20).

Rys. 6.19 Rozkład indukcji w szczelnie dla dwóch różnych położeo wirnika

BLDC

-1

-0,5

0

0 10 20 30 40 50 60 70

mm

Tesla

-1

-0,5

0

0 10 20 30 40 50 60 70

mm

Tesla

CURVE BrFlux density / Normal componentAirgap TETAINI(AIRGAP) (degrees) : 0

CURVE C2D_2Flux density / Normal componentAirgap TETAINI(AIRGAP) (degrees) : 5


66

Rys. 6.20 Rozkład indukcji w szczelnie dla dwóch różnych położeo wirnika – wykresy połączone

Wyświetlone wykresy, jeżeli są okresowe, mogą byd poddane analizie harmonicznej (FFT). Poniżej

przedstawiono procedurę wykonania analizy FFT dla rozkładu indukcji w szczelnie pokazanego na

(rys. 6.21). Przygotowano wykres rozkładu indukcji w szczelnie wzdłuż łuku w środku szczeliny

powietrznej o długości odpowiadającej jednej parze biegunów. Taki wykres reprezentuje jeden okres

rozkładu indukcji.

Rys. 6.21 Rozkład indukcji w szczelnie dla jednej pary biegunów silnika

Obliczenia harmoniczne uruchamiamy opcją Computation-> 2D Spectrum manager (rys. 6.22).

BLDC

-1

-0,5

0

0 10 20 30 40 50 60 70

CURVE BrFlux density / Normal componentAirgap TETAINI(AIRGAP) (degrees) : 0

CURVE C2D_2Flux density / Normal componentAirgap TETAINI(AIRGAP) (degrees) : 5

BLDC

-1

-0,5

0

0,5

1

0 50 100

mm

Tesla

CURVE Br2Flux density / Normal componentAirgap2 TETAINI(AIRGAP) (degrees) : 0


67

Rys. 6.22 Uruchomienie funkcji analizy harmonicznej

W oknie ustawieo analizy harmonicznej wskazujemy nazwę wykresu, podajemy zakres, który

podlegad ma analizie oraz określamy jaką częśd okresu on reprezentuje (rys. 6.23).

Rys. 6.23 Ustawienia analizy harmonicznej

W wyniku działania funkcji otrzymujemy kartę na której wyświetlone są dwa wykresy – górny

reprezentuje oryginalny wykres poddany analizie, dolny zawartośd harmonicznych (rys. 6.24).


68

Rys. 6.24 Analiza harmoniczna rozkładu indukcji w szczelinie

Postprocesor programu Flux umożliwia również przedstawienie wyników obliczeo na wykresach

trójwymiarowy. W tym celu należy uruchomid menadżera wykresów 3D (rys. 6.25) i ustawid

odpowiednie opcje (rys. 6.26) – np. dla pokazania rozkładu indukcji w szczelinie powietrznej dla

kolejnych pozycji wirnika (rys. 6.27).

Rys. 6.25 Uruchomienie menadżera wykresów 3D

BLDC

-1

-0,5

0

0,5

1

0 50 100

mm

Tesla

250

500

750

5 10 15

(E-3) Tesla

CURVE Br2Flux density / Normal componentAirgap2 TETAINI(AIRGAP) (degrees) : 0 Full cycle / Normal

SPECTRUM FFT_Br2From Br2Fundamental 6,844E-3


69

Rys. 6.26 Ustawienie opcji wykresu 3D

Rys. 6.27 rozkładu indukcji w szczelinie powietrznej dla kolejnych pozycji wirnika


70

6.3.2 Strumień sprzężony z uzwojeniem w funkcji położenia wirnika

Poniżej zostanie zaprezentowana procedura przygotowania wykresu strumienia sprzężonego z

uzwojeniem w funkcji położenia wirnika (). Wykres ten może stanowid podstawę wyznaczenia

przebiegu napięcia indukowanego rotacji lub indukcyjności uzwojeo.

Model geometryczny silnika reprezentuje jeden biegun, w którym znajdują się po trzy żłobki trzech

uzwojeo fazowych (dla uzwojenia jednowarstwowego). Zakłada się, że do uzwojenia fazowego AS

należą żłobki SLOT_4, SLOT_5, SLOT_6. Ze żłobków tych zostanie zdefiniowana grupa regionów o

nazwie Phase_AS (rys. 6.28).

Rys. 6.28 Zdefiniowanie grupy regionów reprezentującej żłobki uzwojenia fazowego AS

W kolejnym kroku zostanie ustalona liczba zwojów dla regionów reprezentujących żłobki stojana. Z

menu górnego Physics należy wybrad opcję Coefficients -> Modify (rys. 6.29).

Rys. 6.29 Ustawieni liczby zwojów

Wykres strumienia sprzężonego z uzwojeniem fazy AS w funkcji kąta obrotu wirnika uzyskujemy

wybierając odpowiednie opcje w oknie menadżera wykresów 2D (). Strumieo sprzężony znajduje się

w sekcji Inductacne –> flux seen by region.


71

Rys. 6.30 Ustawienia dla wykresu strumienia sprzężonego z uzwojeniem fazy AS

Uzyskany wykres strumienia sprzężonego pokazano na rys. 6.31.

Rys. 6.31 Wykres strumienia sprzężonego z uzwojeniem fazy AS

BLDC

-200

-100

0

100

200

0 50 100 150

degrees

(E-3) Weber

CURVE Phi_asInductance / Flux seen by the region (region considered as a Conductor)TETAINI(AIRGAP)SLOT_4 ; SLOT_5 ; SLOT_6 ;


72

6.3.3 Napięcie indukowane rotacji

Wyznaczenie napięcia indukowanego rotacji e(t) na podstawie wykresu strumienia sprzężonego z

uzwojeniem.

Na podstawie wyników uzyskanych w poprzednim punkcie należy wyznaczyd napięcia indukowane

rotacji – napięcie indukowane w uzwojeniach stojana przez pole wzbudzone magnesami trwałymi

gdzie: - kąt obrotu wirnika w radianach, m – prędkośd kątowa wirnika.

Uzyskane w poprzednim wyniki strumienia sprzężonego z uzwojeniem AS zapisano w pliku

tekstowym. W tym celu należy wybrad z menu kontekstowego opcję Values-> Save all as… oraz podad

nazwę pliku, do którego zostaną zapisane wyniki (rys. 6.32).

Rys. 6.32 Zapisanie wyników obliczeo w pliku tekstowym

Wyniki zapisane w pliku tekstowym należy otworzyd w programie, który umożliwi przeprowadzenie

różniczkowania przebiegu. Do obliczenia napięcia indukowanego rotacji można wykorzystad np.

program Excel (rys. 6.33).

Rys. 6.33 Import danych do programu Excel

Na podstawie wartości strumienia sprzężonego napisano formuły obliczającą napięcie indukowane

rotacji (rys. 6.34). Wyniki obliczeo z programu Flux2D umieszczone są odpowiednio w kolumnach A-

kąt położenia wirnika w stopniach, C – strumieo sprzężony z uzwojeniem fazowym AS [Wb].


73

Rys. 6.34 Formuły obliczające napięcie indukowane rotacji

Uzyskane wyniki obliczeo w programie Excel – przebieg napięcia indukowanego rotacji –

przedstawiono na rys. 6.35

Rys. 6.35 Wykres strumienia sprzężonego oraz przebieg napięcia indukowanego rotacji w programie Excel

6.3.4 Moment zaczepowy

Poniżej zostanie zaprezentowana procedura obliczania momentu zaczepowego (ang. cogging torque)

Tc(). Wartośd i przebieg momentu zaczepowego wynika ze zmiany reluktancji szczeliny powietrznej

wynikającej między innymi z użłobkowania stojana. Moment zaczepowy oblicza się przy zachowaniu

wzbudzenia pola magnesami trwałymi ale bez zasilania uzwojeo.

Wykres momentu zaczepowego w funkcji kąta obrotu wirnika definiuje się w oknie menadżera

wykresów dwuwymiarowych (rys. 6.36). Jako parametr wybiera się kąt obrotu, a wielkośd do obliczeo

Torque-> Moment. Istotne jest wskazanie jednej z części wirnika jako regionu do obliczeo momentu.

Na rys.6.37 przedstawiono zależnośd momentu zaczepowego od położenia kątowego wirnika.

-3,00E-01

-2,00E-01

-1,00E-01

0,00E+00

1,00E-01

2,00E-01

3,00E-01

0 30 60 90 120 150 180

Phi_as [Wb]

-400

-300

-200

-100

0

100

200

300

400

0 30 60 90 120 150 180

E_rot [V]


74

Rys. 6.36 Definiowanie wykresu momentu zaczepowego

Rys. 6.37. Zależnośd momentu zaczepowego od kąta obrotu wirnika

Wyniki obliczeo momentu dotyczą tylko ¼ modelu – należy więc je przemnożyd przez 4.

BLDC - cogging torque

-250

0

250

0 50 100 150

degrees

(E-3) Newton.m

CURVE Te_rotorTorque / MomentTETAINI(AIRGAP)ROTOR ;


75

7 Bibliografia 1. Cedrat. Strona firmowa producenta oprogramowania Flux. [Online] www.cedrat.com.

2. Antal, Ludwik. Materiały dydaktyczne Instytut Maszyn, Napędów i Pomiarów Elektrycznych.

*Online+ Politechnika Wrocławska. http://www.imne.pwr.wroc.pl/zme/Antal/AN/.

3. TERMAGSOFT. strona firmowa dystrybutora programu Flux2D. [Online] www.termagsoft.com.pl.


76

8 Skrypt

Opisany wyżej model numeryczny silnika bezszczotkowego z magnesami trwałymi można

wygenerowad automatycznie przy wykorzystaniu wcześniej przygotowanego skryptu w języku

Python. Kod programu został podzielony na funkcje odpowiadające kolejnym etapom przygotowania

modelu geometrycznego i fizycznego. Parametry modelu zostały zdefiniowane na początku kodu.

Uruchomienie skryptu z modelem numerycznym silnika bezszczotkowego z magnesami trwałymi

następuje po wybraniu opcji Priject->Command file->Execute In direct mode… i wskazaniu

odpowiedniego pliku (rys. 8.1).

Rys. 8.1 Uruchomienie skyrptu w języku python

Efekt działania skryptu to zdyskretyzowany model geometryczny z przyporządkowanymi do regionów

odpowiednimi właściwościami materiałowymi oraz utworzony odpowiedni plik wynikowy stanowiący

podstawę do przeprowadzenia obliczeo rozkładu indukcji magnetycznej. Na rys.8.2 pokazano efekt

wykonania kodu zawartego w opracowanym skrypcie.


77

Rys.8.2. Model silnika wygenerowany przez program Flux po uruchomieniu skrtptu

#! Preflu2D 9.3

#=====================================================================================

# BRUSHLESS PERMANENT MAGNET MOTOR

# author: dr inz Michal MICHNA

# email: [email protected]#

#

# desription: Numerical model of brushless permanent magnet motor for FLux2D

#=====================================================================================

closeProject()

newProject()

# GLOBAL PARAMETERS OF MOTOR GEOMETRY

#class MotorParameters

Nph=3 #[-] number of phase

p=2; #[-] number of pole pairs

dri=38; #[mm] inner diameter of rotor = diameter of shaft

delta=1.0; #[mm] width of airgap

hm=5; #[mm] high of magnet

alfam=0.6; #[-] magnet span 4*360/qs

q=3; #[-] number of slots for one phase and one pole

les=100; #[mm] stator length

ds=94; #[mm] inner diameter of stator

dse=155.1; #[mm] outer diameter of stator

bs1=2.6; #[mm] width of slot opening

bs2=3.6; #[mm] width of stator slot wedge

bs3=5.9; #[mm] width of stator slot

hs1=0.7; #[mm] hight of slot opening

hs2=0.2; #[mm] hight of stator slot wedge

hs3=13.1; #[mm] hight of stator slot

mesh=3

# Curent sources

jmax=7 #[A/mm2] maximum value of current density in the slot

def Parameters() :

global Nph,p,dri,delta,hm,alfam,q,les,ds,dse,bs1,bs,hs2,hs;


78

try:

ParameterGeom(name='NPH : number of phase', expression=str(Nph));

ParameterGeom(name='P : number of pole pairs', expression=str(p));

ParameterGeom(name='Q : number of slots for one phase and one

pole',expression=str(q));

ParameterGeom(name='NS : number of slots',expression='2*Nph*p*q');

ParameterGeom(name='TAUS : slot pitch',expression='360/NS');

ParameterGeom(name='TAUP : pole pitch',expression='360/2/P');

ParameterGeom(name='DRI : inner diameter of rotor = diameter of

shaft',expression=str(dri));

ParameterGeom(name='DELTA : width of airgap',expression=str(delta));

ParameterGeom(name='HM : high of magnet',expression=str(hm));

ParameterGeom(name='ALFAM : magnet span',expression=str(alfam));

ParameterGeom(name='LES : stator length',expression=str(les));

ParameterGeom(name='DS : inner diameter of stator',expression=str(ds));

ParameterGeom(name='DSE : outer diameter of stator',expression=str(dse));

ParameterGeom(name='BS1 : width of slot opening',expression=str(bs1));

ParameterGeom(name='BS2 : width of stator slot wedge',expression=str(bs2));

ParameterGeom(name='BS3 : width of slot opening',expression=str(bs3));

ParameterGeom(name='HS1 : hight of slot opening',expression=str(hs1));

ParameterGeom(name='HS2 : hight of slot wedge',expression=str(hs2));

ParameterGeom(name='HS3 : hight of stator slot',expression=str(hs3));

ParameterGeom(name='DM : diameter of magnet',expression='DS-2*DELTA');

ParameterGeom(name='DR : outer diameter of rotor',expression='DM-2*HM');

ParameterGeom(name='TAUM : MAGNET SPAN',expression='ALFAM*TAUP');

ParameterGeom(name='MESH : MESH DENSIT COEFICIENT',expression=str(mesh));

except :

resetError()

def CoordSystem() :

try:

CoordSysCylindrical(name='MAIN : MAIN COORDINATE SYSTEM',

parentCoordSys=GlobalUnits(lengthUnit=LengthUnit['MILLIMETER'],angleUnit=AngleUnit['DEGREE']),

origin=['0','0','0'],

rotationAngles=RotationAngles(angleX='0',angleY='0',angleZ='0'));

CoordSysCylindrical(name='ROTOR : Rotor coordinate system',

parentCoordSys=Local(coordSys=CoordSys['MAIN']),

origin=['0','0'],

rotationAngles=RotationAngles(angleZ='TAUP/2'));

CoordSysCylindrical(name='AIRGAP : Air-gap coordinate system',


origin=['0','TAUP/2','0'],

rotationAngles=RotationAngles(angleZ='TAUP/2'));

CoordSysCylindrical(name='STATOR : STATOR COORDINATE SYSTEM',


origin=['0','TAUS/2','0'],

rotationAngles=RotationAngles(angleZ='TAUS/2'))

;

CoordSysCartesian(name='STATORSLOT : STATOR COORDINATE SYSTEM',

parentCoordSys=Local(coordSys=CoordSys['STATOR']),

origin=['DS/2','0','0'],

rotationAngles=RotationAngles(angleZ='0'));

except :

resetError()

def RotorPoints() :

PointCoordinates(color=Color['White'],visibility=Visibility['VISIBLE'],

coordSys=CoordSys['MAIN'],

uvw=['0','0','0'],

nature=Nature['STANDARD']); #P1


coordSys=CoordSys['ROTOR'],

uvw=['DRI/2','-TAUP/2','0'],




uvw=['DRI/2','TAUP/2','0'],


PointCoordinates(color=Color['White'], visibility=Visibility['VISIBLE'],


uvw=['DR/2','-TAUP/2','0'],




79


uvw=['DR/2','-TAUM/2','0'],

nature=Nature['STANDARD']) ; #P5



uvw=['DR/2','TAUM/2','0'],




uvw=['DR/2','TAUP/2','0'],




uvw=['DM/2','-TAUP/2','0'],




uvw=['DM/2','-TAUM/2','0'],




uvw=['DM/2','TAUM/2','0'],




uvw=['DM/2','TAUP/2','0'],


def RotorLines() :

LineSegment(color=Color['White'], visibility=Visibility['VISIBLE'],

defPoint=[Point[1],Point[2]],

nature=Nature['STANDARD']); #L1












nature=Nature['STANDARD']) ; #L5










LineArcPivotPoint(color=Color['White'],visibility=Visibility['VISIBLE'],


defPoint=[Point[2],Point[3],Point[1]],




















80








def StatorPoints() :


coordSys=CoordSys['STATOR'],

uvw=['DS/2','-TAUS/2','0'],




uvw=['DS/2','-Atan2d(BS1/2,DS/2)','0'],




uvw=['DS/2','0','0'],




uvw=['DSE/2','-TAUS/2','0'],




uvw=['DSE/2','0','0'],



coordSys=CoordSys['STATORSLOT'],

uvw=['HS1','-BS1/2','0'],




uvw=['HS1','0','0'],




uvw=['HS1+HS2','-BS2/2','0'],




uvw=['HS1+HS2','0','0'],




uvw=['HS1+HS2+HS3','-BS3/2','0'],




uvw=['HS1+HS2+HS3','0','0'],




uvw=['HS1+HS2+HS3+BS3/2','0','0'],


def StatorLines() :

















81






































def AirGapPoints() :


coordSys=CoordSys['AIRGAP'],

uvw=['DS/2-2/3*DELTA','-TAUP/2','0'],




uvw=['DS/2-2/3*DELTA','TAUP/2','0'],




uvw=['DS/2-1/3*DELTA','-TAUP/2','0'],




uvw=['DS/2-1/3*DELTA','TAUP/2','0'],


def AirGapLines() :

global Nph, q;

#index = 30 + 12*(Nph*q-1) #85

index = 157



defPoint=[Point[index+1],Point[index+2],Point[1]],




defPoint=[Point[index+3],Point[index+4],Point[1]],



defPoint=[Point[8],Point[index+1]],



defPoint=[Point[index+1],Point[index+3]],




82

defPoint=[Point[index+3],Point[12]],



defPoint=[Point[11],Point[index+2]],



defPoint=[Point[index+2],Point[index+4]],



defPoint=[Point[index+4],Point[145]],


def Transformation() :

TransfAffineLine2PT(name='SLOTMIRROR : mirror of stator slot',

point=[Point[1],Point[16]],

factor='-1')

TransfRotation3AnglesPivotPoint(name='SLOTROTATION : rotation of the stator slots',


pivotPoint=Point[1],

rotationAngles=RotationAngles(angleZ='taus'))

def StatorTrans () :

global Nph, q;

FaceAutomatic[6,7,8,9,10].propagate(transformation=Transf['SLOTMIRROR'],

repetitionNumber=1,

buildingOption='ADD FACES AND ASSOCIATED LINKED MESH GENERATOR',

regionPropagation='WITH THE SAME REGION')

FaceAutomatic[6,7,8,11,12,13].propagate(transformation=Transf['SLOTROTATION'],

repetitionNumber=str(Nph*q-1),


regionPropagation='WITH THE SAME REGION')

FaceAutomatic[9,10,14,15].propagate(transformation=Transf['SLOTROTATION'],

repetitionNumber=str(Nph*q-1),


regionPropagation='WITH INCREMENT')

#RegionFace['SLOT_1'].name='PHASE_B'

def Regions() :

RegionFace(name='SHAFT', color=Color['Turquoise'], visibility=Visibility['VISIBLE']);

RegionFace(name='ROTOR', color=Color['Cyan'], visibility=Visibility['VISIBLE']);

RegionFace(name='MAGNET', color=Color['Red'], visibility=Visibility['VISIBLE']);

RegionFace(name='ROTOR_AIR', color=Color['Turquoise'],

visibility=Visibility['VISIBLE']);

RegionFace(name='AIRGAP', color=Color['Yellow'], visibility=Visibility['VISIBLE']);

RegionFace(name='STATOR_AIR', color=Color['Turquoise'],


RegionFace(name='SLOT_OPENING', color=Color['Turquoise'],


RegionFace(name='SLOT_WEDGE', color=Color['Turquoise'],


RegionFace(name='STATOR', color=Color['Cyan'], visibility=Visibility['VISIBLE']);

RegionFace(name='SLOT_1', color=Color['Cyan'], visibility=Visibility['VISIBLE']);

#RegionFace(name='PHASE_A', color=Color['Red'], visibility=Visibility['VISIBLE']);

#RegionFace(name='PHASE_B', color=Color['Green'], visibility=Visibility['VISIBLE']);

#RegionFace(name='PHASE_C', color=Color['Yellow'], visibility=Visibility['VISIBLE']);

assignRegionToFaces(face=[Face[1]], region=RegionFace['SHAFT']);

assignRegionToFaces(face=[Face[2]], region=RegionFace['ROTOR']);

assignRegionToFaces(face=[Face[3],Face[5]], region=RegionFace['ROTOR_AIR']);

assignRegionToFaces(face=[Face[4]], region=RegionFace['MAGNET']);

assignRegionToFaces(face=[Face[6]], region=RegionFace['STATOR']);

assignRegionToFaces(face=[Face[7]], region=RegionFace['SLOT_OPENING']);

assignRegionToFaces(face=[Face[8]], region=RegionFace['SLOT_WEDGE']);

assignRegionToFaces(face=[Face[9],Face[10]], region=RegionFace['SLOT_1']);

def AirGapRegions():

assignRegionToFaces(face=[Face[98]], region=RegionFace['AIRGAP']);

assignRegionToFaces(face=[Face[97]], region=RegionFace['STATOR_AIR']);

assignRegionToFaces(face=[Face[96]], region=RegionFace['ROTOR_AIR']);

def Meshing() :

global p;

# calculte mesh density of the middle layer in the air gap

airgap = int(360/(2*p))


83

#mesh lines

MeshLineArithmetic(name='ML_AIRGAP : air gap line density', color=Color['White'],

number=str(airgap));

MeshLineLengths(name='ML_SHAFT : GESTOSC SIATKI NA KRAWEDZIACH WALKA',

color=Color['White'], lengthUnit=LengthUnit['MILLIMETER'],

lengths=['MESH*PI()*DRI/2/P/15','MESH*PI()*DRI/2/P/15'])

MeshLineLengths(name='ML_ROTOR_YOKE : GESTOSC SIATKI NA KRAWEDZIACH JARZMA WIRNIKA',


lengths=['MESH*PI()*DRI/2/P/15','MESH*PI()*DR/2/P/45'])

MeshLineLengths(name='ML_ROTOR : GESTOSC SIATKI NA KRAWEDZIACH WIRNIKA',


lengths=['MESH*Pi()*DR/2/P/45','MESH*Pi()*DR/2/P/45'])

MeshLineLengths(name='ML_MAGNET : GESTOSC SIATKI NA KRAWEDZIACH MAGNESU',


lengths=['Pi()*DM/2/P/90','Pi()*DM/2/P/90'])

MeshLineLengths(name='ML_STATOR : GESTOSC SIATKI NA KRAWEDZI WEWNETRZNEJ STOJANA',


lengths=['Pi()*DS/2/P/90','Pi()*DS/2/P/90'])

MeshLineLengths(name='ML_STATOREX : GESTOSC SIATKI NA KRAWEDZI ZEWNETRZNEJ STOJANA',


lengths=['MESH*Pi()*DSE/2/P/45','MESH*Pi()*DSE/2/P/45'])

# mesh points

MeshPoint(name='MP_SLOT', lengthUnit=LengthUnit['MILLIMETER'], color=Color['Red'],

value='MESH*BS3/5');

MeshPoint(name='MP_WEDGE', lengthUnit=LengthUnit['MILLIMETER'], color=Color['Red'],

value='MESH*2*HS2');

#Assign mesh density

LineArcPivotPoint[251,252].assignMeshLine(meshLine=MeshLine['ML_AIRGAP']);

LineArcPivotPoint[1,6,9].assignMeshLine(meshLine=MeshLine['ML_SHAFT']);

LineArcPivotPoint[2,7].assignMeshLine(meshLine=MeshLine['ML_ROTOR_YOKE']);

LineArcPivotPoint[10,11,12].assignMeshLine(meshLine=MeshLine['ML_ROTOR']);

LineArcPivotPoint[13,14,15].assignMeshLine(meshLine=MeshLine['ML_MAGNET']);

LineArcPivotPoint[16,17].assignMeshLine(meshLine=MeshLine['ML_STATOR']);

LineArcPivotPoint[18].assignMeshLine(meshLine=MeshLine['ML_STATOREX']);

Point[17,18,19,20].assignMeshPoint(meshPoint=MeshPoint['MP_WEDGE']);

Point[21,22,23].assignMeshPoint(meshPoint=MeshPoint['MP_SLOT']);

assignMeshGeneratorToFace(face=[Face[9]], meshGenerator=MeshGenerator['MAPPED']);

def Phisic() :

global les;

ApplicationMagneticDC2D(domain2D=Domain2DPlane(lengthUnit=LengthUnit['MILLIMETER'],

depth=str(les)),

solverFE=SolverFEAutomatic(),

coilCoefficient=CoilCoefficientAutomatic());

# DEFINE MATERIALS

#Material(name='STEEL : nonlinear steel',

propertyBH=PropertyBhNonlinearJmu(initialMur='6400', js='2.2'));

Material(name='STEEL_SP : nonlinear steel', propertyBH=PropertyBhNonlinearSpline

(splinePoints=[ BHPoint(h=0.0, b=0.0),

BHPoint(h=79.58, b=0.64),

BHPoint(h=135.3, b=0.92),

BHPoint(h=159.2, b=1.01),

BHPoint(h=191.0, b=1.1),

BHPoint(h=238.7, b=1.2),

BHPoint(h=318.3, b=1.3),

BHPoint(h=493.4, b=1.4),

BHPoint(h=644.6, b=1.45),

BHPoint(h=875.4, b=1.5),

BHPoint(h=1273.2, b=1.55),

BHPoint(h=1591.5, b=1.58),

BHPoint(h=2148.6, b=1.6),

BHPoint(h=3342.3, b=1.65),

BHPoint(h=4774.6, b=1.7),

BHPoint(h=6525.4, b=1.75),

BHPoint(h=9151.4, b=1.8),


84

BHPoint(h=11936.3, b=1.85),

BHPoint(h=15119.7, b=1.9),

BHPoint(h=18541.6, b=1.95),

BHPoint(h=22281.7, b=2.0),

BHPoint(h=27454.2, b=2.05),

BHPoint(h=35809.9, b=2.1),

BHPoint(h=47746.5, b=2.15),

BHPoint(h=63662.0, b=2.2),

BHPoint(h=93901.4, b=2.25),

BHPoint(h=127324.0, b=2.3)]));

# Magnets from BakkerMagnetics www.bakkermagnetics.com

Material(name='BM_N35 : Sintered NdFeB permanent magnet',

propertyBH=PropertyBhMagnetOneDirection(br='1.2', mur='1.10'));





# Magnets from ArnoldMagnetics www.arnoldmagnetics.com

Material(name='AM_N35 : Sintered NdFeB permanent magnet',






# Magnets from NINGBO www.zhaobao-magnet.com

Material(name='NINGBO_N35_20 : Sintered NdFeB permanent magnet T=20C',












#importMaterial(fileName='C:/Programs/Cedrat/Materials/FLUX_101_MATERI.DAT',

materialNames=['FLU_COPPER :']);

importMaterial(fileName='C:/Cedrat/Materials/FLUX_101_MATERI.DAT',

materialNames=['FLU_COPPER :']);

#--------------------------------------------------------------------------------------

------------------------

# ASSIGN MATERIALS TO THE REGIONS

# For all simulations

RegionFace['SHAFT','ROTOR_AIR','AIRGAP','STATOR_AIR','SLOT_OPENING','SLOT_WEDGE'].magne

ticDC2D=MagneticDC2DFaceVacuum();

RegionFace['STATOR','ROTOR'].magneticDC2D=MagneticDC2DFaceMagnetic(material=Material['S

TEEL_SP']);

#1. No-load simulation (BACK-EMF, Cogging torque)

#RegionFace['PHASE_A','PHASE_B','PHASE_C'].magneticDC2D=MagneticDC2DFaceVacuum();

RegionFace['SLOT_1','SLOT_2','SLOT_3','SLOT_4','SLOT_5','SLOT_6','SLOT_7','SLOT_8','SLO

T_9'].magneticDC2D=MagneticDC2DFaceVacuum();

RegionFace['MAGNET'].magneticDC2D=MagneticDC2DFaceMagnetic(material=Material['NINGBO_N4

0_40']);

orientRegSurfMaterial(region=RegionFace['MAGNET'],coordSys=CoordSys['ROTOR'],orientatio

n='Positive_Radial',center=['0','0'],angle='0');

#orientRegSurfMaterial(region=RegionFace['MAGNET'],coordSys=CoordSys['ROTOR'],orientati

on='Positive_Orthoradial',center=['0','0'],angle='0');


on='Direction',center=['0','0'],angle='0')

#Negative_Radial, Positive_Orthoradial, Negative_Orthoradial

# 2. Inductance calculation for PHASE_A

#RegionFace['PHASE_A'].magneticDC2D=MagneticDC2DFaceFormulaConductor(currentDensity=str

(jmax), material=Material['FLU_COPPER'];

#RegionFace['PHASE_A'].magneticDC2D=MagneticDC2DFaceFormulaConductor(currentDensity='7'

, material=Material['FLU_COPPER']);

#RegionFace['PHASE_B'].magneticDC2D=MagneticDC2DFaceVacuum();

#RegionFace['PHASE_C'].magneticDC2D=MagneticDC2DFaceVacuum();

#RegionFace['MAGNET'].magneticDC2D=MagneticDC2DFaceVacuum();


85

# 3. Electromagnetic torque calculation

#RegionFace['PHASE_A'].magneticDC2D=MagneticDC2DFaceFormulaConductor(currentDensity='5'

, material=Material['FLU_COPPER'];

#RegionFace['PHASE_B'].magneticDC2D=MagneticDC2DFaceFormulaConductor(currentDensity='-

2.5', material=Material['FLU_COPPER'];

#RegionFace['PHASE_C'].magneticDC2D=MagneticDC2DFaceFormulaConductor(currentDensity='-

2.5', material=Material['FLU_COPPER'];

#RegionFace['MAGNET'].magneticDC2D=MagneticDC2DFaceMagnetic(material=Material['MAGNET']

);


on='Positive_Radial',center=['0','0'],angle='0');

#--------------------------------------------------------------------------------------

------------------------

# DEFINE MECHANICAL PROPERTIS

MechanicalSetCompressibleRemeshing(name='AIRGAP : Rotating airgap');

MechanicalSetFixed(name='STATOR');

MechanicalSetRotation1Axis(name='ROTOR : rotating part of the motor',

kinematics=RotatingMultiStatic(),

rotationAxis=RotationZAxis(coordSys=CoordSys['ROTOR'],

pivot=['0','0']));

#

RegionFace['MAGNET','ROTOR','ROTOR_AIR','SHAFT'].mechanicalSet=MechanicalSet['ROTOR'];

RegionFace['STATOR','STATOR_AIR','SLOT_WEDGE','SLOT_OPENING'].mechanicalSet=MechanicalS

et['STATOR'];

RegionFace['SLOT_1','SLOT_2','SLOT_3','SLOT_4','SLOT_5','SLOT_6','SLOT_7','SLOT_8','SLO

T_9'].mechanicalSet=MechanicalSet['STATOR'];

RegionFace['AIRGAP'].mechanicalSet=MechanicalSet['AIRGAP'];

# PERIODICITY

PeriodicityNumberZaxis(physicalType=PeriodicityAnticyclicType(),

repetitionNumber='2*P',

domainOriginAngle='360/2/P');

Parameters();

CoordSystem();

#-------------------------

RotorPoints();

RotorLines();

buildFaces(); # 1 - shaft, 2 - rotor yoke, 3 - rotor air, 4 - magnet, 5 - rotor air

#------------------------

StatorPoints();

StatorLines();

buildFaces(); # 6-stator yoke, 7-slot opennig, 8-slot wedge, 9,10-slot

#-----------------------

Regions();

Transformation();

StatorTrans();

AirGapPoints();

AirGapLines();

buildFaces(); #

AirGapRegions();

#-----------

Meshing();

meshLines()

meshFaces()

#-----------

Phisic()

#saveProjectAs('solar01.FLU')

#closeProject()

#exit()

Download - Modelowanie i analiza przetworników elektromechanicznych z ... · Modelowanie i analiza przetworników elektromechanicznych z wykorzystaniem MES 4 1 Program Flux2D FLUX2D jest programem

Top Related