pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/simcases/run_example_cases.py

@@ -0,0 +1,69 @@
+'''
+================================================================================
+pyvale: the python computer aided validation engine
+
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+'''
+import time
+from pathlib import Path
+from pyvale.mooseherder import (MooseConfig,
+                         MooseRunner,
+                         GmshRunner)
+
+
+EXAMPLE_CASES = [13,16,17]
+USER_DIR = Path.home()
+FORCE_GMSH = False
+CASES_DIR = Path('src/simcases/')
+
+def run_one_case(case_str: str) -> None:
+    print(80*'=')
+    print(f'Running: {case_str}')
+    print(80*'=')
+
+    case_files = (case_str+'.geo',case_str+'.i')
+    case_dir =  CASES_DIR / case_str
+
+    gmsh_run_time = 0.0
+    if (case_dir / case_files[0]).is_file():
+        gmsh_runner = GmshRunner(USER_DIR / 'gmsh/bin/gmsh')
+
+        gmsh_start = time.perf_counter()
+        gmsh_runner.run(case_dir / case_files[0])
+        gmsh_run_time = time.perf_counter()-gmsh_start
+
+    config = {'main_path': USER_DIR / 'moose',
+            'app_path': USER_DIR / 'proteus',
+            'app_name': 'proteus-opt'}
+
+    moose_config = MooseConfig(config)
+    moose_runner = MooseRunner(moose_config)
+
+    moose_runner.set_run_opts(n_tasks = 1,
+                              n_threads = 8,
+                              redirect_out = False)
+
+    moose_start_time = time.perf_counter()
+    moose_runner.run(case_dir / case_files[1])
+    moose_run_time = time.perf_counter() - moose_start_time
+
+    print()
+    print("="*80)
+    print(f'CASE: {case_str}')
+    print(f'Gmsh run time = {gmsh_run_time:.2f} seconds')
+    print(f'MOOSE run time = {moose_run_time:.3f} seconds')
+    print("="*80)
+    print()
+
+
+def main() -> None:
+    for ss in EXAMPLE_CASES:
+        case_str = 'case' + str(ss).zfill(2)
+        run_one_case(case_str)
+
+
+if __name__ == '__main__':
+    main()
+

pyvale/strain/__init__.py

@@ -0,0 +1,13 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+
+from .strain import calculate_2d
+from .strainimport import import_2d
+from .strainresults import StrainResults
+
+__all__ = ["calculate_2d",
+           "StrainResults",
+           "import_2d"]

pyvale/strain/cpp/bindings.cpp

@@ -0,0 +1,25 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+// pybind header files
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+#include <pybind11/iostream.h>
+
+// Strain Header files
+#include "./strain.hpp"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(strain_cpp, m) {
+
+    py::add_ostream_redirect(m, "ostream_redirect");
+    
+    // Bind the engine function
+    m.def("strain_engine", &strain::engine, "Run DIC analysis on input images with config");
+}
+

pyvale/strain/cpp/smooth.cpp

