pytessel 1.2.4__cp39-cp39-macosx_11_0_arm64.whl

pytessel/isosurface.h

@@ -0,0 +1,180 @@
+/**************************************************************************
+ *                                                                        *
+ *   Author: Ivo Filot <ivo@ivofilot.nl>                                  *
+ *                                                                        *
+ *   PyTessel is free software:                                           *
+ *   you can redistribute it and/or modify it under the terms of the      *
+ *   GNU General Public License as published by the Free Software         *
+ *   Foundation, either version 3 of the License, or (at your option)     *
+ *   any later version.                                                   *
+ *                                                                        *
+ *   PyTessel is distributed in the hope that it will be useful,          *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty          *
+ *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.              *
+ *   See the GNU General Public License for more details.                 *
+ *                                                                        *
+ *   You should have received a copy of the GNU General Public License    *
+ *   along with this program.  If not, see http://www.gnu.org/licenses/.  *
+ *                                                                        *
+ **************************************************************************/
+
+#pragma once
+
+#include <vector>
+#include <iostream>
+#include <cmath>
+#include <mutex>
+#include <memory>
+
+#include "edgetable.h"
+#include "triangletable.h"
+#include "scalar_field.h"
+
+#define PRECISION_LIMIT 0.000000001
+
+/*
+ *            z
+ *            |
+ *            4----5
+ *         /|     /|
+ *        7-|--6 |
+ *        | 0--|-1--- y
+ *        |/     |/
+ *        3----2
+ *     /
+ *    x
+ *
+ */
+
+class Cube{
+private:
+    unsigned int i,j,k;                           // starting position of the cube
+    float values[8];                              // vector holding cube values
+    unsigned int cubidx;                          // cubeindex (whether there is an intersection)
+
+public:
+    Cube();
+
+    Cube(unsigned int _i, unsigned int _j, unsigned int _k, const ScalarField &_vp);
+
+    void set_cube_index(float _isovalue);
+
+    unsigned int get_cube_index() const;
+
+    float get_value_from_vertex(unsigned int _p) const;
+    Vec3 get_position_from_vertex(unsigned int _p) const;
+};
+
+/*
+ *               + 0
+ *              /|\
+ *             / | \
+ *            /  |  \
+ *           /   |   \
+ *          /    |    \
+ *         /     |     \
+ *        +-------------+ 1
+ *       3 \     |     /
+ *          \    |    /
+ *           \   |   /
+ *            \  |  /
+ *             \ | /
+ *              \|/
+ *               + 2
+ */
+
+class Tetrahedron{
+private:
+    unsigned int i,j,k;     //!< starting position of the cube
+    float values[4];
+    unsigned int tetidx;    //!< cubeindex (whether there is an intersection)
+    Vec3 pos[4];       //!< coordinates of the gridpoints
+
+public:
+    Tetrahedron(unsigned int _i, unsigned int _j, unsigned int _k, const ScalarField &_vp, unsigned int _pos);
+
+    void set_tetrahedron_index(float _isovalue);
+
+    unsigned int get_tetrahedron_index() const;
+
+    float get_value_from_vertex(unsigned int _p) const;
+
+    const Vec3& get_position_from_vertex(unsigned int _p) const;
+};
+
+class Triangle{
+public:
+    Vec3 p1, p2, p3;
+
+    Triangle();
+
+    Triangle(const Vec3 &_p1, const Vec3 &_p2, const Vec3 &_p3);
+
+    void transform_to_real(const ScalarField &_vp);
+
+    float get_x(unsigned int i) const;
+
+    float get_y(unsigned int i) const;
+
+    float get_z(unsigned int i) const;
+};
+
+/**
+ * @brief      generates an isosurface using either the marching cubes or the
+ *             marching tetrahedra algorithm, input is a (tabulated) scalar
+ *             field
+ */
+class IsoSurface {
+private:
+    std::vector<Cube> cube_table;
+    std::vector<Tetrahedron> tetrahedra_table;
+    std::vector<Triangle> triangles;
+    std::shared_ptr<ScalarField> vp_ptr;        // pointer to ScalarField obj
+    unsigned int grid_dimensions[3];
+    float isovalue;                             // isovalue setting
+
+public:
+    /**
+     * @brief      default constructor
+     *
+     * @param      _sf   pointer to ScalarField object
+     */
+    IsoSurface(const std::shared_ptr<ScalarField>& _sf);
+
+    /**
+     * @brief      generate isosurface using marching cubes algorithm
+     *
+     * @param[in]  _isovalue  The isovalue
+     */
+    void marching_cubes(float _isovalue);
+
+    /**
+     * @brief      generate isosurface using marching tetrahedra algorithm
+     *
+     * @param[in]  _isovalue  The isovalue
+     */
+    void marching_tetrahedra(float _isovalue);
+
+    /**
+     * @brief      Gets the triangles pointer.
+     *
+     * @return     The triangles pointer.
+     */
+    const std::vector<Triangle>* get_triangles_ptr() const;
+
+    inline float get_isovalue() const {
+        return this->isovalue;
+    }
+
+    inline const std::shared_ptr<ScalarField>& get_scalar_field() const {
+        return this->vp_ptr;
+    }
+
+private:
+    void sample_grid_with_cubes(float _isovalue);
+    void sample_grid_with_tetrahedra(float _isovalue);
+    void construct_triangles_from_cubes(float _isovalue);
+    void construct_triangles_from_tetrahedra(float _isovalue);
+    Vec3 interpolate_from_cubes(const Cube &_cub, unsigned int _p1, unsigned int _p2, float _isovalue);
+    Vec3 interpolate_from_tetrahedra(const Tetrahedron &_cub, unsigned int _p1, unsigned int _p2, float _isovalue);
+};

