src/math/Triangle.cpp

/* Copyright (c) 2008, 2010 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. 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 "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 *
 * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
 * research, please cite the appropriate papers when you publish your
 * work.  Good starting points are:
 *                                                                      
 * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
 * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
 * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
 * [4] Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [4] , Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011). *
 *
 *  Triangle.cpp
 *
 *  Purpose: Provide basic triangle object for OpenMD
 *
 *  Created by Charles F. Vardeman II on 29 July 2008.
 *  @author  Charles F. Vardeman II
 *  @version $Id$
 *
 */

#include "math/Triangle.hpp"

using namespace OpenMD;


Triangle::Triangle() :  normal_(V3Zero), centroid_(V3Zero), area_(0.0), 
                        mass_(0.0), facetVelocity_(V3Zero), 
                        a_(V3Zero), b_(V3Zero), c_(V3Zero),
                        HaveArea_(false), HaveNormal_(false), 
                        HaveUnitNormal_(false), HaveCentroid_(false) {}

void Triangle::addVertices(Vector3d P1, Vector3d P2, Vector3d P3){
  vertices_[0] = P1;
  vertices_[1] = P2;
  vertices_[2] = P3;

  // Compute some quantites like a,b,c
  a_ = P1-P2;
  b_ = P1-P3;
  c_ = P2-P3;  
}


RealType Triangle::computeArea(){
  HaveArea_ = true;
  area_ = getNormal().length() * 0.5;
  return area_;
}
// This should return the normal for our calculations.
Vector3d Triangle::computeNormal(){
  HaveNormal_ = true;
  normal_ = cross(a_,b_);
  return normal_;
}
// This should return the normal for our calculations.
Vector3d Triangle::computeUnitNormal(){
  HaveUnitNormal_ = true;
  unitnormal_ = cross(a_,b_);
  unitnormal_.normalize();
  return unitnormal_;
}

Vector3d Triangle::computeCentroid(){
  HaveCentroid_ = true;
  centroid_ = (vertices_[0] + vertices_[1] + vertices_[2])/RealType(3.0);
  return centroid_;
}


Mat3x3d Triangle::computeHydrodynamicTensor(RealType viscosity) {
  
  Vector3d u0 = -a_;
  Vector3d v0 = centroid_ - vertices_[0];
  RealType s0 = 0.5*cross(u0,v0).length();
  
  Vector3d u1 = -c_;
  Vector3d v1 = centroid_ - vertices_[1];
  RealType s1 = 0.5*cross(u1,v1).length();
  
  Vector3d u2 = b_;
  Vector3d v2 = centroid_ - vertices_[2];
  RealType s2 = 0.5*cross(u2,v2).length();
  
  Mat3x3d H;
  H = hydro_tensor(centroid_,centroid_,vertices_[1],vertices_[0],s0,viscosity)+
    hydro_tensor(centroid_,centroid_,vertices_[1],vertices_[2],s1,viscosity)+
    hydro_tensor(centroid_,centroid_,vertices_[2],vertices_[0],s2,viscosity);

  return H.inverse();
}