@@ -0,0 +1,140 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+// STD library Header files
+#include <vector>
+
+// common_cpp Header files
+#include <Eigen/Dense>
+
+// Strain Header files
+#include "./smooth.hpp"
+
+
+namespace smooth {
+
+    // bilinear lagrange polynomials
+    Eigen::VectorXd q4(std::vector<int> &x, std::vector<int> &y, 
+                       std::vector<double>& disp_vals){
+
+        Eigen::MatrixXd A(disp_vals.size(), 4);
+        Eigen::VectorXd b(disp_vals.size());
+        
+        for (size_t i = 0; i < x.size(); ++i) {
+            double ss_x = x[i];
+            double ss_y = y[i];
+            A(i, 0) = 1.0;
+            A(i, 1) = ss_x;
+            A(i, 2) = ss_y;
+            A(i, 3) = ss_x * ss_y;
+            b(i) = disp_vals[i];
+        }
+
+        // solve linear system A * coeffs = b
+        Eigen::VectorXd coeffs = (A.transpose() * A).ldlt().solve(A.transpose() * b);
+        return coeffs;
+    }
+
+    // biquadratic lagrange polynomials
+    Eigen::VectorXd q9(std::vector<int>& x, std::vector<int>& y,
+                       std::vector<double>& disp_vals) {
+
+        Eigen::MatrixXd A(disp_vals.size(), 9);
+        Eigen::VectorXd b(disp_vals.size());
+
+        for (size_t i = 0; i < x.size(); ++i) {
+            double ss_x = x[i];
+            double ss_y = y[i];
+            A(i, 0) = 1.0;
+            A(i, 1) = ss_x;
+            A(i, 2) = ss_y;
+            A(i, 3) = ss_x * ss_y;
+            A(i, 4) = ss_x * ss_x;
+            A(i, 5) = ss_y * ss_y;
+            A(i, 6) = ss_x * ss_x * ss_y;
+            A(i, 7) = ss_x * ss_y * ss_y;
+            A(i, 8) = ss_x * ss_x * ss_y * ss_y;
+
+            b(i) = disp_vals[i];
+        }
+
+        Eigen::VectorXd coeffs = (A.transpose() * A).ldlt().solve(A.transpose() * b);
+        return coeffs;
+    }
+
+
+    // 2D Gaussian kernel with a given radius and sigma
+    std::vector<std::vector<double>> make_gaussian_kernel(int radius, double sigma) {
+        std::vector<std::vector<double>> kernel(2 * radius + 1, std::vector<double>(2 * radius + 1));
+        double sum = 0.0;
+
+        for (int y = -radius; y <= radius; ++y) {
+            for (int x = -radius; x <= radius; ++x) {
+                double value = std::exp(-(x * x + y * y) / (2.0 * sigma * sigma));
+                kernel[y + radius][x + radius] = value;
+                sum += value;
+            }
+        }
+
+        // Normalize the kernel
+        for (int y = 0; y < 2 * radius + 1; ++y) {
+            for (int x = 0; x < 2 * radius + 1; ++x) {
+                kernel[y][x] /= sum;
+            }
+        }
+
+        return kernel;
+    }
+
+    // Reflect index at boundaries (mirrored edges)
+    int mirror_index(int idx, int max) {
+        if (idx < 0) return -idx;
+        if (idx >= max) return 2 * max - idx - 2;
+        return idx;
+    }
+
+   void gaussian_2d(std::vector<double>& data,
+                               const std::vector<int>& mask,
+                               int width, int height, double sigma) {
+
+        int radius = static_cast<int>(std::ceil(3.0 * sigma));
+        std::vector<std::vector<double>> kernel = make_gaussian_kernel(radius, sigma);
+
+        std::vector<double> result(data.size(), 0.0);
+
+        for (int y = 0; y < height; ++y) {
+            for (int x = 0; x < width; ++x) {
+
+                int idx = y * width + x;
+                if (mask[idx]==-1) continue;
+
+                double weighted_sum = 0.0;
+                double weight_total = 0.0;
+
+                for (int ky = -radius; ky <= radius; ++ky) {
+                    for (int kx = -radius; kx <= radius; ++kx) {
+                        int nx = mirror_index(x + kx, width);
+                        int ny = mirror_index(y + ky, height);
+                        int nidx = ny * width + nx;
+
+                        if (mask[nidx]!=-1) {
+                            double weight = kernel[ky + radius][kx + radius];
+                            weighted_sum += data[nidx] * weight;
+                            weight_total += weight;
+                        }
+                    }
+                }
+
+                if (weight_total > 0.0) {
+                    result[idx] = weighted_sum / weight_total;
+                }
+            }
+        }
+
+        data = result;
+    }
+
+}

pyvale/strain/cpp/smooth.hpp

