Welcome to website of Marek Gayer, Ph.D.

Home » Projects » NanoFEM Platform - Documentation Draft » 9. Creating transistor in Salome - NanoFEM Platform - Documentation Draft

NanoFEM Platform - Documentation Draft

Date: February 1, 2008 , Last update April 15, 2009
Author: Marek Gayer
Category: NanoFEM platform , Simulation , Visualization

Content of the article

9. Creating transistor in Salome

9.1. Loading a complete example

To load a complete example, choose, File -> Load script… command from Salome menu, and select /home/user/med/mulmos_49.py. This way, in study will appear geometry and mesh will be automatically generated.

Note: If you have another installation of Salome, you can also download Full source code of the example . You may need to change the paths from /home/user/med/ in the files.

Our transistor is a structure composed from multiple materials. In this section we will step by step describe how to create it from scratch.

9.2. Building rectangular blocks

An optimal strategy to modelling in Salome is to begin with easier parts. Therefore we start with rectangular parts.

Fig. 9.1

Defining control gate vertex coordinates

Fig. 9.2

Creating control gate from vertices

First we select from menu File -> New, then we switch to geometry module. We start building the easiest part of the transistor, which are its rectangular parts. These rectangular parts we can later directly use, or we can use them as parts of building objects for building more complex structures such as compounds.

Because our cuboids are orthogonal^9.1 to its X, Y and Z axis, we can specify them in Salome just by providing two diagonal points.

First we specify two diagonal points of the box we want to create. This corresponds to two points, where one has minimal X, Y, Z cooordinates from whole box and the second has maximum X, Y, Z coordinates. From Salome menu, we choose New Entity -> Basic -> Point. In dialog box which will appear, see Figure 9.1 , we enter the name controlGateVertex1, and as X, Y, Z coordinates, we enter values: 8, -135, 415 and we press Apply button. Then we enter the name controlGateVertex2, and as coordinates we enter: 75, -125, 515 and this time we press OK button. This way, Salome will create the two points and will insert them in Object browser.

Form these points, we create rectangular structure, called box. We select New Entity -> Primitives -> Box. In dialog box which will appear, see Figure 9.2 , we enter the name for the box as Control gate. For the points, we select from the Salome Object browser points controlGateVertex1 and controlGateVertex2 and press OK button.

In same way, we create also the following structures. The coordinates and names of vertexes and names of boxes are as following (we provide them in Python syntax, from which the coordinates and names are obvious). These commands can be placed to Python scripts for using with Dump study/Load script Salome features. In further text we will describe repeated, already explained actions, which have to be again choosen in user interface of Salome by these scripts.

controlGateVertex1 = geompy.MakeVertex(8, -135, 415)
controlGateVertex2 = geompy.MakeVertex(75, -125, 515)
controlGate = geompy.MakeBoxTwoPnt(controlGateVertex1, controlGateVertex2)

sourceVertex1 = geompy.MakeVertex(15, -75, 355)
sourceVertex2 = geompy.MakeVertex(75, -65, 395)
source = geompy.MakeBoxTwoPnt(sourceVertex1, sourceVertex2)

drainVertex1 = geompy.MakeVertex(15, -75, 535)
drainVertex2 = geompy.MakeVertex(75, -65, 575)
drain = geompy.MakeBoxTwoPnt(drainVertex1, drainVertex2)

This way, we now have constructed the controlGate, source and drain parts of the transistor

9.3. Scratching the surface of transistor parts

Fig. 9.3

Scratching the gate

Fig. 9.4

Scratched gate