Mat3x3d Triangle::hydro_tensor(
                               const Vector3d& ri,
                               const Vector3d& rj0,
                               const Vector3d& rj1,
                               const Vector3d& rj2,
                               RealType s, RealType viscosity){
  
  Vector3d v2 = (rj0 + rj1 + rj2) / RealType(3.0);  // sub-centroid
  Vector3d dr = ri - v2;                // real centroid to sub-centroid
  RealType l2 = RealType(1.0)/dr.lengthSquare();  
 
  Mat3x3d G;
  G = (SquareMatrix3<RealType>::identity() + outProduct(dr,dr)*l2)*RealType(sqrt(l2));

  G *= 0.125/3.14159285358979;
  G *= s/viscosity;
  return G;
}
Revision:	2071
Committed:	Sat Mar 7 21:41:51 2015 UTC (10 years, 1 month ago) by gezelter
File size:	4858 byte(s)
Log Message:	Reducing the number of warnings when using g++ to compile.
#	Content
1	/* Copyright (c) 2008, 2010 The University of Notre Dame. All Rights Reserved.
2	*
3	* The University of Notre Dame grants you ("Licensee") a
4	* non-exclusive, royalty free, license to use, modify and
5	* redistribute this software in source and binary code form, provided
6	* that the following conditions are met:
7	*
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	*
11	* 2. Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the
14	* distribution.
15	*
16	* This software is provided "AS IS," without a warranty of any
17	* kind. All express or implied conditions, representations and
18	* warranties, including any implied warranty of merchantability,
19	* fitness for a particular purpose or non-infringement, are hereby
20	* excluded. The University of Notre Dame and its licensors shall not
21	* be liable for any damages suffered by licensee as a result of
22	* using, modifying or distributing the software or its
23	* derivatives. In no event will the University of Notre Dame or its
24	* licensors be liable for any lost revenue, profit or data, or for
25	* direct, indirect, special, consequential, incidental or punitive
26	* damages, however caused and regardless of the theory of liability,
27	* arising out of the use of or inability to use software, even if the
28	* University of Notre Dame has been advised of the possibility of
29	* such damages.
30	*
31	* SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your
32	* research, please cite the appropriate papers when you publish your
33	* work. Good starting points are:
34	*
35	* [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
36	* [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
37	* [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
38	* [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010).
39	* [4] , Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011). *
40	*
41	* Triangle.cpp
42	*
43	* Purpose: Provide basic triangle object for OpenMD
44	*
45	* Created by Charles F. Vardeman II on 29 July 2008.
46	* @author Charles F. Vardeman II
47	* @version $Id$
48	*
49	*/
50
51	#include "math/Triangle.hpp"
52
53	using namespace OpenMD;
54
55
56	Triangle::Triangle() : normal_(V3Zero), centroid_(V3Zero), area_(0.0),
57	mass_(0.0), facetVelocity_(V3Zero),
58	a_(V3Zero), b_(V3Zero), c_(V3Zero),
59	HaveArea_(false), HaveNormal_(false),
60	HaveUnitNormal_(false), HaveCentroid_(false) {}
61
62	void Triangle::addVertices(Vector3d P1, Vector3d P2, Vector3d P3){
63	vertices_[0] = P1;
64	vertices_[1] = P2;
65	vertices_[2] = P3;
66
67	// Compute some quantites like a,b,c
68	a_ = P1-P2;
69	b_ = P1-P3;
70	c_ = P2-P3;
71	}
72
73
74	RealType Triangle::computeArea(){
75	HaveArea_ = true;
76	area_ = getNormal().length() * 0.5;
77	return area_;
78	}
79	// This should return the normal for our calculations.
80	Vector3d Triangle::computeNormal(){
81	HaveNormal_ = true;
82	normal_ = cross(a_,b_);
83	return normal_;
84	}
85	// This should return the normal for our calculations.
86	Vector3d Triangle::computeUnitNormal(){
87	HaveUnitNormal_ = true;
88	unitnormal_ = cross(a_,b_);
89	unitnormal_.normalize();
90	return unitnormal_;
91	}
92
93	Vector3d Triangle::computeCentroid(){
94	HaveCentroid_ = true;
95	centroid_ = (vertices_[0] + vertices_[1] + vertices_[2])/RealType(3.0);
96	return centroid_;
97	}
98
99
100	Mat3x3d Triangle::computeHydrodynamicTensor(RealType viscosity) {
101
102	Vector3d u0 = -a_;
103	Vector3d v0 = centroid_ - vertices_[0];
104	RealType s0 = 0.5*cross(u0,v0).length();
105
106	Vector3d u1 = -c_;
107	Vector3d v1 = centroid_ - vertices_[1];
108	RealType s1 = 0.5*cross(u1,v1).length();
109
110	Vector3d u2 = b_;
111	Vector3d v2 = centroid_ - vertices_[2];
112	RealType s2 = 0.5*cross(u2,v2).length();
113
114	Mat3x3d H;
115	H = hydro_tensor(centroid_,centroid_,vertices_[1],vertices_[0],s0,viscosity)+
116	hydro_tensor(centroid_,centroid_,vertices_[1],vertices_[2],s1,viscosity)+
117	hydro_tensor(centroid_,centroid_,vertices_[2],vertices_[0],s2,viscosity);
118
119	return H.inverse();
120	}
121
122	Mat3x3d Triangle::hydro_tensor(
123	const Vector3d& ri,
124	const Vector3d& rj0,
125	const Vector3d& rj1,
126	const Vector3d& rj2,
127	RealType s, RealType viscosity){
128
129	Vector3d v2 = (rj0 + rj1 + rj2) / RealType(3.0); // sub-centroid
130	Vector3d dr = ri - v2; // real centroid to sub-centroid
131	RealType l2 = RealType(1.0)/dr.lengthSquare();
132
133	Mat3x3d G;
134	G = (SquareMatrix3<RealType>::identity() + outProduct(dr,dr)l2)RealType(sqrt(l2));
135
136	G *= 0.125/3.14159285358979;
137	G *= s/viscosity;
138	return G;
139	}