Commit 75f9ebcb authored by Tomáš Jakubec's avatar Tomáš Jakubec
Browse files

The volume calculation is done. The structure for indexing data of 

different types to mesh elements is also done.
parent 2948fec7

Unstructured_mesh/Unstructured_mesh.pro.user

+1 −1
Original line number Diff line number Diff line 
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE QtCreatorProject>

<!-- Written by QtCreator 4.10.0, 2019-09-19T11:18:12. -->

<!-- Written by QtCreator 4.10.0, 2019-09-19T22:58:18. -->

<qtcreator>

 <data>

  <variable>EnvironmentId</variable>

Unstructured_mesh/main.cpp

+220 −35
Original line number Diff line number Diff line
@@ -164,38 +164,95 @@ void twoPrisms(UnstructuredMesh<3, size_t, double, 6>& mesh3){ 
    DBGCHECK;

}



template <typename Type, Type startIndex, Type EndIndex, int increment = 1, Type... t>

struct MakeCustomIntegerSequence : public MakeCustomIntegerSequence<Type, startIndex + increment, EndIndex, increment, t..., startIndex> {

};

template <typename Type, Type EndIndex, int increment, Type... t>

struct MakeCustomIntegerSequence<Type, EndIndex, EndIndex, increment, t...> {

    using type = std::integer_sequence<Type, t..., EndIndex>;

};



template<typename Type, Type startIndex, Type EndIndex, int increment = 1>

using make_custom_integer_sequence = typename MakeCustomIntegerSequence<Type, startIndex, EndIndex, increment>::type;





template <unsigned int Dimension,typename IndexType, typename Real, unsigned int ...Reserve, unsigned int ... Dimensions>

MeshDataContainer<Vertex<Dimension, double>, Dimensions...>

___ComputeCenters(MeshElements<Dimension, IndexType, Real, Reserve...>& mesh, std::integer_sequence<unsigned int, Dimensions...>){



    MeshDataContainer<Vertex<Dimension, double>, Dimensions...> centers(mesh);



    _ComputeCenters<1, Dimension, Dimensions...>::compute(centers, mesh);



    return centers;

}

