Ice Sheet System Model  4.18
Code documentation
Data Structures | Typedefs | Functions | Variables
bamg Namespace Reference

Data Structures

class  AdjacentTriangle
 
class  BamgQuadtree
 
class  BamgVertex
 
class  CrackedEdge
 
class  Curve
 
class  Edge
 
class  EigenMetric
 
class  GeomEdge
 
class  Geometry
 
class  GeomSubDomain
 
class  GeomVertex
 
class  IntEdge
 
class  ListofIntersectionTriangles
 
class  Mesh
 
class  Metric
 
class  P2
 
class  P2xP2
 
class  SaveMetricInterpole
 
class  SetOfEdges4
 
class  SubDomain
 
class  Triangle
 
class  VertexOnEdge
 
class  VertexOnGeom
 
class  VertexOnVertex
 

Typedefs

typedef P2< double, double > D2
 
typedef P2xP2< double, double > D2xD2
 
typedef P2< int, long long > I2
 
typedef P2< double, double > R2
 

Functions

long long det (const I2 &a, const I2 &b, const I2 &c)
 
AdjacentTriangle CloseBoundaryEdge (I2 A, Triangle *t, double &a, double &b)
 
void swap (Triangle *t1, short a1, Triangle *t2, short a2, BamgVertex *s1, BamgVertex *s2, long long det1, long long det2)
 
AdjacentTriangle Previous (const AdjacentTriangle &ta)
 
AdjacentTriangle Next (const AdjacentTriangle &ta)
 
AdjacentTriangle Adj (const AdjacentTriangle &a)
 
void Adj (GeomEdge *&on, int &i)
 
double LengthInterpole (const Metric &Ma, const Metric &Mb, R2 AB)
 
void SimultaneousMatrixReduction (Metric M1, Metric M2, D2xD2 &V)
 
double abscisseInterpole (const Metric &Ma, const Metric &Mb, R2 AB, double s, int optim)
 
double LengthInterpole (double la, double lb)
 
double abscisseInterpole (double la, double lb, double lab, double s)
 
template<class R , class RR >
RR Det (const P2< R, RR > x, const P2< R, RR > y)
 
template<class R , class RR >
RR Area2 (const P2< R, RR > a, const P2< R, RR > b, const P2< R, RR > c)
 
template<class R , class RR >
R Norme1 (const P2< R, RR > x)
 
template<class R , class RR >
RR Norme2_2 (const P2< R, RR > x)
 
template<class R , class RR >
RR Norme2 (const P2< R, RR > x)
 
template<class R , class RR >
P2< R, RR > Orthogonal (const P2< R, RR > x)
 
template<class T >
T Abs (const T &a)
 
long BigPrimeNumber (long n)
 
template<class T >
T Min (const T &a, const T &b)
 
template<class T >
T Max (const T &a, const T &b)
 
template<class T >
T Max3 (const T &a, const T &b, const T &c)
 
template<class T >
T Min3 (const T &a, const T &b, const T &c)
 
float OppositeAngle (float a)
 
double OppositeAngle (double a)
 

Variables

const double Pi =3.141592653589793238462643383279502884197169399375105820974944592308
 
const float fPi =3.141592653589793238462643383279502884197169399375105820974944592308
 
const int IsVertexOnGeom = 8
 
const int IsVertexOnVertex = 16
 
const int IsVertexOnEdge = 32
 
static const short VerticesOfTriangularEdge [3][2] = {{1,2},{2,0},{0,1}}
 
static const short EdgesVertexTriangle [3][2] = {{1,2},{2,0},{0,1}}
 
static const short OppositeVertex [3] = {0,1,2}
 
static const short OppositeEdge [3] = {0,1,2}
 
static const short NextEdge [3] = {1,2,0}
 
static const short PreviousEdge [3] = {2,0,1}
 
static const short NextVertex [3] = {1,2,0}
 
static const short PreviousVertex [3] = {2,0,1}
 
SaveMetricInterpole LastMetricInterpole
 

Typedef Documentation

◆ D2