pytessel/isosurface_mesh.cpp

@@ -0,0 +1,144 @@
+/**************************************************************************
+ *                                                                        *
+ *   Author: Ivo Filot <ivo@ivofilot.nl>                                  *
+ *                                                                        *
+ *   PyTessel is free software:                                           *
+ *   you can redistribute it and/or modify it under the terms of the      *
+ *   GNU General Public License as published by the Free Software         *
+ *   Foundation, either version 3 of the License, or (at your option)     *
+ *   any later version.                                                   *
+ *                                                                        *
+ *   PyTessel is distributed in the hope that it will be useful,          *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty          *
+ *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.              *
+ *   See the GNU General Public License for more details.                 *
+ *                                                                        *
+ *   You should have received a copy of the GNU General Public License    *
+ *   along with this program.  If not, see http://www.gnu.org/licenses/.  *
+ *                                                                        *
+ **************************************************************************/
+
+#include "isosurface_mesh.h"
+
+/**
+ * @brief      build isosurface mesh object
+ *
+ * @param[in]  _sf   pointer to scalar field
+ * @param[in]  _is   pointer to isosurface
+ */
+IsoSurfaceMesh::IsoSurfaceMesh(const std::shared_ptr<const ScalarField>& _sf,
+                               const std::shared_ptr<const IsoSurface>& _is) :
+    sf(_sf),
+    is(_is) {
+}
+
+/**
+ * @brief      construct surface mesh
+ *
+ * @param[in]  center  whether to center structure
+ */
+void IsoSurfaceMesh::construct_mesh(bool center_mesh) {
+   // grab center
+    this->center = this->sf->get_mat_unitcell() * Vec3(0.5, 0.5, 0.5);
+
+    for(unsigned int i=0; i<this->is->get_triangles_ptr()->size(); i++) {
+        // load all index vertices in a map; this operation needs to be done, else a SEGFAULT
+        // will be thrown further down the lines
+        this->get_index_vertex(is->get_triangles_ptr()->at(i).p1);
+        this->get_index_vertex(is->get_triangles_ptr()->at(i).p2);
+        this->get_index_vertex(is->get_triangles_ptr()->at(i).p3);
+    }
+
+    // build vertex vector from unordered map
+    this->vertices.resize(this->vertices_map.size());
+    for(auto it : this->vertices_map) {
+        this->vertices[it.second] = it.first;
+    }
+
+    double dev = 0.01;
+    this->normals.resize(this->vertices.size());
+
+    // calculate normal vectors
+    #pragma omp parallel for schedule(static)
+    for(unsigned int i=0; i<this->vertices.size(); i++) {
+        // get derivatives
+        double dx0 = sf->get_value_interp(this->vertices[i].x - dev, this->vertices[i].y, this->vertices[i].z);
+        double dx1 = sf->get_value_interp(this->vertices[i].x + dev, this->vertices[i].y, this->vertices[i].z);
+
+        double dy0 = sf->get_value_interp(this->vertices[i].x, this->vertices[i].y - dev, this->vertices[i].z);
+        double dy1 = sf->get_value_interp(this->vertices[i].x, this->vertices[i].y + dev, this->vertices[i].z);
+
+        double dz0 = sf->get_value_interp(this->vertices[i].x, this->vertices[i].y, this->vertices[i].z - dev);
+        double dz1 = sf->get_value_interp(this->vertices[i].x, this->vertices[i].y, this->vertices[i].z + dev);
+
+        Vec3 normal((dx1 - dx0) / (2.0 * dev),
+                    (dy1 - dy0) / (2.0 * dev),
+                    (dz1 - dz0) / (2.0 * dev));
+        normal = -1 * normal.normalized(); // the negative of the gradient is the correct normal
+
+        this->normals[i] = normal * sgn(sf->get_value_interp(this->vertices[i].x, this->vertices[i].y, this->vertices[i].z));
+    }
+
+    // build indices in right orientation based on face normal
+    for(unsigned int i=0; i<this->is->get_triangles_ptr()->size(); i++) {
+        // calculate face normal
+        unsigned int id1 = this->get_index_vertex(is->get_triangles_ptr()->at(i).p1);
+        unsigned int id2 = this->get_index_vertex(is->get_triangles_ptr()->at(i).p2);
+        unsigned int id3 = this->get_index_vertex(is->get_triangles_ptr()->at(i).p3);
+
+        // calculate the orientation of the face with respect to the normal
+        const Vec3 face_normal = (this->normals[id1] + this->normals[id2] + this->normals[id3]) / 3.0f;
+        const Vec3 orientation_face = ((this->vertices[id2] - this->vertices[id1]).cross(this->vertices[id3] - this->vertices[id1])).normalized();
+        const float orientation = face_normal.dot(orientation_face);
+
+        // if orientation is positive, the orientation is correct, if it is negative, the orientation is incorrect and two indices should be swapped
+        if(orientation > 0.0f) {
+            this->indices.push_back(id1);
+            this->indices.push_back(id2);
+            this->indices.push_back(id3);
+        } else {
+            this->indices.push_back(id2);
+            this->indices.push_back(id1);
+            this->indices.push_back(id3);
+        }
+    }
+
+    // center structure
+    if(center_mesh) {
+        Vec3 sum = this->sf->get_mat_unitcell() * Vec3(0.5f, 0.5f, 0.5f);
+
+        #pragma omp parallel for
+        for(unsigned int i=0; i<this->vertices.size(); i++) {
+           this->vertices[i] -= sum;
+        }
+    }
+}
+
+/**
+ * @brief      get the index of a vertex from unordered map
+ *
+ * @param[in]  v     vertex coordinates
+ *
+ * @return     the index
+ */
+unsigned int IsoSurfaceMesh::get_index_vertex(const Vec3 v) {
+    auto got = this->vertices_map.find(v);
+    if(got != this->vertices_map.end()) {
+        return got->second;
+    } else {
+        this->vertices_map.emplace(v, this->vertices_map.size());
+        return this->get_index_vertex(v);
+    }
+}
+
+std::vector<float> IsoSurfaceMesh::get_vertices() const {
+    return std::vector<float>(&this->vertices[0].x, &this->vertices[0].x + this->vertices.size() * 3);
+}
+
+std::vector<float> IsoSurfaceMesh::get_normals() const {
+    return std::vector<float>(&this->normals[0].x, &this->normals[0].x + this->normals.size() * 3);
+}
+
+const std::vector<unsigned int>& IsoSurfaceMesh::get_indices() const {
+    return this->indices;
+}

