Vector is now Vertex. (ca53a5c6) · Commits · Tomáš Jakubec / GTMesh

Unstructured_mesh/Unstructured_mesh.pro

+1 −1

Original line number	Diff line number	Diff line
		@@ -28,7 +28,7 @@ HEADERS += \
		../src/UnstructuredMesh/MeshFunctions/ComputeCenter.h \
		../src/UnstructuredMesh/MeshFunctions/ComputeMeasures.h \
		../src/UnstructuredMesh/MeshFunctions/ComputeNormals.h \
		../src/UnstructuredMesh/MeshFunctions/EdgeOrientation.h \
		../src/UnstructuredMesh/MeshFunctions/EdgesOrientation.h \
		../src/UnstructuredMesh/MeshFunctions/GrammSchmidt.h \
		../src/UnstructuredMesh/MeshFunctions/MeshApply.h \
		../src/UnstructuredMesh/MeshFunctions/MeshColouring.h \

src/NumericStaticArray/Vector.h

+2 −197

Original line number	Diff line number	Diff line
		#ifndef VECTOR_H
		#define VECTOR_H

		#include <math.h>
		#include <iostream>
		#include <initializer_list>
		#include "InlineArrayOperations.h"
		#include <array>

		#include "Vertex.h"

		template <unsigned int Dim, typename Real = double>
		class Vector {
		/**
		* @brief coordinates
		*/
		std::array<Real, Dim> coordinates = {};

		public:
		Vector(){}
		Vector(std::initializer_list<Real> l){
		*this = l;
		}

		Vector<Dim, Real>& operator =(std::initializer_list<Real> l);

		void setCoordinate(Real coord, unsigned int pos){
		coordinates[pos] = coord;
		}


		std::array<Real, Dim>& getCoordinates() {
		return coordinates;
		}

		Real& operator[](unsigned int pos){
		return coordinates[pos];
		}

		const Real& operator[](unsigned int pos) const {
		return coordinates[pos];
		}

		unsigned int size() const {
		return Dim;
		}

		Real normEukleid();

		inline Real sumOfSquares() {
		return inlineScalarProduct<Dim, Real>::computation(coordinates.data(), coordinates.data());
		}

		Vector<Dim, Real> operator-(const Vector<Dim, Real>&) const;
		using Vector = Vertex<Dim, Real>;

		Vector<Dim, Real> operator+(const Vector<Dim, Real>&) const;

		Vector<Dim, Real> operator*(const Real&) const;

		Vector<Dim, Real> operator/(const Real&) const;
		/**
		* @brief operator *
		*
		* Scalar product of two vectors
		* @param v
		* @return
		*/
		Real operator*(const Vector& v);

		Vector<Dim, Real>& operator+=(const Vector<Dim, Real>&);
		Vector<Dim, Real>& operator-=(const Vector<Dim, Real>&);
		Vector<Dim, Real>& operator*=(const Real&);
		Vector<Dim, Real>& operator/=(const Real&);


		bool operator==(const Vector<Dim, Real>&) const;
		bool operator!=(const Vector<Dim, Real>&) const;
		//friend Vertex<Dim, Real>;
		};


		template<unsigned int Dim, typename Real>
		Vector<Dim, Real>& Vector<Dim, Real>::operator =(std::initializer_list<Real> l){
		unsigned int i = 0;

		for(Real x : l){
		if (i < Dim){
		coordinates[i] = x;
		}else{
		break;
		}
		i++;
		}
		if (i < Dim){
		for (; i < Dim; i++) {
		coordinates[i] = Real();
		}
		}
		return *this;
		}

		template <typename Real>
		Vector<3, Real> vectorProduct(const Vector<3, Real>& v1, const Vector<3, Real>& v2){
		@@ -109,108 +18,4 @@ Vector<3, Real> vectorProduct(const Vector<3, Real>& v1, const Vector<3, Real>&




		/*
		** Calculates the Eucleid norm of the point
		*/
		template <unsigned int Dim, typename Real>
		Real Vector<Dim, Real>::normEukleid(){
		return sqrt(sumOfSquares());
		}




		/*
		** Overloaded operators
		*/
		//subtracting two points
		template <unsigned int Dim, typename Real>
		Vector<Dim, Real> Vector<Dim, Real>::operator -(const Vector<Dim, Real>& v) const {
		Vector<Dim, Real> res;
		inlineSubtraction<Dim, Real>::computation(res.coordinates.data(), this->coordinates.data(), v.coordinates.data());
		return res;
		}

		//addition of two points
		template <unsigned int Dim, typename Real>
		Vector<Dim, Real> Vector<Dim, Real>::operator +(const Vector<Dim, Real>& v) const {
		Vector<Dim, Real> res;
		inlineAddition<Dim, Real>::computation(res.coordinates.data(), this->coordinates.data(), v.coordinates.data());
		return res;
		}

		//multiplying coordinates with real number
		template <unsigned int Dim, typename Real>
		Vector<Dim, Real> Vector<Dim, Real>::operator *(const Real& x) const {
		Vector<Dim, Real> res;
		inlineMultiplication<Dim, Real>::computation(res.coordinates.data(), this->coordinates.data(), x);
		return res;
		}


		//division
		template <unsigned int Dim, typename Real>
		Vector<Dim, Real> Vector<Dim, Real>::operator /(const Real& x) const {
		return this->operator*(Real(1.0)/x);
		}




		template<unsigned int Dim, typename Real>
		Real Vector<Dim, Real>::operator*(const Vector &v)
		{
		return inlineScalarProduct<Dim, Real>::computation(coordinates.data(), v.coordinates.data());
		}

		// Adds value of coordinates of another Point
		template <unsigned int Dim, typename Real>
		Vector<Dim, Real>& Vector<Dim, Real>::operator +=(const Vector<Dim, Real>& v){
		inlineAddition<Dim, Real>::computation(coordinates.data(), v.coordinates.data());
		return *this;
		}

		// Subtracts value of coordinates of another Point
		template <unsigned int Dim, typename Real>
		Vector<Dim, Real>& Vector<Dim, Real>::operator -=(const Vector<Dim, Real>& v){
		inlineSubtraction<Dim, Real>::computation(coordinates.data(), v.coordinates.data());
		return *this;
		}


		// Adds value of coordinates of another Point
		template <unsigned int Dim, typename Real>
		Vector<Dim, Real>& Vector<Dim, Real>::operator *=(const Real& x){
		inlineMultiplication<Dim, Real>::computation(coordinates.data(), x);
		return *this;
		}

		// Subtracts value of coordinates of another Point
		template <unsigned int Dim, typename Real>
		Vector<Dim, Real>& Vector<Dim, Real>::operator /=(const Real& x){
		this->operator*=(Real(1.0)/x);
		return *this;
		}

		// Compares two points wether they are the same
		template <unsigned int Dim, typename Real>
		bool Vector<Dim, Real>::operator ==(const Vector<Dim, Real>& v) const {
		for(unsigned int i = 0; i < Dim; i++) {
		if(this->operator[](i) != v[i]){
		return false;
		}
		}
		return true;
		}

		// Compares two points wether they are not the same
		template <unsigned int Dim, typename Real>
		bool Vector<Dim, Real>::operator !=(const Vector<Dim, Real>& v) const {
		return !(*this == v);
		}




		#endif // VECTOR_H

src/UnstructuredMesh/MeshFunctions/ComputeCenter.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -126,7 +126,7 @@ struct _ComputeCenters<2, 3, ComputationMethod::TESSELLATED> {
		IndexType BI = mesh.getEdges().at(sub.index).getVertexBIndex();
		std::array<Vertex<3, Real>, 2> v = {elemCenters.at(i) - mesh.getVertices().at(AI), elemCenters.at(i) - mesh.getVertices().at(BI)};

		GrammSchmidt<2, 3, IndexType, Real>(v);
		grammSchmidt<2, 3, IndexType, Real>(v);
		Real surf = v.at(0).normEukleid() * 0.5 * v.at(1).normEukleid();

		tempVert += subElemCenters.at(sub.index) * (surf * (2.0 / 3.0));

src/UnstructuredMesh/MeshFunctions/ComputeMeasures.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -179,7 +179,7 @@ struct _ComputeMeasures<3, 3, TESSELLATED>{
		Vertex<3,Real>& vertB = mesh.getVertices().at(mesh.getEdges().at(edgeIndex).getVertexBIndex());

		std::array<Vertex<3,Real>, 3> pyramidVec = {vertA - faceCenter, vertB - faceCenter, cellCenter - faceCenter};
		GrammSchmidt<3, 3, IndexType, Real>(pyramidVec);
		grammSchmidt<3, 3, IndexType, Real>(pyramidVec);

		measure += pyramidVec.at(0).normEukleid() * pyramidVec.at(1).normEukleid() * pyramidVec.at(2).normEukleid() * (1.0/6.0);

src/UnstructuredMesh/MeshFunctions/EdgeOrientation.h→src/UnstructuredMesh/MeshFunctions/EdgesOrientation.h

+3 −3

Original line number	Diff line number	Diff line
		#ifndef EDGEORIENTATION_H
		#define EDGEORIENTATION_H
		#ifndef EDGESORIENTATION_H
		#define EDGESORIENTATION_H
		#include "../MeshElements/MeshElement.h"
		#include "../MeshDataContainer/MeshDataContainer.h"
		#include "../../NumericStaticArray/Vector.h"
		@@ -87,4 +87,4 @@ MeshDataContainer<std::vector<bool>, 2> edgesOrientation(MeshElements<3, IndexTy
		}


		#endif // EDGEORIENTATION_H
		#endif // EDGESORIENTATION_H