typedef P2<double,double> bamg::D2

Definition at line 11 of file Metric.h.

◆ D2xD2

typedef P2xP2<double,double> bamg::D2xD2

Definition at line 12 of file Metric.h.

◆ I2

typedef P2<int,long long> bamg::I2

Definition at line 11 of file typedefs.h.

◆ R2

typedef P2<double,double> bamg::R2

Definition at line 12 of file typedefs.h.

Function Documentation

◆ det()

long long bamg::det ( const I2 &  a,
const I2 &  b,
const I2 &  c 
)
inline

Definition at line 8 of file det.h.

8  {
9  long long bax = b.x - a.x ,bay = b.y - a.y;
10  long long cax = c.x - a.x ,cay = c.y - a.y;
11  return bax*cay - bay*cax;
12  }

◆ CloseBoundaryEdge()

AdjacentTriangle bamg::CloseBoundaryEdge ( I2  A,
Triangle *  t,
double &  a,
double &  b 
)

Definition at line 4927 of file Mesh.cpp.

4927  {/*{{{*/
4928  /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CloseBoundaryEdge)*/
4929 
4930  int k=(*t)(0) ? (( (*t)(1) ? ( (*t)(2) ? -1 : 2) : 1 )) : 0;
4931  int dir=0;
4932  if (k<0){
4933  _error_("k<0");
4934  }
4935  int kkk=0;
4936  long long IJ_IA,IJ_AJ;
4937  AdjacentTriangle edge(t,OppositeEdge[k]);
4938  for (;;edge = dir >0 ? Next(Adj(Next(edge))) : Previous(Adj(Previous(edge)))) {
4939  kkk++;
4940  if (kkk>=1000){
4941  _error_("kkk>=1000");
4942  }
4943  BamgVertex &vI = *edge.EdgeVertex(0);
4944  BamgVertex &vJ = *edge.EdgeVertex(1);
4945  I2 I=vI, J=vJ, IJ= J-I;
4946  IJ_IA = (IJ ,(A-I));
4947  if (IJ_IA<0) {
4948  if (dir>0) {a=1;b=0;return edge;}// change of signe => I
4949  else {dir=-1;
4950  continue;}};// go in direction i
4951  IJ_AJ = (IJ ,(J-A));
4952  if (IJ_AJ<0) {
4953  if(dir<0) {a=0;b=1;return edge;}
4954  else {dir = 1;
4955  continue;}}// go in direction j
4956  double IJ2 = IJ_IA + IJ_AJ;
4957  if (IJ2==0){
4958  _error_("IJ2==0");
4959  }
4960  a= IJ_AJ/IJ2;
4961  b= IJ_IA/IJ2;
4962  return edge;
4963  }
4964  }

◆ swap()

void bamg::swap ( Triangle *  t1,
short  a1,
Triangle *  t2,
short  a2,
BamgVertex *  s1,
BamgVertex *  s2,
long long  det1,
long long  det2 
)

Definition at line 4966 of file Mesh.cpp.

4966  { /*{{{*/
4967  /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
4968  // --------------------------------------------------------------
4969  // short a2=aa[a];// les 2 numero de l arete dans les 2 triangles
4970  //
4971  // sb sb
4972  // / | \ / \ !
4973  // as1/ | \ /a2 \ !
4974  // / | \ / t2 \ !
4975  // s1 /t1 | t2 \s2 --> s1 /___as2___\s2 !
4976  // \ a1|a2 / \ as1 /
4977  // \ | / \ t1 /
4978  // \ | / as2 \ a1/
4979  // \ | / \ /
4980  // sa sa
4981  // -------------------------------------------------------------
4982  int as1 = NextEdge[a1];
4983  int as2 = NextEdge[a2];
4984  int ap1 = PreviousEdge[a1];
4985  int ap2 = PreviousEdge[a2];
4986  (*t1)(VerticesOfTriangularEdge[a1][1]) = s2 ; // avant sb
4987  (*t2)(VerticesOfTriangularEdge[a2][1]) = s1 ; // avant sa
4988  // mise a jour des 2 adjacences externes
4989  AdjacentTriangle taas1 = t1->Adj(as1),
4990  taas2 = t2->Adj(as2),
4991  tas1(t1,as1), tas2(t2,as2),
4992  ta1(t1,a1),ta2(t2,a2);
4993  // externe haut gauche
4994  taas1.SetAdj2(ta2, taas1.GetAllFlag_UnSwap());
4995  // externe bas droite
4996  taas2.SetAdj2(ta1, taas2.GetAllFlag_UnSwap());
4997  // remove the Mark UnMarkSwap
4998  t1->SetUnMarkUnSwap(ap1);
4999  t2->SetUnMarkUnSwap(ap2);
5000  // interne
5001  tas1.SetAdj2(tas2);
5002 
5003  t1->det = det1;
5004  t2->det = det2;
5005 
5006  t1->SetSingleVertexToTriangleConnectivity();
5007  t2->SetSingleVertexToTriangleConnectivity();
5008  } // end swap