In cases, that there are parts that are not connected (are not touching themselves only by whole faces, we will need sooner or later to make surface cuts on these objects. These rectangular parts will need to be cut on surface (we call this also as scratched) later, otherwise meshing would fail. Therefore, we append word Box, to reflect that this structure is not yet the final structure, and we will need to cut later either due to need of cutting surface. We create the box with following settings:

gateVertex1 = geompy.MakeVertex(0, -135, 415)
gateVertex2 = geompy.MakeVertex(8, -50, 515)
gateBox = geompy.MakeBoxTwoPnt(gateVertex1, gateVertex2)

From Salome menu we choose Operations -> Boolean -> Cut. We choose as Main Object gateBox and as Tool object we choose controlGate and as name we specify gate, see Figure 9.3 . The result of the operation can be seen on Figure 9.4 . On the surface, where the objects touches is now a new scratch, which fulfill requirements that all neighbouring structures can touch each other only by edges of faces.

Corresponding command in Python:

gate = geompy.MakeCut(gateBox, controlGate)

We create using the boxes approach also bases for structures bottomSource, bottomDrain, bottomOxide, we will make scratches on them later in Chapter 9.7. . Although we could create these structures also later, we recommend to make simpler structures sooner, they can help us to see transistor shape sooner and in this way we can e.g. check if operations we enter are not obviously wrong e.g. to typos in coordinates.

bottomSourceVertex1 = geompy.MakeVertex(15, -65, 355)
bottomSourceVertex2 = geompy.MakeVertex(75, 0, 395)
bottomSourceBox = geompy.MakeBoxTwoPnt(bottomSourceVertex1, bottomSourceVertex2)

bottomDrainVertex1 = geompy.MakeVertex(15, -65, 535)
bottomDrainVertex2 = geompy.MakeVertex(75, 0, 575)
bottomDrainBox = geompy.MakeBoxTwoPnt(bottomDrainVertex1, bottomDrainVertex2)

bottomOxidePoint2 = geompy.MakeVertex(75, 200, 615)
bottomOxidePoint1 = geompy.MakeVertex(0, 0, 315)
bottomOxideBox = geompy.MakeBoxTwoPnt(bottomOxidePoint1, bottomOxidePoint2)

9.4. Making cylindric structures

Fig. 9.5

Control Oxide and Fin cylindrical structures

Now we will make structure, which are not only rectangular. These structures are fin, controlOxide, insulator and tunnelOxide. For shape of controlOxide and fin, see Figure 9.5

It is neccesary to construct block fin from 3 parts. These are two rectangular (finDown, finUp) and one with torus. The cuboid parts are made again the same way - from vertexes and boxes. Note that finDown needed to be scratched, otherwise meshing would fail.

finUpVertex1 = geompy.MakeVertex(65, -60, 415)
finUpVertex2 = geompy.MakeVertex(75, -55, 515)
finUp = geompy.MakeBoxTwoPnt(finUpVertex1, finUpVertex2)
finDownVertex1 = geompy.MakeVertex(60, -55, 415)
finDownVertex2 = geompy.MakeVertex(75, 0, 515)
finDownBox = geompy.MakeBoxTwoPnt(finDownVertex1, finDownVertex2)
finDown = geompy.MakeCut(finDownBox, finUp)

Fig. 9.6

Extracting face

Fig. 9.7

Renaming face

Now we will extract a face needed for making rotation to create the middle part. We display finUp and finDown structures in viewer. From menu, we choose New Entity -> Explode. As a main object we select from Object browser finUp. As the subshapes type, we select face, we check radio button Select subshapes and then we select the appropriate face from finUp structure, see Figure 9.6 .

The face will be extracted as Face_1 and will be insterted in group finUp. We need to rename face to finUpRotationFace. This can be done in object browser. Right click on Face_1 and select Rename and specify the new name, see Figure 9.7

Appropriate Python code for this operation

[finUpRotationFace, geomObj_1, geomObj_2, geomObj_3, geomObj_4, geomObj_5] = geompy.SubShapeAllSorted(finUp, geompy.ShapeType["FACE"])

Fig. 9.8

Creating rotation axis for revolution

Fig. 9.9

Construction by revolution

Now we need to perform revolution operation to rotate the face to form a cylindrical structure. First we need to specify the rotation axis. This is done by specifying two points, rotationAxisVertex1 and rotationAxisVertex2. From these two points, we can form a line, see Figure 9.8 . From menu, we select New Entity -> Generation -> Revolution. We select as Object finUpRotationFace and as Axis rotationAxis and we specify name as finMiddle and as angle 90 degrees, see Figure 9.9

rotationAxisVertex1 = geompy.MakeVertex(65, -55, 515)
rotationAxisVertex2 = geompy.MakeVertex(65, -55, 415)
rotationAxis = geompy.MakeLineTwoPnt(rotationAxisVertex1, rotationAxisVertex2)

finMiddle = geompy.MakeRevolution(finUpRotationFace, rotationAxis, 90*math.pi/180.0)

Finally, we contruct from the structures finUp, finMiddle and finDown final structure fin. We create a compound for this. From menu we select New Entity -> Build -> Compound. Using left mouse button together with control key, we select objects finUp, finMiddle and finDown> and we specify name fin, see Figure 9.10

fin = geompy.MakeCompound([finDown, finUp, finMiddle])

Fig. 9.10

Creating fin compound

Fig. 9.11

Structures fin, tunnelOxide, insulator and controlOxide

With the same method we create also structures tunnelOxide, insulator and controlOxide. We all the time utilize already created rotationAxis. The resulting structures fin, tunnelOxide, insulator and controlOxide are depicted on Figure 9.11 .

tunnelOxideDownVertex1 = geompy.MakeVertex(57, -55, 415)
tunnelOxideDownVertex2 = geompy.MakeVertex(60, 0, 515)
tunnelOxideDown = geompy.MakeBoxTwoPnt(tunnelOxideDownVertex1, tunnelOxideDownVertex2)
tunnelOxideUpVertex1 = geompy.MakeVertex(65, -63, 415)
tunnelOxideUpVertex2 = geompy.MakeVertex(75, -60, 515)
tunnelOxideUp = geompy.MakeBoxTwoPnt(tunnelOxideUpVertex1, tunnelOxideUpVertex2)
[tunnelOxideUpRotationFace,geomObj_6,geomObj_7,geomObj_8,geomObj_9,geomObj_10] = geompy.SubShapeAllSorted(tunnelOxideUp, geompy.ShapeType["FACE"])
tunnelOxideMiddle = geompy.MakeRevolution(tunnelOxideUpRotationFace, rotationAxis, 90*math.pi/180.0)
tunnelOxide = geompy.MakeCompound([tunnelOxideDown, tunnelOxideUp, tunnelOxideMiddle])

insulatorDownVertex1 = geompy.MakeVertex(52, -55, 415)
insulatorDownVertex2 = geompy.MakeVertex(57, 0, 515)
insulatorUpVertex1 = geompy.MakeVertex(65, -68, 415)
insulatorUpVertex2 = geompy.MakeVertex(75, -63, 515)
insulatorDown = geompy.MakeBoxTwoPnt(insulatorDownVertex1, insulatorDownVertex2)
insulatorUp = geompy.MakeBoxTwoPnt(insulatorUpVertex1, insulatorUpVertex2)
[insulatorUpRotationFace,geomObj_11,geomObj_12,geomObj_13,geomObj_14,geomObj_15] = geompy.SubShapeAllSorted(insulatorUp, geompy.ShapeType["FACE"])
insulatorMiddle = geompy.MakeRevolution(insulatorUpRotationFace, rotationAxis, 90*math.pi/180.0)
insulator = geompy.MakeCompound([insulatorDown, insulatorUp, insulatorMiddle])

controlOxideDownVertex1 = geompy.MakeVertex(47, -55, 415)
controlOxideDownVertex2 = geompy.MakeVertex(52, 0, 515)
controlOxideUpVertex1 = geompy.MakeVertex(65, -73, 415)
controlOxideUpVertex2 = geompy.MakeVertex(75, -68, 515)
controlOxideDown = geompy.MakeBoxTwoPnt(controlOxideDownVertex1, controlOxideDownVertex2)
controlOxideUp = geompy.MakeBoxTwoPnt(controlOxideUpVertex1, controlOxideUpVertex2)
[controlOxideUpRotationFace,geomObj_16,geomObj_17,geomObj_18,geomObj_19,geomObj_20] = geompy.SubShapeAllSorted(controlOxideUp, geompy.ShapeType["FACE"])
controlOxideMiddle = geompy.MakeRevolution(controlOxideUpRotationFace, rotationAxis, 90*math.pi/180.0)
controlOxide = geompy.MakeCompound([controlOxideDown, controlOxideUp, controlOxideMiddle])

9.5. Forming poly by cutting mass from polyBox

Fig. 9.12

Cutting Poly

Fig. 9.13

Result of cutting poly

When creating poly structure, we first create a box and cut mass which does not belong to it.

polyVertex1 = geompy.MakeVertex(0, -125, 415)
polyVertex2 = geompy.MakeVertex(75, 0, 515)
polyBox = geompy.MakeBoxTwoPnt(polyVertex1, polyVertex2)

We created polyBox, but we have to cut the mass which belong to controlOxide, insulator, tunnelOxide and fin, as well as space which belong to gate.

Cutting poly is slightly more difficult. We first have to form a compound named polyCutToolObject based on all structures, that we want to cut. This compound we then use to make cut on polyBox, see Figure 9.12 . The result is depicted in shading mode. Shading mode can be turned on by right clicking in the scene displaying the visualized object and choosing Shading mode instead of Wireframe. Final results can be seen on Figure 9.13 .

polyCutToolObject = geompy.MakeCompound([fin, tunnelOxide, insulator, controlOxide, gate])
poly = geompy.MakeCut(polyBox, polyCutToolObject)

9.6. Connecting fin with bottomSource and bottomGate

Fig. 9.14

Extracting faces from fin compound

We perform extrusion operations to quickly create the two remaining structures, which connect fin with bottomSource and bottomDrain. We extract faces from which would 2 create 2 shells (shell can be a collection faces). We again use Explode operation from menu, and we select the 6 faces as you can see on Figure 9.14 . This time you will need to select more then 1 face, you have to use Shift key together with left mouse button to select more then one face. Selected faces will be highlighted with white color. After pressing OK button 6 faces will be extracted and insterted into the Object browser. They will be named Face_1, Face_2, Face_3, Face_4, Face_5 and Face_6

[geomObj_21, geomObj_22, geomObj_23, Face_1, geomObj_24, Face_2, geomObj_25, geomObj_26, Face_3, Face_4, geomObj_27, geomObj_28, Face_5, Face_6, geomObj_29, geomObj_30, geomObj_31] = geompy.SubShapeAllSorted(fin, geompy.ShapeType["FACE"])

Fig. 9.15

Source Extension Shell

Fig. 9.16

Extruding source extension

Now we need to make a shell for these faces. This is done by New Entity -> Build -> Shell. We choose the 3 objects, Face_1, Face_3, Face_5 (this time again with help of Ctrl key), see Figure 9.15 . Now we will make an extrusion from this Shell, which will form a new structure for sourceExtension. From menu we choose: New Entity -> Generation -> Extrusion. As source we choose sourceExtensionShell as vector we again choose rotationAxis. We specify 20 as height and we should receive extrusion as is in Figure 9.16 .

The corresponding Python commands are as follows:

sourceExtensionShell = geompy.MakeShell([Face_1, Face_3, Face_5])
sourceExtension = geompy.MakePrismVecH(sourceExtensionShell, rotationAxis, 20)

In the same way, we create also drainExtension:

drainExtensionShell = geompy.MakeShell([Face_2, Face_4, Face_6]) drainExtension = geompy.MakePrismVecH(drainExtensionShell, rotationAxis, -20)

9.7. Creating scratches on remaining structures

Fig. 9.17

Result of scratching of source

Fig. 9.18

Result of scratching bottom oxide block

We create scratches on remaining structures of our transistor, which were created in Chapter 9.3. . For bottomSource we use botttomSourceBox cut using sourceExtension, see Figure 9.17 . For bottomDrain we use bottomDrainBox cut using drainExtension

bottomSource = geompy.MakeCut(bottomSourceBox, sourceExtension)
bottomDrain = geompy.MakeCut(bottomDrainBox, drainExtension)

For scratching the bootomOxideBox, it is neccesary to make a compound from all the structures that touches it. We have to make compound bottomOxideCutToolObject from bottomSource, bottomDrain, poly, fin, tunnelOxide, insulator, controlOxide, sourceExtension, drainExtension and then to use it as tool object for getting the bottomOxide, see result in Figure 9.18 .

bottomOxideCutToolObject = geompy.MakeCompound([bottomSource, bottomDrain, poly, fin, tunnelOxide, insulator, controlOxide, sourceExtension, drainExtension])
bottomOxide = geompy.MakeCut(bottomOxideBox, bottomOxideCutToolObject)

9.8. Composing mosfet from previous created structure

Fig. 9.19

Mosfet compound

Fig. 9.20

Mosfet compound (with shading visualization)

We create compound mosfet from the following 14 previously created blocks: bottomOxide, controlGate, source, drain, fin, sourceExtension, drainExtension, poly, tunnelOxide, insulator, controlOxide, bottomSource, bottomDrain, gate. The result is depicted on Figure 9.19 .

To be possible to create mesh from this structure, we now have to use operation from menu: Repair -> Glue faces, see Figure 9.20 . We choose as the name mosfetGlued, as base object we select mosfet from Object browser, and we confirm the selection by OK button and all neccessary faces should be glued in the newly created structure mosfetGlued, see the result in shading mode and on different side Figure 9.21 .

Fig. 9.21

Gluing faces on mosfet compound

Fig. 9.22

Detection of faces that can be glued

In some particular cases, it might be possible to select faces which will be glued. This can be done by choosing manual selecting of face to glue, pressing detect button and then deselecting unnecessary faces, see Figure 9.22 .

mosfet = geompy.MakeCompound([bottomOxide, controlGate, source, drain, fin, sourceExtension, drainExtension, poly, tunnelOxide, insulator, controlOxide, bottomSource, bottomDrain, gate])
mosfetGlued = geompy.MakeGlueFaces(mosfet, 1e-07)

9.9. Creating groups on geometry

Fig. 9.23

Creating bottomOxideGroup

Fig. 9.24

Creating group on geometry (controlOxide structure)

Now we create geometry groups corresponding to 14 previous created parts. For this we select New Entity -> Group ->Create, we select Volume group radio button, we name group bottomOxideGroup, we select mosfetGlued from object browser and we choose button Select subshapes and we select bottom part and then we press Add button. The number of the part should appear (e.g. 2 as in our case), see Figure 9.23 . After OK or Apply button the group will be created.

bottomOxideGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(bottomOxideGroup, 2)
mosfetGlued = geompy.GetMainShape(bottomOxideGroup)

This way, we can create all the 14 geometry groups. To create groups from fin, controlOxide, tunnelOxide and insulator needs little more effort, because we need to select more then one part, see Figure 9.24 . More then one parts can be selected either by repeatedly selecting a desired part, and then pressing Add button, or using Shift key to select all parts and then press Add button.

Fig. 9.25

Creating finGroup might be slightly tricky

Fig. 9.26

All groups are created on mosfetGlued

Other complications may appear when creating group from fin. Selecting parts that are covered by another parts may require to select using mouse rectangular selection containing also the surrounding of desired parts (which are hiding our desired part), and then using Remove button to remove the undesired. Anyway, with some effort also the fin part can be groupped, see Figure 9.25 . In the end, in the Object browser you will have all the groups, see Figure 9.26 .

sourceGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(sourceGroup, 144)
mosfetGlued = geompy.GetMainShape(sourceGroup)

bottomSourceGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(bottomSourceGroup, 550)
mosfetGlued = geompy.GetMainShape(bottomSourceGroup)

bottomDrainGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(bottomDrainGroup, 564)
mosfetGlued = geompy.GetMainShape(bottomDrainGroup)

drainGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(drainGroup, 178)
mosfetGlued = geompy.GetMainShape(drainGroup)

gateGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(gateGroup, 578)
mosfetGlued = geompy.GetMainShape(gateGroup)

controlGateGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(controlGateGroup, 110)
mosfetGlued = geompy.GetMainShape(controlGateGroup)

polyGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(polyGroup, 369)
mosfetGlued = geompy.GetMainShape(polyGroup)

sourceExtensionGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(sourceExtensionGroup, 313)
mosfetGlued = geompy.GetMainShape(sourceExtensionGroup)

drainExtensionGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(drainExtensionGroup, 359)
mosfetGlued = geompy.GetMainShape(drainExtensionGroup)

finGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(finGroup, 212)
geompy.AddObject(finGroup, 267)
geompy.AddObject(finGroup, 243)
mosfetGlued = geompy.GetMainShape(finGroup)

controlOxideGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(controlOxideGroup, 520)
geompy.AddObject(controlOxideGroup, 530)
geompy.AddObject(controlOxideGroup, 544)
mosfetGlued = geompy.GetMainShape(controlOxideGroup)

insulatorGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(insulatorGroup, 469)
geompy.AddObject(insulatorGroup, 486)
geompy.AddObject(insulatorGroup, 510)
mosfetGlued = geompy.GetMainShape(insulatorGroup)

tunnelOxideGroup = geompy.CreateGroup(mosfetGlued, geompy.ShapeType["SOLID"])
geompy.AddObject(tunnelOxideGroup, 418)
geompy.AddObject(tunnelOxideGroup, 435)
geompy.AddObject(tunnelOxideGroup, 459)
mosfetGlued = geompy.GetMainShape(tunnelOxideGroup)

9.10. Adding objects to study

When you work with Salome GUI, the objects that are created using Salome operations are automatically added to Object Browser. However, if we manually define Salome objects in Python it is neccesary to add desired objects to study, by using addToStudy method. The following code is generated in addition to above described code when using Dump study command, when applying all the instructions contained in this chapter:

geompy.addToStudy( controlGateVertex1, "controlGateVertex1" )
geompy.addToStudy( controlGateVertex2, "controlGateVertex2" )
geompy.addToStudy( controlGate, "controlGate" )
geompy.addToStudy( sourceVertex1, "sourceVertex1" )
geompy.addToStudy( sourceVertex2, "sourceVertex2" )
geompy.addToStudy( source, "source" )
geompy.addToStudy( drainVertex1, "drainVertex1" )
geompy.addToStudy( drainVertex2, "drainVertex2" )
geompy.addToStudy( drain, "drain" )
geompy.addToStudy( gateVertex1, "gateVertex1" )
geompy.addToStudy( gateVertex2, "gateVertex2" )
geompy.addToStudy( gateBox, "gateBox" )
geompy.addToStudy( gate, "gate" )
geompy.addToStudy( bottomSourceVertex1, "bottomSourceVertex1" )
geompy.addToStudy( bottomSourceVertex2, "bottomSourceVertex2" )
geompy.addToStudy( bottomSourceBox, "bottomSourceBox" )
geompy.addToStudy( bottomDrainVertex1, "bottomDrainVertex1" )
geompy.addToStudy( bottomDrainVertex2, "bottomDrainVertex2" )
geompy.addToStudy( bottomDrainBox, "bottomDrainBox" )
geompy.addToStudy( bottomOxidePoint2, "bottomOxidePoint2" )
geompy.addToStudy( bottomOxidePoint1, "bottomOxidePoint1" )
geompy.addToStudy( bottomOxideBox, "bottomOxideBox" )
geompy.addToStudy( finUpVertex1, "finUpVertex1" )
geompy.addToStudy( finUpVertex2, "finUpVertex2" )
geompy.addToStudy( finUp, "finUp" )
geompy.addToStudyInFather( finUp, finUpRotationFace, "finUpRotationFace" )
geompy.addToStudy( finDownVertex1, "finDownVertex1" )
geompy.addToStudy( finDownVertex2, "finDownVertex2" )
geompy.addToStudy( finDownBox, "finDownBox" )
geompy.addToStudy( finDown, "finDown" )
geompy.addToStudy( rotationAxisVertex1, "rotationAxisVertex1" )
geompy.addToStudy( rotationAxisVertex2, "rotationAxisVertex2" )
geompy.addToStudy( rotationAxis, "rotationAxis" )
geompy.addToStudy( finMiddle, "finMiddle" )
geompy.addToStudy( fin, "fin" )
geompy.addToStudyInFather( fin, Face_1, "Face_1" )
geompy.addToStudyInFather( fin, Face_2, "Face_2" )
geompy.addToStudyInFather( fin, Face_3, "Face_3" )
geompy.addToStudyInFather( fin, Face_4, "Face_4" )
geompy.addToStudyInFather( fin, Face_5, "Face_5" )
geompy.addToStudyInFather( fin, Face_6, "Face_6" )
geompy.addToStudy( tunnelOxideDownVertex1, "tunnelOxideDownVertex1" )
geompy.addToStudy( tunnelOxideDownVertex2, "tunnelOxideDownVertex2" )
geompy.addToStudy( tunnelOxideDown, "tunnelOxideDown" )
geompy.addToStudy( tunnelOxideUpVertex1, "tunnelOxideUpVertex1" )
geompy.addToStudy( tunnelOxideUpVertex2, "tunnelOxideUpVertex2" )
geompy.addToStudy( tunnelOxideUp, "tunnelOxideUp" )
geompy.addToStudyInFather( tunnelOxideUp, tunnelOxideUpRotationFace, "tunnelOxideUpRotationFace" )
geompy.addToStudy( tunnelOxideMiddle, "tunnelOxideMiddle" )
geompy.addToStudy( tunnelOxide, "tunnelOxide" )
geompy.addToStudy( insulatorDownVertex1, "insulatorDownVertex1" )
geompy.addToStudy( insulatorDownVertex2, "insulatorDownVertex2" )
geompy.addToStudy( insulatorUpVertex1, "insulatorUpVertex1" )
geompy.addToStudy( insulatorUpVertex2, "insulatorUpVertex2" )
geompy.addToStudy( insulatorDown, "insulatorDown" )
geompy.addToStudy( insulatorUp, "insulatorUp" )
geompy.addToStudyInFather( insulatorUp, insulatorUpRotationFace, "insulatorUpRotationFace" )
geompy.addToStudy( insulatorMiddle, "insulatorMiddle" )
geompy.addToStudy( insulator, "insulator" )
geompy.addToStudy( controlOxideDownVertex1, "controlOxideDownVertex1" )
geompy.addToStudy( controlOxideDownVertex2, "controlOxideDownVertex2" )
geompy.addToStudy( controlOxideUpVertex1, "controlOxideUpVertex1" )
geompy.addToStudy( controlOxideUpVertex2, "controlOxideUpVertex2" )
geompy.addToStudy( controlOxideDown, "controlOxideDown" )
geompy.addToStudy( controlOxideUp, "controlOxideUp" )
geompy.addToStudyInFather( controlOxideUp, controlOxideUpRotationFace, "controlOxideUpRotationFace" )
geompy.addToStudy( controlOxideMiddle, "controlOxideMiddle" )
geompy.addToStudy( controlOxide, "controlOxide" )
geompy.addToStudy( polyVertex1, "polyVertex1" )
geompy.addToStudy( polyVertex2, "polyVertex2" )
geompy.addToStudy( polyBox, "polyBox" )
geompy.addToStudy( polyCutToolObject, "polyCutToolObject" )
geompy.addToStudy( poly, "poly" )
geompy.addToStudy( sourceExtensionShell, "sourceExtensionShell" )
geompy.addToStudy( sourceExtension, "sourceExtension" )
geompy.addToStudy( drainExtensionShell, "drainExtensionShell" )
geompy.addToStudy( drainExtension, "drainExtension" )
geompy.addToStudy( bottomSource, "bottomSource" )
geompy.addToStudy( bottomDrain, "bottomDrain" )
geompy.addToStudy( bottomOxideCutToolObject, "bottomOxideCutToolObject" )
geompy.addToStudy( bottomOxide, "bottomOxide" )
geompy.addToStudy( mosfet, "mosfet" )
geompy.addToStudy( mosfetGlued, "mosfetGlued" )
geompy.addToStudyInFather( mosfetGlued, bottomOxideGroup, "bottomOxideGroup" )
geompy.addToStudyInFather( mosfetGlued, sourceGroup, "sourceGroup" )
geompy.addToStudyInFather( mosfetGlued, bottomSourceGroup, "bottomSourceGroup" )
geompy.addToStudyInFather( mosfetGlued, bottomDrainGroup, "bottomDrainGroup" )
geompy.addToStudyInFather( mosfetGlued, drainGroup, "drainGroup" )
geompy.addToStudyInFather( mosfetGlued, gateGroup, "gateGroup" )
geompy.addToStudyInFather( mosfetGlued, controlGateGroup, "controlGateGroup" )
geompy.addToStudyInFather( mosfetGlued, polyGroup, "polyGroup" )
geompy.addToStudyInFather( mosfetGlued, sourceExtensionGroup, "sourceExtensionGroup" )
geompy.addToStudyInFather( mosfetGlued, drainExtensionGroup, "drainExtensionGroup" )
geompy.addToStudyInFather( mosfetGlued, finGroup, "finGroup" )
geompy.addToStudyInFather( mosfetGlued, controlOxideGroup, "controlOxideGroup" )
geompy.addToStudyInFather( mosfetGlued, insulatorGroup, "insulatorGroup" )
geompy.addToStudyInFather( mosfetGlued, tunnelOxideGroup, "tunnelOxideGroup" )

9.11. Additional code generated using Salome Dump study command

When you will see a file, generated using Dump study command, you may notice additional code that is placed in the beginning of file with _GEOM suffix (e.g. mulmos49_GEOM.py). These lines have following meaning:

import statements are neccesary to import to global namespace geompy and math module
def statement defines function which is called by main script, e.g. mulmos49.py
global statements imports all the specified indentifiers to global namespace, so they can be used by Salome

import geompy
import math

def RebuildData(theStudy):
geompy.init_geom(theStudy)
global insulator, insulatorDown, bottomSourceGroup, bottomOxideBox, controlOxideDownVertex1, insulatorDownVertex2, finUpVertex1, drainGroup, controlOxideUp, drainVertex1, bottomDrainVertex2, drainExtensionGroup, insulatorUpVertex1, bottomOxidePoint2, controlOxideMiddle, rotationAxis, bottomDrainBox, controlGateGroup, bottomOxidePoint1, finUpRotationFace, controlOxideUpVertex2, finMiddle, bottomSource, finDownVertex1, sourceExtensionGroup, sourceVertex1, controlOxideDown, rotationAxisVertex1, bottomDrain, insulatorUpRotationFace, finDownVertex2, rotationAxisVertex2, finUpVertex2, Face_2, tunnelOxideDownVertex2, sourceVertex2, finUp, controlOxideGroup, Face_4, tunnelOxideDown, gateBox, fin, gate, Face_6, insulatorUp, sourceGroup, tunnelOxideDownVertex1, finGroup, controlGateVertex2, polyCutToolObject, gateVertex1, insulatorMiddle, bottomDrainGroup, poly, gateVertex2, controlOxide, bottomSourceBox, polyVertex2, controlGate, gateGroup, tunnelOxideGroup, mosfet, polyVertex1, polyBox, bottomDrainVertex1, tunnelOxideUpRotationFace, mosfetGlued, polyGroup, drainExtensionShell, bottomSourceVertex1, drainVertex2, finDownBox, bottomOxideCutToolObject, bottomSourceVertex2, insulatorGroup, drainExtension, tunnelOxide, finDown, bottomOxide, Face_1, sourceExtensionShell, insulatorDownVertex1, drain, tunnelOxideUpVertex1, sourceExtension, Face_3, tunnelOxideUp, controlGateVertex1, controlOxideUpRotationFace, controlOxideDownVertex2, tunnelOxideUpVertex2, tunnelOxideMiddle, Face_5, controlOxideUpVertex1, bottomOxideGroup, insulatorUpVertex2, source

^9.1 http://en.wikipedia.org/wiki/Orthogonality

Previous : 8. Geometry modelling in Salome

Next : 10. Meshing transistor in Salome, Computation and Postprocessing