@@ -0,0 +1,53 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+#ifndef DICSMOOTH_H
+#define DICSMOOTH_H
+
+// STD library Header files
+#include <vector>
+#include <Eigen/Dense>
+
+// Program Header files
+
+
+
+
+namespace smooth {
+
+    /**
+     * @brief 
+     * 
+     * @param[in] x displacement x-coordinates within strain window
+     * @param[in] y displacement y-coordinates within strain window
+     * @param[in] disp_vals 
+     * @return Eigen::VectorXd A vector of coefficients for a bilinear fit inside strain window
+     */
+    Eigen::VectorXd q4(std::vector<int> &x, std::vector<int> &y, std::vector<double>& disp_vals);
+
+    /**
+     * @brief 
+     * 
+     * @param[in] x displacement x-coordinates within strain window
+     * @param[in] y displacement y-coordinates within strain window
+     * @param[in] disp_vals 
+     * @return Eigen::VectorXd  A vector of coefficients for a bilinear fit inside strain window
+     */
+    Eigen::VectorXd q9(std::vector<int> &x, std::vector<int> &y, std::vector<double>& disp_vals);
+
+    /**
+     * @brief 
+     * 
+     * @param data 
+     * @param mask 
+     * @param width 
+     * @param height 
+     * @param sigma 
+     */
+    void gaussian_2d(std::vector<double>& data, const std::vector<int>& mask, int width, int height, double sigma);
+
+}
+#endif // DICSMOOTH_H

pyvale/strain/cpp/strain.cpp

