//#####################################################################
// Copyright 2002-2004, Zhaosheng Bao, Robert Bridson, Ron Fedkiw, Geoffrey Irving, Sergey Koltakov, Neil Molino, Joseph Teran.
// This file is part of PhysBAM whose distribution is governed by the license contained in the accompanying file PHYSBAM_COPYRIGHT.txt.
//#####################################################################
// Class TETRAHEDRON_MESH
//#####################################################################
#include "TETRAHEDRON_MESH.h"
#include "SEGMENT_MESH.h"
#include "TRIANGLE_MESH.h"
#include "../Utilities/DEBUG_UTILITIES.h"
using namespace PhysBAM;
//#####################################################################
// Destructor
//#####################################################################
TETRAHEDRON_MESH::
~TETRAHEDRON_MESH()
{
	delete neighbor_nodes;
	delete incident_tetrahedrons;
	delete adjacent_tetrahedrons;
	delete neighbor_tetrahedrons;
	delete segment_mesh;
	delete triangle_mesh;
	delete tetrahedron_edges;
	delete tetrahedron_faces;
	delete boundary_mesh;
	delete node_on_boundary;
	delete boundary_nodes;
	delete edge_tetrahedrons;
	delete triangle_tetrahedrons;
}
//#####################################################################
// Function Delete_Auxiliary_Structures
//#####################################################################
void TETRAHEDRON_MESH::
Delete_Auxiliary_Structures()
{
	delete neighbor_nodes;
	neighbor_nodes = 0;
	delete incident_tetrahedrons;
	incident_tetrahedrons = 0;
	delete adjacent_tetrahedrons;
	adjacent_tetrahedrons = 0;
	delete neighbor_tetrahedrons;
	neighbor_tetrahedrons = 0;
	delete segment_mesh;
	segment_mesh = 0;
	delete triangle_mesh;
	triangle_mesh = 0;
	delete tetrahedron_edges;
	tetrahedron_edges = 0;
	delete tetrahedron_faces;
	tetrahedron_faces = 0;
	delete boundary_mesh;
	boundary_mesh = 0;
	delete node_on_boundary;
	node_on_boundary = 0;
	delete boundary_nodes;
	boundary_nodes = 0;
	delete edge_tetrahedrons;
	edge_tetrahedrons = 0;
	delete triangle_tetrahedrons;
	triangle_tetrahedrons = 0;
}
//#####################################################################
// Function Tetrahedron
//#####################################################################
// faster if incident_tetrahedrons is defined
// returns the tetrahedron containing these nodes - returns 0 if no tetrahedron contains these nodes
int TETRAHEDRON_MESH::
Tetrahedron (const int node1, const int node2, const int node3, const int node4) const
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Initialize_Neighbor_Nodes
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Neighbor_Nodes()
{
	delete neighbor_nodes;
	neighbor_nodes = new LIST_ARRAY<LIST_ARRAY<int> > (number_nodes);

	for (int t = 1; t <= tetrahedrons.m; t++)
	{
		int i, j, k, l;
		tetrahedrons.Get (t, i, j, k, l);
		(*neighbor_nodes) (i).Append_Unique_Element (j);
		(*neighbor_nodes) (i).Append_Unique_Element (k);
		(*neighbor_nodes) (i).Append_Unique_Element (l);
		(*neighbor_nodes) (j).Append_Unique_Element (i);
		(*neighbor_nodes) (j).Append_Unique_Element (k);
		(*neighbor_nodes) (j).Append_Unique_Element (l);
		(*neighbor_nodes) (k).Append_Unique_Element (i);
		(*neighbor_nodes) (k).Append_Unique_Element (j);
		(*neighbor_nodes) (k).Append_Unique_Element (l);
		(*neighbor_nodes) (l).Append_Unique_Element (i);
		(*neighbor_nodes) (l).Append_Unique_Element (j);
		(*neighbor_nodes) (l).Append_Unique_Element (k);
	}

	for (int i = 1; i <= number_nodes; i++) (*neighbor_nodes) (i).Compact(); // remove extra space
}
//#####################################################################
// Function Initialize_Incident_Tetrahedrons
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Incident_Tetrahedrons()
{
	delete incident_tetrahedrons;
	incident_tetrahedrons = new LIST_ARRAY<LIST_ARRAY<int> > (number_nodes);

	for (int t = 1; t <= tetrahedrons.m; t++) // for each tetrahedron, put it on each of its nodes lists of tetrahedrons
	{
		int i, j, k, l;
		tetrahedrons.Get (t, i, j, k, l);
		(*incident_tetrahedrons) (i).Append_Element (t);
		(*incident_tetrahedrons) (j).Append_Element (t);
		(*incident_tetrahedrons) (k).Append_Element (t);
		(*incident_tetrahedrons) (l).Append_Element (t);
	}

	for (int i = 1; i <= number_nodes; i++) (*incident_tetrahedrons) (i).Compact(); // remove extra space
}
//#####################################################################
// Function Initialize_Adjacent_Tetrahedrons
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Adjacent_Tetrahedrons()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Find_And_Append_Adjacent_Tetrahedrons
//#####################################################################
// check for an adjacent tetrahedron that contains node1, node2, and node3 - append to the adjaceny list
void TETRAHEDRON_MESH::
Find_And_Append_Adjacent_Tetrahedrons (const int tetrahedron, const int node1, const int node2, const int node3)
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Initialize_Neighbor_Tetrahedrons
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Neighbor_Tetrahedrons()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Initialize_Segment_Mesh
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Segment_Mesh()
{
	delete segment_mesh;
	bool neighbor_nodes_defined = neighbor_nodes != 0;

	if (!neighbor_nodes) Initialize_Neighbor_Nodes();

	// calculate number of  edges -> half the sum of the degree
	int number_of_edges = 0;

	for (int i = 1; i <= number_nodes; i++) number_of_edges += (*neighbor_nodes) (i).m;

	number_of_edges /= 2;
	segment_mesh = new SEGMENT_MESH();
	segment_mesh->number_nodes = number_nodes;
	segment_mesh->segments.Exact_Resize_Array (2, number_of_edges);
	int edge = 0;

	for (int node = 1; node <= neighbor_nodes->m; node++) for (int k = 1; k <= (*neighbor_nodes) (node).m; k++)
			if (node < (*neighbor_nodes) (node) (k)) // do nodes in ascending order so that no edges are counted more than once
				segment_mesh->segments.Set (++edge, node, (*neighbor_nodes) (node) (k));

	if (!neighbor_nodes_defined)
	{
		delete neighbor_nodes;
		neighbor_nodes = 0;
	}
}
//#####################################################################
// Function Initialize_Triangle_Mesh
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Triangle_Mesh()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Initialize_Tetrahedron_Edges
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Tetrahedron_Edges()
{
	delete tetrahedron_edges;
	tetrahedron_edges = new LIST_ARRAYS<int> (6, tetrahedrons.m);

	if (!segment_mesh) Initialize_Segment_Mesh(); // edges only makes sense when referring to a segment mesh

	// incident_segments make the SEGMENT_MESH::Segment() function faster
	bool incident_segments_defined = segment_mesh->incident_segments != 0;

	if (!segment_mesh->incident_segments) segment_mesh->Initialize_Incident_Segments();

	// for each tetrahedron, make the lists of edges
	for (int t = 1; t <= tetrahedrons.m; t++)
	{
		int i, j, k, l;
		tetrahedrons.Get (t, i, j, k, l);
		tetrahedron_edges->Set (t, segment_mesh->Segment (i, j), segment_mesh->Segment (j, k), segment_mesh->Segment (k, i),
					segment_mesh->Segment (i, l), segment_mesh->Segment (j, l), segment_mesh->Segment (k, l));
	}

	if (!incident_segments_defined)
	{
		delete segment_mesh->incident_segments;
		segment_mesh->incident_segments = 0;
	}
}
//#####################################################################
// Function Initialize_Tetrahedron_Faces
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Tetrahedron_Faces()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Number_Of_Tetrahedrons_Across_Face
//#####################################################################
int TETRAHEDRON_MESH::
Number_Of_Tetrahedrons_Across_Face (const int tetrahedron, const int node1, const int node2, const int node3) const
{
	int count = 0;

	for (int t = 1; t <= (*incident_tetrahedrons) (node1).m; t++)
	{
		int tetrahedron2 = (*incident_tetrahedrons) (node1) (t); // tetrahedron in question
		int i, j, k, l;
		tetrahedrons.Get (tetrahedron2, i, j, k, l);

		if (tetrahedron2 != tetrahedron)
		{
			if (i == node2 && (j == node3 || k == node3 || l == node3)) count++;
			else if (j == node2 && (i == node3 || k == node3 || l == node3)) count++;
			else if (k == node2 && (i == node3 || j == node3 || l == node3)) count++;
			else if (l == node2 && (i == node3 || j == node3 || k == node3)) count++;
		}
	}

	return count;
}
//#####################################################################
// Function Initialize_Boundary_Mesh
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Boundary_Mesh()
{
	delete boundary_mesh;
	boundary_mesh = new TRIANGLE_MESH();
	bool incident_tetrahedrons_defined = incident_tetrahedrons != 0;

	if (!incident_tetrahedrons) Initialize_Incident_Tetrahedrons();

	for (int t = 1; t <= tetrahedrons.m; t++)
	{
		int i, j, k, l;
		tetrahedrons.Get (t, i, j, k, l);

		if (Number_Of_Tetrahedrons_Across_Face (t, i, k, j) == 0) boundary_mesh->triangles.Append_Element (i, k, j);

		if (Number_Of_Tetrahedrons_Across_Face (t, i, j, l) == 0) boundary_mesh->triangles.Append_Element (i, j, l);

		if (Number_Of_Tetrahedrons_Across_Face (t, i, l, k) == 0) boundary_mesh->triangles.Append_Element (i, l, k);

		if (Number_Of_Tetrahedrons_Across_Face (t, j, k, l) == 0) boundary_mesh->triangles.Append_Element (j, k, l);
	}

	if (!incident_tetrahedrons_defined)
	{
		delete incident_tetrahedrons;
		incident_tetrahedrons = 0;
	}

	boundary_mesh->number_nodes = number_nodes; // use the same number of nodes as in the tetrahedron mesh
}
//#####################################################################
// Function Initialize_Node_On_Boundary
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Node_On_Boundary()
{
	delete node_on_boundary;
	node_on_boundary = new LIST_ARRAY<bool> (number_nodes);
	bool boundary_mesh_defined = boundary_mesh != 0;

	if (!boundary_mesh_defined) Initialize_Boundary_Mesh();

	for (int t = 1; t <= boundary_mesh->triangles.m; t++)
	{
		int i, j, k;
		boundary_mesh->triangles.Get (t, i, j, k);
		(*node_on_boundary) (i) = (*node_on_boundary) (j) = (*node_on_boundary) (k) = true;
	}

	if (!boundary_mesh_defined)
	{
		delete boundary_mesh;
		boundary_mesh = 0;
	}
}
//#####################################################################
// Function Initialize_Boundary_Nodes
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Boundary_Nodes()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Initialize_Edge_Tetrahedrons
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Edge_Tetrahedrons()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Initialize_Triangle_Tetrahedrons
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Triangle_Tetrahedrons()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Delete_Tetrahedrons_With_Missing_Nodes
//#####################################################################
int TETRAHEDRON_MESH::
Delete_Tetrahedrons_With_Missing_Nodes()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Delete_Tetrahedrons
//#####################################################################
void TETRAHEDRON_MESH::
Delete_Tetrahedrons (const LIST_ARRAY<int>& deletion_list)
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Number_Of_Boundary_Tetrahedrons
//#####################################################################
int TETRAHEDRON_MESH::
Number_Of_Boundary_Tetrahedrons()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Number_Of_Interior_Tetrahedrons
//#####################################################################
int TETRAHEDRON_MESH::
Number_Of_Interior_Tetrahedrons()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Funcion Number_Of_Nodes_With_Minimum_Valence
//#####################################################################
int TETRAHEDRON_MESH::
Number_Of_Nodes_With_Minimum_Valence()
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Funcion Minimum_Valence
//#####################################################################
int TETRAHEDRON_MESH::
Minimum_Valence (int* index)
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Edge_Neighbours
//#####################################################################
bool TETRAHEDRON_MESH::
Edge_Neighbors (const int tet1, const int tet2) const
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Number_Of_Edge_Neighbors
//#####################################################################
int TETRAHEDRON_MESH::
Number_Of_Edge_Neighbors (const int segment) const
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Initialize_Segment_Mesh_Of_Subset
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Segment_Mesh_Of_Subset (SEGMENT_MESH& segment_mesh_of_subset, const LIST_ARRAY<bool>& subset) const
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Initialize_Boundary_Mesh_Of_Subset
//#####################################################################
void TETRAHEDRON_MESH::
Initialize_Boundary_Mesh_Of_Subset (TRIANGLE_MESH& boundary_mesh_of_subset, const LIST_ARRAY<bool>& subset)
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Update_Adjacent_Tetrahedrons_From_Incident_Tetrahedrons
//#####################################################################
void TETRAHEDRON_MESH::
Update_Adjacent_Tetrahedrons_From_Incident_Tetrahedrons (const int node)
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Update_Neighbor_Nodes_From_Incident_Tetrahedrons
//#####################################################################
void TETRAHEDRON_MESH::
Update_Neighbor_Nodes_From_Incident_Tetrahedrons (const int node)
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Mark_Face_Connected_Component_Incident_On_A_Node
//#####################################################################
// implements a depth first search to find marked connected component
void TETRAHEDRON_MESH::
Mark_Face_Connected_Component_Incident_On_A_Node (const int node, const int tetrahedron_index_in_incident_tetrahedrons, ARRAY<bool>& marked) const
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Tetrahedrons_On_Edge
//#####################################################################
int TETRAHEDRON_MESH::
Tetrahedrons_On_Edge (const int node1, const int node2, LIST_ARRAY<int>* tetrahedrons_on_edge) const
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Tetrahedrons_Across_Face
//#####################################################################
int TETRAHEDRON_MESH::
Tetrahedrons_Across_Face (const int tetrahedron, const int node1, const int node2, const int node3, LIST_ARRAY<int>& tetrahedrons_across_face) const
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Identify_Connected_Components
//#####################################################################
// labels each face connected components with a unique id
void TETRAHEDRON_MESH::
Identify_Face_Connected_Components (ARRAY<int>& label)
{
	NOT_IMPLEMENTED();
}

//#####################################################################
// Function Identify_Edge_Node_Connected_Components
//#####################################################################
// labels each node connected components with a unique id
void TETRAHEDRON_MESH::
Identify_Edge_Connected_Components (ARRAY<int>& label)
{
	NOT_IMPLEMENTED();
}

//#####################################################################