368 lines
14 KiB
C++
368 lines
14 KiB
C++
// Copyright 2015. All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// Author: ryan.latture@gmail.com (Ryan Latture)
|
|
|
|
#include <gtest/gtest.h>
|
|
#include "csv_parser.h"
|
|
#include "setup.h"
|
|
|
|
using namespace fea;
|
|
|
|
namespace {
|
|
void writeStringToTxt(std::string filename, std::string data) {
|
|
std::ofstream output_file;
|
|
output_file.open(filename);
|
|
|
|
if (!output_file.is_open()) {
|
|
std::cerr << "Error opening file" << filename << ".\n";
|
|
}
|
|
else {
|
|
output_file << data;
|
|
output_file.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(SetupTest, CreatesCorrectConfigFromJSON) {
|
|
std::string json = "{\"nodes\":\"nodes_file\"}\n";
|
|
std::string filename = "CreatesCorrectConfig.json";
|
|
writeStringToTxt(filename, json);
|
|
|
|
rapidjson::Document doc = parseJSONConfig(filename);
|
|
|
|
EXPECT_TRUE(doc.HasMember("nodes"));
|
|
std::string nodes_file(doc["nodes"].GetString());
|
|
EXPECT_EQ("nodes_file", nodes_file);
|
|
|
|
if (std::remove(filename.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << filename << ".\n";
|
|
}
|
|
}
|
|
|
|
TEST(SetupTest, CreatesCorrectNodesFromJSON) {
|
|
std::string nodes_file = "CreatesCorrectNodes.csv";
|
|
std::string json = "{\"nodes\":\"" + nodes_file + "\"}\n";
|
|
std::string filename = "CreatesCorrectNodes.json";
|
|
writeStringToTxt(filename, json);
|
|
|
|
rapidjson::Document doc = parseJSONConfig(filename);
|
|
|
|
std::vector<std::vector<double> > expected = {{1, 2, 3},
|
|
{4, 5, 6}};
|
|
|
|
CSVParser csv;
|
|
csv.write(nodes_file, expected, 1, ",");
|
|
|
|
std::vector<Node> nodes = createNodeVecFromJSON(doc);
|
|
|
|
for (size_t i = 0; i < nodes.size(); ++i) {
|
|
for (size_t j = 0; j < nodes[i].size(); ++j) {
|
|
EXPECT_EQ(expected[i][j], nodes[i][j]);
|
|
}
|
|
}
|
|
|
|
if (std::remove(filename.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << filename << ".\n";
|
|
}
|
|
if (std::remove(nodes_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << nodes_file << ".\n";
|
|
}
|
|
}
|
|
|
|
TEST(SetupTest, CreatesCorrectElemsFromJSON) {
|
|
std::string elems_file = "CreatesCorrectElems_elems.csv";
|
|
std::string props_file = "CreatesCorrectElems_props.csv";
|
|
std::string json = "{\"elems\":\"" + elems_file + "\",\"props\":\"" + props_file + "\"}\n";
|
|
std::string filename = "CreatesCorrectElems.json";
|
|
writeStringToTxt(filename, json);
|
|
|
|
rapidjson::Document doc = parseJSONConfig(filename);
|
|
|
|
std::vector<std::vector<unsigned int> > expected_elems = {{1, 2},
|
|
{2, 3}};
|
|
|
|
std::vector<std::vector<double> > expected_props = {{1, 2, 3, 4, 5, 6, 7},
|
|
{8, 9, 10, 11, 12, 13, 14}};
|
|
|
|
CSVParser csv;
|
|
csv.write(elems_file, expected_elems, 0, ",");
|
|
csv.write(props_file, expected_props, 1, ",");
|
|
|
|
std::vector<Elem> elems = createElemVecFromJSON(doc);
|
|
|
|
for (size_t i = 0; i < expected_elems.size(); ++i) {
|
|
for (size_t j = 0; j < expected_elems[i].size(); ++j)
|
|
{
|
|
EXPECT_EQ(expected_elems[i][j], elems[i].node_numbers[j]);
|
|
}
|
|
}
|
|
|
|
for (size_t i = 0; i < expected_props.size(); ++i) {
|
|
EXPECT_DOUBLE_EQ(expected_props[i][0], elems[i].props.EA);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][1], elems[i].props.EIz);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][2], elems[i].props.EIy);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][3], elems[i].props.GJ);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][4], elems[i].props.normal_vec[0]);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][5], elems[i].props.normal_vec[1]);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][6], elems[i].props.normal_vec[2]);
|
|
}
|
|
|
|
if (std::remove(filename.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << filename << ".\n";
|
|
}
|
|
if (std::remove(elems_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << elems_file << ".\n";
|
|
}
|
|
if (std::remove(props_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << props_file << ".\n";
|
|
}
|
|
}
|
|
|
|
TEST(SetupTest, CreatesCorrectBCsFromJSON) {
|
|
std::string bcs_file = "CreatesCorrectBCs.csv";
|
|
std::string json = "{\"bcs\":\"" + bcs_file + "\"}\n";
|
|
std::string filename = "CreatesCorrectBCs.json";
|
|
writeStringToTxt(filename, json);
|
|
|
|
rapidjson::Document doc = parseJSONConfig(filename);
|
|
|
|
std::vector<std::vector<double> > expected = {{10, 20, 30},
|
|
{40, 50, 60}};
|
|
|
|
CSVParser csv;
|
|
csv.write(bcs_file, expected, 1, ",");
|
|
|
|
std::vector<BC> bcs = createBCVecFromJSON(doc);
|
|
|
|
for (size_t i = 0; i < bcs.size(); ++i) {
|
|
EXPECT_EQ((unsigned int) expected[i][0], bcs[i].node);
|
|
EXPECT_EQ((unsigned int) expected[i][1], bcs[i].dof);
|
|
EXPECT_DOUBLE_EQ(expected[i][2], bcs[i].value);
|
|
}
|
|
|
|
if (std::remove(filename.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << filename << ".\n";
|
|
}
|
|
if (std::remove(bcs_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << bcs_file << ".\n";
|
|
}
|
|
}
|
|
|
|
TEST(SetupTest, CreatesCorrectForcesFromJSON) {
|
|
std::string forces_file = "CreatesCorrectForces.csv";
|
|
std::string json = "{\"forces\":\"" + forces_file + "\"}\n";
|
|
std::string filename = "CreatesCorrectForces.json";
|
|
writeStringToTxt(filename, json);
|
|
|
|
rapidjson::Document doc = parseJSONConfig(filename);
|
|
|
|
std::vector<std::vector<double> > expected = {{10, 20, 30},
|
|
{40, 50, 60}};
|
|
|
|
CSVParser csv;
|
|
csv.write(forces_file, expected, 1, ",");
|
|
|
|
std::vector<Force> forces = createForceVecFromJSON(doc);
|
|
|
|
for (size_t i = 0; i < forces.size(); ++i) {
|
|
EXPECT_EQ((unsigned int) expected[i][0], forces[i].node);
|
|
EXPECT_EQ((unsigned int) expected[i][1], forces[i].dof);
|
|
EXPECT_DOUBLE_EQ(expected[i][2], forces[i].value);
|
|
}
|
|
|
|
if (std::remove(filename.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << filename << ".\n";
|
|
}
|
|
if (std::remove(forces_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << forces_file << ".\n";
|
|
}
|
|
}
|
|
|
|
TEST(SetupTest, CreatesCorrectTiesFromJSON) {
|
|
std::string ties_file = "CreatesCorrectTies.csv";
|
|
std::string json = "{\"ties\":\"" + ties_file + "\"}\n";
|
|
std::string filename = "CreatesCorrectTies.json";
|
|
writeStringToTxt(filename, json);
|
|
|
|
rapidjson::Document doc = parseJSONConfig(filename);
|
|
|
|
std::vector<std::vector<double> > expected = {{1, 2, 30, 40},
|
|
{5, 6, 70, 80}};
|
|
|
|
CSVParser csv;
|
|
csv.write(ties_file, expected, 1, ",");
|
|
|
|
std::vector<Tie> ties = createTieVecFromJSON(doc);
|
|
|
|
for (size_t i = 0; i < ties.size(); ++i) {
|
|
EXPECT_EQ((unsigned int) expected[i][0], ties[i].node_number_1);
|
|
EXPECT_EQ((unsigned int) expected[i][1], ties[i].node_number_2);
|
|
EXPECT_DOUBLE_EQ(expected[i][2], ties[i].lmult);
|
|
EXPECT_DOUBLE_EQ(expected[i][3], ties[i].rmult);
|
|
}
|
|
|
|
if (std::remove(filename.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << filename << ".\n";
|
|
}
|
|
if (std::remove(ties_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << ties_file << ".\n";
|
|
}
|
|
}
|
|
|
|
TEST(SetupTest, CreatesCorrectEquationsFromJSON) {
|
|
std::string equations_file = "CreatesCorrectEquations.csv";
|
|
std::string json = "{\"equations\":\"" + equations_file + "\"}\n";
|
|
std::string filename = "CreatesCorrectEquations.json";
|
|
writeStringToTxt(filename, json);
|
|
|
|
rapidjson::Document doc = parseJSONConfig(filename);
|
|
|
|
std::vector<std::vector<double> > expected = {{1, 2, 3, 4, 5, 6},
|
|
{7, 8, 9, 10, 11, 12}};
|
|
|
|
CSVParser csv;
|
|
csv.write(equations_file, expected, 1, ",");
|
|
|
|
std::vector<Equation> equations = createEquationVecFromJSON(doc);
|
|
|
|
for (size_t i = 0; i < equations.size(); ++i) {
|
|
for (size_t j = 0; j < equations[i].terms.size() / 3; ++j) {
|
|
EXPECT_EQ((unsigned int) expected[i][3 * j], equations[i].terms[j].node_number);
|
|
EXPECT_EQ((unsigned int) expected[i][3 * j + 1], equations[i].terms[j].dof);
|
|
EXPECT_DOUBLE_EQ(expected[i][3 * j + 2], equations[i].terms[j].coefficient);
|
|
}
|
|
}
|
|
|
|
if (std::remove(filename.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << filename << ".\n";
|
|
}
|
|
if (std::remove(equations_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << equations_file << ".\n";
|
|
}
|
|
}
|
|
|
|
TEST(SetupTest, CreatesCorrectJobFromJSON) {
|
|
std::string elems_file = "CreatesCorrectJob_elems.csv";
|
|
std::string props_file = "CreatesCorrectJob_props.csv";
|
|
std::string nodes_file = "CreatesCorrectJob_nodes.csv";
|
|
|
|
std::vector<std::vector<unsigned int> > expected_elems = {{1, 2},
|
|
{2, 3}};
|
|
std::vector<std::vector<double> > expected_props = {{1, 2, 3, 4, 5, 6, 7},
|
|
{8, 9, 10, 11, 12, 13, 14}};
|
|
std::vector<std::vector<double> > expected_nodes = {{1, 2, 3},
|
|
{4, 5, 6}};
|
|
|
|
CSVParser csv;
|
|
csv.write(elems_file, expected_elems, 0, ",");
|
|
csv.write(props_file, expected_props, 1, ",");
|
|
csv.write(nodes_file, expected_nodes, 1, ",");
|
|
|
|
std::string json = "{\"elems\":\"" + elems_file + "\",\"props\":\"" + props_file + "\",\"nodes\":\"" + nodes_file + "\"}\n";
|
|
std::string filename = "CreatesCorrectJob.json";
|
|
writeStringToTxt(filename, json);
|
|
|
|
rapidjson::Document doc = parseJSONConfig(filename);
|
|
|
|
Job job = createJobFromJSON(doc);
|
|
|
|
for (size_t i = 0; i < job.nodes.size(); ++i) {
|
|
for (size_t j = 0; j < job.nodes[i].size(); ++j) {
|
|
EXPECT_EQ(expected_nodes[i][j], job.nodes[i][j]);
|
|
}
|
|
}
|
|
for (size_t i = 0; i < expected_elems.size(); ++i) {
|
|
for (size_t j = 0; j < expected_elems[i].size(); ++j)
|
|
{
|
|
EXPECT_EQ(expected_elems[i][j], job.elems[i][j]);
|
|
}
|
|
}
|
|
|
|
for (size_t i = 0; i < expected_props.size(); ++i) {
|
|
EXPECT_DOUBLE_EQ(expected_props[i][0], job.props[i].EA);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][1], job.props[i].EIz);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][2], job.props[i].EIy);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][3], job.props[i].GJ);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][4], job.props[i].normal_vec[0]);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][5], job.props[i].normal_vec[1]);
|
|
EXPECT_DOUBLE_EQ(expected_props[i][6], job.props[i].normal_vec[2]);
|
|
}
|
|
|
|
if (std::remove(filename.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << filename << ".\n";
|
|
}
|
|
if (std::remove(elems_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << elems_file << ".\n";
|
|
}
|
|
if (std::remove(props_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << props_file << ".\n";
|
|
}
|
|
if (std::remove(nodes_file.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << nodes_file << ".\n";
|
|
}
|
|
}
|
|
|
|
TEST(SetupTest, CreatesCorrectOptionsFromJSON) {
|
|
std::string json = "{\"options\":{\"epsilon\":1E-10,\"csv_precision\":10,\"csv_delimiter\":\" \","
|
|
"\"save_nodal_displacements\":true,\"save_nodal_forces\":true,\"save_nodal_forces\":true,"
|
|
"\"save_tie_forces\":true,\"verbose\":true,\"save_report\":true,"
|
|
"\"nodal_displacements_filename\":\"ndf.csv\",\"nodal_forces_filename\":\"nff.csv\","
|
|
"\"tie_forces_filename\":\"tff.csv\",\"report_filename\":\"rf.txt\"}}\n";
|
|
std::string filename = "CreatesCorrectOptions.json";
|
|
writeStringToTxt(filename, json);
|
|
|
|
rapidjson::Document doc = parseJSONConfig(filename);
|
|
|
|
Options expected;
|
|
expected.epsilon = 1E-10;
|
|
expected.csv_precision = 10;
|
|
expected.csv_delimiter = " ";
|
|
expected.save_nodal_displacements = true;
|
|
expected.save_nodal_forces = true;
|
|
expected.save_tie_forces = true;
|
|
expected.save_report = true;
|
|
expected.nodal_displacements_filename = "ndf.csv";
|
|
expected.nodal_forces_filename = "nff.csv";
|
|
expected.tie_forces_filename = "tff.csv";
|
|
expected.report_filename = "rf.txt";
|
|
|
|
Options options = createOptionsFromJSON(doc);
|
|
|
|
EXPECT_DOUBLE_EQ(expected.epsilon, options.epsilon);
|
|
EXPECT_EQ(expected.csv_precision, options.csv_precision);
|
|
EXPECT_EQ(expected.csv_delimiter, options.csv_delimiter);
|
|
EXPECT_EQ(expected.save_nodal_displacements, options.save_nodal_displacements);
|
|
EXPECT_EQ(expected.save_nodal_forces, options.save_nodal_forces);
|
|
EXPECT_EQ(expected.save_tie_forces, options.save_tie_forces);
|
|
EXPECT_EQ(expected.save_report, options.save_report);
|
|
EXPECT_EQ(expected.nodal_displacements_filename, options.nodal_displacements_filename);
|
|
EXPECT_EQ(expected.nodal_forces_filename, options.nodal_forces_filename);
|
|
EXPECT_EQ(expected.tie_forces_filename, options.tie_forces_filename);
|
|
EXPECT_EQ(expected.report_filename, options.report_filename);
|
|
|
|
if (std::remove(filename.c_str()) != 0) {
|
|
std::cerr << "Error removing test csv file " << filename << ".\n";
|
|
}
|
|
}
|