Cube27Node.m

Go to the documentation of this file.

namespace fem{
namespace geometry{


/* (Autoinserted by mtoc++)
 * This source code has been filtered by the mtoc++ executable,
 * which generates code that can be processed by the doxygen documentation tool.
 *
 * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
 * Except for the comments, the function bodies of your M-file functions are untouched.
 * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
 * attached source files that are highly readable by humans.
 *
 * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
 * the correct locations in the source code browser.
 * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
 */

class Cube27Node
  :public fem.geometry.BaseGeometry {
    public:


        Cube27Node(nodes,elems) {
            if nargin < 2
                 this = fem.geometry.RegularHex27Grid;
                 return;
            elseif size(unique(nodes" , "rows^t),1) ~= size(nodes,2);
                error(" Please provide unique points! ");
            end
            this.Nodes= nodes;
            this.Elements= elems;
            this.DofsPerElement= 27;
            /* EdgeIndices = [1 3 7 9 19 21 25 27]; */

            /* % Compute edges */
            e = int16.empty(0,2);
            for i=1:size(elems,1)
                hlp = elems(i,[1 2 4 5 7 8 2 3 5 6 8 9 1 4 2 5 3 6 4 7 5 8 6 9 ... /*  bottom */

                    1 10 2 11 3 12 10 19 11 20 12 21 10 11 11 12 19 20 20 21 ... /*  front  */

                    12 15 15 18 21 24 24 27 6 15 15 24 9 18 18 27 ... /*  right side */

                    4 13 13 22 7 16 16 25 10 13 13 16 19 22 22 25 ... /*  left side */

                    8 17 17 26 16 17 17 18 25 26 26 27 ... /*  back side */

                    20 23 23 26 22 23 23 24 ... /*  top */

                    ]); /*  inner 5 14 13 14 11 14 14 15 14 17 14 23 */

                e(end+1:end+48,:) = reshape(hlp" ,2,[]) ";
            end
            e = unique(e," rows "," stable ");
            this.Edges= e;

            /* % Set Face indices */
            this.MasterFaces= [1:3:25
                            3:3:27
                            1:3 10:12 19:21
                            7:9 16:18 25:27
                            1:9
                            19:27];
            /*  Face node indices for patch objects */
            this.PatchFacesIdx= [1 4 13 10; 4 7 16 13; 13 16 25 22; 10 13 22 19;
                3 6 15 12; 6 9 18 15; 12 15 24 21; 15 18 27 24;
                1 2 11 10; 2 3 12 11; 10 11 20 19; 11 12 21 20;
                7 8 17 16; 8 9 18 17; 16 17 26 25; 17 18 27 26;
                1 2 5 4; 4 5 8 7; 2 3 6 5; 5 6 9 8;
                19 20 23 22; 20 21 24 23; 22 23 26 25; 23 24 27 26];
            this.PatchesPerFace= 4;
            this.Faces= this.computeFaces;

            this.ReverseAxesIndices= [3 2 1 6 5 4 9 8 7 12 11 10 15 14 13 18 17 16 21 20 19 24 23 22 27 26 25
                                       7:9 4:6 1:3 16:18 13:15 10:12 25:27 22:24 19:21
                                       19:27 10:18 1:9];

            this.OrientationCheckIndices(:,:,1) = [1:3; 4:6; 7:9; 10:12; 13:15; 16:18; 19:21; 22:24; 25:27];
            this.OrientationCheckIndices(:,:,2) = [1 4 7; 2 5 8; 3 6 9; 10 13 16; 11 14 17;12 15 18; 19 22 25; 20 23 26; 21 24 27];
            this.OrientationCheckIndices(:,:,3) = [1 10 19; 2 11 20; 3 12 21; 4 13 22; 5 14 23; 6 15 24; 7 16 25; 8 17 26; 9 18 27];
            this.checkOrientation;
        }


        function cube8 = toCube8Node() {
            elems8 = this.Elements(:,[1 3 7 9 19 21 25 27]);
            usednodes = unique(elems8(:)," stable ");
            invidx(usednodes) = 1:length(usednodes);
            elems8 = invidx(elems8);
            cube8 = fem.geometry.Cube8Node(this.Nodes(:,usednodes),elems8);
        }
        function cube20 = toCube20Node() {
            elems20 = this.Elements(:,[1:4 6:10 12 16 18:22 24:27]);
            usednodes = unique(elems20(:)," stable ");
            invidx(usednodes) = 1:length(usednodes);
            elems20 = invidx(elems20);
            cube20 = fem.geometry.Cube20Node(this.Nodes(:,usednodes),elems20);
        }


        function  swapYZ() {
            n = this.Nodes;
            n([2 3],:) = n([3 2],:);
            this.Nodes= n;
            this.Elements= this.Elements(:,[1:3 10:12 19:21 4:6 13:15 22:24 7:9 16:18 25:27]);
            /*  Update faces indices */
            this.Faces= this.computeFaces;
        }



};
}
}