Python Script Tutorial: ModelPart and SubModelPart

In the previous part of the tutorial, we already saw how the ModelPart is the object containing Element, Conditions, Nodes and Properties.

A fundamental feature is that it can also hierarchically contain "SubModelParts" intended as other ModelParts which belong to the same parent. This relation can be repeated recursively, so that each "root" ModelPart can actually own a tree of SubModelParts.

A quite extensive testing can be found here

However let's try to make an example to explain this better.

        #create a ModelPart root
        current_model = Model()
        model_part = current_model.CreateModelPart("Main")

        #now create a SubModelPart
        model_part.CreateSubModelPart("Inlets")

        #let's output what is there:
        print(model_part)

the output is:

    -Main- model part
        Buffer Size : 1
        Number of tables : 0
        Number of sub model parts : 1
        Current solution step index : 0

        Mesh 0 : 
            Number of Nodes      : 0
            Number of Properties : 0
            Number of Elements   : 0
            Number of Conditions : 0

        -Inlets- model part
            Number of tables : 0
            Number of sub model parts : 0

            Mesh 0 : 
                Number of Nodes      : 0
                Number of Properties : 0
                Number of Elements   : 0
                Number of Conditions : 0

We could now verify if a given submodelpart exists, or how many SubModelParts exist as

        model_part.HasSubModelPart("Inlets") #returns True
        model_part.NumberOfSubModelParts() #returns 1
        model_part.GetSubModelPart("Inlets").Name #returns the name --> Inlets

Let's now create some other SubModelParts

        #on the first level
        model_part.CreateSubModelPart("Temp")
        model_part.CreateSubModelPart("Outlet")

        #on the second level --> "sub-sub modelparts"
        sub_model_part_1 = model_part.GetSubModelPart("Inlets")
        sub_model_part_1.CreateSubModelPart("Inlet1")
        sub_model_part_1.CreateSubModelPart("Inlet2")

        #output
        print(model_part)

to give

    -Main- model part
        Buffer Size : 1
        Number of tables : 0
        Number of sub model parts : 3
        Current solution step index : 0

        Mesh 0 : 
            Number of Nodes      : 0
            Number of Properties : 0
            Number of Elements   : 0
            Number of Conditions : 0

        -Outlet- model part
            Number of tables : 0
            Number of sub model parts : 0

            Mesh 0 : 
                Number of Nodes      : 0
                Number of Properties : 0
                Number of Elements   : 0
                Number of Conditions : 0
        -Temp- model part
            Number of tables : 0
            Number of sub model parts : 0

            Mesh 0 : 
                Number of Nodes      : 0
                Number of Properties : 0
                Number of Elements   : 0
                Number of Conditions : 0
        -Inlets- model part
            Number of tables : 0
            Number of sub model parts : 2

            Mesh 0 : 
                Number of Nodes      : 0
                Number of Properties : 0
                Number of Elements   : 0
                Number of Conditions : 0
            -Inlet2- model part
                Number of tables : 0
                Number of sub model parts : 0

                Mesh 0 : 
                    Number of Nodes      : 0
                    Number of Properties : 0
                    Number of Elements   : 0
                    Number of Conditions : 0
            -Inlet1- model part
                Number of tables : 0
                Number of sub model parts : 0

                Mesh 0 : 
                    Number of Nodes      : 0
                    Number of Properties : 0
                    Number of Elements   : 0
                    Number of Conditions : 0

Each ModelPart is only directly aware of its first level siblings. that is

        model_part.HasSubModelPart("Inlet1") #--> returns False

However

        model_part.GetSubModelPart("Inlets").HasSubModelPart("Inlet1") #--> returns True

Eventually we can loop on all the SubModelParts of a given submodelpart by doing

        for part in model_part.SubModelParts:
            print(part.Name)

Which would output

        Outlet
        Inlets
        Temp

Data Ownership

The parent-son relation is such that anything that belongs to a given SubModelPart also belongs to the parent ModelPart.

This implies that the ultimate "owner" of any Node, Element, etc, will be the "root" ModelPart. The consistency of the tree is ensured by the ModelPart API, which provides the tools needed for creating or removing anything any of the contained objects.

As usually let's try to explain this by examples. We can create a node by doing

     model_part.CreateNewNode(1, 1.00,0.00,0.00)

If we Try to create a new node with the same Id and different coordinates we would get an error

    #model_part.CreateNewNode(1, 0.00,0.00,0.00)  #here an error is thrown

However if we try to create a node with the same coordinates twice nothing is actually done (and no error is thrown)

    model_part.CreateNewNode(1, 1.00,0.00,0.00) 
    print(model_part.NumberOfNodes()) #this still returns 1!!

We can now access the node as needed, for example

    model_part.GetNode(1).Id #gives 1
    model_part.GetNode(1,0).X #gives 1.0

Nodes can be created in every order

    model_part.CreateNewNode(2000, 2.00,0.00,0.00)
    model_part.CreateNewNode(2, 2.00,0.00,0.00)

We could then loop over all the nodes

    for node in model_part.Nodes:
         print(node.Id, node.X, node.Y, node.Z)

Or eventually remove nodes one by one by doing

    model_part.RemoveNode(2000)

Let's now see what happens if we add a node to a submodelpart. here the node will be both in root ModelPart and in Inlets, but for example not in "Temp" or "Outlet"

    inlets_model_part = model_part.GetSubModelPart("Inlets")
    inlets_model_part.CreateNewNode(3, 3.00,0.00,0.00)

If we add to a sub-sub modelpart, it will belong to the root and the parent, but for example not to Inlet1

    inlet2_model_part = inlets_model_part.GetSubModelPart("Inlet2")
    inlet2_model_part.CreateNewNode(4, 4.00,0.00,0.00)

Multiple nodes can be removed at once (and from all levels) by flagging them

    for node in model_part.Nodes:
        if(node.Id < 3):
             node.Set(TO_ERASE,True)   
    model_part.RemoveNodesFromAllLevels(TO_ERASE)

One could call simply the function RemoveNodes and remove them from the current level down.

Creating Elements and Conditions

Elements and Conditions can be created from the python interface by providing their connectivity as well as the Properties to be employed in the creation. The string to be provided is the name by which the element is registered in *Kratos.

        model_part.AddProperties(Properties(1))
        model_part.CreateNewElement("Element2D3N", 1, [1,2,3], model_part.GetProperties()[1])

an error is thrown if i try to create an element with the same Id

        #model_part.CreateNewElement("Element2D3N", 1, [1,2,3], model_part.GetProperties()[1])

An identical interface is provided for Conditions, as well as functions equivalent to the nodes for removing from one level or from all the levels.