split_triangle.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics 
//
//  License:         BSD License 
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//                   Riccardo Rossi
//                   Nelson Lafontaine
//                    
//
 
#if !defined(KRATOS_SPLIT_TRIANGLE)
#define  KRATOS_SPLIT_TRIANGLE
 
namespace Kratos {
class TriangleSplit {
public:
    static void TriangleSplitMode(const int aux_ids[6], int edge_ids[3]) {
        /*edge 01*/
        if (aux_ids[3] < 0)
            if (aux_ids[0] > aux_ids[1]) edge_ids[0] = 0;
            else edge_ids[0] = 1;
        else
            edge_ids[0] = 3;
 
        /*edge 12*/
        if (aux_ids[4] < 0)
            if (aux_ids[1] > aux_ids[2]) edge_ids[1] = 1;
            else edge_ids[1] = 2;
        else
            edge_ids[1] = 4;
 
        /*edge 20*/
        if (aux_ids[5] < 0)
            if (aux_ids[2] > aux_ids[0]) edge_ids[2] = 2;
            else edge_ids[2] = 0;
        else
            edge_ids[2] = 5;
    }
 
    inline static void TriangleGetNewConnectivityGID(const int triangle_index,
            const int t[12],
            const int aux_ids[6],
            int* id0, int* id1, int* id2) {
        unsigned int base = triangle_index * 3;
        *id0 = aux_ids[t[base]];
        *id1 = aux_ids[t[base + 1]];
        *id2 = aux_ids[t[base + 2]];
    }
 
 
 
    static int Split_Triangle(const int  edges[3], int t[12], int* nel, int* splitted_edges, int* nint) {
        *splitted_edges = 0;
        int topology[3];
        topology[0] = 0;
        topology[1] = 0;
        topology[2] = 0;
        for (unsigned int i = 0; i < 3; i++) {
            if (edges[i] > 2) {
                topology[i] = 1;
                *splitted_edges = *splitted_edges + 1;
            }
        }
 
        if (*splitted_edges == 0 && *nint == 0) {
            /*no splitting needed*/
            *nel = 1;
            t[0] = 0;
            t[1] = 1;
            t[2] = 2;
            return 0;
        }
    /*WARNING = case new central node needed*/
        else if (*splitted_edges == 0 && *nint == 1) {
            *nel = 3;
 
            t[0] = 3;
            t[1] = 0;
            t[2] = 1;
 
            t[3] = 3;
            t[4] = 1;
            t[5] = 2;
 
            t[5] = 3;
            t[5] = 2;
            t[5] = 0;
            return 1;
        }
 
        else if (*splitted_edges == 1) {
            *nel = 2;
            /* caso 1*/
            if (topology[0] == 1) {
                t[0] = 3;
                t[1] = 2;
                t[2] = 0;
 
                t[3] = 3;
                t[4] = 1;
                t[5] = 2;
            }
 
                /* caso 2*/
            else if (topology[1] == 1) {
                t[0] = 4;
                t[1] = 0;
                t[2] = 1;
 
                t[3] = 4;
                t[4] = 2;
                t[5] = 0;
            }
                /* caso 3*/
            else if (topology[2] == 1) {
                t[0] = 5;
                t[1] = 1;
                t[2] = 2;
 
                t[3] = 5;
                t[4] = 0;
                t[5] = 1;
            }
 
            return 1;
 
        }
 
        else if (*splitted_edges == 2) {
            *nel = 3;
            /* caso 4*/
            if (topology[0] == 1 && topology[1] == 1) {
                if (edges[2] == 0) // si colapso al nodo 0 local
                {
                    t[0] = 4;
                    t[1] = 3;
                    t[2] = 1;
 
                    t[3] = 4;
                    t[4] = 0;
                    t[5] = 3;
 
                    t[6] = 4;
                    t[7] = 2;
                    t[8] = 0;
                }
                else if (edges[2] == 2) // si colapso al nodo 2 local
                {
                    t[0] = 4;
                    t[1] = 3;
                    t[2] = 1;
 
                    t[3] = 4;
                    t[4] = 2;
                    t[5] = 3;
 
                    t[6] = 3;
                    t[7] = 2;
                    t[8] = 0;
                }
 
            }
                /* caso 5*/
            else if (topology[1] == 1 && topology[2] == 1) {
                if (edges[0] == 0) // si colapso al nodo 0 local
                {
                    t[0] = 5;
                    t[1] = 4;
                    t[2] = 2;
 
                    t[3] = 5;
                    t[4] = 0;
                    t[5] = 4;
 
                    t[6] = 4;
                    t[7] = 0;
                    t[8] = 1;
                }
                else if (edges[0] == 1) 
                {
                    t[0] = 5;
                    t[1] = 4;
                    t[2] = 2;
 
                    t[3] = 5;
                    t[4] = 1;
                    t[5] = 4;
 
                    t[6] = 5;
                    t[7] = 0;
                    t[8] = 1;
                }
            }
 
 
                /* caso 3*/
            else if (topology[0] == 1 && topology[2] == 1) {
                if (edges[1] == 1) 
                {
                    t[0] = 5;
                    t[1] = 0;
                    t[2] = 3;
 
                    t[3] = 5;
                    t[4] = 3;
                    t[5] = 1;
 
                    t[6] = 5;
                    t[7] = 1;
                    t[8] = 2;
                }
                else if (edges[1] == 2) 
                {
                    t[0] = 5;
                    t[1] = 0;
                    t[2] = 3;
 
                    t[3] = 5;
                    t[4] = 3;
                    t[5] = 2;
 
                    t[6] = 3;
                    t[7] = 1;
                    t[8] = 2;
                }
 
            }
 
            return 1;
        }
        else if (*splitted_edges == 3) {
            *nel = 4;
            t[0] = 5;
            t[1] = 0;
            t[2] = 3;
 
            t[3] = 5;
            t[4] = 3;
            t[5] = 4;
 
            t[6] = 4;
            t[7] = 3;
            t[8] = 1;
 
            t[9] = 5;
            t[10] = 4;
            t[11] = 2;
 
            return 1;
        } else {
            return 0;
        }
 
    }
}; //class TriangleSplit
} //Namespace Kratos
 
#endif /* KRATOS_SPLIT_TRIANGLE  defined */