#pragma once

#include "gmsh.h"
#include <iostream>
#include <msclr\marshal_cppstd.h>

using System::IntPtr; 
using System::Runtime::InteropServices::Marshal;


/* Instructions for adding functions
double &                            ->  [System::Runtime::InteropServices::Out] double%
const std::vector<int> &            ->  array<int>^
const std::vector<double> &         ->  array<double>^
const std::size_t                   ->  IntPtr
const std::size_t&                  ->  IntPtr^
const std::vector<std::size_t> &    ->  array<IntPtr>^
const gmsh::vectorpair &            ->  array<System::Tuple<int, int>^>^
const std::string &                 ->  System::String^

*/
namespace GmshCommon {
	public ref class Gmsh
	{
	public:
        // Top-level functions                                                                                                      
		static void Initialize()
		{
			gmsh::initialize();
		}
        static int IsInitialized()
        {
            return gmsh::isInitialized();
        }
		static void FinalizeAll()
		{
			gmsh::finalize();
		}
        static void Open(System::String^ filepath)
        {
            gmsh::open(msclr::interop::marshal_as<std::string>(filepath));
        }
        static void Merge(System::String^ filepath)
        {
            gmsh::merge(msclr::interop::marshal_as<std::string>(filepath));
        }
        static void Write(System::String^ filepath)
        {
            gmsh::write(msclr::interop::marshal_as<std::string>(filepath));
        }
        static void Clear()
		{
			gmsh::clear();
		}
        //                                                                                                                          
        ref class Option
        {
        public:
            static void SetNumber(System::String^ parameter, double value)
            {
                gmsh::option::setNumber(msclr::interop::marshal_as<std::string>(parameter), value);
            }
            static double GetNumber(System::String^ parameter)
            {
                double value = 0;
                gmsh::option::getNumber(msclr::interop::marshal_as<std::string>(parameter), value);
                return value;
            }
            static void SetString(System::String^ parameter, System::String^ value)
            {
                gmsh::option::setString(msclr::interop::marshal_as<std::string>(parameter), msclr::interop::marshal_as<std::string>(value));
            }
            static System::String^ GetString(System::String^ parameter)
            {
                std::string value;
                gmsh::option::getString(msclr::interop::marshal_as<std::string>(parameter), value);

                return gcnew System::String(value.c_str());
            }
        };
        //                                                                                                                          
        ref class Model
        {
        public:
            static void Add(System::String^ name)
            {
                gmsh::model::add(msclr::interop::marshal_as<std::string>(name));
            }
            static System::String^ GetCurrent()
            {
                std::string name;

                gmsh::model::getCurrent(name);

                return gcnew System::String(name.c_str());
            }
            static void SetCurrent(System::String^ name)
            {
                gmsh::model::setCurrent(msclr::interop::marshal_as<std::string>(name));
            }
            static void GetEntities([System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% dimTags)
            {
                return GetEntities(dimTags, -1);
            }
            static void GetEntities([System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% dimTags,
                int dim)
            {
                gmsh::vectorpair nDimTags;
                //for (int i = 0; i < dimTags->Length; ++i)
                //	nDimTags[i] = std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2);

                gmsh::model::getEntities(nDimTags, dim);

                dimTags = gcnew array<System::Tuple<int, int>^>(nDimTags.size());
                for (int i = 0; i < dimTags->Length; ++i)
                    dimTags[i] = gcnew System::Tuple<int, int>(nDimTags[i].first, nDimTags[i].second);
            }
            static void SetEntityName(int dim, int tag, System::String^ name)
            {
                gmsh::model::setEntityName(dim, tag, msclr::interop::marshal_as<std::string>(name));
            }
            static System::String^ GetEntityName(int dim, int tag)
            {
                std::string name;
                gmsh::model::getEntityName(dim, tag, name);

                return gcnew System::String(name.c_str());
            }
            static array<System::Tuple<int, int>^>^ GetPhysicalGroups(int dim)
            {
                gmsh::vectorpair nDimTags;
                gmsh::model::getPhysicalGroups(nDimTags, dim);

                array<System::Tuple<int, int>^>^ dimTags = gcnew array<System::Tuple<int, int>^>(nDimTags.size());
                for (int i = 0; i < nDimTags.size(); ++i)
                    dimTags[i] = gcnew System::Tuple<int, int>(nDimTags[i].first, nDimTags[i].second);

                return dimTags;
            }
            static array<int>^ GetEntitiesForPhysicalGroup(int dim, int tag)
            {
                std::vector<int> tags;
                //
                gmsh::model::getEntitiesForPhysicalGroup(dim, tag, tags);
                //
                array<int>^ entities = gcnew array<int>(tags.size());
                Marshal::Copy(IntPtr(tags.data()), entities, 0, entities->Length);
                //
                return entities;
            }
            static int AddPhysicalGroup(int dim, array<int>^ tags, System::String^ name)
            {
                return AddPhysicalGroup(dim, tags, -1, name);
            }
            static int AddPhysicalGroup(int dim, array<int>^ tags, int tag, System::String^ name)
            {
                std::vector<int> ntags(tags->Length);
                Marshal::Copy(tags, 0, IntPtr(ntags.data()), tags->Length);

                return gmsh::model::addPhysicalGroup(dim, ntags, tag, msclr::interop::marshal_as<std::string>(name));
            }
            static void RemovePhysicalGroups(array<System::Tuple<int, int>^>^ dimTags)
            {
                gmsh::vectorpair nDimTags;
                //
                for (int i = 0; i < dimTags->Length; ++i)
                {
                    nDimTags.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));
                }
                //
                gmsh::model::removePhysicalGroups(nDimTags);
            }
            static void SetPhysicalName(int dim, int tag, System::String^ name)
            {
                gmsh::model::setPhysicalName(dim, tag, msclr::interop::marshal_as<std::string>(name));
            }
            static System::String^ GetPhysicalName(int dim, int tag)
            {
                std::string name;
                gmsh::model::getPhysicalName(dim, tag, name);
                return gcnew System::String(name.c_str());
            }
            static void GetBoundary(array<System::Tuple<int, int>^>^ tags,
                [System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% outDimTags,
                System::Boolean combined, System::Boolean oriented, System::Boolean recursive)
            {
                gmsh::vectorpair dimTags, nOutDimTags;
                for (int i = 0; i < tags->Length; ++i)
                {
                    dimTags.push_back(std::pair<int, int>(tags[i]->Item1, tags[i]->Item2));
                }
                gmsh::model::getBoundary(dimTags, nOutDimTags, combined, oriented, recursive);

                outDimTags = gcnew array<System::Tuple<int, int>^>(nOutDimTags.size());
                for (int i = 0; i < nOutDimTags.size(); ++i)
                    outDimTags[i] = gcnew System::Tuple<int, int>(nOutDimTags[i].first, nOutDimTags[i].second);
            }
            static void GetAdjacencies(int dim, int tag, [System::Runtime::InteropServices::Out] array<int>^% upward,
                [System::Runtime::InteropServices::Out] array<int>^% downward)
            {
                std::vector<int> upward_native;
                std::vector<int> downward_native;
                //
                gmsh::model::getAdjacencies(dim, tag, upward_native, downward_native);
                //
                upward = gcnew array<int>(upward_native.size());
                if (upward_native.size() > 0)
                    Marshal::Copy(IntPtr(upward_native.data()), upward, 0, upward->Length);
                //
                downward = gcnew array<int>(downward_native.size());
                if (downward_native.size() > 0)
                    Marshal::Copy(IntPtr(downward_native.data()), downward, 0, downward->Length);
            }
            static void GetBoundingBox(int dim, int tag,
                [System::Runtime::InteropServices::Out] double% xmin, [System::Runtime::InteropServices::Out] double% ymin,
                [System::Runtime::InteropServices::Out] double% zmin, [System::Runtime::InteropServices::Out] double% xmax,
                [System::Runtime::InteropServices::Out] double% ymax, [System::Runtime::InteropServices::Out] double% zmax)
            {
                double xmin_native = 0;
                double ymin_native = 0;
                double zmin_native = 0;
                double xmax_native = 0;
                double ymax_native = 0;
                double zmax_native = 0;
                //
                gmsh::model::getBoundingBox(dim, tag, xmin_native, ymin_native, zmin_native, xmax_native, ymax_native, zmax_native);
                //
                xmin = xmin_native;
                ymin = ymin_native;
                zmin = zmin_native;
                xmax = xmax_native;
                ymax = ymax_native;
                zmax = zmax_native;
            }
            static int AddDiscreteEntity(int dim, int tag)
            {
                return gmsh::model::addDiscreteEntity(dim, tag);
            }
            static void RemoveEntities(array<System::Tuple<int, int>^>^ tags)
            {
                RemoveEntities(tags, false);
            }
            static void RemoveEntities(array<System::Tuple<int, int>^>^ tags, System::Boolean recursive)
            {
                gmsh::vectorpair dimTags;
                for (int i = 0; i < tags->Length; ++i)
                {
                    dimTags.push_back(std::pair<int, int>(tags[i]->Item1, tags[i]->Item2));
                }

                gmsh::model::removeEntities(dimTags, recursive);
            }
            static System::String^ GetType(int dim, int tag)
            {
                std::string value;
                gmsh::model::getType(dim, tag, value);
                return gcnew System::String(value.c_str());
            }
            static void GetValue(int dim, int tag, array<double>^ parametricCoord,
                [System::Runtime::InteropServices::Out] array<double>^% coord)
            {
                std::vector<double> parametricCoord_native(parametricCoord->Length);
                Marshal::Copy(parametricCoord, 0, IntPtr(&parametricCoord_native[0]), parametricCoord->Length);
                //
                std::vector<double> coord_native;
                //
                gmsh::model::getValue(dim, tag, parametricCoord_native, coord_native);
                //
                coord = gcnew array<double>(coord_native.size());
                Marshal::Copy(IntPtr(coord_native.data()), coord, 0, coord_native.size());
            }
            static void GetNormal(int tag, array<double>^ parametricCoord,
                [System::Runtime::InteropServices::Out] array<double>^% normals)
            {
                std::vector<double> parametricCoord_native(parametricCoord->Length);
                Marshal::Copy(parametricCoord, 0, IntPtr(&parametricCoord_native[0]), parametricCoord->Length);
                //
                std::vector<double> normals_native;
                //
                gmsh::model::getNormal(tag, parametricCoord_native, normals_native);
                //
                normals = gcnew array<double>(normals_native.size());
                Marshal::Copy(IntPtr(normals_native.data()), normals, 0, normals_native.size());
            }
            static void GetParametrization(int dim, int tag, array<double>^ coord,
                [System::Runtime::InteropServices::Out] array<double>^% parametricCoord)
            {
                std::vector<double> coord_native(coord->Length);
                Marshal::Copy(coord, 0, IntPtr(&coord_native[0]), coord->Length);
                //
                std::vector<double> parametricCoord_native;
                //
                gmsh::model::getParametrization(dim, tag, coord_native, parametricCoord_native);
                //
                parametricCoord = gcnew array<double>(parametricCoord_native.size());
                Marshal::Copy(IntPtr(parametricCoord_native.data()), parametricCoord, 0, parametricCoord_native.size());
            }
            static void GetParametrizationBounds(int dim, int tag,
                [System::Runtime::InteropServices::Out] array<double>^% min,
                [System::Runtime::InteropServices::Out] array<double>^% max)
            {
                std::vector<double> min_native;
                std::vector<double> max_native;
                //
                gmsh::model::getParametrizationBounds(dim, tag, min_native, max_native);
                //
                min = gcnew array<double>(min_native.size());
                Marshal::Copy(IntPtr(min_native.data()), min, 0, min_native.size());
                //
                max = gcnew array<double>(max_native.size());
                Marshal::Copy(IntPtr(max_native.data()), max, 0, max_native.size());
            }
            //                                                                                                                      
            ref class Geo
            {
            public:
                static void Synchronize()
                {
                    gmsh::model::geo::synchronize();
                }
                static int AddVolume(array<int>^ shellTags)
                {
                    return AddVolume(shellTags, -1);
                }
                static int AddVolume(array<int>^ shellTags, int tag)
                {
                    std::vector<int> nShellTags(shellTags->Length);
                    Marshal::Copy(shellTags, 0, IntPtr(nShellTags.data()), shellTags->Length);

                    return gmsh::model::geo::addVolume(nShellTags, tag);
                }
                static int AddSurfaceLoop(array<int>^ surfaceTags)
                {
                    return AddSurfaceLoop(surfaceTags, -1);
                }
                static int AddSurfaceLoop(array<int>^ surfaceTags, int tag)
                {
                    std::vector<int> nSurfaceTags(surfaceTags->Length);
                    Marshal::Copy(surfaceTags, 0, IntPtr(nSurfaceTags.data()), surfaceTags->Length);

                    return gmsh::model::geo::addSurfaceLoop(nSurfaceTags, tag);
                }

                //
                ref class Mesh
                {
                public:
                    
                };
            };
            //                                                                                                                      
            ref class Mesh
            {
            public:
                static void Generate(int dim)
                {
                    gmsh::model::mesh::generate(dim);
                }
                static void Optimize(System::String^ method, bool force, int niter,
                    array<System::Tuple<int, int>^>^ dimTags)
                {
                    std::string method_native = msclr::interop::marshal_as<std::string>(method);
                    //
                    gmsh::vectorpair dimTags_native;
                    //
                    for (int i = 0; i < dimTags->Length; ++i)
                    {
                        dimTags_native.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));
                    }
                    //
                    gmsh::model::mesh::optimize(method_native, force, niter, dimTags_native);
                }
                static void AffineTransform(array<double>^ affineTransform, array<array<int>^>^ dimTags)
                {
                    std::vector<double> af(affineTransform->Length);
                    Marshal::Copy(affineTransform, 0, IntPtr(&af[0]), affineTransform->Length);

                    //std::vector<int> dt(dimTags->Length);
                    //Marshal::Copy(dimTags, 0, IntPtr(&dt[0]), dimTags->Length);

                    gmsh::model::mesh::affineTransform(af);
                }
                static void Clear()
                {
                    gmsh::model::mesh::clear();
                }
                static void Clear(array<System::Tuple<int, int>^>^ dimTags)
                {
                    gmsh::vectorpair dimTags_native;
                    //
                    for (int i = 0; i < dimTags->Length; ++i)
                    {
                        dimTags_native.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));
                    }
                    //
                    gmsh::model::mesh::clear(dimTags_native);
                }
                static void AddNodes(int dim, int tag, array<IntPtr>^ nodeTags, array<double>^ coordinates)
                {
                    std::vector<size_t> nnodeTags(nodeTags->Length);
                    Marshal::Copy(nodeTags, 0, IntPtr(nnodeTags.data()), nodeTags->Length);

                    std::vector<double> coord(coordinates->Length);
                    Marshal::Copy(coordinates, 0, IntPtr(coord.data()), coordinates->Length);

                    gmsh::model::mesh::addNodes(dim, tag, nnodeTags, coord);
                }
                static void AddFaces(int faceType, array<IntPtr>^ faceTags, array<IntPtr>^ faceNodes)
                {
                    std::vector<size_t> nFaceTags(faceTags->Length), nFaceNodes(faceNodes->Length);

                    Marshal::Copy(faceTags, 0, IntPtr(nFaceTags.data()), faceTags->Length);
                    Marshal::Copy(faceNodes, 0, IntPtr(nFaceNodes.data()), faceNodes->Length);

                    gmsh::model::mesh::addFaces(faceType, nFaceTags, nFaceNodes);
                }
                static void AddElements(int dim, int tag, array<int>^ elementTypes,
                    array<array<IntPtr>^>^ elementTags, array <array<IntPtr>^>^ nodeTags)
                {
                    std::vector<int> nElementTypes(elementTypes->Length);
                    Marshal::Copy(elementTypes, 0, IntPtr(nElementTypes.data()), elementTypes->Length);

                    std::vector < std::vector<size_t>> nElementTags(elementTags->Length);
                    for (int i = 0; i < elementTags->Length; ++i)
                    {
                        nElementTags[i] = std::vector<size_t>(elementTags[i]->Length);
                        Marshal::Copy(elementTags[i], 0, IntPtr(nElementTags[i].data()), elementTags[i]->Length);
                    }

                    std::vector < std::vector<size_t>> nNodeTags(nodeTags->Length);
                    for (int i = 0; i < nodeTags->Length; ++i)
                    {
                        nNodeTags[i] = std::vector<size_t>(nodeTags[i]->Length);
                        Marshal::Copy(nodeTags[i], 0, IntPtr(nNodeTags[i].data()), nodeTags[i]->Length);
                    }

                    gmsh::model::mesh::addElements(dim, tag, nElementTypes, nElementTags, nNodeTags);
                }
                static void ClassifySurfaces(double angle, System::Boolean boundary, System::Boolean forReparametrization,
                    double curveAngle, System::Boolean exportDiscrete)
                {
                    gmsh::model::mesh::classifySurfaces(angle, boundary, forReparametrization, curveAngle, exportDiscrete);
                }
                static void CreateGeometry()
                {
                    gmsh::model::mesh::createGeometry();
                }
                static void CreateTopology()
                {
                    CreateTopology(true, true);
                }
                static void CreateTopology(System::Boolean makeSimplyConnected, System::Boolean exportDiscrete)
                {
                    gmsh::model::mesh::createTopology(makeSimplyConnected, exportDiscrete);

                }
                static void GetIntegrationPoints(int elementType, System::String^ integrationType,
                    [System::Runtime::InteropServices::Out] array<double>^% localCoord,
                    [System::Runtime::InteropServices::Out] array<double>^% weights)
                {
                    std::vector<double> nLocalCoord, nWeights;
                    gmsh::model::mesh::getIntegrationPoints(elementType, msclr::interop::marshal_as<std::string>(integrationType),
                        nLocalCoord, nWeights);


                    localCoord = gcnew array<double>(nLocalCoord.size());
                    Marshal::Copy(IntPtr(nLocalCoord.data()), localCoord, 0, nLocalCoord.size());

                    weights = gcnew array<double>(nWeights.size());
                    Marshal::Copy(IntPtr(nWeights.data()), weights, 0, nWeights.size());
                }
                static void GetElementTypes([System::Runtime::InteropServices::Out] array<int>^% types, int dim)
                {
                    GetElementTypes(types, dim, -1);
                }
                static void GetElementTypes([System::Runtime::InteropServices::Out] array<int>^% types)
                {
                    GetElementTypes(types, -1, -1);
                }
                static void GetElementTypes([System::Runtime::InteropServices::Out] array<int>^% types, int dim, int tag)
                {
                    std::vector<int> nTypes;
                    gmsh::model::mesh::getElementTypes(nTypes, dim, tag);

                    types = gcnew array<int>(nTypes.size());
                    Marshal::Copy(IntPtr(nTypes.data()), types, 0, nTypes.size());
                }
                static void GetNodes([System::Runtime::InteropServices::Out] array<IntPtr>^% nodeTags,
                    [System::Runtime::InteropServices::Out] array<double>^% coord,
                    int dim, int tag, System::Boolean includeBoundary, System::Boolean returnParametricCoord)
                {
                    std::vector<size_t> nodeTags_native;
                    std::vector<double> coord_native, parametricCoord_native;
                    gmsh::model::mesh::getNodes(nodeTags_native, coord_native, parametricCoord_native, dim, tag, includeBoundary, returnParametricCoord);

                    coord = gcnew array<double>(coord_native.size());
                    if (coord_native.size() > 0)
                        Marshal::Copy(IntPtr(coord_native.data()), coord, 0, coord_native.size());

                    //parametricCoord = gcnew array<double>(parametricCoord_native.size());
                    //if (parametricCoord_native.size() > 0)
                    //	Marshal::Copy(IntPtr(parametricCoord_native.data()), parametricCoord, 0, parametricCoord_native.size());

                    nodeTags = gcnew array<IntPtr>(nodeTags_native.size());
                    if (nodeTags_native.size() > 0)
                        Marshal::Copy(IntPtr(nodeTags_native.data()), nodeTags, 0, nodeTags_native.size());
                }
                static void GetElement(IntPtr elementTag, int elementType,
                    [System::Runtime::InteropServices::Out] array<IntPtr>^% nodeTags,
                    [System::Runtime::InteropServices::Out] int% dim,
                    [System::Runtime::InteropServices::Out] int% tag)
                {
                    size_t eTag(elementTag.ToInt64());
                    std::vector<size_t> nodeTags_native;
                    int ndim, ntag;

                    gmsh::model::mesh::getElement(eTag, elementType, nodeTags_native, ndim, ntag);
                    dim = ndim;
                    tag = ntag;

                    nodeTags = gcnew array<IntPtr>(nodeTags_native.size());
                    if (nodeTags_native.size() > 0)
                        Marshal::Copy(IntPtr(nodeTags_native.data()), nodeTags, 0, nodeTags_native.size());
                }
                static System::String^ GetElementProperties(
                    int elementType,
                    [System::Runtime::InteropServices::Out] int% dim,
                    [System::Runtime::InteropServices::Out] int% order,
                    [System::Runtime::InteropServices::Out] int% numNodes,
                    [System::Runtime::InteropServices::Out] array<double>^% localNodeCoords,
                    [System::Runtime::InteropServices::Out] int% numPrimaryNodes)
                {
                    int dimTemp, orderTemp, numNodesTemp, numPrimaryNodesTemp;
                    std::string elementNameTemp;
                    std::vector<double> localNodeCoordTemp;

                    gmsh::model::mesh::getElementProperties(elementType, elementNameTemp, dimTemp, orderTemp, numNodesTemp, localNodeCoordTemp, numPrimaryNodesTemp);

                    localNodeCoords = gcnew array<double>(localNodeCoordTemp.size());
                    if (localNodeCoordTemp.size() > 0)
                        Marshal::Copy(IntPtr(localNodeCoordTemp.data()), localNodeCoords, 0, localNodeCoordTemp.size());

                    dim = dimTemp;
                    order = orderTemp;
                    numNodes = numNodesTemp;
                    numPrimaryNodes = numPrimaryNodesTemp;
                    return gcnew System::String(elementNameTemp.c_str());


                }
                static void GetMaxElementTag([System::Runtime::InteropServices::Out] IntPtr% maxTag)
                {
                    size_t maxTag_native;
                    gmsh::model::mesh::getMaxElementTag(maxTag_native);
                    maxTag = IntPtr((int)maxTag_native);
                }
                static void GetElementQualities(array<IntPtr>^ elementTags,
                    [System::Runtime::InteropServices::Out] array<double>^% elementsQuality, System::String^ qualityName)
                {
                    std::vector<size_t> elementTags_native(elementTags->Length);
                    Marshal::Copy(elementTags, 0, IntPtr(elementTags_native.data()), elementTags->Length);
                    // Preallocate
                    std::vector<double> elementsQuality_native(elementTags->Length);
                    //
                    std::string qualityName_native = msclr::interop::marshal_as<std::string>(qualityName);
                    //
                    gmsh::model::mesh::getElementQualities(elementTags_native, elementsQuality_native, qualityName_native);
                    //
                    elementsQuality = gcnew array<double>(elementsQuality_native.size());
                    Marshal::Copy(IntPtr(elementsQuality_native.data()), elementsQuality, 0, elementsQuality_native.size());
                }
                static void GetElements(
                    [System::Runtime::InteropServices::Out] array<int>^% elementTypes,
                    [System::Runtime::InteropServices::Out] array<array<IntPtr>^>^% elementTags,
                    [System::Runtime::InteropServices::Out] array<array<IntPtr>^>^% nodeTags,
                    int dim, int tag)
                {
                    std::vector<int> elementTypesN;
                    std::vector<std::vector<size_t>> elementTagsN, nodeTagsN;

                    gmsh::model::mesh::getElements(elementTypesN, elementTagsN, nodeTagsN, dim, tag);

                    for (int i = 0; i < nodeTagsN.size(); ++i)
                    {
                        for (int j = 0; j < nodeTagsN[i].size(); ++j)
                        {
                            if (nodeTagsN[i][j] == 0)
                            {
                                std::cout << "Bad index found in node tags: " << nodeTagsN[i][j] << " (i " << i << ", j " << j << ")" << std::endl;
                                //throw std::exception("Abject failure.");
                            }
                        }
                    }

                    elementTypes = gcnew array<int>(elementTypesN.size());
                    if (elementTypesN.size() > 0)
                        Marshal::Copy(IntPtr(elementTypesN.data()), elementTypes, 0, elementTypesN.size());

                    if (elementTagsN.size() < 1)
                        elementTags = gcnew array <array<IntPtr>^>(1);
                    else
                        elementTags = gcnew array< array<IntPtr>^>(elementTagsN.size());

                    for (int i = 0; i < elementTagsN.size(); ++i)
                    {
                        elementTags[i] = gcnew array<IntPtr>(elementTagsN[i].size());
                        Marshal::Copy(IntPtr(elementTagsN[i].data()), elementTags[i], 0, elementTagsN[i].size());

                        //for (int j = 0; j < elementTagsN[i].size(); ++j)
                        //	elementTags[i][j] = static_cast<long>(elementTagsN[i][j]);
                    }

                    if (nodeTagsN.size() < 1)
                        nodeTags = gcnew array< array<IntPtr>^>(1);
                    else
                        nodeTags = gcnew array< array<IntPtr>^>(nodeTagsN.size());

                    for (int i = 0; i < nodeTagsN.size(); ++i)
                    {
                        nodeTags[i] = gcnew array<IntPtr>(nodeTagsN[i].size());
                        Marshal::Copy(IntPtr(nodeTagsN[i].data()), nodeTags[i], 0, nodeTagsN[i].size());

                        //for (int j = 0; j < nodeTagsN[i].size(); ++j)
                        //{
                        //	nodeTags[i][j] = (IntPtr)static_cast<long>(nodeTagsN[i][j]);
                        //}
                    }
                }
                static void RemoveDuplicateNodes(array<System::Tuple<int, int>^>^ tags)
                {
                    gmsh::vectorpair dimTags;
                    for (int i = 0; i < tags->Length; ++i)
                    {
                        dimTags.push_back(std::pair<int, int>(tags[i]->Item1, tags[i]->Item2));
                    }
                    gmsh::model::mesh::removeDuplicateNodes(dimTags);
                }
                static void RemoveDuplicateNodes()
                {
                    gmsh::model::mesh::removeDuplicateNodes();
                }
                static void RemoveDuplicateElements()
                {
                    gmsh::model::mesh::removeDuplicateElements();
                }
                static void CreateFaces()
                {
                    gmsh::model::mesh::createFaces();
                }
                static void GetAllFaces(int dim, [System::Runtime::InteropServices::Out] array<IntPtr>^% faceTags,
                    [System::Runtime::InteropServices::Out] array<IntPtr>^% faceNodes)
                {
                    std::vector<size_t> face_tags, face_nodes;
                    gmsh::model::mesh::getAllFaces(dim, face_tags, face_nodes);

                    faceTags = gcnew array<IntPtr>(face_tags.size());
                    Marshal::Copy(IntPtr(face_tags.data()), faceTags, 0, face_tags.size());

                    //for (int i = 0; i < face_tags.size(); ++i)
                    //	faceTags[i] = static_cast<long>(face_tags[i]);

                    faceNodes = gcnew array<IntPtr>(face_nodes.size());
                    Marshal::Copy(IntPtr(face_nodes.data()), faceNodes, 0, face_nodes.size());

                    //for (int i = 0; i < face_nodes.size(); ++i)
                    //	faceNodes[i] = static_cast<long>(face_nodes[i]);
                }
                static void GetJacobians(int elementType, int tag, array<double>^ localCoord,
                    [System::Runtime::InteropServices::Out] array<double>^% jacobians,
                    [System::Runtime::InteropServices::Out] array<double>^% determinants,
                    [System::Runtime::InteropServices::Out] array<double>^% coord)
                {
                    std::vector<double> nLocalCoord(localCoord->Length), nJacobians, nDeterminants, nCoord;
                    Marshal::Copy(localCoord, 0, IntPtr(nLocalCoord.data()), localCoord->Length);

                    gmsh::model::mesh::getJacobians(elementType, nLocalCoord, nJacobians, nDeterminants, nCoord, tag);

                    jacobians = gcnew array<double>(nJacobians.size());
                    determinants = gcnew array<double>(nDeterminants.size());
                    coord = gcnew array<double>(nCoord.size());

                    Marshal::Copy(IntPtr(nJacobians.data()), jacobians, 0, nJacobians.size());
                    Marshal::Copy(IntPtr(nDeterminants.data()), determinants, 0, nDeterminants.size());
                    Marshal::Copy(IntPtr(nCoord.data()), coord, 0, nCoord.size());
                }
                static void Recombine()
                {
                    gmsh::model::mesh::recombine();
                }
                static void Refine()
                {
                    gmsh::model::mesh::refine();
                }
                static void SetRecombine(int dim, int tag)
                {
                    SetRecombine(dim, tag, 45.);
                }
                static void SetRecombine(int dim, int tag, double angle)
                {
                    gmsh::model::mesh::setRecombine(dim, tag, angle);
                }
                static void SetAlgorithm(int dim, int tag, int val)
                {
                    gmsh::model::mesh::setAlgorithm(dim, tag, val);
                }
                static void SetSizeFromBoundary(int dim, int tag, int val)
                {
                    gmsh::model::mesh::setSizeFromBoundary(dim, tag, val);
                }
                static void SetCompound(int dim, array<int>^ tags)
                {
                    std::vector<int> tags_native(tags->Length);
                    Marshal::Copy(tags, 0, IntPtr(tags_native.data()), tags->Length);
                    //
                    gmsh::model::mesh::setCompound(dim, tags_native);
                }
                static void SetTransfiniteCurve(int tag, int numNodes)
                {
                    gmsh::model::mesh::setTransfiniteCurve(tag, numNodes);
                }
                static void SetTransfiniteCurve(int tag, int numNodes, System::String^ meshType, double coef)
                {
                    std::string meshType_native = msclr::interop::marshal_as<std::string>(meshType);
                    //
                    gmsh::model::mesh::setTransfiniteCurve(tag, numNodes, meshType_native, coef);
                }
                static void SetTransfiniteSurface(int tag)
                {
                    gmsh::model::mesh::setTransfiniteSurface(tag);
                }
                static void SetTransfiniteSurface(int tag, System::String^ arrangement)
                {
                    std::string arrangement_native = msclr::interop::marshal_as<std::string>(arrangement);
                    //
                    gmsh::model::mesh::setTransfiniteSurface(tag, arrangement_native);
                }
                static void SetTransfiniteSurface(int tag, System::String^ arrangement, array<int>^ cornerTags)
                {
                    std::string arrangement_native = msclr::interop::marshal_as<std::string>(arrangement);
                    //
                    std::vector<int> cornerTags_native(cornerTags->Length);
                    Marshal::Copy(cornerTags, 0, IntPtr(cornerTags_native.data()), cornerTags->Length);
                    //
                    gmsh::model::mesh::setTransfiniteSurface(tag, arrangement_native, cornerTags_native);
                }
                static void SetTransfiniteVolume(int tag)
                {
                    gmsh::model::mesh::setTransfiniteVolume(tag);
                }
                static void SetTransfiniteVolume(int tag, array<int>^ cornerTags)
                {
                    std::vector<int> cornerTags_native(cornerTags->Length);
                    Marshal::Copy(cornerTags, 0, IntPtr(cornerTags_native.data()), cornerTags->Length);
                    //
                    gmsh::model::mesh::setTransfiniteVolume(tag, cornerTags_native);
                }
                static void SetTransfiniteAutomatic()
                {
                    gmsh::model::mesh::setTransfiniteAutomatic();
                }
                static void SetTransfiniteAutomatic(double cornerAngle)
                {
                    gmsh::vectorpair& dimTags_native = gmsh::vectorpair();
                    bool recombine = true;
                    //
                    gmsh::model::mesh::setTransfiniteAutomatic(dimTags_native, cornerAngle, recombine);
                }
                static void SetTransfiniteAutomatic(double cornerAngle, bool recombine)
                {
                    gmsh::vectorpair& dimTags_native = gmsh::vectorpair();
                    //
                    gmsh::model::mesh::setTransfiniteAutomatic(dimTags_native, cornerAngle, recombine);
                }
                static void SetTransfiniteAutomatic(array<System::Tuple<int, int>^>^ dimTags, double cornerAngle,
                    bool recombine)
                {
                    gmsh::vectorpair dimTags_native(0);
                    for (int i = 0; i < dimTags->Length; ++i)
                        dimTags_native.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));
                    //
                    gmsh::model::mesh::setTransfiniteAutomatic(dimTags_native, cornerAngle, recombine);
                }
                static void SetSmoothing(int dim, int tag, int val)
                {
                    gmsh::model::mesh::setSmoothing(dim, tag, val);
                }
                static void SetOutwardOrientation(int tag)
                {
                    gmsh::model::mesh::setOutwardOrientation(tag);
                }
                static inline void SetOrder(int order)
                {
                    gmsh::model::mesh::setOrder(order);
                }
                static void GetSizes(array<System::Tuple<int, int>^>^ dimTags,
                    [System::Runtime::InteropServices::Out] array<double>^% sizes)
                {
                    std::vector<double> sizes_native;
                    //
                    gmsh::vectorpair dimTags_native;
                    for (int i = 0; i < dimTags->Length; ++i)
                    {
                        dimTags_native.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));
                    }
                    //
                    gmsh::model::mesh::getSizes(dimTags_native, sizes_native);
                    //
                    sizes = gcnew array<double>(sizes_native.size());
                    Marshal::Copy(IntPtr(sizes_native.data()), sizes, 0, sizes_native.size());
                }
                //
                ref class Field
                {
                public:

                };
            };
            //                                                                                                                      
            ref class OCC
            {
            public:
                static void Extrude(array<System::Tuple<int, int>^>^ dimTags, double dx, double dy, double dz,
                    [System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% outDimTags,
                    array<int>^ numElements, array<double>^ heights, bool recombine)
                {
                    gmsh::vectorpair dimTags_native(0);
                    for (int i = 0; i < dimTags->Length; ++i)
                        dimTags_native.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));
                    //
                    gmsh::vectorpair outDimTags_native;
                    //
                    std::vector<int> numElements_native(numElements->Length);
                    Marshal::Copy(numElements, 0, IntPtr(numElements_native.data()), numElements->Length);
                    //
                    std::vector<double> heights_native(heights->Length);
                    Marshal::Copy(heights, 0, IntPtr(heights_native.data()), heights->Length);
                    //
                    gmsh::model::occ::extrude(dimTags_native, dx, dy, dz, outDimTags_native, numElements_native, heights_native, recombine);
                    //
                    outDimTags = gcnew array<System::Tuple<int, int>^>(outDimTags_native.size());
                    for (int i = 0; i < outDimTags_native.size(); ++i)
                        outDimTags[i] = gcnew System::Tuple<int, int>(outDimTags_native[i].first, outDimTags_native[i].second);
                }
                static void Revolve(array<System::Tuple<int, int>^>^ dimTags,
                    double x, double y, double z, double ax, double ay, double az, double angle,
                    [System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% outDimTags,
                    array<int>^ numElements, array<double>^ heights, bool recombine)
                {
                    gmsh::vectorpair dimTags_native(0);
                    for (int i = 0; i < dimTags->Length; ++i)
                        dimTags_native.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));
                    //
                    gmsh::vectorpair outDimTags_native;
                    //
                    std::vector<int> numElements_native(numElements->Length);
                    Marshal::Copy(numElements, 0, IntPtr(numElements_native.data()), numElements->Length);
                    //
                    std::vector<double> heights_native(heights->Length);
                    Marshal::Copy(heights, 0, IntPtr(heights_native.data()), heights->Length);
                    //
                    gmsh::model::occ::revolve(dimTags_native, x, y, z, ax, ay, az, angle, outDimTags_native,
                        numElements_native, heights_native, recombine);
                    //
                    outDimTags = gcnew array<System::Tuple<int, int>^>(outDimTags_native.size());
                    for (int i = 0; i < outDimTags_native.size(); ++i)
                        outDimTags[i] = gcnew System::Tuple<int, int>(outDimTags_native[i].first, outDimTags_native[i].second);
                }
                static void Synchronize()
                {
                    gmsh::model::occ::synchronize();
                }
                static void ImportShapes(System::String^ fileName,
                    [System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% dimTags,
                    System::Boolean highestDimOnly, System::String^ format)
                {
                    gmsh::vectorpair outDimTags;
                    gmsh::model::occ::importShapes(msclr::interop::marshal_as<std::string>(fileName), outDimTags, highestDimOnly, msclr::interop::marshal_as<std::string>(format));

                    dimTags = gcnew array<System::Tuple<int, int>^>(outDimTags.size());
                    for (int i = 0; i < outDimTags.size(); ++i)
                        dimTags[i] = gcnew System::Tuple<int, int>(outDimTags[i].first, outDimTags[i].second);
                }
                static array<System::Tuple<int, int>^>^ GetEntities(int dim)
                {
                    gmsh::vectorpair outDimTags;
                    gmsh::model::occ::getEntities(outDimTags, dim);

                    array<System::Tuple<int, int>^>^ dimTags = gcnew array<System::Tuple<int, int>^>(outDimTags.size());
                    for (int i = 0; i < outDimTags.size(); ++i)
                        dimTags[i] = gcnew System::Tuple<int, int>(outDimTags[i].first, outDimTags[i].second);

                    return dimTags;
                }
                static void Remove(array<System::Tuple<int, int>^>^ dimTags)
                {
                    Remove(dimTags, false);
                }
                static void Remove(array<System::Tuple<int, int>^>^ dimTags, System::Boolean recursive)
                {
                    gmsh::vectorpair udimTags(dimTags->Length);
                    for (int i = 0; i < dimTags->Length; ++i)
                        udimTags.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));

                    gmsh::model::occ::remove(udimTags, recursive);
                }
                static void RemoveAllDuplicates()
                {
                    gmsh::model::occ::removeAllDuplicates();
                }
                static void Defeature(array<int>^ volumeTags, array<int>^ surfaceTags,
                    [System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% outDimTags,
                    bool removeVolume)
                {
                    std::vector<int> volumeTags_native(volumeTags->Length);
                    Marshal::Copy(volumeTags, 0, IntPtr(volumeTags_native.data()), volumeTags->Length);
                    //
                    std::vector<int> surfaceTags_native(surfaceTags->Length);
                    Marshal::Copy(surfaceTags, 0, IntPtr(surfaceTags_native.data()), surfaceTags->Length);
                    //
                    gmsh::vectorpair outDimTags_native;
                    //
                    gmsh::model::occ::defeature(volumeTags_native, surfaceTags_native, outDimTags_native, removeVolume);
                    //
                    outDimTags = gcnew array<System::Tuple<int, int>^>(outDimTags_native.size());
                    for (int i = 0; i < outDimTags_native.size(); ++i)
                        outDimTags[i] = gcnew System::Tuple<int, int>(outDimTags_native[i].first, outDimTags_native[i].second);
                }
                static void GetDistance(int dim1, int tag1, int dim2, int tag2,
                    [System::Runtime::InteropServices::Out] double% distance)
                {
                    double x1, y1, z1, x2, y2, z2;
                    GetDistance(dim1, tag1, dim2, tag2, distance, x1, y1, z1, x2, y2, z2);
                }
                static void GetDistance(int dim1, int tag1, int dim2, int tag2,
                    [System::Runtime::InteropServices::Out] double% distance, [System::Runtime::InteropServices::Out] double% x1,
                    [System::Runtime::InteropServices::Out] double% y1, [System::Runtime::InteropServices::Out] double% z1,
                    [System::Runtime::InteropServices::Out] double% x2, [System::Runtime::InteropServices::Out] double% y2,
                    [System::Runtime::InteropServices::Out] double% z2)
                {
                    double distance_native = 0;
                    double x1_native = 0;
                    double y1_native = 0;
                    double z1_native = 0;
                    double x2_native = 0;
                    double y2_native = 0;
                    double z2_native = 0;
                    //
                    gmsh::model::occ::getDistance(dim1, tag1, dim2, tag2, distance_native, x1_native, y1_native, z1_native,
                                                                                           x2_native, y2_native, z2_native);
                    distance = distance_native;
                    x1 = x1_native;
                    y1 = y1_native;
                    z1 = z1_native;
                    x2 = x2_native;
                    y2 = y2_native;
                    z2 = z2_native;
                }
                static void Fragment(array<System::Tuple<int, int>^>^ objectDimTags, array<System::Tuple<int, int>^>^ toolDimTags,
                    [System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% outDimTags,
                    [System::Runtime::InteropServices::Out] array<array<System::Tuple<int, int>^>^>^% outDimTagsMap,
                    System::Boolean removeObject, System::Boolean removeTool)
                {
                    Fragment(objectDimTags, toolDimTags, outDimTags, outDimTagsMap, -1, removeObject, removeTool);
                }
                static void Fragment(array<System::Tuple<int, int>^>^ objectDimTags, array<System::Tuple<int, int>^>^ toolDimTags,
                    [System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% outDimTags,
                    [System::Runtime::InteropServices::Out] array<array<System::Tuple<int, int>^>^>^% outDimTagsMap,
                    int tag, System::Boolean removeObject, System::Boolean removeTool)
                {
                    gmsh::vectorpair noutDimTags, nobjectDimTags, ntoolDimTags;
                    std::vector<gmsh::vectorpair> noutDimTagsMap;

                    for (int i = 0; i < objectDimTags->Length; ++i)
                        nobjectDimTags.push_back(std::pair<int, int>(objectDimTags[i]->Item1, objectDimTags[i]->Item2));

                    for (int i = 0; i < toolDimTags->Length; ++i)
                        ntoolDimTags.push_back(std::pair<int, int>(toolDimTags[i]->Item1, toolDimTags[i]->Item2));

                    gmsh::model::occ::fragment(nobjectDimTags, ntoolDimTags, noutDimTags, noutDimTagsMap, tag, removeObject, removeTool);

                    outDimTags = gcnew array < System::Tuple<int, int>^>(noutDimTags.size());
                    for (int i = 0; i < noutDimTags.size(); ++i)
                        outDimTags[i] = gcnew System::Tuple<int, int>(noutDimTags[i].first, noutDimTags[i].second);

                    outDimTagsMap = gcnew array< array < System::Tuple<int, int>^>^>(noutDimTagsMap.size());
                    for (int i = 0; i < noutDimTagsMap.size(); ++i)
                    {
                        outDimTagsMap[i] = gcnew array<System::Tuple<int, int>^>(noutDimTagsMap[i].size());
                        for (int j = 0; j < noutDimTagsMap[i].size(); ++j)
                            outDimTagsMap[i][j] = gcnew System::Tuple<int, int>(noutDimTagsMap[i][j].first, noutDimTagsMap[i][j].second);
                    }

                }
                static void HealShapes([System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% outDimTags,
                    array<System::Tuple<int, int>^>^ dimTags, double tolerance, System::Boolean fixDegenerate,
                    System::Boolean fixSmallEdges, System::Boolean fixSmallFaces,
                    System::Boolean sewFaces, System::Boolean makeSolids)
                {
                    gmsh::vectorpair noutDimTags, nDimTags;
                    for (int i = 0; i < dimTags->Length; ++i)
                        nDimTags.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));

                    gmsh::model::occ::healShapes(noutDimTags, nDimTags, tolerance, fixDegenerate, fixSmallEdges, fixSmallFaces, sewFaces, makeSolids);


                    outDimTags = gcnew array < System::Tuple<int, int>^>(noutDimTags.size());
                    for (int i = 0; i < noutDimTags.size(); ++i)
                        outDimTags[i] = gcnew System::Tuple<int, int>(noutDimTags[i].first, noutDimTags[i].second);
                }
                static void Intersect(array<System::Tuple<int, int>^>^ objectDimTags, array<System::Tuple<int, int>^>^ toolDimTags,
                    [System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% outDimTags,
                    [System::Runtime::InteropServices::Out] array<array<System::Tuple<int, int>^>^>^% outDimTagsMap,
                    int tag, System::Boolean removeObject, System::Boolean removeTool)
                {
                    gmsh::vectorpair noutDimTags, nobjectDimTags, ntoolDimTags;
                    std::vector<gmsh::vectorpair> noutDimTagsMap;

                    for (int i = 0; i < objectDimTags->Length; ++i)
                        nobjectDimTags.push_back(std::pair<int, int>(objectDimTags[i]->Item1, objectDimTags[i]->Item2));

                    for (int i = 0; i < toolDimTags->Length; ++i)
                        ntoolDimTags.push_back(std::pair<int, int>(toolDimTags[i]->Item1, toolDimTags[i]->Item2));

                    gmsh::model::occ::intersect(nobjectDimTags, ntoolDimTags, noutDimTags, noutDimTagsMap, tag, removeObject, removeTool);

                    outDimTags = gcnew array < System::Tuple<int, int>^>(noutDimTags.size());
                    for (int i = 0; i < noutDimTags.size(); ++i)
                        outDimTags[i] = gcnew System::Tuple<int, int>(noutDimTags[i].first, noutDimTags[i].second);

                    outDimTagsMap = gcnew array< array < System::Tuple<int, int>^>^>(noutDimTagsMap.size());
                    for (int i = 0; i < noutDimTagsMap.size(); ++i)
                    {
                        outDimTagsMap[i] = gcnew array<System::Tuple<int, int>^>(noutDimTagsMap[i].size());
                        for (int j = 0; j < noutDimTagsMap[i].size(); ++j)
                            outDimTagsMap[i][j] = gcnew System::Tuple<int, int>(noutDimTagsMap[i][j].first, noutDimTagsMap[i][j].second);
                    }

                }
                static void GetMass(int dim, int tag, [System::Runtime::InteropServices::Out] double% mass)
                {
                    double mass_native = 0;
                    gmsh::model::occ::getMass(dim, tag, mass_native);
                    mass = mass_native;
                }
                static void GetCenterOfMass(int dim, int tag, [System::Runtime::InteropServices::Out] double% x,
                    [System::Runtime::InteropServices::Out] double% y, [System::Runtime::InteropServices::Out] double% z)
                {
                    double x_native = 0;
                    double y_native = 0;
                    double z_native = 0;
                    gmsh::model::occ::getCenterOfMass(dim, tag, x_native, y_native, z_native);
                    x = x_native;
                    y = y_native;
                    z = z_native;
                }
                static void GetEntitiesInBoundingBox(double xMin, double yMin, double zMin, double xMax, double yMax, double zMax,
                    [System::Runtime::InteropServices::Out] array<System::Tuple<int, int>^>^% outDimTags, int dim)
                {
                    gmsh::vectorpair outDimTags_native;
                    //
                    gmsh::model::occ::getEntitiesInBoundingBox(xMin, yMin, zMin, xMax, yMax, zMax, outDimTags_native, dim);
                    //
                    outDimTags = gcnew array<System::Tuple<int, int>^>(outDimTags_native.size());
                    for (int i = 0; i < outDimTags_native.size(); ++i)
                        outDimTags[i] = gcnew System::Tuple<int, int>(outDimTags_native[i].first, outDimTags_native[i].second);
                }
                static int AddPoint(double x, double y, double z, int tag)
                {
                    return AddPoint(x, y, z, 0.0, tag);
                }
                static int AddPoint(double x, double y, double z, double meshSize)
                {
                    return AddPoint(x, y, z, meshSize, -1);
                }
                static int AddPoint(double x, double y, double z)
                {
                    return AddPoint(x, y, z, 0, -1);
                }
                static int AddPoint(double x, double y, double z, double meshSize, int tag)
                {
                    return gmsh::model::occ::addPoint(x, y, z, meshSize, tag);
                }
                static int AddLine(int startTag, int endTag)
                {
                    return AddLine(startTag, endTag, -1);
                }
                static int AddLine(int startTag, int endTag, int tag)
                {
                    return gmsh::model::occ::addLine(startTag, endTag, tag);
                }
                static int AddBSpline(array<int>^ pointTags, int tag, int degree, array<double>^ weights, array<double>^ knots, array<int>^ multiplicities)
                {
                    std::vector<int> pointTags_native(pointTags->Length), multiplicities_native(multiplicities->Length);
                    std::vector<double> weights_native(weights->Length), knots_native(knots->Length);

                    Marshal::Copy(pointTags, 0, IntPtr(pointTags_native.data()), pointTags->Length);
                    Marshal::Copy(weights, 0, IntPtr(weights_native.data()), weights->Length);
                    Marshal::Copy(knots, 0, IntPtr(knots_native.data()), knots->Length);
                    Marshal::Copy(multiplicities, 0, IntPtr(multiplicities_native.data()), multiplicities->Length);


                    return gmsh::model::occ::addBSpline(pointTags_native, tag, degree, weights_native, knots_native, multiplicities_native);
                }
                static int AddBSpline(array<int>^ pointTags, int tag, int degree, array<double>^ weights)
                {
                    std::vector<int> pointTags_native(pointTags->Length);
                    std::vector<double> weights_native(weights->Length);

                    Marshal::Copy(pointTags, 0, IntPtr(pointTags_native.data()), pointTags->Length);
                    Marshal::Copy(weights, 0, IntPtr(weights_native.data()), weights->Length);

                    return gmsh::model::occ::addBSpline(pointTags_native, tag, degree, weights_native);
                }
                static int AddCurveLoop(array<int>^ curveTags)
                {
                    return AddCurveLoop(curveTags, -1);
                }
                static int AddCurveLoop(array<int>^ curveTags, int tag)
                {
                    std::vector<int> curveTags_native(curveTags->Length);

                    Marshal::Copy(curveTags, 0, IntPtr(curveTags_native.data()), curveTags->Length);

                    return gmsh::model::occ::addCurveLoop(curveTags_native, tag);
                }
                static int AddPlaneSurface(array<int>^ wireTags)
                {
                    return AddPlaneSurface(wireTags, -1);
                }
                static int AddPlaneSurface(array<int>^ wireTags, int tag)
                {
                    std::vector<int> wireTags_native(wireTags->Length);

                    Marshal::Copy(wireTags, 0, IntPtr(wireTags_native.data()), wireTags->Length);

                    return gmsh::model::occ::addPlaneSurface(wireTags_native, tag);
                }
                static int AddBSplineSurface(array<int>^ pointTags, int numPointsU, int tag, int degreeU, int degreeV,
                    array<double>^ weights, array<double>^ knotsU, array<double>^ knotsV, array<int>^ multiplicitiesU,
                    array<int>^ multiplicitiesV, array<int>^ wireTags, bool wire3d)
                {
                    std::vector<int> pointTags_native(pointTags->Length),
                        multiplicitiesU_native(multiplicitiesU->Length), multiplicitiesV_native(multiplicitiesV->Length),
                        wireTags_native(wireTags->Length);
                    std::vector<double> weights_native(weights->Length), knotsU_native(knotsU->Length), knotsV_native(knotsV->Length);

                    Marshal::Copy(pointTags, 0, IntPtr(pointTags_native.data()), pointTags->Length);
                    Marshal::Copy(weights, 0, IntPtr(weights_native.data()), weights->Length);
                    Marshal::Copy(knotsU, 0, IntPtr(knotsU_native.data()), knotsU->Length);
                    Marshal::Copy(knotsV, 0, IntPtr(knotsV_native.data()), knotsV->Length);
                    Marshal::Copy(multiplicitiesU, 0, IntPtr(multiplicitiesU_native.data()), multiplicitiesU->Length);
                    Marshal::Copy(multiplicitiesV, 0, IntPtr(multiplicitiesV_native.data()), multiplicitiesV->Length);
                    Marshal::Copy(wireTags, 0, IntPtr(wireTags_native.data()), wireTags->Length);

                    return gmsh::model::occ::addBSplineSurface(pointTags_native, numPointsU, tag, degreeU, degreeV, weights_native,
                        knotsU_native, knotsV_native,
                        multiplicitiesU_native, multiplicitiesV_native,
                        wireTags_native, wire3d);

                }
                static int AddBSplineSurface(array<int>^ pointTags, int numPointsU, int tag, int degreeU, int degreeV,
                    array<double>^ weights, array<int>^ wireTags, bool wire3d)
                {
                    std::vector<int> pointTags_native(pointTags->Length),
                        wireTags_native(wireTags->Length);
                    std::vector<double> weights_native(weights->Length);

                    Marshal::Copy(pointTags, 0, IntPtr(pointTags_native.data()), pointTags->Length);
                    Marshal::Copy(weights, 0, IntPtr(weights_native.data()), weights->Length);
                    Marshal::Copy(wireTags, 0, IntPtr(wireTags_native.data()), wireTags->Length);

                    return gmsh::model::occ::addBSplineSurface(pointTags_native, numPointsU, tag, degreeU, degreeV, weights_native,
                        std::vector<double>(), std::vector<double>(),
                        std::vector<int>(), std::vector<int>(),
                        wireTags_native, wire3d);
                }
                static int AddBSplineSurface(array<int>^ pointTags, int numPointsU, int tag, int degreeU, int degreeV,
                    array<double>^ weights)
                {
                    std::vector<int> pointTags_native(pointTags->Length);
                    std::vector<double> weights_native(weights->Length);

                    Marshal::Copy(pointTags, 0, IntPtr(pointTags_native.data()), pointTags->Length);
                    Marshal::Copy(weights, 0, IntPtr(weights_native.data()), weights->Length);

                    return gmsh::model::occ::addBSplineSurface(pointTags_native, numPointsU, tag, degreeU, degreeV, weights_native,
                        std::vector<double>(), std::vector<double>(),
                        std::vector<int>(), std::vector<int>());
                }
                static int AddWire(array<int>^ curveTags, int tag, bool checkClosed)
                {
                    std::vector<int> curveTags_native(curveTags->Length);
                    Marshal::Copy(curveTags, 0, IntPtr(curveTags_native.data()), curveTags->Length);

                    return gmsh::model::occ::addWire(curveTags_native, tag, checkClosed);
                }
                static int AddSurfaceLoop(array<int>^ surfaceTags)
                {
                    return AddSurfaceLoop(surfaceTags, -1);
                }
                static int AddSurfaceLoop(array<int>^ surfaceTags, int tag)
                {
                    std::vector<int> nSurfaceTags(surfaceTags->Length);
                    Marshal::Copy(surfaceTags, 0, IntPtr(nSurfaceTags.data()), surfaceTags->Length);

                    return gmsh::model::occ::addSurfaceLoop(nSurfaceTags, tag);
                }
                static int AddVolume(array<int>^ shellTags)
                {
                    return AddVolume(shellTags, -1);
                }
                static int AddVolume(array<int>^ shellTags, int tag)
                {
                    std::vector<int> nShellTags(shellTags->Length);
                    Marshal::Copy(shellTags, 0, IntPtr(nShellTags.data()), shellTags->Length);

                    return gmsh::model::occ::addVolume(nShellTags, tag);
                }
                static void SetSize(array<System::Tuple<int, int>^>^ dimTags, double size)
                {
                    gmsh::vectorpair dimTags_native;
                    for (int i = 0; i < dimTags->Length; ++i)
                    {
                        dimTags_native.push_back(std::pair<int, int>(dimTags[i]->Item1, dimTags[i]->Item2));
                    }
                    //
                    gmsh::model::occ::mesh::setSize(dimTags_native, size);
                }

                //
                ref class Mesh
                {
                public:

                };
            };

        };
        //
        ref class Logger
        {
        public:
            static void Write(System::String^ message, System::String^ level)
            {
                gmsh::logger::write(msclr::interop::marshal_as<std::string>(message), msclr::interop::marshal_as<std::string>(level));
            }
            static void Start()
            {
                gmsh::logger::start();
            }
            static array<System::String^>^ Get()
            {
                std::vector<std::string> messages;
                gmsh::logger::get(messages);
                array<System::String^>^ log = gcnew array<System::String^>(messages.size());
                for (int i = 0; i < log->Length; ++i)
                {
                    log[i] = gcnew System::String(messages[i].c_str());
                }

                return log;
            }
            static void Stop()
            {
                gmsh::logger::stop();
            }
            static System::String^ GetLastError()
            {
                std::string error;
                gmsh::logger::getLastError(error);

                return gcnew System::String(error.c_str());
            }
        };
        //
	};
}