◆ Previous()

AdjacentTriangle bamg::Previous ( const AdjacentTriangle &  ta)
inline

Definition at line 158 of file Mesh.h.

158  {
159  return AdjacentTriangle(ta.t,PreviousEdge[ta.a]);
160  }

◆ Next()

AdjacentTriangle bamg::Next ( const AdjacentTriangle &  ta)
inline

Definition at line 161 of file Mesh.h.

161  {
162  return AdjacentTriangle(ta.t,NextEdge[ta.a]);
163  }

◆ Adj() [1/2]

AdjacentTriangle bamg::Adj ( const AdjacentTriangle &  a)
inline

Definition at line 164 of file Mesh.h.

164  {
165  return a.Adj();
166  }

◆ Adj() [2/2]

void bamg::Adj ( GeomEdge *&  on,
int &  i 
)
inline

Definition at line 167 of file Mesh.h.

167  {
168  int j=i;i=on->AdjVertexIndex[i];on=on->Adj[j];
169  }

◆ LengthInterpole() [1/2]

double bamg::LengthInterpole ( const Metric &  Ma,
const Metric &  Mb,
R2  AB 
)

Definition at line 158 of file Metric.cpp.

158  {/*{{{*/
159  /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/LengthInterpole)*/
160 
161  double k=1./2.;
162  int level=0;
163  static int kkk=0;
164  static Metric Ms1[32],Ms2[32];
165  static double lMs1[32],lMs2[32];
166  static double K[32];
167  double l=0,sss=0;
168  Ms1[level]=Ma;
169  Ms2[level]=Mb;
170  double sa = Ma.Length(AB.x,AB.y);
171  double sb = Mb.Length(AB.x,AB.y);
172  lMs1[level]=sa;
173  lMs2[level]=sb;
174  K[level]=k;
175  level++;
176  int i=0;
177  double * L= LastMetricInterpole.L, *S = LastMetricInterpole.S;
178  double sstop = 0.1; // Max(0.6,(sa+sb)/5000);
179  while (level) {
180  level--;
181  Metric M1=Ms1[level];
182  Metric M2=Ms2[level];
183  k=K[level];
184  double s1= lMs1[level];
185  double s2= lMs2[level];
186 
187  double s= (s1+s2)*k;
188  if( s > sstop && level < 30 && i < 500-level ) {
189  Metric Mi(0.5,M1,0.5,M2);
190  double si = Mi.Length(AB.x,AB.y);
191  if( Abs((s1+s2)-(si+si)) > s1*0.001)
192  {
193  k=k/2;
194  // we begin by the end to walk in the correct direction from a to b
195  // due to the stack
196  Ms1[level]=Mi;
197  Ms2[level]=M2;
198  lMs1[level]=si;
199  lMs2[level]=s2;
200  K[level]=k;
201  level++;
202  Ms1[level]=M1;
203  Ms2[level]=Mi;
204  lMs1[level]=s1;
205  lMs2[level]=si;
206  K[level]=k;
207  level++;
208  }
209  else
210  L[i]= l += s,S[i]=sss+=k,i++;
211  }
212  else
213  L[i]= l += s,S[i]=sss+=k,i++;
214  }
215  // warning for optimisation S is in [0:0.5] not in [0:1]
216  if (i>=512){
217  _error_("i>=512");
218  }
219  LastMetricInterpole.lab=l;
220  LastMetricInterpole.opt=i;
221  if (i>200 && kkk++<10) _printf_("WARNING: LengthInterpole: ( i=" << i << " l=" << l << " sss=" << sss << " ) " << sstop << "\n");
222  return l;
223  }