void twoDeformedPrisms(UnstructuredMesh<3, size_t, double, 6>& mesh3){

    DBGCHECK;

        mesh3.GetVertices().push_back({0, {0,0,1}});

        mesh3.GetVertices().push_back({1, {1,0,0}});

        mesh3.GetVertices().push_back({2, {0,1,0}});

        mesh3.GetVertices().push_back({3, {1,1,0}});

        mesh3.GetVertices().push_back({4, {0,0,2}});

        mesh3.GetVertices().push_back({5, {1,0,1}});

        mesh3.GetVertices().push_back({6, {0,1,1}});

        mesh3.GetVertices().push_back({7, {1,1,2}});

    DBGCHECK;

        mesh3.GetEdges().push_back({0,0,1});

        mesh3.GetEdges().push_back({1,0,2});

        mesh3.GetEdges().push_back({2,1,3});

        mesh3.GetEdges().push_back({3,2,3});

        mesh3.GetEdges().push_back({4,0,4});

        mesh3.GetEdges().push_back({5,1,5});

        mesh3.GetEdges().push_back({6,3,7});

        mesh3.GetEdges().push_back({7,2,6});

        mesh3.GetEdges().push_back({8,4,5});

        mesh3.GetEdges().push_back({9,5,7});

        mesh3.GetEdges().push_back({10,6,7});

        mesh3.GetEdges().push_back({11,4,6});

        mesh3.GetEdges().push_back({12,6,5});

        mesh3.GetEdges().push_back({13,2,1});

    DBGCHECK;

    size_t index = 0;

        mesh3.GetFaces().push_back(index);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(0,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(1,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(13,true);

        mesh3.GetFaces().push_back(++index);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(13,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(2,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(3,true);

        mesh3.GetFaces().push_back(++index);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(0,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(5,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(8,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(4,true);

        mesh3.GetFaces().push_back(++index);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(1,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(4,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(11,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(7,true);

        mesh3.GetFaces().push_back(++index);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(3,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(6,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(10,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(7,true);

        mesh3.GetFaces().push_back(++index);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(2,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(6,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(9,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(5,true);

        mesh3.GetFaces().push_back(++index);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(8,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(12,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(11,true);

        mesh3.GetFaces().push_back(++index);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(9,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(10,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(12,true);

        mesh3.GetFaces().push_back(++index);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(12,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(7,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(13,true);

        mesh3.GetFaces().at(index).GetSubelements().AddSubelement(5,true);

    DBGCHECK;



        mesh3.GetFaces().at(0).SetNextBElem(2,0);

        mesh3.GetFaces().at(2).SetNextBElem(3,0);

        mesh3.GetFaces().at(3).SetNextBElem(8,0);

        mesh3.GetFaces().at(8).SetNextBElem(6,0);

        mesh3.GetFaces().at(6).SetNextBElem(0,0);

        mesh3.GetCells().push_back(0);

        mesh3.GetCells().at(0).SetBoundaryElementIndex(0);



template <unsigned int Dimension,typename IndexType, typename Real, unsigned int ...Reserve>

auto ComputeCenters(MeshElements<Dimension, IndexType, Real, Reserve...>& mesh){

        mesh3.GetFaces().at(1).SetNextBElem(5,1);

        mesh3.GetFaces().at(5).SetNextBElem(4,1);

        mesh3.GetFaces().at(4).SetNextBElem(8,1);

        mesh3.GetFaces().at(8).SetNextBElem(7,1);

        mesh3.GetFaces().at(7).SetNextBElem(1,1);

        mesh3.GetCells().push_back(1);

        mesh3.GetCells().at(1).SetBoundaryElementIndex(1);



    return ___ComputeCenters(mesh, make_custom_integer_sequence<unsigned int, 1, Dimension>{});

    DBGCHECK;

}







void testMesh2D() {

    using sit = UnstructuredMesh<2, size_t, double>;

    sit mesh;
@@ -296,6 +353,21 @@ void testMesh2D() { 
    for(sit::Cell& cell : mesh.GetCells()){

        DBGVAR(centers.GetDataDim<2>().at(cell.GetIndex()))

    }



/*

    DBGMSG("computing measures");



    auto measures = ComputeMeasures(mesh);





    for(double edgeM :measures.GetDataDim<1>()) {

        DBGVAR(edgeM)

    }



    for(double cellM :measures.GetDataDim<2>()) {

        DBGVAR(cellM)

    }

*/

}
@@ -350,15 +422,29 @@ void testMesh3D() { 
    //_ComputeCenters<1,3, 3,2,1>::compute<size_t, double, 6>(centers, mesh3);

    auto centers = ComputeCenters(mesh3);



    auto& faceCent = centers.GetDataDim<2>();

    for(auto& center : faceCent) {

        DBGVAR(center)

    for(auto& face : mesh3.GetFaces()) {

        face.SetCenter(centers.template GetDataDim<2>().at(face.GetIndex()));

        DBGVAR(face.GetCenter())

    }

    DBGMSG("cellCenter");

    for(sit3::Cell& cell : mesh3.GetCells()){

        DBGVAR(centers.GetDataDim<3>().at(cell.GetIndex()))

    for(auto& cell : mesh3.GetCells()) {

        cell.SetCenter(centers.template GetDataDim<3>().at(cell.GetIndex()));

        DBGVAR(cell.GetCenter())

    }



    DBGMSG("measure computation");



    auto measures = ComputeMeasures(mesh3);

    for(double edgeM : measures.GetDataDim<1>()) {

        DBGVAR(edgeM)

    }

    for(double faceM : measures.GetDataDim<2>()) {

        DBGVAR(faceM)

    }



    for(double cellM : measures.GetDataDim<3>()) {

        DBGVAR(cellM)

    }



    //DBGVAR(centers.template GetDataDim<3>().at(0))
@@ -367,6 +453,63 @@ void testMesh3D() { 






void test3DMeshDeformedPrisms() {

    UnstructuredMesh<3, size_t, double, 6> mesh3;

    twoDeformedPrisms(mesh3);



    //_ComputeCenters<1,3, 3,2,1>::compute<size_t, double, 6>(centers, mesh3);

    auto centers = ComputeCenters(mesh3);



    for(auto& face : mesh3.GetFaces()) {

        face.SetCenter(centers[face]);

        DBGVAR(face.GetCenter())

    }

    DBGMSG("cellCenter");

    for(auto& cell : mesh3.GetCells()) {

        cell.SetCenter(centers[cell]);

        DBGVAR(cell.GetCenter())

    }



    DBGMSG("measure computation");



    auto measures = ComputeMeasures(mesh3);

    for(double edgeM : measures.GetDataDim<1>()) {

        DBGVAR(edgeM)

    }

    for(double faceM : measures.GetDataDim<2>()) {

        DBGVAR(faceM)

    }



    for(double cellM : measures.GetDataDim<3>()) {

        DBGVAR(cellM)

    }

}

















void testMeshDataContainer() {

    UnstructuredMesh<3, size_t, double, 6> mesh3;

    twoDeformedPrisms(mesh3);





    MeshDataContainer<std::tuple<int, double, char, double>, 3,2,0> container(mesh3);







    for(auto& c : container.GetDataDim<0>()) {

        c=42;

    }



    for(auto& v : mesh3.GetVertices()){

        DBGVAR(container.at(v))

    }

}



template <unsigned int ... Is>

class ClassA

 {
@@ -379,13 +522,53 @@ class ClassA 


 };





//template <typename ... t> class ClassB{};



template<typename  Tuple, unsigned int ... Is>

class ClassB

 {

   public:

      ClassB (const std::integer_sequence<unsigned int, Is...>, Tuple t)

      {std::tuple_element_t<0,Tuple> typ = 0;

          DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), std::get<0>(t), typ) }



 };





template <typename ... t> class ClassC{};



template<unsigned int ... Is, typename ...Types>

class ClassC<std::integer_sequence<unsigned int,Is...>, std::tuple<Types...>>

 {

   public:

      ClassC (const std::integer_sequence<unsigned int, Is...>, std::tuple<Types...>)

      {std::tuple_element_t<0,std::tuple<Types...>> typ = 0;

          DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ) }



      ClassC () {

          std::tuple_element_t<0,std::tuple<Types...>> typ = 42.15;

          std::tuple_element_t<1,std::tuple<Types...>> typ2 = 42.15;

          DBGVAR(sizeof... (Is), std::get<0>(std::array<size_t, sizeof...(Is)>{Is...}), typ, typ2)

      }

 };







void testTemplate() {

    ClassA n(std::make_integer_sequence<unsigned int, 3>{});

    UnstructuredMesh<3,size_t, double,6> mesh3;

    //MeshDataContainer<Vertex<3, double>, 0,1,2> centers2(mesh3,std::make_integer_sequence<unsigned int, 3>{}, Vertex<3, double>{});

    //ComputeCenters(mesh3);

    ClassA u(make_custom_integer_sequence<unsigned int, 10, 0, -2>{});



    ClassA p(make_custom_integer_sequence<unsigned int, 10, 0, -2>{});

    std::tuple<double, char> t{};

    t={1,2};

    ClassB u(make_custom_integer_sequence<unsigned int, 2, 0, -2>{}, t);



    ClassC<std::integer_sequence<unsigned int, 2,0>, std::tuple<double, char>> c(make_custom_integer_sequence<unsigned int, 2, 0, -2>{}, std::tuple<double, char>{});

    ClassC<std::integer_sequence<unsigned int, 2,0>, std::tuple<double, char>> cc;

    ClassC<std::integer_sequence<unsigned int, 2,0>, decltype(std::make_tuple(1.0, 'a'))> ccc;

}
@@ -394,7 +577,9 @@ void testTemplate() { 


int main()

{

    testMesh2D();

    testMesh3D();

    //testMesh2D();

    //testMesh3D();

    //test3DMeshDeformedPrisms();

    testMeshDataContainer();

    //testTemplate();

}

Unstructured_mesh/mesh_element.h

+1 −24
Original line number Diff line number Diff line
@@ -131,16 +131,7 @@ public: 
        :MeshElementBase<IndexType>(index), CellBoundaryConnection<IndexType> () {

        Subelements.fill({INVALID_INDEX(IndexType), false});

    }

    /*

    Vertex<3, Real> ComputeCenter(const MeshElements<3, IndexType, Real, Reserve>& ref){



        Vertex<3,Real> tmpCenter = {};

        for(unsigned char i = 0; i < numberOfElements; i++){

            tmpCenter += ref.template GetElements<1>().at(subElements[i]).ComputeCenter(ref);

        }

        ComputationalySignificantElement<3, Real>::Center = tmpCenter * (1.0 / numberOfElements);

    }

    */

};
@@ -238,21 +229,7 @@ public: 
    void SetBoundaryElementIndex(IndexType index){

        BoundaryElement = index;

    }

/*

    Vertex<MeshDim, Real> ComputeCenter(MeshElements<MeshDim, IndexType, Real, Reserve>& ref){

        IndexType boundary = this->BoundaryElement;

        size_t tmp_boundary = boundary;

        Vertex<MeshDim, Real> tmpCenter = {};

        int numberOfBoundaries = 0;

        do {

            numberOfBoundaries++;

            tmpCenter += ref.GetFaces().at(tmp_boundary).ComputeCenter(ref);

            tmp_boundary = ref.GetFaces().at(tmp_boundary).GetNextBElem(this->GetIndex());

        } while(boundary != tmp_boundary);

        ComputationalySignificantElement<MeshDim, Real>::Center = tmpCenter * (1.0 / numberOfBoundaries);

        return ComputationalySignificantElement<MeshDim, Real>::Center;

    }

*/



};

Unstructured_mesh/mesh_functions.h

+374 −7

File changed.

Preview size limit exceeded, changes collapsed.

Unstructured_mesh/vertex.h

+18 −0
Original line number Diff line number Diff line
@@ -47,6 +47,15 @@ public: 


    Vertex<Dim, Real> operator/(const Real&) const;



    /**

     * @brief operator *

     *

     * Scalar product of two vectors

     * @param v

     * @return

     */

    Real operator*(const Vertex<Dim, Real>& v);





    Vertex<Dim, Real>& operator+=(const Vertex<Dim, Real>&);

    Vertex<Dim, Real>& operator-=(const Vertex<Dim, Real>&);
@@ -122,6 +131,15 @@ Vertex<Dim, Real> Vertex<Dim, Real>::operator /(const Real& x) const { 
    return this->operator*(Real(1.0)/x);

}





template<unsigned int Dim, typename Real>

Real Vertex<Dim, Real>::operator*(const Vertex<Dim, Real> &v)

{

    return inlineScalarProduct<Dim, Real>::computation(Coordinates, v.Coordinates);

}







// Adds value of coordinates of another Point

template <unsigned int Dim, typename Real>

Vertex<Dim, Real>& Vertex<Dim, Real>::operator +=(const Vertex<Dim, Real>& v){