pytessel/isosurface_mesh.h

@@ -0,0 +1,104 @@
+/**************************************************************************
+ *                                                                        *
+ *   Author: Ivo Filot <ivo@ivofilot.nl>                                  *
+ *                                                                        *
+ *   PyTessel is free software:                                           *
+ *   you can redistribute it and/or modify it under the terms of the      *
+ *   GNU General Public License as published by the Free Software         *
+ *   Foundation, either version 3 of the License, or (at your option)     *
+ *   any later version.                                                   *
+ *                                                                        *
+ *   PyTessel is distributed in the hope that it will be useful,          *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty          *
+ *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.              *
+ *   See the GNU General Public License for more details.                 *
+ *                                                                        *
+ *   You should have received a copy of the GNU General Public License    *
+ *   along with this program.  If not, see http://www.gnu.org/licenses/.  *
+ *                                                                        *
+ **************************************************************************/
+
+#pragma once
+
+#include <fstream>
+#include <set>
+#include <vector>
+#include <unordered_map>
+#include <memory>
+
+#include "vec3.h"
+#include "isosurface.h"
+
+// add SGN function for Windows
+template <typename T> float sgn(T val) {
+    return (T(0) < val) - (val < T(0));
+}
+
+/**
+ * @brief      structure to put Vec3f in a map
+ */
+struct KeyFuncs
+{
+    size_t operator()(const Vec3& k)const
+    {
+        return std::hash<float>()(k.x) ^ std::hash<float>()(k.y) ^ std::hash<float>()(k.z);
+    }
+
+    bool operator()(const Vec3& a, const Vec3& b)const
+    {
+            return a.x == b.x && a.y == b.y && a.z == b.z;
+    }
+};
+
+/**
+ * @brief      Class for iso surface mesh.
+ */
+class IsoSurfaceMesh{
+private:
+    std::unordered_map<Vec3, unsigned int, KeyFuncs, KeyFuncs> vertices_map;
+    std::vector<Vec3> vertices;
+    std::vector<Vec3> normals;
+    std::vector<unsigned int> indices;
+
+    std::shared_ptr<const ScalarField> sf;
+    std::shared_ptr<const IsoSurface> is;
+
+    Vec3 center;
+
+public:
+    /**
+     * @brief      build isosurface mesh object
+     *
+     * @param[in]  _sf   pointer to scalar field
+     * @param[in]  _is   pointer to isosurface
+     */
+    IsoSurfaceMesh(const std::shared_ptr<const ScalarField>& _sf,
+                   const std::shared_ptr<const IsoSurface>& _is);
+
+    IsoSurfaceMesh(const std::vector<float>& vertices,
+                   const std::vector<float>& normals,
+                   const std::vector<unsigned int>& indices);
+
+    /**
+     * @brief      construct surface mesh
+     *
+     * @param[in]  center_mesh  whether to center structure
+     */
+    void construct_mesh(bool center_mesh);
+
+    std::vector<float> get_vertices() const;
+
+    std::vector<float> get_normals() const;
+
+    const std::vector<unsigned int>& get_indices() const;
+
+private:
+    /**
+     * @brief      get the index of a vertex from unordered map
+     *
+     * @param[in]  v     vertex coordinates
+     *
+     * @return     the index
+     */
+    unsigned int get_index_vertex(const Vec3 v);
+};