◆ SimultaneousMatrixReduction()

void bamg::SimultaneousMatrixReduction ( Metric  M1,
Metric  M2,
D2xD2 &  V 
)

Definition at line 225 of file Metric.cpp.

225  {/*{{{*/
226  /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/ReductionSimultanee)*/
227 
228  /*In this routine we must return a matrix V that is composed of the
229  * eigen vectors of N=inv(M1) M2.
230  * Instead of looking at N directly, we are going to use the fact that
231  * M1 and M2 are symmetrical, positive definite.
232  * The eigen values of N are given by solving
233  * inv(M1) M2 V = lambda V
234  * which is equivalent to
235  * M2 V = lambda M1 V
236  * and we will hence solve
237  * (M2 - lambda M1) V = 0
238  */
239 
240  //M1 and M2 components
241  double a11=M1.a11,a21=M1.a21,a22=M1.a22;
242  double b11=M2.a11,b21=M2.a21,b22=M2.a22;
243 
244  /*To get the eigen values, we solve the following problem:
245  * det(M2-lambda M1) = 0
246  * (b11 - lambda a11)(b22-lambda a22) - (b21-lambda a21)^2
247  * and we have the following trinome:
248  * a lambda^2 + b lambda + c =0
249  * with:
250  * a = a11 a22 - a21 a21 (=det(M1))
251  * b = -a11 b22 -b11 a22 + 2 b21 a21
252  * c = b11 b22 - b21 b21 (=det(M2))
253  * */
254  const double a= a11*a22 - a21*a21;
255  const double b=-a11*b22 - b11*a22+2*b21*a21;
256  const double c=-b21*b21 + b11*b22;
257  const double bb=b*b,ac=a*c;
258  const double delta= bb-4*ac;
259 
260  // first, case of a double root if:
261  // - all the terms are very small (a??)
262  // - or : delta is very small
263  if ( (bb + Abs(ac) < 1.0e-34 ) || (delta < 1.0e-6*bb) ){
264  //all vectors are eigen vectors -> choose 1,0 and 0,1
265  V= D2xD2(1,0,0,1);
266  }
267 
268  //general case: two distinct roots: lambda1 and lambda2
269  else {
270 
271  /*Compute eigen values*/
272  const double delta2 = sqrt(delta);
273  double lambda[2];
274  lambda[0]= (-b - delta2)/(2*a);
275  lambda[1]= (-b + delta2)/(2*a);
276 
277  /*compute eigen vectors*/
278  double vp[2][2];
279  double v0,v1,v2;
280  double s0,s1;
281 
282  for(int i=0;i<2;i++){
283  /*Now, one must find the eigen vectors. For that we use the
284  * following property of the inner product
285  * (Ax,b) = transp(b) Ax = transp(x) transp(A) b
286  * = (transp(A) b ,x)
287  * Here we are dealing with A= M2 - lambda M1 which is symmetrical:
288  * for all (x,y) in R2
289  * ((M2 - lambda M1)x,y)=((M2 - lambda M1)y,x)
290  * If y is in Ker(M2 - lambda M1):
291  * for all x in R2
292  * ((M2 - lambda M1)y,x)=0
293  * This shows that:
294  * Ker(M2 - lambda M1) is orthogonal to Im(M2 - lambda M1)
295  * To find the eigen vectors, we only have to find two vectors
296  * of the image and take their perpendicular as long as they are
297  * not 0.
298  * To do that, we take (1,0) and (0,1) and take the larger norm*/
299 
300  //compute V = M2 - lambdai M1
301  v0 = b11 - lambda[i]*a11;
302  v1 = b21 - lambda[i]*a21;
303  v2 = b22 - lambda[i]*a22;
304 
305  // compute s1=norm(V(1,0)) and s0=norm(V(0,1))
306  s0 = v0*v0 + v1*v1;
307  s1 = v1*v1 + v2*v2;
308 
309  //compute vp1 = (vp1x,vp1y)
310  if(s1 < s0){
311  s0=sqrt(s0);
312  vp[0][i]= v1/s0;
313  vp[1][i]= - v0/s0;
314  }
315  else{
316  s1=sqrt(s1);
317  vp[0][i]= v2/s1;
318  vp[1][i]= - v1/s1;
319  }
320  }
321 
322  //compute V from vp
323  V=D2xD2(vp[0][0],vp[0][1],vp[1][0],vp[1][1]);
324  }
325  }

