PtreeTissueBuilder.cpp

Go to the documentation of this file.

/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
#include "PtreeTissueBuilder.h"

#include "AttributeStore.h"
#include "Cell.h"
#include "Mesh.h"
#include "Node.h"
#include "Tissue.h"
#include "Wall.h"
#include "WallType.h"

#include <boost/optional.hpp>
#include <boost/property_tree/ptree.hpp>
#include <array>
#include <iostream>
#include <list>

using namespace std;
using namespace boost::property_tree;
using boost::optional;

namespace SimPT_Sim {

Tissue PtreeTissueBuilder::Build(const ptree& pt)
{
        Tissue tissue;

        tissue.m_mesh = BuildMesh(pt.get_child("mesh"));
        tissue.m_cell_attributes = BuildAttributeStore(
                "cell",
                pt.get_child("parameters.model.attributes.cell_attributes_array"),
                pt.get_child("mesh.cells.cell_array"));
        tissue.m_node_attributes = BuildAttributeStore(
                "node",
                pt.get_child("parameters.model.attributes.node_attributes_array"),
                pt.get_child("mesh.nodes.node_array"));
        tissue.m_wall_attributes = BuildAttributeStore(
                "wall",
                pt.get_child("parameters.model.attributes.wall_attributes_array"),
                pt.get_child("mesh.walls.wall_array"));

        return tissue;
}

shared_ptr<AttributeStore> PtreeTissueBuilder::BuildAttributeStore(
        const string& entity_id, const ptree& index_pt, const ptree& values_pt)
{
        const auto as = make_shared<AttributeStore>(index_pt);
        const auto id = entity_id + ".attributes";

        for(auto it = values_pt.begin(); it != values_pt.end(); it++){
                const auto pt2 = it->second.get_child(id);
                for (const auto& name : as->GetAttributeNames<bool>()) {
                        as->Container<bool>(name).push_back(pt2.get<bool>(name, as->GetDefaultValue<bool>(name)));
                }
                for (const auto& name : as->GetAttributeNames<int>()) {
                        as->Container<int>(name).push_back(pt2.get<int>(name, as->GetDefaultValue<int>(name)));
                }
                for (const auto& name : as->GetAttributeNames<bool>()) {
                        as->Container<double>(name).push_back(pt2.get<double>(name, as->GetDefaultValue<double>(name)));
                }
                for (const auto& name : as->GetAttributeNames<string>()) {
                        as->Container<string>(name).push_back(pt2.get<string>(name, as->GetDefaultValue<string>(name)));
                }
        }

        return as;
}

shared_ptr<Mesh> PtreeTissueBuilder::BuildMesh(const ptree& mesh_pt)
{
        auto cells_pt             = mesh_pt.get_child("cells");
        const auto& nodes_pt      = mesh_pt.get_child("nodes");
        const auto& walls_pt      = mesh_pt.get_child("walls");

        // Set up empty mesh.
        unsigned int num_chem     = cells_pt.get<unsigned int>("chemical_count");
        m_mesh = make_shared<Mesh>(num_chem);

        // Nodes
        BuildNodes(nodes_pt);

        // Cells
        BuildCells(cells_pt);
        BuildBoundaryPolygon(cells_pt);
        assert((m_mesh->GetCells().size() == cells_pt.get<unsigned int>("count")) && "CellCount does match with file!");

        // Allocate Walls (we need to have read the cells before constructing walls)
        BuildWalls(walls_pt);
        ConnectCellsToWalls(cells_pt);

        m_mesh->ConstructNeighborList(m_mesh->GetBoundaryPolygon());
        m_mesh->UpdateNodeOwningNeighbors(m_mesh->GetBoundaryPolygon());
        for (auto cell : m_mesh->GetCells()) {
                m_mesh->ConstructNeighborList(cell);
                m_mesh->UpdateNodeOwningNeighbors(cell);
        }

        return m_mesh;
}

void PtreeTissueBuilder::BuildBoundaryPolygon(const ptree& cells_pt)
{
        const auto& boundary_pt = cells_pt.get_child("boundary_polygon");
        {
                vector<unsigned int> node_ids;
                auto const& node_array_pt = boundary_pt.get_child("node_array");
                for (auto const& node_v : node_array_pt) {
                        auto const& node_pt = node_v.second;
                        node_ids.push_back(node_pt.get_value<unsigned int>());
                }
                auto boundary_polygon = m_mesh->BuildBoundaryPolygon(node_ids);
                boundary_polygon->ReadPtree(boundary_pt);
        }
}

void PtreeTissueBuilder::BuildCells(const ptree& cells_pt)
{
        for (auto cell_v : cells_pt.get_child("cell_array")) {
                auto cell_pt = cell_v.second;
                unsigned int id = cell_pt.get<unsigned int>("id");

                vector<unsigned int> node_ids;
                auto const& node_array_pt = cell_pt.get_child("node_array");
                for (auto const& node_v : node_array_pt) {
                        auto const& node_pt = node_v.second;
                        node_ids.push_back(node_pt.get_value<unsigned int>());
                }

                auto new_cell = m_mesh->BuildCell(id, node_ids);
                new_cell->ReadPtree(cell_pt);
        }
}

void PtreeTissueBuilder::BuildNodes(const ptree& nodes_pt)
{
        for (const auto& node_v : nodes_pt.get_child("node_array")) {
                const ptree& node_pt = node_v.second;
                unsigned int id = node_pt.get<unsigned int>("id");
                array<double, 3> arr {{ node_pt.get<double>("x"), node_pt.get<double>("y"), 0.0 }};
                const bool at_boundary = node_pt.get<bool>("boundary");
                auto new_node = m_mesh->BuildNode(id, arr, at_boundary);
                new_node->ReadPtree(node_pt);
        }
}

void PtreeTissueBuilder::BuildWalls(const ptree& walls_pt)
{
        optional<const ptree&> wall_array_pt = walls_pt.get_child_optional("wall_array");
        if (wall_array_pt) {
                for (const auto& wall_v : *wall_array_pt) {
                        const ptree& wall_pt = wall_v.second;
                        const unsigned int wall_id = wall_pt.get<unsigned int>("id");

                        auto& mesh_cells = m_mesh->GetCells();
                        int const c1_id = wall_pt.get<int>("c1");
                        int const c2_id = wall_pt.get<int>("c2");
                        auto c1 = (c1_id != -1) ? mesh_cells[c1_id] : m_mesh->GetBoundaryPolygon();
                        auto c2 = (c2_id != -1) ? mesh_cells[c2_id] : m_mesh->GetBoundaryPolygon();

                        auto& mesh_nodes = m_mesh->GetNodes();
                        unsigned int const n1_id = wall_pt.get<unsigned int>("n1");
                        unsigned int const n2_id = wall_pt.get<unsigned int>("n2");
                        auto n1 = mesh_nodes[n1_id];
                        auto n2 = mesh_nodes[n2_id];

                        auto wall = m_mesh->BuildWall(wall_id, n1, n2, c1, c2);
                        wall->ReadPtree(wall_pt);
                }
        }
}

void PtreeTissueBuilder::ConnectCellsToWalls(const ptree& cells_pt)
{
        auto& mesh_cells = m_mesh->GetCells();
        auto& mesh_walls = m_mesh->GetWalls();

        const ptree& cell_array_pt = cells_pt.get_child("cell_array");
        for (const auto & cell_v : cell_array_pt) {
                const unsigned int id = cell_v.second.get<unsigned int>("id");
                optional<const ptree&> wall_array_pt = cell_v.second.get_child_optional("wall_array");
                if (wall_array_pt) {
                        for (const auto& wall_v : *wall_array_pt) {
                                const unsigned int w_id = wall_v.second.get_value<unsigned int>();
                                const auto eql = [w_id](Wall* w) {
                                        return w_id == w->GetIndex();
                                };
                                auto it = find_if(mesh_walls.begin(), mesh_walls.end(), eql);
                                assert((it != mesh_walls.end()) && "Cannot find the cell wall!");
                                mesh_cells[id]->GetWalls().push_back((*it));
                        }
                }
        }

        optional<const ptree&> bp_wall_array_pt = cells_pt.get_child_optional("boundary_polygon.wall_array");
        if (bp_wall_array_pt) {
                for (const auto& wall_v : *bp_wall_array_pt) {
                        const unsigned int w_id = wall_v.second.get_value<unsigned int>();
                        const auto eql = [w_id](Wall* w) {
                                return w_id == w->GetIndex();
                        };
                        auto it = find_if(mesh_walls.begin(), mesh_walls.end(), eql);
                        assert((it != mesh_walls.end()) && "Cannot find the boundary wall!");
                        m_mesh->GetBoundaryPolygon()->GetWalls().push_back((*it));
                }
        }

        for (auto &wall : m_mesh->GetWalls()) {
                m_mesh->UpdateNodeOwningWalls(wall);
        }
}

}  // namespace