pytessel/scalar_field.cpp

@@ -0,0 +1,239 @@
+/**************************************************************************
+ *                                                                        *
+ *   Author: Ivo Filot <ivo@ivofilot.nl>                                  *
+ *                                                                        *
+ *   PyTessel is free software:                                           *
+ *   you can redistribute it and/or modify it under the terms of the      *
+ *   GNU General Public License as published by the Free Software         *
+ *   Foundation, either version 3 of the License, or (at your option)     *
+ *   any later version.                                                   *
+ *                                                                        *
+ *   PyTessel is distributed in the hope that it will be useful,          *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty          *
+ *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.              *
+ *   See the GNU General Public License for more details.                 *
+ *                                                                        *
+ *   You should have received a copy of the GNU General Public License    *
+ *   along with this program.  If not, see http://www.gnu.org/licenses/.  *
+ *                                                                        *
+ **************************************************************************/
+
+#include "scalar_field.h"
+
+/**
+ * @brief      constructor
+ *
+ * @param[in]  _filename   url to filename
+ * @param[in]  _flag_is_locpot  whether this file is a locpot
+ */
+ScalarField::ScalarField(const std::vector<float>& _grid,
+                         const std::vector<unsigned int>& _dimensions,
+                         const std::vector<float>& _unitcell) {
+
+    this->grid = _grid;
+    this->grid_dimensions = {_dimensions[0], _dimensions[1], _dimensions[2]};
+    for(unsigned int i=0; i<3; i++) {
+        for(unsigned int j=0; j<3; j++) {
+            this->unitcell[i][j] = _unitcell[i*3 + j];
+        }
+    }
+    this->inverse(this->unitcell, &this->unitcell_inverse);
+}
+
+/*
+ * float get_value_interp(x,y,z)
+ *
+ * Grabs a value from the 3D scalar field. Calculate the value
+ * by using a trilinear interpolation.
+ *
+ * The trilinear interpolation algorithm has been extracted from:
+ * http://paulbourke.net/miscellaneous/interpolation/
+ *
+ * Future algorithm can make use of a cubic interpolation.
+ *
+ */
+float ScalarField::get_value_interp(float x, float y, float z) const {
+    if(!this->is_inside(x,y,z)) {
+        return 0.0f;
+    }
+
+    // cast the input to the nearest grid point
+    Vec3 r = this->realspace_to_grid(x,y,z);
+
+    // recast
+    if(r.x < 0.0) r.x += (float)this->grid_dimensions[0];
+    if(r.y < 0.0) r.y += (float)this->grid_dimensions[1];
+    if(r.z < 0.0) r.z += (float)this->grid_dimensions[2];
+
+    // calculate value using trilinear interpolation
+    float xd = remainderf(r.x, 1.0);
+    float yd = remainderf(r.y, 1.0);
+    float zd = remainderf(r.z, 1.0);
+
+    if(xd < 0) xd += 1.0;
+    if(yd < 0) yd += 1.0;
+    if(zd < 0) zd += 1.0;
+
+    float x0 = fmod(floor(r.x), this->grid_dimensions[0]);
+    float x1 = fmod(ceil(r.x), this->grid_dimensions[0]);
+    float y0 = fmod(floor(r.y), this->grid_dimensions[1]);
+    float y1 = fmod(ceil(r.y), this->grid_dimensions[1]);
+    float z0 = fmod(floor(r.z), this->grid_dimensions[2]);
+    float z1 = fmod(ceil(r.z), this->grid_dimensions[2]);
+
+    return
+    this->get_value(x0, y0, z0) * (1.0 - xd) * (1.0 - yd) * (1.0 - zd) +
+    this->get_value(x1, y0, z0) * xd                 * (1.0 - yd) * (1.0 - zd) +
+    this->get_value(x0, y1, z0) * (1.0 - xd) * yd                 * (1.0 - zd) +
+    this->get_value(x0, y0, z1) * (1.0 - xd) * (1.0 - yd) * zd                 +
+    this->get_value(x1, y0, z1) * xd                 * (1.0 - yd) * zd                 +
+    this->get_value(x0, y1, z1) * (1.0 - xd) * yd                 * zd                 +
+    this->get_value(x1, y1, z0) * xd                 * yd                 * (1.0 - zd) +
+    this->get_value(x1, y1, z1) * xd                 * yd                 * zd;
+}
+
+/**
+ * @brief      test whether point is inside unit cell
+ *
+ * @param[in]  x     x position
+ * @param[in]  y     y position
+ * @param[in]  z     z position
+ *
+ * @return     True if inside, False otherwise.
+ */
+bool ScalarField::is_inside(float x, float y, float z) const {
+    // cast the input to the nearest grid point
+    Vec3 d = this->realspace_to_direct(x,y,z);
+
+    if(d.x < 0 || d.x > 1.0) {
+        return false;
+    }
+    if(d.y < 0 || d.y > 1.0) {
+        return false;
+    }
+    if(d.z < 0 || d.z > 1.0) {
+        return false;
+    }
+
+    return true;
+}
+
+/*
+ * float get_value(i,j,k)
+ *
+ * Grabs the value at a particular grid point.
+ *
+ * This is a convenience function for the get_value_interp() function
+ *
+ */
+float ScalarField::get_value(unsigned int i, unsigned int j, unsigned int k) const {
+    unsigned int idx = k * this->grid_dimensions[0] * this->grid_dimensions[1] +
+                       j * this->grid_dimensions[0] +
+                       i;
+    return this->grid[idx];
+}
+
+/*
+ * Vec3 grid_to_realspace(i,j,k)
+ *
+ * Converts a grid point to a realspace vector. This function
+ * is not being used at the moment.
+ *
+ */
+Vec3 ScalarField::grid_to_realspace(float i, float j, float k) const {
+    float dx = (float)i / (float)grid_dimensions[0];
+    float dy = (float)j / (float)grid_dimensions[1];
+    float dz = (float)k / (float)grid_dimensions[2];
+
+    Vec3 r;
+    r.x = this->unitcell[0][0] * dx + this->unitcell[1][0] * dy + this->unitcell[2][0] * dz;
+    r.y = this->unitcell[0][1] * dx + this->unitcell[1][1] * dy + this->unitcell[2][1] * dz;
+    r.z = this->unitcell[0][2] * dx + this->unitcell[1][2] * dy + this->unitcell[2][2] * dz;
+
+    return r;
+}
+
+Vec3 ScalarField::realspace_to_direct(float x, float y, float z) const {
+    Vec3 d;
+    d.x = this->unitcell_inverse[0][0] * x + this->unitcell_inverse[0][1] * y + this->unitcell_inverse[0][2] * z;
+    d.y = this->unitcell_inverse[1][0] * x + this->unitcell_inverse[1][1] * y + this->unitcell_inverse[1][2] * z;
+    d.z = this->unitcell_inverse[2][0] * x + this->unitcell_inverse[2][1] * y + this->unitcell_inverse[2][2] * z;
+
+    return d;
+}
+
+/*
+ * Vec3 realspace_to_grid(i,j,k)
+ *
+ * Convert 3d realspace vector to a position on the grid. Non-integer
+ * values (i.e. floating point) are given as the result.
+ *
+ * This is a convenience function for the get_value_interp() function
+ *
+ */
+Vec3 ScalarField::realspace_to_grid(float i, float j, float k) const {
+    Vec3 g = this->realspace_to_direct(i, j, k);
+
+    g.x *= float(this->grid_dimensions[0]);
+    g.y *= float(this->grid_dimensions[1]);
+    g.z *= float(this->grid_dimensions[2]);
+
+    return g;
+}
+
+void ScalarField::copy_grid_dimensions(unsigned int _grid_dimensions[]) const {
+    for(unsigned int i=0; i<3; i++) {
+        _grid_dimensions[i] = this->grid_dimensions[i];
+    }
+}
+
+float ScalarField::get_max() const {
+    return *std::max_element(this->grid.begin(), this->grid.end());
+}
+
+float ScalarField::get_min() const {
+    return *std::min_element(this->grid.begin(), this->grid.end());
+}
+
+void ScalarField::inverse(const mat33& mat, mat33* invmat) {
+    // computes the inverse of a matrix m
+    float det = mat[0][0] * (mat[1][1] * mat[2][2] - mat[2][1] * mat[1][2]) -
+                mat[0][1] * (mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0]) +
+                mat[0][2] * (mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0]);
+
+    float invdet = 1.0 / det;
+
+    (*invmat)[0][0] = (mat[1][1] * mat[2][2] - mat[2][1] * mat[1][2]) * invdet;
+    (*invmat)[0][1] = (mat[0][2] * mat[2][1] - mat[0][1] * mat[2][2]) * invdet;
+    (*invmat)[0][2] = (mat[0][1] * mat[1][2] - mat[0][2] * mat[1][1]) * invdet;
+    (*invmat)[1][0] = (mat[1][2] * mat[2][0] - mat[1][0] * mat[2][2]) * invdet;
+    (*invmat)[1][1] = (mat[0][0] * mat[2][2] - mat[0][2] * mat[2][0]) * invdet;
+    (*invmat)[1][2] = (mat[1][0] * mat[0][2] - mat[0][0] * mat[1][2]) * invdet;
+    (*invmat)[2][0] = (mat[1][0] * mat[2][1] - mat[2][0] * mat[1][1]) * invdet;
+    (*invmat)[2][1] = (mat[2][0] * mat[0][1] - mat[0][0] * mat[2][1]) * invdet;
+    (*invmat)[2][2] = (mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1]) * invdet;
+}
+
+std::vector<float> ScalarField::get_unitcell_vf() const {
+    std::vector<float> ans(9,0.0);
+
+    for(unsigned int i=0; i<3; i++) {
+        for(unsigned int j=0; j<3; j++) {
+            ans[i*3 + j] = this->unitcell[i][j];
+        }
+    }
+
+    return ans;
+}
+
+std::vector<float> ScalarField::get_unitcell_inverse() const {
+    std::vector<float> ans(9,0.0);
+
+    for(unsigned int i=0; i<3; i++) {
+        for(unsigned int j=0; j<3; j++) {
+            ans[i*3 + j] = this->unitcell_inverse[i][j];
+        }
+    }
+
+    return ans;
+}