◆ abscisseInterpole() [1/2]

double bamg::abscisseInterpole ( const Metric &  Ma,
const Metric &  Mb,
R2  AB,
double  s,
int  optim 
)

Definition at line 327 of file Metric.cpp.

327  { /*{{{*/
328  /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/abscisseInterpole)*/
329 
330  if(!optim) LengthInterpole(Ma,Mb,AB);
331  double l = s* LastMetricInterpole.lab,r;
332  int j=LastMetricInterpole.opt-1;
333 
334  double * L= LastMetricInterpole.L, *S = LastMetricInterpole.S;
335  // warning for optimisation S is the abcisse in [0:0.5]
336  // and L is le lenght
337  if(l<=L[0]){
338  r=2*S[0]*l/L[0];
339  }
340  else if (l>=L[j]){
341  r=1;
342  }
343  else{
344  int i=0;
345  while (j-i>1){
346  int k;
347  k= (i+j)/2;
348  if(l<=L[k]){
349  j=k;// l<=L[j]
350  }
351  else{
352  i=k; // L[i]<l
353  }
354  };
355  if (i==j){
356  r = 2*S[i];
357  }
358  else{
359  r = 2*(S[i]*(L[j]-l)+ S[j]*(l-L[i]))/(L[j]-L[i]);
360  }
361  }
362  if (r>1 || r<0){
363  _error_("r>1 || r<0");
364  }
365  return r ;
366  }

◆ LengthInterpole() [2/2]

double bamg::LengthInterpole ( double  la,
double  lb 
)
inline

Definition at line 128 of file Metric.h.

128  {
129  return ( Abs(la - lb) < 1.0e-6*Max3(la,lb,1.0e-20) ) ? (la+lb)/2 : la*lb*log(la/lb)/(la-lb);
130  }

◆ abscisseInterpole() [2/2]

double bamg::abscisseInterpole ( double  la,
double  lb,
double  lab,
double  s 
)
inline

Definition at line 131 of file Metric.h.

131  {
132  return ( Abs(la - lb) <1.0e-6*Max3(la,lb,1.0e-20)) ? s : (exp(s*lab*(la-lb)/(la*lb))-1)*lb/(la-lb);
133  }

◆ Det()

template<class R , class RR >
RR bamg::Det ( const P2< R, RR >  x,
const P2< R, RR >  y 
)
inline

Definition at line 77 of file R2.h.

77  {
78  return (RR) x.x * (RR) y.y - (RR) x.y * (RR) y.x ;
79  }

◆ Area2()

template<class R , class RR >
RR bamg::Area2 ( const P2< R, RR >  a,
const P2< R, RR >  b,
const P2< R, RR >  c 
)
inline

Definition at line 81 of file R2.h.

81  {
82  return Det(b-a,c-a) ;
83  }

◆ Norme1()

template<class R , class RR >
R bamg::Norme1 ( const P2< R, RR >  x)
inline

Definition at line 85 of file R2.h.

85  {
86  return (Abs(x.x)+Abs(x.y)) ;
87  }

◆ Norme2_2()

