Changeset 5143


Ignore:
Timestamp:
08/11/10 09:01:16 (15 years ago)
Author:
Mathieu Morlighem
Message:

Renamed some Bamg fields and classes

Location:
issm/trunk/src/c/objects
Files:
10 edited
2 moved

Legend:

Unmodified
Added
Removed
  • issm/trunk/src/c/objects/Bamg/AdjacentTriangle.cpp

    r5141 r5143  
    44#include <ctime>
    55
    6 #include "TriangleAdjacent.h"
     6#include "AdjacentTriangle.h"
    77#include "Mesh.h"
    88
     
    1414
    1515        /*Methods*/
    16         /*FUNCTION TriangleAdjacent::Locked {{{1*/
    17         int  TriangleAdjacent::Locked() const {
     16        /*FUNCTION AdjacentTriangle::Locked {{{1*/
     17        int  AdjacentTriangle::Locked() const {
    1818                return t->TriaAdjSharedEdge[a] & 4;
    1919        }
    2020        /*}}}*/
    21         /*FUNCTION TriangleAdjacent::MarkUnSwap {{{1*/
    22         int  TriangleAdjacent::MarkUnSwap() const {
     21        /*FUNCTION AdjacentTriangle::MarkUnSwap {{{1*/
     22        int  AdjacentTriangle::MarkUnSwap() const {
    2323                return t->TriaAdjSharedEdge[a] & 8;
    2424        }
    2525        /*}}}*/
    26         /*FUNCTION TriangleAdjacent::GetAllFlag_UnSwap {{{1*/
    27         int  TriangleAdjacent::GetAllFlag_UnSwap() const {
     26        /*FUNCTION AdjacentTriangle::GetAllFlag_UnSwap {{{1*/
     27        int  AdjacentTriangle::GetAllFlag_UnSwap() const {
    2828                // take all flag except MarkUnSwap
    2929                return t->TriaAdjSharedEdge[a] & 1012;
    3030        }
    3131        /*}}}*/
    32         /*FUNCTION TriangleAdjacent::SetLock {{{1*/
    33         void TriangleAdjacent::SetLock(){
     32        /*FUNCTION AdjacentTriangle::SetLock {{{1*/
     33        void AdjacentTriangle::SetLock(){
    3434                t->SetLocked(a);
    3535        }
    3636        /*}}}*/
    37         /*FUNCTION TriangleAdjacent::Adj {{{1*/
    38         TriangleAdjacent TriangleAdjacent::Adj() const {
     37        /*FUNCTION AdjacentTriangle::Adj {{{1*/
     38        AdjacentTriangle AdjacentTriangle::Adj() const {
    3939                return  t->Adj(a);
    4040        }
    4141        /*}}}*/
    42         /*FUNCTION TriangleAdjacent::EdgeVertex {{{1*/
    43         BamgVertex* TriangleAdjacent::EdgeVertex(const int & i) const {
     42        /*FUNCTION AdjacentTriangle::EdgeVertex {{{1*/
     43        BamgVertex* AdjacentTriangle::EdgeVertex(const int & i) const {
    4444                return t->TriaVertices[VerticesOfTriangularEdge[a][i]];
    4545        }
    4646        /*}}}*/
    47         /*FUNCTION TriangleAdjacent::OppositeVertex {{{1*/
    48         BamgVertex* TriangleAdjacent::OppositeVertex() const {
     47        /*FUNCTION AdjacentTriangle::OppositeVertex {{{1*/
     48        BamgVertex* AdjacentTriangle::OppositeVertex() const {
    4949                return t->TriaVertices[bamg::OppositeVertex[a]];
    5050        }
    5151        /*}}}*/
    52         /*FUNCTION TriangleAdjacent::det {{{1*/
    53         Icoor2 & TriangleAdjacent::det() const {
     52        /*FUNCTION AdjacentTriangle::det {{{1*/
     53        Icoor2 & AdjacentTriangle::det() const {
    5454                return t->det;
    5555        }
    5656        /*}}}*/
    57         /*FUNCTION TriangleAdjacent::swap {{{1*/
    58         int TriangleAdjacent::swap(){
     57        /*FUNCTION AdjacentTriangle::swap {{{1*/
     58        int AdjacentTriangle::swap(){
    5959                return  t->swap(a);
    6060        }
    6161        /*}}}*/
    62         /*FUNCTION TriangleAdjacent::SetAdj2 {{{1*/
    63         void TriangleAdjacent::SetAdj2(const TriangleAdjacent & ta, int l  ){
     62        /*FUNCTION AdjacentTriangle::SetAdj2 {{{1*/
     63        void AdjacentTriangle::SetAdj2(const AdjacentTriangle & ta, int l  ){
    6464                //set Adjacent Triangle of a triangle
    6565                if(t) {
  • issm/trunk/src/c/objects/Bamg/AdjacentTriangle.h

    r5141 r5143  
    1111        class Triangle;
    1212
    13         class TriangleAdjacent {
     13        class AdjacentTriangle {
    1414
    1515                public:
     
    1818
    1919                        //Constructors
    20                         TriangleAdjacent() {};
    21                         TriangleAdjacent(Triangle* tt,int  aa): t(tt),a(aa &3) {};
     20                        AdjacentTriangle() {};
     21                        AdjacentTriangle(Triangle* tt,int  aa): t(tt),a(aa &3) {};
    2222
    2323                        //Operators
     
    2525                        operator Triangle & () const {return *t;}
    2626                        operator int() const {return a;}
    27                         TriangleAdjacent & operator++(){ a= NextEdge[a]; return *this; }
    28                         TriangleAdjacent operator--(){ a= PreviousEdge[a]; return *this; }
     27                        AdjacentTriangle & operator++(){ a= NextEdge[a]; return *this; }
     28                        AdjacentTriangle operator--(){ a= PreviousEdge[a]; return *this; }
    2929
    3030                        //Methods
     
    3535                        int  GetAllFlag_UnSwap() const;
    3636                        void SetLock();
    37                         void SetAdj2(const TriangleAdjacent &ta, int l=0);
     37                        void SetAdj2(const AdjacentTriangle &ta, int l=0);
    3838                        int  swap();
    39                         TriangleAdjacent Adj() const;
     39                        AdjacentTriangle Adj() const;
    4040                        BamgVertex* EdgeVertex(const int & i) const;
    4141                        BamgVertex* OppositeVertex() const;
  • issm/trunk/src/c/objects/Bamg/BamgVertex.cpp

    r5124 r5143  
    5252                if (tstart->det <0){ // outside
    5353                        double ba,bb;
    54                         TriangleAdjacent edge= CloseBoundaryEdge(IBTh,tstart,ba,bb) ;
     54                        AdjacentTriangle edge= CloseBoundaryEdge(IBTh,tstart,ba,bb) ;
    5555                        tstart = edge;
    5656                        vP.m= Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1));
  • issm/trunk/src/c/objects/Bamg/Edge.h

    r5130 r5143  
    1616
    1717                public:
    18                         BamgVertex* v[2];
    19                         long ref;
    20                         GeometricalEdge* onGeometry;
    21                         Edge* adj[2]; // the 2 adj edges if on the same curve
     18                        BamgVertex      *v[2];
     19                        long             ref;
     20                        GeometricalEdge *onGeometry;
     21                        Edge            *adj[2];       // the 2 adj edges if on the same curve
    2222
    2323                        //Operators
    24                         BamgVertex & operator[](int i){return *v[i];};
    25                         BamgVertex * operator()(int i){return v[i];};
    26                         R2       operator()(double t) const; // return the point
    27                         const BamgVertex & operator[](int i) const { return *v[i];};
     24                        BamgVertex       &operator[](int i){return *v[i];   };
     25                        BamgVertex       *operator()(int    i){return v[i];};
     26                        R2                operator()(double  t) const;// return the point
     27                        const BamgVertex &operator[](int i) const{return *v[i];};
    2828
    2929                        //Methods
  • issm/trunk/src/c/objects/Bamg/GeometricalEdge.h

    r5130 r5143  
    1313
    1414                public:
    15                         GeometricalVertex* v[2];
    16                         long ref;
    17                         long CurveNumber;
    18                         R2   tg[2]; // the 2 tangentes (tg[0] =0 => no continuity)
    19                         GeometricalEdge* Adj[2];
    20                         int DirAdj[2];
    21                         int flag ;
     15                        GeometricalVertex *v[2];
     16                        long               ref;
     17                        long               CurveNumber;
     18                        R2                 tg[2];        // the 2 tangentes (tg[0] =0 => no continuity)
     19                        GeometricalEdge   *Adj[2];
     20                        int                DirAdj[2];
     21                        int                flag;
    2222
    2323                        //Operators
  • issm/trunk/src/c/objects/Bamg/Geometry.cpp

    r5130 r5143  
    6969
    7070                double Hmin = HUGE_VAL;// the infinie value
    71                 int i,j,k,n,i1,i2;
     71                int i,j,k,n,i0,i1,i2,i3;
    7272
    7373                /*initialize some variables*/
    74                 verbose=bamgopts->verbose;
    75                 nbv  = bamggeom->VerticesSize[0];
    76                 nbe  = bamggeom->EdgesSize[0];
     74                verbose= bamgopts->verbose;
     75                nbv    = bamggeom->VerticesSize[0];
     76                nbe    = bamggeom->EdgesSize[0];
    7777
    7878                //some checks
     
    122122                //Edges
    123123                if (bamggeom->Edges){
    124                         R2     zero2(0,0);
    125                         double* len=NULL;
     124                        R2      zerovector(0,0);
     125                        double* verticeslength=NULL;
    126126
    127127                        if(verbose>5) printf("      processing Edges\n");
     
    129129                        edges = new GeometricalEdge[nbe];
    130130
    131                         //initialize len (length of each edge)
    132                         len = new double[nbv];
    133                         for(i=0;i<nbv;i++) len[i]=0;
    134 
     131                        //initialize verticeslength (sum of the lengths of the edges holding vertex)
     132                        verticeslength = new double[nbv];
     133                        for(i=0;i<nbv;i++) verticeslength[i]=0;
     134
     135                        /*Loop over the edges*/
    135136                        for (i=0;i<nbe;i++){
    136137
    137                                 //printf("%i th edge of geometry: [%i %i]\n",i+1,(int)bamggeom->Edges[i*3+0],(int)bamggeom->Edges[i*3+1]);
    138138                                i1=(int)bamggeom->Edges[i*3+0]-1; //-1 for C indexing
    139139                                i2=(int)bamggeom->Edges[i*3+1]-1; //-1 for C indexing
     140                                edges[i].v[0]= vertices + i1;     //pointer toward vertex i1 (=&vertices[i1])
     141                                edges[i].v[1]= vertices + i2;     //pointer toward vertex i2
    140142                                edges[i].ref=(long)bamggeom->Edges[i*3+2];
    141143
    142                                 edges[i].v[0]= vertices + i1;
    143                                 edges[i].v[1]= vertices + i2;
    144 
    145144                                //get length of edge
    146                                 R2    x12=vertices[i2].r-vertices[i1].r;
     145                                R2     x12=vertices[i2].r-vertices[i1].r;
    147146                                double l12=sqrt((x12,x12));
    148147                                Hmin=Min(Hmin,l12);
    149148
    150149                                //initialize other fields
    151                                 edges[i].tg[0]=zero2;
    152                                 edges[i].tg[1]=zero2;
     150                                edges[i].tg[0]=zerovector;
     151                                edges[i].tg[1]=zerovector;
    153152                                edges[i].DirAdj[0] = edges[i].DirAdj[1] = -1;
    154                                 edges[i].Adj[0] = edges[i].Adj[1] = 0;
     153                                edges[i].Adj[0] = edges[i].Adj[1] = NULL;
    155154                                edges[i].flag = 0;
    156155
    157156                                //Cracked?
    158                                 if (edges[i].ref!=1){
    159                                         edges[i].SetCracked();
    160                                 }
     157                                if (edges[i].ref!=1) edges[i].SetCracked();
    161158
    162159                                //prepare metric
    163160                                vertices[i1].color++;
    164161                                vertices[i2].color++;
    165                                 len[i1] += l12;
    166                                 len[i2] += l12;
     162                                verticeslength[i1] += l12;
     163                                verticeslength[i2] += l12;
    167164                        }
    168165
    169166                        // definition  the default of the given mesh size
    170                         for (i=0;i<nbv;i++)
    171                          if (vertices[i].color > 0)
    172                           vertices[i].m=Metric(len[i] /(double) vertices[i].color);
    173                          else
    174                           vertices[i].m=Metric(Hmin);
    175                         delete [] len;
     167                        for (i=0;i<nbv;i++) {
     168                                if (vertices[i].color > 0)
     169                                 vertices[i].m=Metric(verticeslength[i] /(double) vertices[i].color);
     170                                else
     171                                 vertices[i].m=Metric(Hmin);
     172                        }
     173                        delete [] verticeslength;
    176174                       
    177175                }
     
    217215                                tg.x=bamggeom->TangentAtEdges[k*4+2];
    218216                                tg.y=bamggeom->TangentAtEdges[k*4+3];
    219                                 if (j!=0 && j!=1){
    220                                         ISSMERROR("TangentAtEdges second index should be 1 or 2 only");
    221                                 }
     217                                if (i<0 || i>=nbe) ISSMERROR("TangentAtEdges first index exceeds matrix dimension");
     218                                if (j!=0 && j!=1)  ISSMERROR("TangentAtEdges second index should be 1 or 2 only");
    222219                                edges[i].tg[j] = tg;
    223220                        }
     
    231228                        for (i=0;i<n;i++) {     
    232229                                j=(int)bamggeom->Corners[i]-1; //for C indexing
    233                                 if (j>nbv-1 || j<0){
    234                                         ISSMERROR("Bad corner definition: should in [0 %i]",nbv);
    235                                 }
     230                                if (j>nbv-1 || j<0) ISSMERROR("Bad corner definition: should in [0 %i]",nbv);
     231                                /*Required => at the same time SetRequired and SetCorner*/
    236232                                vertices[j].SetCorner();
    237                                 vertices[j].SetRequired();  }
     233                                vertices[j].SetRequired();
     234                        }
    238235                }
    239236
     
    245242                        for (i=0;i<n;i++) {     
    246243                                j=(int)bamggeom->RequiredVertices[i]-1; //for C indexing
    247                                 if (j>nbv-1 || j<0){
    248                                         ISSMERROR("Bad RequiredVerticess  definition: should in [0 %i]",nbv);
    249                                 }
    250                                 vertices[j].SetRequired();  }
     244                                if (j>nbv-1 || j<0) ISSMERROR("Bad RequiredVerticess  definition: should in [0 %i]",nbv);
     245                                vertices[j].SetRequired();
     246                        }
    251247                }
    252248
     
    258254                        for (i=0;i<n;i++) {     
    259255                                j=(int)bamggeom->RequiredEdges[i]-1; //for C indexing
    260                                 if (j>nbe-1 || j<0){
    261                                         ISSMERROR("Bad RequiredEdges definition: should in [0 %i]",nbe);
    262                                 }
     256                                if (j>nbe-1 || j<0) ISSMERROR("Bad RequiredEdges definition: should in [0 %i]",nbe);
    263257                                edges[j].SetRequired(); 
    264258                        }
     
    267261                //SubDomain
    268262                if(bamggeom->SubDomains){
    269                         long i0,i1,i2,i3;
    270263                        if(verbose>5) printf("      processing SubDomains\n");
    271264                        if (bamggeom->SubDomainsSize[1]!=4) ISSMERROR("SubDomains should have 4 columns");
    272265                        NbSubDomains=bamggeom->SubDomainsSize[0];
    273266                        subdomains = new GeometricalSubDomain[NbSubDomains];
    274                         for (i=0;i<NbSubDomains;i++) {
     267                        for (i=0;i<NbSubDomains;i++){
    275268                                i0=(int)bamggeom->SubDomains[i*4+0];
    276269                                i1=(int)bamggeom->SubDomains[i*4+1];
  • issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.cpp

    r5130 r5143  
    254254                                ilast=ifirst;
    255255                                double ba,bb;
    256                                 TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
     256                                AdjacentTriangle edge=CloseBoundaryEdge(a,t,ba,bb);
    257257                                BamgVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
    258258                                NewItem(A,Metric(ba,v0,bb,v1));
     
    260260                                // test if the point b is in the same side
    261261                                if (det(v0.i,v1.i,b)>=0) {
    262                                         TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
     262                                        AdjacentTriangle edge=CloseBoundaryEdge(a,t,ba,bb);
    263263                                        BamgVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
    264264                                        NewItem(A,Metric(ba,v0,bb,v1));
     
    284284                                else if (detj<=0) // go to j direction on gamma
    285285                                 ocut = NextEdge[ocut];         
    286                                 TriangleAdjacent tadj =t->Adj(ocut);
     286                                AdjacentTriangle tadj =t->Adj(ocut);
    287287                                t = tadj;
    288288                                iedge= tadj;
     
    290290                                        double ba,bb;
    291291                                        long int verbose=2;
    292                                         TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb);
     292                                        AdjacentTriangle edge=CloseBoundaryEdge(a,t,ba,bb);
    293293                                        BamgVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);
    294294                                        NewItem(A,Metric(ba,v0,bb,v1));
     
    304304                                t=tbegin;
    305305                                double ba,bb;
    306                                 TriangleAdjacent edge=CloseBoundaryEdge(b,t,ba,bb);
     306                                AdjacentTriangle edge=CloseBoundaryEdge(b,t,ba,bb);
    307307                                NewItem(B,Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1)));
    308308                                return;
     
    412412                                        ilast=NewItem(t, ba[0],ba[1],ba[2]);     
    413413
    414                                         TriangleAdjacent ta =t->Adj(ocut);
     414                                        AdjacentTriangle ta =t->Adj(ocut);
    415415                                        t = ta;
    416416                                        iedge= ta;
    417417                                        if (t->det <= 0)  {
    418418                                                double ba,bb;
    419                                                 TriangleAdjacent edge=CloseBoundaryEdge(b,t,ba,bb);
     419                                                AdjacentTriangle edge=CloseBoundaryEdge(b,t,ba,bb);
    420420                                                NewItem(B,Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1)));
    421421                                                return;
  • issm/trunk/src/c/objects/Bamg/Mesh.cpp

    r5130 r5143  
    263263
    264264                double Hmin = HUGE_VAL;// the infinie value
    265                 long i1,i2,i3,iref;
     265                long i1,i2,i3;
    266266                long i,j;
    267267                Metric M1(1);
     
    309309        void Mesh::ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts){
    310310
    311                 int verbose;
    312                 double Hmin = HUGE_VAL;// the infinie value
    313                 long i1,i2,i3,iref;
    314                 long i,j;
    315                 long ifgeom=0;
     311                int    verbose;
     312                double Hmin = HUGE_VAL;    // the infinie value
     313                long   i1,i2,i3;
     314                long   i,j;
    316315                Metric M1(1);
    317316
     
    349348                        //other triangles will be added for each edge
    350349                        for (i=0;i<nbt;i++){
    351                                 Triangle & t = triangles[i];
     350                                Triangle &t=triangles[i];
    352351                                i1=(long)bamgmesh->Triangles[i*4+0]-1; //for C indexing
    353352                                i2=(long)bamgmesh->Triangles[i*4+1]-1; //for C indexing
     
    11381137                        if (nbzerodet == 1) {
    11391138                                iedge = OppositeEdge[izerodet];
    1140                                 TriangleAdjacent ta = t->Adj(iedge);
     1139                                AdjacentTriangle ta = t->Adj(iedge);
    11411140
    11421141                                // the point is on the edge
     
    22832282                        //Now, we are going to go through the adjacent triangle that hold i1 till
    22842283                        //we find one that has the cracked edge
    2285                         TriangleAdjacent ta(tbegin,EdgesVertexTriangle[k][0]);
     2284                        AdjacentTriangle ta(tbegin,EdgesVertexTriangle[k][0]);
    22862285                        count=0;
    22872286                        do {
     
    23582357
    23592358                        //Force Edges
    2360                         TriangleAdjacent ta(0,0);
     2359                        AdjacentTriangle ta(0,0);
    23612360                        for (int i = 0; i < nbe; i++){
    23622361
     
    25752574                                        }
    25762575
    2577                                         TriangleAdjacent  ta(t,EdgesVertexTriangle[v0->vint][0]);// previous edges
     2576                                        AdjacentTriangle  ta(t,EdgesVertexTriangle[v0->vint][0]);// previous edges
    25782577
    25792578                                        while (1) {
     
    30723071                if (t->det <0) { // outside
    30733072                        double ba,bb;
    3074                         TriangleAdjacent edge= CloseBoundaryEdge(a,t,ba,bb) ;
     3073                        AdjacentTriangle edge= CloseBoundaryEdge(a,t,ba,bb) ;
    30753074                        return Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1));}
    30763075                else { // inside
     
    31483147                                //Loop over the edges of t
    31493148                                for(j=0;j<3;j++){
    3150                                         TriangleAdjacent tj(t,j);
     3149                                        AdjacentTriangle tj(t,j);
    31513150                                        BamgVertex &vA = *tj.EdgeVertex(0);
    31523151                                        BamgVertex &vB = *tj.EdgeVertex(1);
     
    31573156                                        if (t->Locked(j)) continue;
    31583157
    3159                                         TriangleAdjacent tadjj = t->Adj(j);       
     3158                                        AdjacentTriangle tadjj = t->Adj(j);       
    31603159                                        Triangle* ta=tadjj;
    31613160
     
    31823181                        for (i=nbvold;i<nbv;i++){
    31833182                                BamgVertex*          s  = vertices + i;
    3184                                 TriangleAdjacent ta(s->t, EdgesVertexTriangle[s->vint][1]);
     3183                                AdjacentTriangle ta(s->t, EdgesVertexTriangle[s->vint][1]);
    31853184                                Triangle*        tbegin= (Triangle*) ta;
    31863185                                long kt;
     
    35213520
    35223521        //enforce the boundary
    3523         TriangleAdjacent ta(0,0);
     3522        AdjacentTriangle ta(0,0);
    35243523        long nbloss = 0,knbe=0;
    35253524        for ( i = 0; i < nbe; i++){
     
    35443543                        krm++;
    35453544                        for (int j=0;j<3;j++){
    3546                                 TriangleAdjacent ta =  triangles[i].Adj(j);
     3545                                AdjacentTriangle ta =  triangles[i].Adj(j);
    35473546                                Triangle &tta = *(Triangle*)ta;
    35483547                                //if edge between remove and not remove
     
    40354034                        }
    40364035                        BamgVertex & vi = vertices[i];
    4037                         TriangleAdjacent ta(t,EdgesVertexTriangle[vertices[i].vint][0]);
     4036                        AdjacentTriangle ta(t,EdgesVertexTriangle[vertices[i].vint][0]);
    40384037                        BamgVertex *pvj0 = ta.EdgeVertex(0);
    40394038                        while (1) {
     
    42464245                        for(int j=0;j<3;j++)
    42474246                          {
    4248                                 const TriangleAdjacent ta = t.Adj(j);
     4247                                const AdjacentTriangle ta = t.Adj(j);
    42494248                                const Triangle & tt = ta;
    42504249                                if (&tt >= lastT)
     
    42954294                                if (t.Hidden(j)) invisibleedge=j,nbinvisible++;
    42964295
    4297                                 const TriangleAdjacent ta = t.Adj(j);
     4296                                const AdjacentTriangle ta = t.Adj(j);
    42984297                                const Triangle & tt = ta;
    42994298
     
    43874386                        }
    43884387                        // --------------------------
    4389                         TriangleAdjacent ta0(t0.Adj(i0)),ta1(t0.Adj(i1)),ta2(t0.Adj(i2));
     4388                        AdjacentTriangle ta0(t0.Adj(i0)),ta1(t0.Adj(i1)),ta2(t0.Adj(i2));
    43904389                        // save the flag Hidden
    43914390                        int hid[]={t0.Hidden(0),t0.Hidden(1),t0.Hidden(2)};
     
    47444743                        ISSMERROR("k>=3");
    47454744                }
    4746                 TriangleAdjacent t1 = t->Adj(jj=ii[0]);
     4745                AdjacentTriangle t1 = t->Adj(jj=ii[0]);
    47474746                if ((t1.det() < 0 ) && (k == 2))
    47484747                 t1 = t->Adj(jj=ii[1]);
     
    54535452        /*Intermediary*/
    54545453        /*FUNCTION CloseBoundaryEdge{{{1*/
    5455         TriangleAdjacent CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) {
     5454        AdjacentTriangle CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) {
    54565455                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CloseBoundaryEdge)*/
    54575456
     
    54635462                int kkk=0; 
    54645463                Icoor2 IJ_IA,IJ_AJ;
    5465                 TriangleAdjacent edge(t,OppositeEdge[k]);         
     5464                AdjacentTriangle edge(t,OppositeEdge[k]);         
    54665465                for (;;edge = dir >0 ? Next(Adj(Next(edge))) : Previous(Adj(Previous(edge)))) { 
    54675466                        kkk++;
     
    54935492        /*}}}1*/
    54945493        /*FUNCTION CloseBoundaryEdgeV2{{{1*/
    5495         TriangleAdjacent CloseBoundaryEdgeV2(I2 C,Triangle *t, double &a,double &b) {
     5494        AdjacentTriangle CloseBoundaryEdgeV2(I2 C,Triangle *t, double &a,double &b) {
    54965495                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CloseBoundaryEdgeV2)*/
    54975496                // walk around the vertex
     
    55145513                Icoor2 l0 = imax,l1 = imax;
    55155514                double dd2 =  imax;// infinity
    5516                 TriangleAdjacent er;
     5515                AdjacentTriangle er;
    55175516                int  cas=-2;
    55185517                for (int j=0;j<3;j++)
    55195518                  {
    5520                         TriangleAdjacent ta=t->FindBoundaryEdge(j);
     5519                        AdjacentTriangle ta=t->FindBoundaryEdge(j);
    55215520                        if  (! (Triangle *) ta) continue;
    55225521                        s0 = ta.EdgeVertex(0);
     
    55825581                  {
    55835582                        t=er;
    5584                         TriangleAdjacent edge(er);
     5583                        AdjacentTriangle edge(er);
    55855584
    55865585                        int kkk=0; 
     
    56425641        /*}}}1*/
    56435642/*FUNCTION ForceEdge{{{1*/
    5644 int ForceEdge(BamgVertex &a, BamgVertex & b,TriangleAdjacent & taret)  {
     5643int ForceEdge(BamgVertex &a, BamgVertex & b,AdjacentTriangle & taret)  {
    56455644        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
    56465645
     
    56505649        }
    56515650        int k=0;
    5652         taret=TriangleAdjacent(0,0); // erreur
    5653 
    5654         TriangleAdjacent tta(a.t,EdgesVertexTriangle[a.vint][0]);
     5651        taret=AdjacentTriangle(0,0); // erreur
     5652
     5653        AdjacentTriangle tta(a.t,EdgesVertexTriangle[a.vint][0]);
    56555654        BamgVertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
    56565655        // we turn around a in the  direct sens 
     
    56705669
    56715670        while (v2 != &b) {
    5672                 TriangleAdjacent tc = Previous(Adj(tta));   
     5671                AdjacentTriangle tc = Previous(Adj(tta));   
    56735672                v1 = v2;
    56745673                v2 = tc.EdgeVertex(0);
     
    57415740        (*t2)(VerticesOfTriangularEdge[a2][1]) = s1  ; // avant sa
    57425741        // mise a jour des 2 adjacences externes
    5743         TriangleAdjacent taas1 = t1->Adj(as1),
     5742        AdjacentTriangle taas1 = t1->Adj(as1),
    57445743                                                  taas2 = t2->Adj(as2),
    57455744                                                  tas1(t1,as1), tas2(t2,as2),
     
    57635762/*}}}1*/
    57645763        /*FUNCTION SwapForForcingEdge{{{1*/
    5765         int SwapForForcingEdge(BamgVertex   *  & pva ,BamgVertex  * &   pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
     5764        int SwapForForcingEdge(BamgVertex   *  & pva ,BamgVertex  * &   pvb ,AdjacentTriangle & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
    57665765                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SwapForForcingEdge)*/
    57675766                // l'arete ta coupe l'arete pva pvb
     
    57735772                if(tt1.Locked()) return 0; // frontiere croise
    57745773
    5775                 TriangleAdjacent tt2 = Adj(tt1);
     5774                AdjacentTriangle tt2 = Adj(tt1);
    57765775                Triangle *t1=tt1,*t2=tt2;// les 2 triangles adjacent
    57775776                short a1=tt1,a2=tt2;// les 2 numero de l arete dans les 2 triangles
  • issm/trunk/src/c/objects/Bamg/Mesh.h

    r5130 r5143  
    2727                        Geometry                    & Gh;                    // Geometry
    2828                        Mesh                        & BTh;                   // Background Mesh Bth== *this =>no background
     29                        BamgVertex                   *vertices;
     30                        Triangle                     *triangles;
     31                        Edge                         *edges;
     32                        QuadTree                     *quadtree;
     33                        BamgVertex                  **ordre;
     34                        SubDomain                    *subdomains;
    2935                        long                          NbRef;                 // counter of ref on the this class if 0 we can delete
    3036                        long                          maxnbv,nbtx;           // nombre max de sommets , de triangles
     
    3541                        long                          NbOfTriangleSearchFind;
    3642                        long                          NbOfSwapTriangle;
    37                         BamgVertex                   *vertices;
    3843                        long                          NbVerticesOnGeomVertex;
    3944                        VertexOnGeom                 *VerticesOnGeomVertex;
     
    5055                        R2                            pmin,pmax;             // extrema
    5156                        double                        coefIcoor;             // coef to integer Icoor1;
    52                         Triangle                     *triangles;
    53                         Edge                         *edges;
    54                         QuadTree                     *quadtree;
    55                         BamgVertex                  **ordre;
    56                         SubDomain                    *subdomains;
    5757                        ListofIntersectionTriangles   lIntTria;
    5858
     
    156156
    157157        /*Intermediary*/
    158         TriangleAdjacent CloseBoundaryEdge(I2 ,Triangle *, double &,double &) ;
    159         TriangleAdjacent CloseBoundaryEdgeV2(I2 A,Triangle *t, double &a,double &b);
     158        AdjacentTriangle CloseBoundaryEdge(I2 ,Triangle *, double &,double &) ;
     159        AdjacentTriangle CloseBoundaryEdgeV2(I2 A,Triangle *t, double &a,double &b);
    160160        void  swap(Triangle *t1,short a1,
    161161                                Triangle *t2,short a2,
    162162                                BamgVertex *s1,BamgVertex *s2,Icoor2 det1,Icoor2 det2);
    163163        int SwapForForcingEdge(BamgVertex   *  & pva ,BamgVertex  * &   pvb ,
    164                                 TriangleAdjacent & tt1,Icoor2 & dets1,
     164                                AdjacentTriangle & tt1,Icoor2 & dets1,
    165165                                Icoor2 & detsa,Icoor2 & detsb, int & nbswap);
    166         int ForceEdge(BamgVertex &a, BamgVertex & b,TriangleAdjacent & taret) ;
    167         inline TriangleAdjacent Previous(const TriangleAdjacent & ta){
    168                 return TriangleAdjacent(ta.t,PreviousEdge[ta.a]);
     166        int ForceEdge(BamgVertex &a, BamgVertex & b,AdjacentTriangle & taret) ;
     167        inline AdjacentTriangle Previous(const AdjacentTriangle & ta){
     168                return AdjacentTriangle(ta.t,PreviousEdge[ta.a]);
    169169        }
    170         inline TriangleAdjacent Next(const TriangleAdjacent & ta){
    171                 return TriangleAdjacent(ta.t,NextEdge[ta.a]);
     170        inline AdjacentTriangle Next(const AdjacentTriangle & ta){
     171                return AdjacentTriangle(ta.t,NextEdge[ta.a]);
    172172        }
    173         inline  TriangleAdjacent Adj(const TriangleAdjacent & a){
     173        inline  AdjacentTriangle Adj(const AdjacentTriangle & a){
    174174                return  a.Adj();
    175175        }
  • issm/trunk/src/c/objects/Bamg/Triangle.cpp

    r5120 r5143  
    7474        /*}}}*/
    7575        /*FUNCTION Triangle::FindBoundaryEdge{{{1*/
    76         TriangleAdjacent Triangle::FindBoundaryEdge(int i) const{
     76        AdjacentTriangle Triangle::FindBoundaryEdge(int i) const{
    7777                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FindBoundaryEdge)*/
    7878
     
    103103                        outside = !ttc->link;
    104104                        //if both previous triangle are outside, return
    105                         if (outside+outsidep == 1) return TriangleAdjacent(t,j);
     105                        if (outside+outsidep == 1) return AdjacentTriangle(t,j);
    106106
    107107                        //update t and j
     
    117117                } while (this!= t);
    118118                //not found, return empty triangle
    119                 return TriangleAdjacent(NULL,0);
     119                return AdjacentTriangle(NULL,0);
    120120        }
    121121        /*}}}1*/
  • issm/trunk/src/c/objects/Bamg/Triangle.h

    r5124 r5143  
    33
    44#include "./include.h"
    5 #include "TriangleAdjacent.h"
     5#include "AdjacentTriangle.h"
    66
    77namespace bamg {
     
    1414        class Triangle {
    1515
    16                 friend class TriangleAdjacent;
     16                friend class AdjacentTriangle;
    1717
    1818                private:
    19                         BamgVertex*   TriaVertices[3];      // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer
    20                         Triangle* TriaAdjTriangles[3];  // 3 pointers toward the adjacent triangles
    21                         short     TriaAdjSharedEdge[3]; // number of the edges in the adjacent triangles the edge number 1 is the edge number TriaAdjSharedEdge[1] in the Adjacent triangle 1
     19                        BamgVertex *TriaVertices[3];        // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer
     20                        Triangle   *TriaAdjTriangles[3];    // 3 pointers toward the adjacent triangles
     21                        short       TriaAdjSharedEdge[3];   // edge id in the adjacent triangles. The edge number 1 is the edge number TriaAdjSharedEdge[1] in the Adjacent triangle 1
    2222
    2323                public:
    24                         Icoor2 det; // determinant du triangle (2 fois l aire des vertices entieres)
     24                        Icoor2 det; //Integer determinant (twice its area)
    2525                        union {
    26                                 Triangle * link ;
    27                                 long color;
     26                                Triangle *link;
     27                                long      color;
    2828                        };
    2929
     
    4949                        double QualityQuad(int a,int option=1) const;
    5050                        short  NuEdgeTriangleAdj(int i) const {return TriaAdjSharedEdge[i&3]&3;} // Number of the  adjacent edge in adj tria 
    51                         TriangleAdjacent FindBoundaryEdge(int i) const;
    52                         TriangleAdjacent Adj(int i)  const {return TriangleAdjacent(TriaAdjTriangles[i],TriaAdjSharedEdge[i]&3);};
     51                        AdjacentTriangle FindBoundaryEdge(int i) const;
     52                        AdjacentTriangle Adj(int i)  const {return AdjacentTriangle(TriaAdjTriangles[i],TriaAdjSharedEdge[i]&3);};
    5353                        Triangle* TriangleAdj(int i) const {return TriaAdjTriangles[i&3];}
    5454                        Triangle* Quadrangle(BamgVertex * & v0,BamgVertex * & v1,BamgVertex * & v2,BamgVertex * & v3) const ;
  • issm/trunk/src/c/objects/objects.h

    r5120 r5143  
    100100#include "./Bamg/Direction.h"
    101101#include "./Bamg/BamgVertex.h"
    102 #include "./Bamg/TriangleAdjacent.h"
     102#include "./Bamg/AdjacentTriangle.h"
    103103#include "./Bamg/Edge.h"
    104104#include "./Bamg/GeometricalVertex.h"
Note: See TracChangeset for help on using the changeset viewer.