@@ -0,0 +1,390 @@
+// ================================================================================
+// pyvale: the python validation engine
+// License: MIT
+// Copyright (C) 2025 The Computer Aided Validation Team
+// ================================================================================
+
+// STD library Header files
+#include <cmath>
+#include <omp.h>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+
+// pybind header files
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+
+// eigen header files
+#include <Eigen/Dense>
+
+// common_cpp header files
+#include "../../common_cpp/progressbar.hpp"
+#include "../../common_cpp/defines.hpp"
+#include "../../common_cpp/util.hpp"
+
+// Program Header files
+#include "./smooth.hpp"
+#include "./strain.hpp"
+
+
+
+namespace py = pybind11;
+
+namespace strain {
+
+    Eigen::Matrix2d I = Eigen::Matrix2d::Identity();
+
+    void engine(const py::array_t<int> &ss_x_arr,
+                const py::array_t<int> &ss_y_arr,
+                const py::array_t<double> &u_arr,
+                const py::array_t<double> &v_arr,
+                const int nss_x, const int nss_y, 
+                const int nimg, const int sw_size, 
+                const int q, const std::string &form,
+                const std::vector<std::string> &filenames,
+                const common_util::SaveConfig &strain_save_conf){
+
+        TITLE("Strain Config");
+        INFO_OUT("Number of Images:", nimg)
+        INFO_OUT("Strain window size:", sw_size)
+        INFO_OUT("Strain element (4 = bilinear, 9 is biquadratic):", q);
+        INFO_OUT("Strain formulation:", form);
+        INFO_OUT("Saving data to folder:", strain_save_conf.basepath)
+        INFO_OUT("Saving data as binary ", strain_save_conf.binary)
+
+
+        const bool save_at_end = strain_save_conf.at_end;
+        const int nwindows = nss_x*nss_y;
+
+        // get raw pointers for numpy arrays
+        int* ss_x = static_cast<int*>(ss_x_arr.request().ptr);
+        int* ss_y = static_cast<int*>(ss_y_arr.request().ptr);
+        double* u = static_cast<double*>(u_arr.request().ptr);
+        double* v = static_cast<double*>(v_arr.request().ptr);
+
+        // function wrapper for bilinear or biquadratic element
+        std::function<Eigen::VectorXd(std::vector<int>&, std::vector<int>&, std::vector<double>&)> smooth_window = (q == 4) ? smooth::q4 : smooth::q9;
+
+
+        strain::Window window(sw_size);
+        strain::Results results(save_at_end ? nimg * nwindows : nwindows);
+
+
+        TITLE("Deformation Gradient and Strain Calculation")
+
+        // loop over the displacement images
+        for (int img_num = 0; img_num < nimg; img_num++) {
+
+            ProgressBar pbar(filenames[img_num], nwindows);
+
+            // loop over strain windows within the image
+            for (int sw = 0; sw < nwindows; sw++){
+
+                int x0 = ss_x[sw];
+                int y0 = ss_y[sw];
+                results.x[sw] = x0;
+                results.y[sw] = y0;
+
+                // TODO: through a warning. NAN out the entire window.
+                // it should be up to the user whether they correct with
+                // outlier removal / smoothing.
+                results.valid_window[sw] = fill_window(ss_x, ss_y, u, v, img_num,
+                                                sw, window, nss_x,
+                                                nss_y, sw_size);
+
+                // element coefficients
+                Eigen::VectorXd uc;
+                Eigen::VectorXd vc;
+
+                // 2D deformation gradient matrix and identity matrix
+                Eigen::Matrix2d deform_grad = Eigen::Matrix2d::Zero();
+                Eigen::Matrix2d eps = Eigen::Matrix2d::Zero();
+
+                if (results.valid_window[sw]){
+                    uc = smooth_window(window.x, window.y, window.u);
+                    vc = smooth_window(window.x, window.y, window.v);
+                    deform_grad = compute_def_grad(q, uc, vc, x0, y0);
+                    eps = compute_strain(form, deform_grad);
+                    append_results(sw, results, save_at_end, x0, y0, 
+                                   deform_grad, eps, nwindows, img_num);
+                }
+
+                if (omp_get_thread_num() == 0) pbar.update(sw+1);
+
+            }
+
+            // finish up progress bar
+            pbar.finish();
+
+            if (!save_at_end){
+                strain::save_to_disk(img_num, results, strain_save_conf, 
+                                     nwindows, nimg, filenames);
+            }
+        }
+
+        if (save_at_end){
+            for (int img_num = 0; img_num < nimg; img_num++)
+                strain::save_to_disk(img_num, results, strain_save_conf,
+                                     nwindows, nimg, filenames);
+        }
+    }
+
+
+
+    bool fill_window(int *ss_x, int *ss_y, double *u, double *v,
+                            int img, int sw, Window &window,
+                            int nss_x, int nss_y, int sw_size){
+
+        const int swr = sw_size / 2;
+        const int x0_idx = sw % nss_x;
+        const int y0_idx = sw / nss_x;
+        const int xmin = x0_idx - swr;
+        const int xmax = x0_idx + swr;
+        const int ymin = y0_idx - swr;
+        const int ymax = y0_idx + swr;
+
+        // check centre of strain window is within mask bounds
+        if ((xmin < 0) || (xmax >= nss_x) || (ymin < 0) || (ymax >= nss_y)) return false;
+        
+        int widx = 0;
+        for (int j = ymin; j <= ymax; j++){
+            for (int i = xmin; i <= xmax; i++){
+
+                // index in 3d results array
+                int idx_2d = nss_x*j + i;
+                int idx_3d = nss_x*nss_y*img + idx_2d;
+
+                // check if all subsets in the strain window are not nan
+                if (std::isnan(u[idx_3d]) || std::isnan(v[idx_3d])) return false;
+
+                // populate subset window
+                window.x[widx] = ss_x[idx_2d];
+                window.y[widx] = ss_y[idx_2d];
+                window.u[widx] = u[idx_3d];
+                window.v[widx] = v[idx_3d];
+
+                //std::cout << window.x[idx] << " " << window.y[idx] << " ";
+                //std::cout << window.u[idx] << " " << window.v[idx] << std::endl;
+                widx++;
+            }
+        }
+        return true;
+    }
+
+
+    Eigen::Matrix2d compute_def_grad(const int q, const Eigen::VectorXd &uc, 
+                                     const Eigen::VectorXd& vc, const double x0, 
+                                     const double y0) {
+
+        Eigen::Matrix2d grad;
+
+        if (q == 4) {
+            grad(0,0) = 1.0 + uc[1] + uc[3]*y0;
+            grad(0,1) = uc[2] + uc[3]*x0;
+            grad(1,0) = vc[1] + vc[3]*y0;
+            grad(1,1) = 1.0 + vc[2] + vc[3]*x0;
+        }
+        else if (q == 9) {
+            grad(0,0) = 1.0 + uc[1] + uc[3]*y0 + 2.0*uc[4]*x0 + 2.0*uc[6]*x0*y0 + uc[7]*y0*y0 + 2.0*uc[8]*x0*y0*y0;
+            grad(0,1) = uc[2] + uc[3]*x0 + 2.0*uc[5]*y0 + uc[6]*x0*x0 + 2.0*uc[7]*x0*y0 + 2.0*uc[8]*x0*x0*y0;
+            grad(1,0) = vc[1] + vc[3]*y0 + 2.0*vc[4]*x0 + 2.0*vc[6]*x0*y0 + vc[7]*y0*y0 + 2.0*vc[8]*x0*y0*y0;
+            grad(1,1) = 1.0 + vc[2] + vc[3]*x0 + 2.0*vc[5]*y0 + vc[6]*x0*x0 + 2.0*vc[7]*x0*y0 + 2.0*vc[8]*x0*x0*y0;
+        }
+
+        return grad;
+    }
+
+    Eigen::Matrix2d compute_strain(const std::string& form, const Eigen::Matrix2d& deform_grad) {
+        if (form == "GREEN")        return green(deform_grad);
+        else if (form == "ALMANSI") return almansi(deform_grad);
+        else if (form == "HENCKY")  return hencky(deform_grad);
+        else if (form == "BIOT_EULER") return biot_euler(deform_grad);
+        else if (form == "BIOT_LAGRANGE") return biot_lagrange(deform_grad);
+
+        std::cerr << "Unknown Strain formulation: '" << form << "'." << std::endl;
+        return Eigen::Matrix2d::Zero();
+    }
+
+
+    inline Eigen::Matrix2d green(Eigen::Matrix2d F){
+        return 0.5 * (F.transpose() * F - I);
+    }
+
+
+
+
+
+    inline Eigen::Matrix2d hencky(Eigen::Matrix2d F){
+        Eigen::Matrix2d C = F.transpose() * F;
+
+        Eigen::SelfAdjointEigenSolver<Eigen::Matrix2d> solver(C);
+        if (solver.info() != Eigen::Success)
+            throw std::runtime_error("Eigen decomposition failed.");
+
+        // Get eigenvectors and sqrt-eigenvalues
+        const Eigen::Matrix2d Q = solver.eigenvectors();
+        const Eigen::Vector2d eigvals = solver.eigenvalues();
+
+        return Q * (0.5 * eigvals.array().log().matrix().asDiagonal()) * Q.transpose();
+    }
+
+
+
+
+    inline Eigen::Matrix2d almansi(Eigen::Matrix2d F){
+        Eigen::Matrix2d B = F * F.transpose();
+        Eigen::Matrix2d B_inv = B.inverse();
+        return 0.5 * (I - B_inv); 
+    }
+
+
+
+
+
+    inline Eigen::Matrix2d biot_euler(Eigen::Matrix2d F){
+
+        Eigen::Matrix2d C = F * F.transpose();
+
+        Eigen::SelfAdjointEigenSolver<Eigen::Matrix2d> solver(C);
+        if (solver.info() != Eigen::Success)
+            throw std::runtime_error("Eigen decomposition failed.");
+
+        // U = sqrt(C) = Q * sqrt(D) * Q^T
+        Eigen::Matrix2d D_sqrt = solver.eigenvalues().cwiseSqrt().asDiagonal();
+        Eigen::Matrix2d U = solver.eigenvectors() * D_sqrt * solver.eigenvectors().transpose();
+
+        return U - I;
+
+    }
+
+
+
+
+    inline Eigen::Matrix2d biot_lagrange(Eigen::Matrix2d F){
+
+        Eigen::Matrix2d C = F.transpose() * F;
+
+        Eigen::SelfAdjointEigenSolver<Eigen::Matrix2d> solver(C);
+        if (solver.info() != Eigen::Success)
+            throw std::runtime_error("Eigen decomposition failed.");
+
+        // U = sqrt(C) = Q * sqrt(D) * Q^T
+        Eigen::Matrix2d D_sqrt = solver.eigenvalues().cwiseSqrt().asDiagonal();
+        Eigen::Matrix2d U = solver.eigenvectors() * D_sqrt * solver.eigenvectors().transpose();
+
+        return U - I;
+
+    }
+
+
+    void append_results(int sw, strain::Results &results, 
+                        const bool save_at_end, const int x0, const int y0, 
+                        const Eigen::Matrix2d &deform_grad, 
+                        const Eigen::Matrix2d &eps, 
+                        const int nwindows, const int img){
+
+        // index in results arrays depending on whether saving at end or on a per image basis
+        int idx;
+        if (save_at_end) idx = nwindows * img + sw;
+        else idx = sw;
+
+        results.def_grad[4*idx+0] = deform_grad(0,0);
+        results.def_grad[4*idx+1] = deform_grad(0,1);
+        results.def_grad[4*idx+2] = deform_grad(1,0);
+        results.def_grad[4*idx+3] = deform_grad(1,1);
+        results.strain[4*idx+0] = eps(0,0);
+        results.strain[4*idx+1] = eps(0,1);
+        results.strain[4*idx+2] = eps(1,0);
+        results.strain[4*idx+3] = eps(1,1);
+    }
+
+    void save_to_disk(int img_num, const strain::Results &results, 
+                      const common_util::SaveConfig &strain_save_conf, 
+                      const int nwindows, const int nimg,
+                      const std::vector<std::string> filenames){
+
+        const std::string delimiter = strain_save_conf.delimiter;
+
+        // open the file
+        std::stringstream outfile_str;
+        std::ofstream outfile;
+
+
+        // file extension
+        std::string file_ext;
+        if (strain_save_conf.binary) file_ext=".dic2d";
+        else file_ext=".csv";
+
+        // Extract the base filename without extension
+        std::string full_filename = filenames[img_num];
+        size_t dot_pos = full_filename.find(".");
+        if (dot_pos != std::string::npos) {
+            full_filename = full_filename.substr(0, dot_pos);
+        }
+
+        // output filename
+        outfile_str << strain_save_conf.basepath << "/" <<
+        strain_save_conf.prefix << full_filename << file_ext;
+
+        // set the img var to 0 after opening file if not saving at end
+        if (!strain_save_conf.at_end) img_num = 0;
+
+        // save in binary format
+        if (strain_save_conf.binary){
+            outfile.open(outfile_str.str(), std::ios::binary);
+
+            for (int i = 0; i < nwindows; ++i) {
+                int idx = img_num * nwindows + i;
+                common_util::write_int(outfile, results.x[idx]);
+                common_util::write_int(outfile, results.y[idx]);
+                common_util::write_dbl(outfile, results.def_grad[4*idx+0]);
+                common_util::write_dbl(outfile, results.def_grad[4*idx+1]);
+                common_util::write_dbl(outfile, results.def_grad[4*idx+2]);
+                common_util::write_dbl(outfile, results.def_grad[4*idx+3]);
+                common_util::write_dbl(outfile, results.strain[4*idx+0]);
+                common_util::write_dbl(outfile, results.strain[4*idx+1]);
+                common_util::write_dbl(outfile, results.strain[4*idx+2]);
+                common_util::write_dbl(outfile, results.strain[4*idx+3]);
+            }
+
+            outfile.close();
+        }
+        else {
+            outfile.open(outfile_str.str());
+
+            // column headers
+            outfile << "window_x" << delimiter;
+            outfile << "window_y" << delimiter;
+            outfile << "def_grad_00" << delimiter;
+            outfile << "def_grad_01" << delimiter;
+            outfile << "def_grad_10" << delimiter;
+            outfile << "def_grad_11" << delimiter;
+            outfile << "eps_00" << delimiter;
+            outfile << "eps_01" << delimiter;
+            outfile << "eps_10" << delimiter;
+            outfile << "eps_11\n";
+
+            for (int i = 0; i < nwindows; i++) {
+                int idx = img_num * nwindows + i;
+                if (results.valid_window[idx]) {
+                    outfile << results.x[idx] << delimiter;
+                    outfile << results.y[idx] << delimiter;
+                    outfile << results.def_grad[4*idx+0] << delimiter;
+                    outfile << results.def_grad[4*idx+1] << delimiter;
+                    outfile << results.def_grad[4*idx+2] << delimiter;
+                    outfile << results.def_grad[4*idx+3] << delimiter;
+                    outfile << results.strain[4*idx+0] << delimiter;
+                    outfile << results.strain[4*idx+1] << delimiter;
+                    outfile << results.strain[4*idx+2] << delimiter;
+                    outfile << results.strain[4*idx+3] << "\n";
+                }
+            }
+            outfile.close();
+        }
+    }
+
+
+
+} // namespace strain