template<class R , class RR >
RR bamg::Norme2_2 ( const P2< R, RR >  x)
inline

Definition at line 89 of file R2.h.

89  {
90  return (RR)x.x*(RR)x.x + (RR)x.y*(RR)x.y ;
91  }

◆ Norme2()

template<class R , class RR >
RR bamg::Norme2 ( const P2< R, RR >  x)
inline

Definition at line 93 of file R2.h.

93  {
94  return sqrt((RR)x.x*(RR)x.x + (RR)x.y*(RR)x.y) ;
95  }

◆ Orthogonal()

template<class R , class RR >
P2<R,RR> bamg::Orthogonal ( const P2< R, RR >  x)
inline

Definition at line 97 of file R2.h.

97  {
98  return P2<R,RR>(-x.y,x.x);
99  }

◆ Abs()

template<class T >
T bamg::Abs ( const T &  a)
inline

Definition at line 5 of file Abs.h.

5 {return a <0 ? -a : a;}

◆ BigPrimeNumber()

long bamg::BigPrimeNumber ( long  n)

Definition at line 6 of file BigPrimeNumber.cpp.

6  {
7  /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/AGoodNumberPrimeWith)*/
8 
9  /*list of big prime numbers*/
10  const long BigPrimeNumber[] ={ 567890359L,
11  567890431L, 567890437L, 567890461L, 567890471L,
12  567890483L, 567890489L, 567890497L, 567890507L,
13  567890591L, 567890599L, 567890621L, 567890629L , 0};
14 
15  /*initialize o and pi*/
16  long o = 0;
17  long pi = BigPrimeNumber[1];
18 
19  /*loop until BigPrimeNumber[i]==0 (end of BigPrimeNumber)*/
20  for (int i=0; BigPrimeNumber[i]; i++){
21 
22  /*compute r, remainder of the division of BigPrimeNumber[i] by n*/
23  long r = BigPrimeNumber[i] % n;
24 
25  /*compute oo = min ( r , n-r , |n - 2r|, |n-3r|)*/
26  long oo = Min(Min(r,n-r),Min(Abs(n-2*r),Abs(n-3*r)));
27  if(o < oo){
28  o = oo;
29  pi = BigPrimeNumber[i];
30  }
31  }
32  return pi;
33  }

◆ Min()

template<class T >
T bamg::Min ( const T &  a,
const T &  b 
)
inline

Definition at line 6 of file extrema.h.

6 {return a < b ? a : b;}

◆ Max()

template<class T >
T bamg::Max ( const T &  a,
const T &  b 
)
inline

Definition at line 7 of file extrema.h.

7 {return a > b ? a : b;}

◆ Max3()

template<class T >
T bamg::Max3 ( const T &  a,
const T &  b,
const T &  c 
)
inline

Definition at line 8 of file extrema.h.

8 {return Max(Max(a,b),c);}

◆ Min3()

template<class T >
T bamg::Min3 ( const T &  a,
const T &  b,
const T &  c 
)
inline

Definition at line 9 of file extrema.h.

9 {return Min(Min(a,b),c);}

◆ OppositeAngle() [1/2]

float bamg::OppositeAngle ( float  a)
inline

Definition at line 8 of file OppositeAngle.h.

8 {return a<0 ? PI+a:a-PI;}

◆ OppositeAngle() [2/2]

double bamg::OppositeAngle ( double  a)
inline

Definition at line 9 of file OppositeAngle.h.

9 {return a<0 ? PI+a:a-PI;}

Variable Documentation

◆ Pi

const double bamg::Pi =3.141592653589793238462643383279502884197169399375105820974944592308

Definition at line 8 of file macros.h.

◆ fPi

const float bamg::fPi =3.141592653589793238462643383279502884197169399375105820974944592308

Definition at line 9 of file macros.h.

◆ IsVertexOnGeom

const int bamg::IsVertexOnGeom = 8

Definition at line 10 of file macros.h.

◆ IsVertexOnVertex

const int bamg::IsVertexOnVertex = 16

Definition at line 11 of file macros.h.

◆ IsVertexOnEdge

const int bamg::IsVertexOnEdge = 32

Definition at line 12 of file macros.h.

◆ VerticesOfTriangularEdge

const short bamg::VerticesOfTriangularEdge[3][2] = {{1,2},{2,0},{0,1}}
static

Definition at line 13 of file macros.h.

◆ EdgesVertexTriangle

const short bamg::EdgesVertexTriangle[3][2] = {{1,2},{2,0},{0,1}}
static

Definition at line 14 of file macros.h.

◆ OppositeVertex

const short bamg::OppositeVertex[3] = {0,1,2}
static

Definition at line 15 of file macros.h.

◆ OppositeEdge

const short bamg::OppositeEdge[3] = {0,1,2}
static

Definition at line 16 of file macros.h.

◆ NextEdge

const short bamg::NextEdge[3] = {1,2,0}
static

Definition at line 17 of file macros.h.

◆ PreviousEdge

const short bamg::PreviousEdge[3] = {2,0,1}
static

Definition at line 18 of file macros.h.

◆ NextVertex

const short bamg::NextVertex[3] = {1,2,0}
static

Definition at line 19 of file macros.h.

◆ PreviousVertex

const short bamg::PreviousVertex[3] = {2,0,1}
static

Definition at line 20 of file macros.h.

◆ LastMetricInterpole

SaveMetricInterpole bamg::LastMetricInterpole

Definition at line 12 of file Metric.cpp.

bamg::LastMetricInterpole
SaveMetricInterpole LastMetricInterpole
Definition: Metric.cpp:12
bamg::PreviousEdge
static const short PreviousEdge[3]
Definition: macros.h:18
_printf_
#define _printf_(StreamArgs)
Definition: Print.h:22
bamg::Adj
AdjacentTriangle Adj(const AdjacentTriangle &a)
Definition: Mesh.h:164
bamg::SaveMetricInterpole::lab
double lab
Definition: Metric.h:90
bamg::Max3
T Max3(const T &a, const T &b, const T &c)
Definition: extrema.h:8
bamg::SaveMetricInterpole::L
double L[1024]
Definition: Metric.h:91
bamg::BigPrimeNumber
long BigPrimeNumber(long n)
Definition: BigPrimeNumber.cpp:6
bamg::Max
T Max(const T &a, const T &b)
Definition: extrema.h:7
bamg::OppositeEdge
static const short OppositeEdge[3]
Definition: macros.h:16
bamg::Next
AdjacentTriangle Next(const AdjacentTriangle &ta)
Definition: Mesh.h:161
bamg::I2
P2< int, long long > I2
Definition: typedefs.h:11
IJ
#define IJ(i, j, l)
Definition: Quadtree.cpp:79
bamg::LengthInterpole
double LengthInterpole(const Metric &Ma, const Metric &Mb, R2 AB)
Definition: Metric.cpp:158
bamg::Det
RR Det(const P2< R, RR > x, const P2< R, RR > y)
Definition: R2.h:77
PI
const double PI
Definition: constants.h:11
bamg::SaveMetricInterpole::opt
int opt
Definition: Metric.h:89
_error_
#define _error_(StreamArgs)
Definition: exceptions.h:49
bamg::VerticesOfTriangularEdge
static const short VerticesOfTriangularEdge[3][2]
Definition: macros.h:13
bamg::SaveMetricInterpole::S
double S[1024]
Definition: Metric.h:91
bamg::Abs
T Abs(const T &a)
Definition: Abs.h:5
bamg::D2xD2
P2xP2< double, double > D2xD2
Definition: Metric.h:12
bamg::Previous
AdjacentTriangle Previous(const AdjacentTriangle &ta)
Definition: Mesh.h:158
bamg::Min
T Min(const T &a, const T &b)
Definition: extrema.h:6
bamg::NextEdge
static const short NextEdge[3]
Definition: macros.h:17
Generated on Thu Jul 2 2020 08:09:31 for Ice Sheet System Model by   doxygen 1.8.19