Changeset 3243


Ignore:
Timestamp:
03/10/10 09:47:13 (16 years ago)
Author:
Mathieu Morlighem
Message:

removed some typedefs

Location:
issm/trunk/src/c/Bamgx
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/Bamgx/BamgObjects.h

    r3242 r3243  
    3434       
    3535        /*INLINE functions{{{1*/
    36         inline Real8 det3x3(Real8 A[3] ,Real8 B[3],Real8 C[3]){
     36        inline double det3x3(double A[3] ,double B[3],double C[3]){
    3737                return A[0]*( B[1]*C[2]-B[2]*C[1])
    3838                  - A[1]*( B[0]*C[2]-B[2]*C[0])
    … …  
    5757                if (deta <=0) ret = -1;
    5858                else {
    59                         Real8 a = sqrt((Real8) (ac,ac)),
    60                                         b = sqrt((Real8) (bc,bc)),
    61                                         c = sqrt((Real8) (ab,ab)),
     59                        double a = sqrt((double) (ac,ac)),
     60                                        b = sqrt((double) (bc,bc)),
     61                                        c = sqrt((double) (ab,ab)),
    6262                                        p = a+b+c;
    63                         Real8 h= Max(Max(a,b),c),ro=deta/p;
     63                        double h= Max(Max(a,b),c),ro=deta/p;
    6464                        ret = ro/h;}
    6565                        return ret;
    … …  
    7979        /*}}}1*/
    8080        /*INLINE functions of CLASS VertexOnVertex{{{1*/
    81         inline void VertexOnVertex::Set(const Triangles & Th ,Int4 i,Triangles & ThNew) {
     81        inline void VertexOnVertex::Set(const Triangles & Th ,long i,Triangles & ThNew) {
    8282                *this = Th.VertexOnBThVertex[i]; 
    8383                v = ThNew.vertices + Th.Number(v);
    … …  
    8787        /*INLINE functions of CLASS Triangles{{{1*/
    8888        inline  void  Triangles::ReMakeTriangleContainingTheVertex(){
    89                 register Int4 i;
     89                register long i;
    9090                for ( i=0;i<nbv;i++){
    9191                        vertices[i].vint=0;
    … …  
    9797        inline  void  Triangles::UnMarkUnSwapTriangle()
    9898          {
    99                 register Int4 i;
     99                register long i;
    100100                for ( i=0;i<nbt;i++)
    101101                 for(int  j=0;j<3;j++)
    … …  
    104104
    105105        inline  void   Triangles::SetVertexFieldOn(){
    106                 for (Int4 i=0;i<nbv;i++)
     106                for (long i=0;i<nbv;i++)
    107107                 vertices[i].onGeometry=0;
    108                 for (Int4 j=0;j<NbVerticesOnGeomVertex;j++ )
     108                for (long j=0;j<NbVerticesOnGeomVertex;j++ )
    109109                 VerticesOnGeomVertex[j].SetOn();
    110                 for (Int4 k=0;k<NbVerticesOnGeomEdge;k++ )
     110                for (long k=0;k<NbVerticesOnGeomEdge;k++ )
    111111                 VerticesOnGeomEdge[k].SetOn();
    112112        }             
    113113        inline  void   Triangles::SetVertexFieldOnBTh(){
    114                 for (Int4 i=0;i<nbv;i++)
     114                for (long i=0;i<nbv;i++)
    115115                 vertices[i].onGeometry=0;
    116                 for (Int4 j=0;j<NbVertexOnBThVertex;j++ )
     116                for (long j=0;j<NbVertexOnBThVertex;j++ )
    117117                 VertexOnBThVertex[j].SetOnBTh();
    118                 for (Int4 k=0;k<NbVertexOnBThEdge;k++ )
     118                for (long k=0;k<NbVertexOnBThEdge;k++ )
    119119                 VertexOnBThEdge[k].SetOnBTh();
    120120
    … …  
    177177                 link = ThNew.triangles + Th.Number(link);
    178178          }
    179         inline  Triangle::Triangle(Triangles *Th,Int4 i,Int4 j,Int4 k) {
     179        inline  Triangle::Triangle(Triangles *Th,long i,long j,long k) {
    180180                Vertex *v=Th->vertices;
    181                 Int4 nbv = Th->nbv;
     181                long nbv = Th->nbv;
    182182                if (i<0 || j<0 || k<0){
    183183                        throw ErrorException(__FUNCT__,exprintf("i<0 || j<0 || k<0"));
    … …  
    211211        /*}}}1*/
    212212         /*INLINE functions of CLASS Edge{{{1*/
    213         inline void Edge::Set(const Triangles & Th ,Int4 i,Triangles & ThNew)
     213        inline void Edge::Set(const Triangles & Th ,long i,Triangles & ThNew)
    214214          {
    215215                *this = Th.edges[i];
    … …  
    244244        /*}}}1*/
    245245         /*INLINE functions of CLASS SubDomain{{{1*/
    246         inline void SubDomain::Set(const Triangles & Th ,Int4 i,Triangles & ThNew)
     246        inline void SubDomain::Set(const Triangles & Th ,long i,Triangles & ThNew)
    247247          {
    248248                *this = Th.subdomains[i];
    … …  
    265265        /*}}}1*/
    266266        /*INLINE functions of CLASS Vertex{{{1*/
    267         Int4 inline Vertex::Optim(int i,int koption){
    268                 Int4 ret=0;
     267        long inline Vertex::Optim(int i,int koption){
     268                long ret=0;
    269269                if ( t && (vint >= 0 ) && (vint <3) ){
    270270                        ret = t->Optim(vint,koption);
    … …  
    281281        /*}}}1*/
    282282        /*INLINE functions of CLASS VertexOnEdge{{{1*/
    283         inline void VertexOnEdge::Set(const Triangles & Th ,Int4 i,Triangles & ThNew)
     283        inline void VertexOnEdge::Set(const Triangles & Th ,long i,Triangles & ThNew)
    284284          {
    285285                *this = Th.VertexOnBThEdge[i]; 
    … …  
    335335
    336336        /*Other prototypes IN TRIANGLES.CPP (TO BE REORGANIZED){{{1*/
    337         Int4 AGoodNumberPrimeWith(Int4 n);
     337        long AGoodNumberPrimeWith(long n);
    338338        TriangleAdjacent CloseBoundaryEdge(I2 ,Triangle *, double &,double &) ;
    339339        TriangleAdjacent CloseBoundaryEdgeV2(I2 A,Triangle *t, double &a,double &b);

  • issm/trunk/src/c/Bamgx/Bamgx.cpp

    r3242 r3243  
    130130                        // init with hmax
    131131                        Metric Mhmax(hmax);
    132                         for (Int4 iv=0;iv<BTh.nbv;iv++) BTh[iv].m = Mhmax;
     132                        for (int iv=0;iv<BTh.nbv;iv++) BTh[iv].m = Mhmax;
    133133                        // change using hVertices if required
    134134                        if (bamgmesh_in->hVertices){

  • issm/trunk/src/c/Bamgx/meshtype.h

    r3242 r3243  
    1717
    1818        //typedefs
    19         typedef double Real8;
    20         typedef long   Int4;
    2119        typedef int  Icoor1; 
    2220#if LONG_BIT > 63 //64 bits or more
    … …  
    2523        typedef double Icoor2;
    2624#endif
    27         typedef P2<Icoor1,Icoor2> I2;
    28         typedef P2xP2<short,Int4>  I2xI2;
    29         typedef P2<Real8,Real8>   R2;
    30         typedef P2<double,Real8>   R2xR2;
     25        typedef P2<Icoor1,Icoor2>  I2;
     26        typedef P2xP2<short,long>  I2xI2;
     27        typedef P2<double,double>  R2;
     28        typedef P2<double,double>  R2xR2;
    3129
    3230        //Some parameters
    33         const double  Pi =3.141592653589793238462643383279502884197169399375105820974944592308;
    34         const float   fPi=3.141592653589793238462643383279502884197169399375105820974944592308;
    35         const  int    IsVertexOnGeom = 8;
    36         const  int    IsVertexOnVertex = 16;
    37         const  int    IsVertexOnEdge = 32;
    38         static const  short VerticesOfTriangularEdge[3][2] = {{1,2},{2,0},{0,1}};
    39         static const  short EdgesVertexTriangle[3][2] = {{1,2},{2,0},{0,1}};
    40         static const  short OppositeVertex[3] = {0,1,2};
    41         static const  short OppositeEdge[3] =  {0,1,2};
    42         static const  short NextEdge[3] = {1,2,0};
    43         static const  short PreviousEdge[3] = {2,0,1};
    44         static const  short NextVertex[3] = {1,2,0};
    45         static const  short PreviousVertex[3] = {2,0,1};
     31        const double Pi =3.141592653589793238462643383279502884197169399375105820974944592308;
     32        const float  fPi=3.141592653589793238462643383279502884197169399375105820974944592308;
     33        const  int   IsVertexOnGeom = 8;
     34        const  int   IsVertexOnVertex = 16;
     35        const  int   IsVertexOnEdge = 32;
     36        static const short VerticesOfTriangularEdge[3][2] = {{1,2},{2,0},{0,1}};
     37        static const short EdgesVertexTriangle[3][2] = {{1,2},{2,0},{0,1}};
     38        static const short OppositeVertex[3] = {0,1,2};
     39        static const short OppositeEdge[3] =  {0,1,2};
     40        static const short NextEdge[3] = {1,2,0};
     41        static const short PreviousEdge[3] = {2,0,1};
     42        static const short NextVertex[3] = {1,2,0};
     43        static const short PreviousVertex[3] = {2,0,1};
    4644#if LONG_BIT > 63
    4745        const  Icoor1 MaxICoor   = 1073741823; // 2^30-1 =111...111 (29 times)
    … …  
    6159        template<class T> inline T Min3 (const T &a,const T & b,const T & c){return Min(Min(a,b),c);}
    6260        template<class T> inline void  HeapSort(T *c,long n){
    63                 /*Intermediary*/
    6461                int l,j,r,i;
    6562                T   crit;
    … …  
    8784        }
    8885        template<class T> inline void  HeapSort(int** porder,T* c,int n){
    89                 /*Intermediary*/
    9086                int  l,j,r,i;
    9187                T    crit;
    … …  
    142138                return  bax*cay - bay*cax;
    143139        }
    144 
    145140}
    146141#endif

  • issm/trunk/src/c/Bamgx/objects/CrackedEdge.h

    r3237 r3243  
    7373                        //Constructors
    7474                        CrackedEdge() :a(),b() {}
    75                         CrackedEdge(Edge * start, Int4  i,Int4 j) : a(start+i),b(start+j) {};
     75                        CrackedEdge(Edge * start, long  i,long j) : a(start+i),b(start+j) {};
    7676                        CrackedEdge(Edge * e0, Edge * e1 ) : a(e0),b(e1) {};
    7777

  • issm/trunk/src/c/Bamgx/objects/DoubleAndInt4.h

    r3232 r3243  
    1111                public:
    1212                        double q;
    13                         Int4 i3j;
     13                        long i3j;
    1414
    1515                        //Operators

  • issm/trunk/src/c/Bamgx/objects/Edge.h

    r3237 r3243  
    2121                public:
    2222                        Vertex* v[2];
    23                         Int4 ref;
     23                        long ref;
    2424                        GeometricalEdge* onGeometry;
    2525                        Edge* adj[2]; // the 2 adj edges if on the same curve
    … …  
    3232
    3333                        //Methods
    34                         void ReNumbering(Vertex *vb,Vertex *ve, Int4 *renu){
     34                        void ReNumbering(Vertex *vb,Vertex *ve, long *renu){
    3535                                if (v[0] >=vb && v[0] <ve) v[0] = vb + renu[v[0]-vb];
    3636                                if (v[1] >=vb && v[1] <ve) v[1] = vb + renu[v[1]-vb];
    … …  
    4747
    4848                        //Inline methods
    49                         inline void Set(const Triangles &,Int4,Triangles &);
     49                        inline void Set(const Triangles &,long,Triangles &);
    5050
    5151        };

  • issm/trunk/src/c/Bamgx/objects/GeometricalEdge.cpp

    r3232 r3243  
    1717        /*Methods*/
    1818        /*FUNCTION GeometricalEdge::R1tg{{{1*/
    19         Real8 GeometricalEdge::R1tg(Real8 theta,R2 & t) const // 1/R of radius of cuvature
     19        double GeometricalEdge::R1tg(double theta,R2 & t) const // 1/R of radius of cuvature
    2020          { R2 A=v[0]->r,B=v[1]->r;
    21                 Real8 dca,dcb,dcta,dctb;
    22                 Real8 ddca,ddcb,ddcta,ddctb;
    23                 // Real8 t1 = 1 -theta;
    24                 // Real8 t1t1 = t1*t1;
    25                 Real8 tt = theta*theta;
     21                double dca,dcb,dcta,dctb;
     22                double ddca,ddcb,ddcta,ddctb;
     23                // double t1 = 1 -theta;
     24                // double t1t1 = t1*t1;
     25                double tt = theta*theta;
    2626                if ( theta<0){
    2727                        throw ErrorException(__FUNCT__,exprintf("theta<0"));
    … …  
    4848                        }
    4949                 else { // 1-t*t, t-t*t, t*t
    50                          Real8 t = theta;
     50                         double t = theta;
    5151                         // cb = t*t;
    5252                         dcb = 2*t;
    … …  
    6464                else
    6565                 if (TgB()){
    66                          Real8 t = 1-theta;
     66                         double t = 1-theta;
    6767                         //ca = t*t;
    6868                         dca = -2*t;
    … …  
    8282
    8383                R2 dd =  A*ddca + B*ddcb + tg[0]* ddcta + tg[1] * ddctb;
    84                 Real8 d2=(d,d);
    85                 Real8 sd2 = sqrt(d2);
     84                double d2=(d,d);
     85                double sd2 = sqrt(d2);
    8686                t=d;
    8787                if(d2>1.0e-20) {t/=sd2;return Abs(Det(d,dd))/(d2*sd2);}
    … …  
    9090        /*}}}1*/
    9191        /*FUNCTION GeometricalEdge::F{{{1*/
    92         R2 GeometricalEdge::F(Real8 theta) const // parametrization of the curve edge
     92        R2 GeometricalEdge::F(double theta) const // parametrization of the curve edge
    9393          { R2 A=v[0]->r,B=v[1]->r;
    94                 Real8 ca,cb,cta,ctb;
     94                double ca,cb,cta,ctb;
    9595                if ( theta<-1e-12){
    9696                        throw ErrorException(__FUNCT__,exprintf("theta<-1e-12"));
    … …  
    107107                        }
    108108                 else { // 1-t*t, t-t*t, t*t
    109                          Real8 t = theta;
     109                         double t = theta;
    110110                         cb = t*t;
    111111                         ca = 1-cb;
    … …  
    115115                else
    116116                 if (TgB()){
    117                          Real8 t = 1-theta;
     117                         double t = 1-theta;
    118118                         ca = t*t;
    119119                         cb = 1-ca;

  • issm/trunk/src/c/Bamgx/objects/GeometricalEdge.h

    r3232 r3243  
    2121                public:
    2222                        GeometricalVertex* v[2];
    23                         Int4 ref;
    24                         Int4 CurveNumber;
     23                        long ref;
     24                        long CurveNumber;
    2525                        R2   tg[2]; // the 2 tangentes (tg[0] =0 => no continuity)
    2626                        GeometricalEdge* Adj[2];
    … …  
    3535
    3636                        //Methods
    37                         R2 F(Real8 theta) const ; // parametrization of the curve edge
    38                         Real8 R1tg(Real8 theta,R2 &t) const ; // 1/radius of curvature + tangente
     37                        R2 F(double theta) const ; // parametrization of the curve edge
     38                        double R1tg(double theta,R2 &t) const ; // 1/radius of curvature + tangente
    3939                        int  Cracked() const {return flag & 1;}
    4040                        int  Dup() const { return flag & 32;}

  • issm/trunk/src/c/Bamgx/objects/GeometricalSubDomain.h

    r3232 r3243  
    1919                        GeometricalEdge *edge;
    2020                        int sens; // -1 or 1
    21                         Int4 ref;
     21                        long ref;
    2222
    2323                        //Inline methods

  • issm/trunk/src/c/Bamgx/objects/Geometry.cpp

    r3242 r3243  
    1616        /*FUNCTION  Geometry::Geometry(const Geometry & Gh){{{1*/
    1717        Geometry::Geometry(const Geometry & Gh) {
    18                 Int4 i;
     18                long i;
    1919                *this = Gh;
    2020                NbRef =0;
    … …  
    223223                NbOfCurves=0;
    224224
    225                 Real8 Hmin = HUGE_VAL;// the infinie value
    226                 Int4 hvertices=0;
     225                double Hmin = HUGE_VAL;// the infinie value
     226                long hvertices=0;
    227227                int i,j,k,n,i1,i2;
    228228
    … …  
    250250                                vertices[i].r.x=(double)bamggeom->Vertices[i*3+0];
    251251                                vertices[i].r.y=(double)bamggeom->Vertices[i*3+1];
    252                                 vertices[i].ReferenceNumber=(Int4)bamggeom->Vertices[i*3+2];
     252                                vertices[i].ReferenceNumber=(long)bamggeom->Vertices[i*3+2];
    253253                                vertices[i].DirOfSearch=NoDirOfSearch;
    254254                                vertices[i].color =0;
    … …  
    297297                                i1=(int)bamggeom->Edges[i*3+0]-1; //-1 for C indexing
    298298                                i2=(int)bamggeom->Edges[i*3+1]-1; //-1 for C indexing
    299                                 edges[i].ref=(Int4)bamggeom->Edges[i*3+2];
     299                                edges[i].ref=(long)bamggeom->Edges[i*3+2];
    300300
    301301                                edges[i].v[0]= vertices + i1;
    … …  
    304304                                //get length of edge
    305305                                R2    x12=vertices[i2].r-vertices[i1].r;
    306                                 Real8 l12=sqrt((x12,x12));
     306                                double l12=sqrt((x12,x12));
    307307                                Hmin=Min(Hmin,l12);
    308308
    … …  
    466466                //SubDomain
    467467                if(bamggeom->SubDomains){
    468                         Int4 i0,i1,i2,i3;
     468                        long i0,i1,i2,i3;
    469469                        if(verbose>5) printf("      processing SubDomains\n");
    470470                        NbSubDomains=bamggeom->NumSubDomains;
    … …  
    493493                long int verbosity=0;
    494494
    495                 Int4 i,j,k;
     495                long i,j,k;
    496496                int jj;
    497                 Int4* head_v=new Int4[nbv];
    498                 Int4* next_p=new Int4[2*nbe];
     497                long* head_v=new long[nbv];
     498                long* next_p=new long[2*nbe];
    499499                float* eangle=new float[nbe];
    500500                double eps=1e-20;
    … …  
    635635                        //compute vector of edge i that goes from vertex 0 to vertex 1
    636636                        R2 v10=edges[i].v[1]->r - edges[i].v[0]->r;
    637                         Real8 lv10=Norme2(v10);
     637                        double lv10=Norme2(v10);
    638638                        //check that its length is not 0
    639639                        if(lv10==0) {
    … …  
    644644                        //build chains head_v and next_p
    645645                        for (j=0;j<2;j++){
    646                                 Int4 v=Number(edges[i].v[j]);
     646                                long v=Number(edges[i].v[j]);
    647647                                next_p[k]=head_v[v];
    648648                                head_v[v]=k++; //post increment: head_v[v]=k; and then k=k+1;
    … …  
    656656                        //exchange vertices position in head_v and next_p till tey are sorted
    657657                        while (exch){
    658                                 Int4 *p=head_v+i;               // pointer toward head_v[vertex i]
    659                                 Int4 *po=p;                     // copy of pointer p
    660                                 Int4  n=*p;                     // next value of edge holding i
     658                                long *p=head_v+i;               // pointer toward head_v[vertex i]
     659                                long *po=p;                     // copy of pointer p
     660                                long  n=*p;                     // next value of edge holding i
    661661                                register float angleold=-1000 ; // angle = - infinity
    662662                                ord=0; exch=0;
    … …  
    665665                                while (n >=0){
    666666                                        ord++;
    667                                         register Int4  i1=n/2;       // i1 = floor (n/2)
    668                                         register Int4  j1=n%2;       // j1 = 1 if n is odd
    669                                         register Int4* pn=next_p+n;  // pointer to next_p[n]
     667                                        register long  i1=n/2;       // i1 = floor (n/2)
     668                                        register long  j1=n%2;       // j1 = 1 if n is odd
     669                                        register long* pn=next_p+n;  // pointer to next_p[n]
    670670
    671671                                        //  n = next_p[n] = position in edge of next vertex i
    … …  
    695695                        // angular test on current vertex to guess whether it is a corner (ord = number of edges horlding i)
    696696                        if(ord == 2) {
    697                                 Int4  n1 = head_v[i];
    698                                 Int4  n2 = next_p[n1];
    699                                 Int4  i1 = n1/2, i2 = n2/2; // edge number
    700                                 Int4  j1 = n1%2, j2 = n2%2; // vertex in the edge
     697                                long  n1 = head_v[i];
     698                                long  n2 = next_p[n1];
     699                                long  i1 = n1/2, i2 = n2/2; // edge number
     700                                long  j1 = n1%2, j2 = n2%2; // vertex in the edge
    701701                                float angle1=  j1 ? OppositeAngle(eangle[i1]) : eangle[i1];
    702702                                float angle2= !j2 ? OppositeAngle(eangle[i2]) : eangle[i2];
    … …  
    718718
    719719                        // close the list around the vertex
    720                         Int4 no=-1, ne = head_v[i];
     720                        long no=-1, ne = head_v[i];
    721721                        while (ne >=0) ne = next_p[no=ne];       
    722722                        if(no>=0) next_p[no] = head_v[i];
    … …  
    727727                for (i=0;i<nbe;i++){
    728728                        for (j=0;j<2;j++){
    729                                 Int4 n1 = next_p[k++];
    730                                 Int4 i1 = n1/2 ,j1=n1%2;
     729                                long n1 = next_p[k++];
     730                                long i1 = n1/2 ,j1=n1%2;
    731731                                if( edges[i1].v[j1] != edges[i].v[j]) {
    732732                                        throw ErrorException(__FUNCT__,exprintf("Bug Adj edge"));
    … …  
    743743                        R2    AB =edges[i].v[1]->r -edges[i].v[0]->r;       
    744744                        //Get length of AB
    745                         Real8 lAB=Norme2(AB);
     745                        double lAB=Norme2(AB);
    746746                        //initialize tangent
    747                         Real8 ltg2[2];
     747                        double ltg2[2];
    748748                        ltg2[0]=0;ltg2[1]=0;
    749749
    … …  
    751751                        for (jj=0;jj<2;jj++) {
    752752                                R2    tg =edges[i].tg[jj];
    753                                 Real8 ltg=Norme2(tg);
     753                                double ltg=Norme2(tg);
    754754
    755755                                //by default, tangent=[0 0]
    … …  
    777777                        for (i=0;i<nbe;i++) edges[i].SetUnMark();
    778778                        NbOfCurves = 0;
    779                         Int4  nbgem=0;
     779                        long  nbgem=0;
    780780                        for (int level=0;level < 2 && nbgem != nbe;level++)
    781781                         for (i=0;i<nbe;i++) {
    … …  
    920920        /*}}}1*/
    921921        /*FUNCTION  Geometry::ProjectOnCurve {{{1*/
    922         GeometricalEdge* Geometry::ProjectOnCurve(const Edge & e,Real8 s,Vertex &V,VertexOnGeom &GV ) const {
    923                 Real8 save_s=s;
     922        GeometricalEdge* Geometry::ProjectOnCurve(const Edge & e,double s,Vertex &V,VertexOnGeom &GV ) const {
     923                double save_s=s;
    924924                int NbTry=0;
    925925retry:   
    … …  
    937937                GeometricalEdge *ge[mxe+1];
    938938                int    sensge[mxe+1];
    939                 Real8  lge[mxe+1];
     939                double  lge[mxe+1];
    940940                int bge=mxe/2,tge=bge;
    941941                ge[bge] = e.onGeometry;
    … …  
    10001000                 vg1 = VertexOnGeom( *(Vertex *) vg1,*eg1,sens1);
    10011001
    1002                 Real8 sg;
     1002                double sg;
    10031003                if (eg0 == eg1) {
    1004                         register Real8 s0= vg0,s1=vg1;
     1004                        register double s0= vg0,s1=vg1;
    10051005                        sg =  s0 * (1.0-s) +  s * s1;
    10061006                        on=eg0;}
    10071007                else {
    10081008                        R2 AA=V0,BB;
    1009                         Real8 s0,s1;
     1009                        double s0,s1;
    10101010                        int i=bge;
    1011                         Real8 ll=0;
     1011                        double ll=0;
    10121012                        for(i=bge;i<tge;i++){
    10131013                                if ( i<0 || i>mxe){
    … …  
    10221022                                        throw ErrorException(__FUNCT__,exprintf("s>1.0"));
    10231023                                }
    1024                                 Real8 ls= s*ll;
     1024                                double ls= s*ll;
    10251025                                on =0;
    10261026                                s0 = vg0;
    10271027                                s1= sensge[bge];
    1028                                 Real8 l0=0,l1;
     1028                                double l0=0,l1;
    10291029                                i=bge;
    10301030                                while (  (l1=lge[i]) < ls ) {

  • issm/trunk/src/c/Bamgx/objects/Geometry.h

    r3232 r3243  
    2525
    2626                public:
    27                         Int4 NbRef;     // counter of ref on the this class if 0 we can delete
    28                         Int4 nbvx,nbtx; // maximum number of vertices
    29                         Int4 nbv,nbt,nbiv,nbe; // number of vertices
    30                         Int4 NbSubDomains; //
    31                         Int4 NbOfCurves;
     27                        long NbRef;     // counter of ref on the this class if 0 we can delete
     28                        long nbvx,nbtx; // maximum number of vertices
     29                        long nbv,nbt,nbiv,nbe; // number of vertices
     30                        long NbSubDomains; //
     31                        long NbOfCurves;
    3232                        GeometricalVertex* vertices;
    3333                        Triangle* triangles;
    … …  
    3737                        Curve* curves;
    3838                        R2 pmin,pmax; // extrema
    39                         Real8 coefIcoor;  // coef to integer Icoor1;
    40                         Real8 MaximalAngleOfCorner;
     39                        double coefIcoor;  // coef to integer Icoor1;
     40                        double MaximalAngleOfCorner;
    4141
    4242                        //Constructor/Destructors
    … …  
    4646
    4747                        //Operators
    48                         const GeometricalVertex & operator[]  (Int4 i) const { return vertices[i];};
    49                         GeometricalVertex & operator[](Int4 i) { return vertices[i];};
    50                         const  GeometricalEdge & operator()  (Int4 i) const { return edges[i];};
    51                         GeometricalEdge & operator()(Int4 i) { return edges[i];};
     48                        const GeometricalVertex & operator[]  (long i) const { return vertices[i];};
     49                        GeometricalVertex & operator[](long i) { return vertices[i];};
     50                        const  GeometricalEdge & operator()  (long i) const { return edges[i];};
     51                        GeometricalEdge & operator()(long i) { return edges[i];};
    5252
    5353                        //Methods
    … …  
    5757                                return  I2( (Icoor1) (coefIcoor*(P.x-pmin.x))
    5858                                                        ,(Icoor1) (coefIcoor*(P.y-pmin.y)) );}
    59                         Real8 MinimalHmin() {return 2.0/coefIcoor;}
    60                         Real8 MaximalHmax() {return Max(pmax.x-pmin.x,pmax.y-pmin.y);}
     59                        double MinimalHmin() {return 2.0/coefIcoor;}
     60                        double MaximalHmax() {return Max(pmax.x-pmin.x,pmax.y-pmin.y);}
    6161                        void ReadGeometry(BamgGeom* bamggeom, BamgOpts* bamgopts);
    6262                        void EmptyGeometry();
    … …  
    6464                        void AfterRead();
    6565                        Geometry(BamgGeom* bamggeom, BamgOpts* bamgopts) {EmptyGeometry();ReadGeometry(bamggeom,bamgopts);AfterRead();}
    66                         Int4 Number(const GeometricalVertex & t) const  { return &t - vertices;}
    67                         Int4 Number(const GeometricalVertex * t) const  { return t - vertices;}
    68                         Int4 Number(const GeometricalEdge & t) const  { return &t - edges;}
    69                         Int4 Number(const GeometricalEdge * t) const  { return t - edges;}
    70                         Int4 Number(const Curve * c) const  { return c - curves;}
    71                         void UnMarkEdges() {for (Int4 i=0;i<nbe;i++) edges[i].SetUnMark();}
    72                         GeometricalEdge *  ProjectOnCurve(const Edge & ,Real8,Vertex &,VertexOnGeom &) const ;
     66                        long Number(const GeometricalVertex & t) const  { return &t - vertices;}
     67                        long Number(const GeometricalVertex * t) const  { return t - vertices;}
     68                        long Number(const GeometricalEdge & t) const  { return &t - edges;}
     69                        long Number(const GeometricalEdge * t) const  { return t - edges;}
     70                        long Number(const Curve * c) const  { return c - curves;}
     71                        void UnMarkEdges() {for (long i=0;i<nbe;i++) edges[i].SetUnMark();}
     72                        GeometricalEdge *  ProjectOnCurve(const Edge & ,double,Vertex &,VertexOnGeom &) const ;
    7373                        GeometricalEdge *  Contening(const R2 P,  GeometricalEdge * start) const;
    7474                        void WriteGeometry(BamgGeom* bamggeom, BamgOpts* bamgopts);

  • issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.cpp

    r3242 r3243  
    1919                long int verbosity=2;
    2020                Icoor2 deta[3], deti,detj;
    21                 Real8 ba[3];
     21                double ba[3];
    2222                int nbt =0,ifirst=-1,ilast;
    2323                int i0,i1,i2;
    … …  
    3838                        t=tbegin = Bh.FindTriangleContaining(a,deta);
    3939                        if( t->det>=0)
    40                          ilast=NewItem(t,Real8(deta[0])/t->det,Real8(deta[1])/t->det,Real8(deta[2])/t->det);
     40                         ilast=NewItem(t,double(deta[0])/t->det,double(deta[1])/t->det,double(deta[2])/t->det);
    4141                        else
    4242                          {// find the nearest boundary edge  of the vertex A
    … …  
    9494                        if ( det(vi,vj,b)>=0) {
    9595                                t=tbegin;
    96                                 Real8 ba,bb;
     96                                double ba,bb;
    9797                                TriangleAdjacent edge=CloseBoundaryEdge(b,t,ba,bb);
    9898                                NewItem(B,Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1)));
    … …  
    104104                                i=VerticesOfTriangularEdge[iedge][0];
    105105                                j=VerticesOfTriangularEdge[iedge][1];
    106                                 Real8 dij = detj-deti;
     106                                double dij = detj-deti;
    107107                                if (i+j+k != 0 + 1 +2){
    108108                                        throw ErrorException(__FUNCT__,exprintf("i+j+k != 0 + 1 +2"));
    … …  
    191191                                                        dt[1]=bamg::det((*t)[2],(*t)[0],b);
    192192                                                        dt[2]=bamg::det((*t)[0],(*t)[1],b);
    193                                                         Real8 dd = t->det;
     193                                                        double dd = t->det;
    194194                                                        NewItem(t,dt[0]/dd,dt[1]/dd,dt[2]/dd);     
    195195                                                        return ;}
    … …  
    216216        }
    217217        /*}}}1*/
    218         /*FUNCTION ListofIntersectionTriangles::NewItem(Triangle * tt,Real8 d0,Real8 d1,Real8 d2) {{{1*/
    219         int  ListofIntersectionTriangles::NewItem(Triangle * tt,Real8 d0,Real8 d1,Real8 d2) {
     218        /*FUNCTION ListofIntersectionTriangles::NewItem(Triangle * tt,double d0,double d1,double d2) {{{1*/
     219        int  ListofIntersectionTriangles::NewItem(Triangle * tt,double d0,double d1,double d2) {
    220220                register int n;
    221221                R2 x(0,0);
    … …  
    257257        /*}}}1*/
    258258        /*FUNCTION ListofIntersectionTriangles::Length{{{1*/
    259         Real8  ListofIntersectionTriangles::Length(){
     259        double  ListofIntersectionTriangles::Length(){
    260260                // computation of the length
    261261
    … …  
    275275
    276276                y = lIntTria[0].x;
    277                 Real8 sxy, s = 0;
     277                double sxy, s = 0;
    278278                lIntTria[0].s =0;
    279279                SegI->lBegin=s;
    … …  
    303303        /*}}}1*/
    304304        /*FUNCTION ListofIntersectionTriangles::NewPoints{{{1*/
    305         Int4 ListofIntersectionTriangles::NewPoints(Vertex* vertices,Int4 &nbv,Int4 nbvx){
     305        long ListofIntersectionTriangles::NewPoints(Vertex* vertices,long &nbv,long nbvx){
    306306
    307307                //If length<1.5, do nothing
    308                 Real8 s=Length();
     308                double s=Length();
    309309                if (s<1.5) return 0;
    310310
    311                 const Int4 nbvold=nbv;
     311                const long nbvold=nbv;
    312312                int ii = 1 ;
    313313                R2 y,x;
    314314                Metric My,Mx ;
    315                 Real8 sx =0,sy;
     315                double sx =0,sy;
    316316                int nbi=Max(2,(int) (s+0.5));
    317                 Real8 sint=s/nbi;
    318                 Real8 si  =sint;
     317                double sint=s/nbi;
     318                double si  =sint;
    319319
    320320                int EndSeg=Size;
    … …  
    337337                        sy =lIntTria[ii].s;
    338338                        Metric My=lIntTria[ii].m;
    339                         Real8 lxy = sy-sx;
    340                         Real8 cy = abscisseInterpole(Mx,My,y-x,(si-sx)/lxy);
     339                        double lxy = sy-sx;
     340                        double cy = abscisseInterpole(Mx,My,y-x,(si-sx)/lxy);
    341341
    342342                        R2 C;
    343                         Real8 cx = 1-cy;
     343                        double cx = 1-cy;
    344344                        C = SegI ? SegI->F(si): x * cx + y *cy;
    345345                        //C.Echo();

  • issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.h

    r3232 r3243  
    2323                        public:
    2424                                Triangle* t;
    25                                 Real8  bary[3];  // use if t != 0
     25                                double  bary[3];  // use if t != 0
    2626                                R2 x;
    2727                                Metric m;
    28                                 Real8 s; // curvilinear coordinate
    29                                 Real8 sp;// length of the previous segment in m
    30                                 Real8 sn;// length of the next segment in m
     28                                double s; // curvilinear coordinate
     29                                double sp;// length of the previous segment in m
     30                                double sn;// length of the next segment in m
    3131                };
    3232
    … …  
    3434                        public:
    3535                                GeometricalEdge * e;
    36                                 Real8 sBegin,sEnd; // abscisse of the seg on edge parameter
    37                                 Real8 lBegin,lEnd; // length abscisse set in ListofIntersectionTriangles::Length
     36                                double sBegin,sEnd; // abscisse of the seg on edge parameter
     37                                double lBegin,lEnd; // length abscisse set in ListofIntersectionTriangles::Length
    3838                                int last;// last index  in ListofIntersectionTriangles for this Sub seg of edge
    3939
    4040                                //Methods
    41                                 R2 F(Real8 s){
    42                                         Real8 c01=lEnd-lBegin, c0=(lEnd-s)/c01, c1=(s-lBegin)/c01;
     41                                R2 F(double s){
     42                                        double c01=lEnd-lBegin, c0=(lEnd-s)/c01, c1=(s-lBegin)/c01;
    4343                                        if (lBegin>s || s>lEnd){
    4444                                                throw ErrorException(__FUNCT__,exprintf("lBegin>s || s>lEnd"));
    … …  
    5252                        int MaxSize;
    5353                        int Size;
    54                         Real8 len;
     54                        double len;
    5555                        int state;
    5656                        IntersectionTriangles * lIntTria;
    … …  
    7777                        //Methods
    7878                        void  init(){state=0;len=0;Size=0;}
    79                         int   NewItem(Triangle * tt,Real8 d0,Real8 d1,Real8 d2);
     79                        int   NewItem(Triangle * tt,double d0,double d1,double d2);
    8080                        int   NewItem(R2,const Metric & );
    8181                        void  SplitEdge(const Triangles & ,const R2 &,const R2  &,int nbegin=0);
    82                         Real8 Length();
    83                         Int4  NewPoints(Vertex *,Int4 & nbv,Int4 nbvx);
    84                         void  NewSubSeg(GeometricalEdge *e,Real8 s0,Real8 s1){
     82                        double Length();
     83                        long  NewPoints(Vertex *,long & nbv,long nbvx);
     84                        void  NewSubSeg(GeometricalEdge *e,double s0,double s1){
    8585                                long int verbosity=0;
    8686                                if (NbSeg>=MaxNbSeg) {

  • issm/trunk/src/c/Bamgx/objects/Metric.cpp

    r3232 r3243  
    1616
    1717        /*Constructor/Destructor*/
    18         /*FUNCTION Metric::Metric(const Real8  a[3],const  Metric m0, const  Metric m1,const  Metric  m2 ){{{1*/
    19         Metric::Metric(const Real8  a[3],const  Metric m0, const  Metric m1,const  Metric m2 ){
     18        /*FUNCTION Metric::Metric(const double  a[3],const  Metric m0, const  Metric m1,const  Metric  m2 ){{{1*/
     19        Metric::Metric(const double  a[3],const  Metric m0, const  Metric m1,const  Metric m2 ){
    2020                Metric mab(a[0]*m0.a11 + a[1]*m1.a11 + a[2]*m2.a11,
    2121                                        a[0]*m0.a21 + a[1]*m1.a21 + a[2]*m2.a21,
    … …  
    2727                R2 v2(-v1.y,v1.x);
    2828
    29                 Real8 h1 = a[0] / m0(v1) + a[1] / m1(v1) + a[2] / m2(v1);
    30                 Real8 h2 = a[0] / m0(v2) + a[1] / m1(v2) + a[2] / m2(v2);
     29                double h1 = a[0] / m0(v1) + a[1] / m1(v1) + a[2] / m2(v1);
     30                double h2 = a[0] / m0(v2) + a[1] / m1(v2) + a[2] / m2(v2);
    3131
    3232                vab.lambda1 =  1 / (h1*h1);
    … …  
    3535        }
    3636        /*}}}1*/
    37         /*FUNCTION Metric::Metric( Real8  a,const  Metric ma, Real8  b,const  Metric mb){{{1*/
    38         Metric::Metric( Real8  a,const  Metric ma, Real8  b,const  Metric mb) {
     37        /*FUNCTION Metric::Metric( double  a,const  Metric ma, double  b,const  Metric mb){{{1*/
     38        Metric::Metric( double  a,const  Metric ma, double  b,const  Metric mb) {
    3939                Metric mab(a*ma.a11+b*mb.a11,a*ma.a21+b*mb.a21,a*ma.a22+b*mb.a22);
    4040                MatVVP2x2 vab(mab);
    … …  
    4444
    4545
    46                 Real8 h1 = a / ma(v1) + b / mb(v1);
    47                 Real8 h2 = a / ma(v2) + b / mb(v2);
     46                double h1 = a / ma(v1) + b / mb(v1);
     47                double h2 = a / ma(v2) + b / mb(v2);
    4848                vab.lambda1 =  1 / (h1*h1);
    4949                vab.lambda2 =  1 / (h2*h2);
    … …  
    117117        /*Intermediary*/
    118118        /*FUNCTION LengthInterpole{{{1*/
    119         Real8 LengthInterpole(const Metric Ma,const  Metric Mb, R2 AB) {
    120                 Real8 k=1./2.;
     119        double LengthInterpole(const Metric Ma,const  Metric Mb, R2 AB) {
     120                double k=1./2.;
    121121                int level=0;
    122122                static int kkk=0;
    123123                static  Metric Ms1[32],Ms2[32];
    124                 static Real8 lMs1[32],lMs2[32];
     124                static double lMs1[32],lMs2[32];
    125125                static double K[32];
    126                 Real8 l=0,sss=0;
     126                double l=0,sss=0;
    127127                Ms1[level]=Ma;
    128128                Ms2[level]=Mb;
    129                 Real8 sa =  Ma(AB);
    130                 Real8 sb =  Mb(AB);
     129                double sa =  Ma(AB);
     130                double sb =  Mb(AB);
    131131                lMs1[level]=sa;
    132132                lMs2[level]=sb;
    … …  
    134134                level++;
    135135                int i=0;
    136                 Real8 * L= LastMetricInterpole.L, *S = LastMetricInterpole.S;
    137                 Real8  sstop = 0.1; // Max(0.6,(sa+sb)/5000);
     136                double * L= LastMetricInterpole.L, *S = LastMetricInterpole.S;
     137                double  sstop = 0.1; // Max(0.6,(sa+sb)/5000);
    138138                while (level) {
    139139                        level--;
    … …  
    141141                        Metric M2=Ms2[level];
    142142                        k=K[level];
    143                         Real8 s1=  lMs1[level];
    144                         Real8 s2=  lMs2[level];
    145 
    146                         Real8 s= (s1+s2)*k;
     143                        double s1=  lMs1[level];
     144                        double s2=  lMs2[level];
     145
     146                        double s= (s1+s2)*k;
    147147                        if( s > sstop   && level < 30 && i < 500-level ) {
    148148                                Metric Mi(0.5,M1,0.5,M2);
    149                                 Real8 si = Mi(AB);
     149                                double si = Mi(AB);
    150150                                if( Abs((s1+s2)-(si+si)) > s1*0.001)
    151151                                  {
    … …  
    286286        /*}}}1*/
    287287        /*FUNCTION abscisseInterpole{{{1*/
    288         Real8 abscisseInterpole(const Metric Ma,const  Metric Mb, R2 AB,Real8 s,int optim) {
     288        double abscisseInterpole(const Metric Ma,const  Metric Mb, R2 AB,double s,int optim) {
    289289                if(!optim)  LengthInterpole(Ma,Mb,AB);
    290                 Real8 l  = s* LastMetricInterpole.lab,r;
     290                double l  = s* LastMetricInterpole.lab,r;
    291291                int j=LastMetricInterpole.opt-1,i=0,k;
    292292
    293                 Real8 * L= LastMetricInterpole.L, *S = LastMetricInterpole.S;
     293                double * L= LastMetricInterpole.L, *S = LastMetricInterpole.S;
    294294                // warning for optimisation S is the abcisse in [0:0.5]
    295295                // and L is le lenght

  • issm/trunk/src/c/Bamgx/objects/Metric.h

    r3242 r3243  
    2323                public:
    2424                        //fields
    25                         Real8 a11,a21,a22;
     25                        double a11,a21,a22;
    2626                        //friends
    2727                        friend class MatVVP2x2;
    … …  
    2929                        Metric(){};
    3030                        Metric(const MatVVP2x2);
    31                         Metric(Real8 a): a11(1/(a*a)),a21(0),a22(1/(a*a)){}
    32                         Metric(Real8 a,Real8 b,Real8 c) :a11(a),a21(b),a22(c){}
    33                         Metric( Real8  a,const  Metric ma, Real8  b,const  Metric mb);
    34                         Metric(const Real8  a[3],const  Metric m0,const  Metric m1,const  Metric m2 );
     31                        Metric(double a): a11(1/(a*a)),a21(0),a22(1/(a*a)){}
     32                        Metric(double a,double b,double c) :a11(a),a21(b),a22(c){}
     33                        Metric( double  a,const  Metric ma, double  b,const  Metric mb);
     34                        Metric(const double  a[3],const  Metric m0,const  Metric m1,const  Metric m2 );
    3535                        void  Echo();
    3636                        R2    mul(const R2 x)const {return R2(a11*x.x+a21*x.y,a21*x.x+a22*x.y);}
    37                         Real8 det() const {return a11*a22-a21*a21;} 
     37                        double det() const {return a11*a22-a21*a21;} 
    3838                        R2    Orthogonal(const R2 x){return R2(-(a21*x.x+a22*x.y),a11*x.x+a21*x.y);}
    3939                        R2    Orthogonal(const I2 x){return R2(-(a21*x.x+a22*x.y),a11*x.x+a21*x.y);}
    … …  
    4141                        inline void Box(double &hx,double &hy) const ; 
    4242                        //operators
    43                         Metric operator*(Real8 c) const {Real8 c2=c*c;return  Metric(a11*c2,a21*c2,a22*c2);}
    44                         Metric operator/(Real8 c) const {Real8 c2=1/(c*c);return  Metric(a11*c2,a21*c2,a22*c2);}
     43                        Metric operator*(double c) const {double c2=c*c;return  Metric(a11*c2,a21*c2,a22*c2);}
     44                        Metric operator/(double c) const {double c2=1/(c*c);return  Metric(a11*c2,a21*c2,a22*c2);}
    4545                        operator D2xD2(){ return D2xD2(a11,a21,a21,a22);}
    46                         Real8  operator()(R2 x) const { return sqrt(x.x*x.x*a11+2*x.x*x.y*a21+x.y*x.y*a22);};
    47                         Real8  operator()(R2 x,R2 y) const { return x.x*y.x*a11+(x.x*x.y+x.y*y.x)*a21+x.y*y.y*a22;};
     46                        double  operator()(R2 x) const { return sqrt(x.x*x.x*a11+2*x.x*x.y*a21+x.y*x.y*a22);};
     47                        double  operator()(R2 x,R2 y) const { return x.x*y.x*a11+(x.x*x.y+x.y*y.x)*a21+x.y*y.y*a22;};
    4848
    4949        };
    … …  
    6767                        void Maxh(double h) {Max(1.0/(h*h));}
    6868                        void Isotrope() {lambda1=lambda2=bamg::Max(lambda1,lambda2);}
    69                         Real8 hmin() const {return sqrt(1/bamg::Max3(lambda1,lambda2,1e-30));}
    70                         Real8 hmax() const {return sqrt(1/bamg::Max(bamg::Min(lambda1,lambda2),1e-30));}
    71                         Real8 lmax() const {return bamg::Max3(lambda1,lambda2,1e-30);}
    72                         Real8 lmin() const {return bamg::Max(bamg::Min(lambda1,lambda2),1e-30);}
    73                         Real8 Aniso2() const  { return lmax()/lmin();}
    74                         Real8 Aniso() const  { return sqrt( Aniso2());}
    75                         void BoundAniso(const Real8 c){ BoundAniso2(1/(c*c));}
    76                         inline void BoundAniso2(const Real8 coef);
     69                        double hmin() const {return sqrt(1/bamg::Max3(lambda1,lambda2,1e-30));}
     70                        double hmax() const {return sqrt(1/bamg::Max(bamg::Min(lambda1,lambda2),1e-30));}
     71                        double lmax() const {return bamg::Max3(lambda1,lambda2,1e-30);}
     72                        double lmin() const {return bamg::Max(bamg::Min(lambda1,lambda2),1e-30);}
     73                        double Aniso2() const  { return lmax()/lmin();}
     74                        double Aniso() const  { return sqrt( Aniso2());}
     75                        void BoundAniso(const double c){ BoundAniso2(1/(c*c));}
     76                        inline void BoundAniso2(const double coef);
    7777                        //operators
    7878                        void operator *=(double coef){ lambda1*=coef;lambda2*=coef;}
    … …  
    8080
    8181        class SaveMetricInterpole {
    82                 friend Real8 LengthInterpole(const Metric ,const  Metric , R2 );
    83                 friend Real8 abscisseInterpole(const Metric ,const  Metric , R2 ,Real8 ,int );
     82                friend double LengthInterpole(const Metric ,const  Metric , R2 );
     83                friend double abscisseInterpole(const Metric ,const  Metric , R2 ,double ,int );
    8484                int opt;
    85                 Real8 lab;
    86                 Real8 L[1024],S[1024];
     85                double lab;
     86                double L[1024],S[1024];
    8787        };
    8888
    … …  
    9090        //Functions
    9191        void  SimultaneousMatrixReduction( Metric M1,  Metric M2,D2xD2 &V);
    92         Real8 LengthInterpole(const Metric Ma,const  Metric Mb, R2 AB);
    93         Real8 abscisseInterpole(const Metric Ma,const  Metric Mb, R2 AB,Real8 s,int optim=0);
     92        double LengthInterpole(const Metric Ma,const  Metric Mb, R2 AB);
     93        double abscisseInterpole(const Metric Ma,const  Metric Mb, R2 AB,double s,int optim=0);
    9494
    9595        //inlines
    96         inline void  MatVVP2x2::BoundAniso2(const Real8 coef){
     96        inline void  MatVVP2x2::BoundAniso2(const double coef){
    9797                if (coef<=1.00000000001){
    9898                        if (lambda1 < lambda2)
    … …  
    117117        }
    118118        inline   void  Metric::Box(double &hx,double &hy) const {
    119                 Real8 d=  a11*a22-a21*a21;
     119                double d=  a11*a22-a21*a21;
    120120                hx = sqrt(a22/d);
    121121                hy = sqrt(a11/d);
    122122        }
    123         inline Real8 LengthInterpole(Real8 la,Real8 lb) {
     123        inline double LengthInterpole(double la,double lb) {
    124124                return ( Abs(la - lb) < 1.0e-6*Max3(la,lb,1.0e-20) ) ?  (la+lb)/2  : la*lb*log(la/lb)/(la-lb);
    125125        }
    126         inline Real8 abscisseInterpole(Real8 la,Real8 lb,Real8 lab,Real8 s){
     126        inline double abscisseInterpole(double la,double lb,double lab,double s){
    127127                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);
    128128        }

  • issm/trunk/src/c/Bamgx/objects/QuadTree.cpp

    r3233 r3243  
    9494                 throw ErrorException(__FUNCT__,exprintf("MaxISize <= MaxICoor"));
    9595         }
    96          for (Int4 i=0;i<nbv;i++)
     96         for (long i=0;i<nbv;i++)
    9797          Add(t->vertices[i]);
    9898        }
    … …  
    212212                Icoor1   jj[MaxDeep];
    213213                register int level=0; // levelevelevel
    214                 register Int4 n0;
     214                register long n0;
    215215                register QuadTreeBox* b;
    216216                IntQuad  h=MaxISize,h0;
    … …  
    358358                // init for optimisation ---
    359359                b = root;
    360                 register Int4  n0;
     360                register long  n0;
    361361                if (!root->n)
    362362                 return vn; // empty tree
    … …  
    466466        /*}}}1*/
    467467        /*FUNCTION QuadTree::ToClose {{{1*/
    468         Vertex *   QuadTree::ToClose(Vertex & v,Real8 seuil,Icoor1 hx,Icoor1 hy){
     468        Vertex *   QuadTree::ToClose(Vertex & v,double seuil,Icoor1 hx,Icoor1 hy){
    469469                const Icoor1 i=v.i.x;
    470470                const Icoor1 j=v.i.y;
    … …  
    505505                                          {
    506506                                                R2 XY(X,b->v[k]->r);
    507                                                 Real8 dd;
     507                                                double dd;
    508508                                                if( (dd= LengthInterpole(Mx(XY), b->v[k]->m(XY)))  < seuil ){
    509509                                                        return b->v[k];

  • issm/trunk/src/c/Bamgx/objects/QuadTree.h

    r3232 r3243  
    5656                        Vertex* NearestVertex(Icoor1 i,Icoor1 j);
    5757                        Vertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j);
    58                         Vertex* ToClose(Vertex & ,Real8 ,Icoor1,Icoor1);
     58                        Vertex* ToClose(Vertex & ,double ,Icoor1,Icoor1);
    5959                        long    SizeOf() const {return sizeof(QuadTree)+sb->SizeOf();}
    6060                        void    Add( Vertex & w);

  • issm/trunk/src/c/Bamgx/objects/SetOfE4.cpp

    r3233 r3243  
    99
    1010        /*Constructor*/
    11         /*FUNCTION  SetOfEdges4::SetOfEdges4(Int4 mmx,Int4 nnx){{{1*/
    12         SetOfEdges4::SetOfEdges4(Int4 mmx,Int4 nnx){
     11        /*FUNCTION  SetOfEdges4::SetOfEdges4(long mmx,long nnx){{{1*/
     12        SetOfEdges4::SetOfEdges4(long mmx,long nnx){
    1313
    1414                /*Intermediary*/
    … …  
    1919                nbax =mmx; // 3 * number of triangles
    2020                NbOfEdges=0;
    21                 head = new Int4 [nx];
     21                head = new long [nx];
    2222                Edges= new Int4Edge[nbax];
    2323
    … …  
    3030        /*Methods*/
    3131        /*FUNCTION  SetOfEdges4::find {{{1*/
    32         Int4 SetOfEdges4::find(Int4 ii,Int4 jj) {
     32        long SetOfEdges4::find(long ii,long jj) {
    3333
    3434                /*Intermediary*/
    … …  
    5858        /*}}}1*/
    5959        /*FUNCTION  SetOfEdges4::add{{{1*/
    60         Int4 SetOfEdges4::add(Int4 ii,Int4 jj) {
     60        long SetOfEdges4::add(long ii,long jj) {
    6161
    6262                /*Intermediary*/

  • issm/trunk/src/c/Bamgx/objects/SetOfE4.h

    r3232 r3243  
    99                friend class SetOfEdges4;
    1010                public:
    11                 Int4 i,j;
    12                 Int4 next;
     11                long i,j;
     12                long next;
    1313        };
    1414
    … …  
    1616
    1717                private:
    18                         Int4 nx,nbax,NbOfEdges;
    19                         Int4* head;
     18                        long nx,nbax,NbOfEdges;
     19                        long* head;
    2020                        Int4Edge* Edges;
    2121
    2222                public:
    23                         SetOfEdges4(Int4 ,Int4);// nb Edges mx , nb de sommet
     23                        SetOfEdges4(long ,long);// nb Edges mx , nb de sommet
    2424                        ~SetOfEdges4() {delete [] head; delete [] Edges;}
    25                         Int4 add (Int4 ii,Int4 jj);
    26                         Int4 SortAndAdd (Int4 ii,Int4 jj) {return ii <=jj ? add (ii,jj)  : add (jj,ii) ;}
    27                         Int4  nb(){return NbOfEdges;}
    28                         Int4 find (Int4 ii,Int4 jj);
    29                         Int4 SortAndFind (Int4 ii,Int4 jj) {return ii <=jj ? find (ii,jj)  : find (jj,ii) ;}
    30                         Int4 i(Int4 k){return Edges[k].i;}
    31                         Int4 j(Int4 k){return Edges[k].j;}
    32                         Int4 newarete(Int4 k){return NbOfEdges == k+1;}
     25                        long add (long ii,long jj);
     26                        long SortAndAdd (long ii,long jj) {return ii <=jj ? add (ii,jj)  : add (jj,ii) ;}
     27                        long  nb(){return NbOfEdges;}
     28                        long find (long ii,long jj);
     29                        long SortAndFind (long ii,long jj) {return ii <=jj ? find (ii,jj)  : find (jj,ii) ;}
     30                        long i(long k){return Edges[k].i;}
     31                        long j(long k){return Edges[k].j;}
     32                        long newarete(long k){return NbOfEdges == k+1;}
    3333
    3434                        //operators
    35                         Int4Edge & operator[](Int4 k){return  Edges[k];}
     35                        Int4Edge & operator[](long k){return  Edges[k];}
    3636        };
    3737}

  • issm/trunk/src/c/Bamgx/objects/SubDomain.h

    r3232 r3243  
    1919                public:
    2020                        Triangle * head;
    21                         Int4  ref; 
     21                        long  ref; 
    2222                        int sens; // -1 or 1
    2323                        Edge* edge; // to  geometrical 
    2424
    2525                        //Inline methods
    26                         inline void Set(const Triangles &,Int4,Triangles &);
     26                        inline void Set(const Triangles &,long,Triangles &);
    2727        };
    2828

  • issm/trunk/src/c/Bamgx/objects/Triangle.cpp

    r3242 r3243  
    9292        /*}}}*/
    9393        /*FUNCTION Triangle::Optim{{{1*/
    94         Int4  Triangle::Optim(short i,int koption) {
     94        long  Triangle::Optim(short i,int koption) {
    9595                // turn around (positive direction)
    9696                Triangle *t=this;
    97                 Int4 NbSwap =0;
     97                long NbSwap =0;
    9898                int  k = 0;
    9999                int  j = OppositeEdge[i];
    … …  
    183183                                         else {
    184184                                                 // critere de Delaunay anisotrope
    185                                                  Real8 som;
     185                                                 double som;
    186186                                                 I2 AB=(I2) *sb - (I2) *sa;
    187187                                                 I2 MAB2=((I2) *sb + (I2) *sa);

  • issm/trunk/src/c/Bamgx/objects/Triangle.h

    r3242 r3243  
    2929                        union {
    3030                                Triangle * link ;
    31                                 Int4 color;
     31                                long color;
    3232                        };
    3333
    3434                        //Constructors/Destructors
    3535                        Triangle() {}
    36                         Triangle(Triangles *Th,Int4 i,Int4 j,Int4 k);
     36                        Triangle(Triangles *Th,long i,long j,long k);
    3737                        Triangle(Vertex *v0,Vertex *v1,Vertex *v2);
    3838
    … …  
    4646                        void   Echo();
    4747                        int    swap(short a1,int=0);
    48                         Int4   Optim(short a,int =0);
     48                        long   Optim(short a,int =0);
    4949                        int    Locked(int a)const { return TriaAdjSharedEdge[a]&4;}
    5050                        int    Hidden(int a)const { return TriaAdjSharedEdge[a]&16;}
    … …  
    5858                        Triangle* TriangleAdj(int i) const {return TriaAdjTriangles[i&3];}
    5959                        Triangle* Quadrangle(Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const ;
    60                         void  ReNumbering(Triangle *tb,Triangle *te, Int4 *renu){
     60                        void  ReNumbering(Triangle *tb,Triangle *te, long *renu){
    6161                                if (link  >=tb && link  <te) link  = tb + renu[link -tb];
    6262                                if (TriaAdjTriangles[0] >=tb && TriaAdjTriangles[0] <te) TriaAdjTriangles[0] = tb + renu[TriaAdjTriangles[0]-tb];
    … …  
    6464                                if (TriaAdjTriangles[2] >=tb && TriaAdjTriangles[2] <te) TriaAdjTriangles[2] = tb + renu[TriaAdjTriangles[2]-tb];   
    6565                        }
    66                         void ReNumbering(Vertex *vb,Vertex *ve, Int4 *renu){
     66                        void ReNumbering(Vertex *vb,Vertex *ve, long *renu){
    6767                                if (TriaVertices[0] >=vb && TriaVertices[0] <ve) TriaVertices[0] = vb + renu[TriaVertices[0]-vb];
    6868                                if (TriaVertices[1] >=vb && TriaVertices[1] <ve) TriaVertices[1] = vb + renu[TriaVertices[1]-vb];

  • issm/trunk/src/c/Bamgx/objects/Triangles.cpp

    r3242 r3243  
    4242                  int kt=0;
    4343                  int * kk    = new int [Tho.nbv];
    44                   Int4 * reft = new Int4[Tho.nbt];
    45                   Int4 nbInT =    Tho.TriangleReferenceList(reft);
    46                   Int4 * refv = new Int4[Tho.nbv];
     44                  long * reft = new long[Tho.nbt];
     45                  long nbInT =    Tho.TriangleReferenceList(reft);
     46                  long * refv = new long[Tho.nbv];
    4747
    4848                  for (i=0;i<Tho.nbv;i++)
    … …  
    8484                  printf("   number of triangles %i, remove = \n",kt,nbInT-kt);
    8585                  printf("   number of New boundary edge %i\n",nbNewBedge);
    86                   Int4 inbvx =k;
     86                  long inbvx =k;
    8787                  PreInit(inbvx);
    8888                  for (i=0;i<Tho.nbv;i++)
    … …  
    138138          }
    139139        /*}}}1*/
    140         /*FUNCTION Triangles::Triangles(Triangles & Th,Geometry * pGh,Triangles * pBth,Int4 nbvxx) COPY{{{1*/
    141         Triangles::Triangles(Triangles & Th,Geometry * pGh,Triangles * pBth,Int4 nbvxx)
     140        /*FUNCTION Triangles::Triangles(Triangles & Th,Geometry * pGh,Triangles * pBth,long nbvxx) COPY{{{1*/
     141        Triangles::Triangles(Triangles & Th,Geometry * pGh,Triangles * pBth,long nbvxx)
    142142          : Gh(*(pGh?pGh:&Th.Gh)), BTh(*(pBth?pBth:this)) {
    143143                  Gh.NbRef++;
    144144                  nbvxx = Max(nbvxx,Th.nbv);
    145                   Int4 i;
     145                  long i;
    146146                  // do all the allocation to be sure all the pointer existe
    147147
    … …  
    234234        void Triangles::ReadMesh(double* index,double* x,double* y,int nods,int nels){
    235235
    236                 Real8 Hmin = HUGE_VAL;// the infinie value
    237                 Int4 i1,i2,i3,iref;
    238                 Int4 i,j;
    239                 Int4 hvertices =0;
     236                double Hmin = HUGE_VAL;// the infinie value
     237                long i1,i2,i3,iref;
     238                long i,j;
     239                long hvertices =0;
    240240                Metric M1(1);
    241241                int Version=1,dim=2;
    … …  
    266266                for (i=0;i<nbt;i++){
    267267                        Triangle & t = triangles[i];
    268                         i1=(Int4)index[i*3+0]-1; //for C indexing
    269                         i2=(Int4)index[i*3+1]-1; //for C indexing
    270                         i3=(Int4)index[i*3+2]-1; //for C indexing
     268                        i1=(long)index[i*3+0]-1; //for C indexing
     269                        i2=(long)index[i*3+1]-1; //for C indexing
     270                        i3=(long)index[i*3+2]-1; //for C indexing
    271271                        t=Triangle(this,i1,i2,i3);
    272272                        t.color=i;
    … …  
    284284
    285285                int verbose;
    286                 Real8 Hmin = HUGE_VAL;// the infinie value
    287                 Int4 i1,i2,i3,iref;
    288                 Int4 i,j;
    289                 Int4 hvertices =0;
    290                 Int4 ifgeom=0;
     286                double Hmin = HUGE_VAL;// the infinie value
     287                long i1,i2,i3,iref;
     288                long i,j;
     289                long hvertices =0;
     290                long ifgeom=0;
    291291                Metric M1(1);
    292292                int Version=1,dim=2;
    … …  
    312312                                vertices[i].DirOfSearch =NoDirOfSearch;
    313313                                vertices[i].m=M1;
    314                                 vertices[i].color=(Int4)bamgmesh->Vertices[i*3+2];
     314                                vertices[i].color=(long)bamgmesh->Vertices[i*3+2];
    315315                        }
    316316                        nbtx=2*nbvx-2; // for filling The Holes and quadrilaterals
    … …  
    327327                        for (i=0;i<nbt;i++){
    328328                                Triangle & t = triangles[i];
    329                                 i1=(Int4)bamgmesh->Triangles[i*4+0]-1; //for C indexing
    330                                 i2=(Int4)bamgmesh->Triangles[i*4+1]-1; //for C indexing
    331                                 i3=(Int4)bamgmesh->Triangles[i*4+2]-1; //for C indexing
     329                                i1=(long)bamgmesh->Triangles[i*4+0]-1; //for C indexing
     330                                i2=(long)bamgmesh->Triangles[i*4+1]-1; //for C indexing
     331                                i3=(long)bamgmesh->Triangles[i*4+2]-1; //for C indexing
    332332                                t=Triangle(this,i1,i2,i3);
    333                                 t.color=(Int4)bamgmesh->Triangles[i*4+3];
     333                                t.color=(long)bamgmesh->Triangles[i*4+3];
    334334                        }
    335335                }
    … …  
    341341                if(bamgmesh->Quadrilaterals){
    342342                        if(verbose>5) printf("      processing Quadrilaterals\n");
    343                         Int4 i1,i2,i3,i4,iref;
     343                        long i1,i2,i3,i4,iref;
    344344                        triangles =new Triangle[nbt];
    345345                        for (i=0;i<bamgmesh->NumQuadrilaterals;i++){
    … …  
    347347                                Triangle & t1 = triangles[2*i];
    348348                                Triangle & t2 = triangles[2*i+1];
    349                                 i1=(Int4)bamgmesh->Quadrilaterals[i*4+0]-1; //for C indexing
    350                                 i2=(Int4)bamgmesh->Quadrilaterals[i*4+1]-1; //for C indexing
    351                                 i3=(Int4)bamgmesh->Quadrilaterals[i*4+2]-1; //for C indexing
    352                                 i4=(Int4)bamgmesh->Quadrilaterals[i*4+3]-1; //for C indexing
     349                                i1=(long)bamgmesh->Quadrilaterals[i*4+0]-1; //for C indexing
     350                                i2=(long)bamgmesh->Quadrilaterals[i*4+1]-1; //for C indexing
     351                                i3=(long)bamgmesh->Quadrilaterals[i*4+2]-1; //for C indexing
     352                                i4=(long)bamgmesh->Quadrilaterals[i*4+3]-1; //for C indexing
    353353                                t1=Triangle(this,i1,i2,i3);
    354354                                t2=Triangle(this,i3,i4,i1);
    … …  
    383383                        VerticesOnGeomEdge= new  VertexOnGeom[NbVerticesOnGeomEdge] ;
    384384                        for (i=0;i<NbVerticesOnGeomEdge;i++){
    385                                 Int4  i1,i2;
    386                                 Real8 s;
    387                                 i1=(Int4)bamgmesh->VerticesOnGeometricEdge[i*3+0]-1; //for C indexing
    388                                 i2=(Int4)bamgmesh->VerticesOnGeometricEdge[i*3+1]-1; //for C indexing
    389                                 s =(Int4)bamgmesh->VerticesOnGeometricEdge[i*3+2];
     385                                long  i1,i2;
     386                                double s;
     387                                i1=(long)bamgmesh->VerticesOnGeometricEdge[i*3+0]-1; //for C indexing
     388                                i2=(long)bamgmesh->VerticesOnGeometricEdge[i*3+1]-1; //for C indexing
     389                                s =(long)bamgmesh->VerticesOnGeometricEdge[i*3+2];
    390390                                VerticesOnGeomEdge[i]=VertexOnGeom(vertices[i1],Gh.edges[i2],s);
    391391                        }
    … …  
    419419                                edges[i].adj[1]=0;
    420420                                R2 x12 = vertices[i2].r-vertices[i1].r;
    421                                 Real8 l12=sqrt( (x12,x12));       
     421                                double l12=sqrt( (x12,x12));       
    422422
    423423                                if (!hvertices) {
    … …  
    447447                                for (j=0;j<2;j++) {
    448448                                        Vertex *v=edges[i].v[j];
    449                                         Int4 i0=v->color,j0;
     449                                        long i0=v->color,j0;
    450450                                        if(i0==-1){
    451451                                                v->color=i*2+j;
    … …  
    503503                //SubDomain
    504504                if(bamgmesh->SubDomains){
    505                         Int4 i3,head,sens;
     505                        long i3,head,sens;
    506506                        if(verbose>5) printf("      processing SubDomains\n");
    507507                        NbSubDomains=bamgmesh->NumSubDomains;
    … …  
    548548
    549549                //Build reft that holds the number the subdomain number of each triangle
    550                 Int4* reft = new Int4[nbt];
    551                 Int4 nbInT = TriangleReferenceList(reft);
     550                long* reft = new long[nbt];
     551                long nbInT = TriangleReferenceList(reft);
    552552
    553553                //Vertices
    … …  
    810810        /*}}}1*/
    811811        /*FUNCTION Triangles::ReadMetric{{{1*/
    812         void Triangles::ReadMetric(BamgOpts* bamgopts,const Real8 hmin1=1.0e-30,const Real8 hmax1=1.0e30,const Real8 coef=1) {
     812        void Triangles::ReadMetric(BamgOpts* bamgopts,const double hmin1=1.0e-30,const double hmax1=1.0e30,const double coef=1) {
    813813                int  i,j;
    814814
    815815                if(bamgopts->verbose>3) printf("      processing metric\n");
    816816
    817                 Real8 hmin = Max(hmin1,MinimalHmin());
    818                 Real8 hmax = Min(hmax1,MaximalHmax());
     817                double hmin = Max(hmin1,MinimalHmin());
     818                double hmax = Min(hmax1,MaximalHmax());
    819819
    820820                //for now we only use j==3
    … …  
    822822
    823823                for (i=0;i<nbv;i++){
    824                         Real8 h;
     824                        double h;
    825825                        if (j == 1){
    826826                                h=bamgopts->metric[i];
    … …  
    830830                                //do not erase metric computed by hVertices
    831831                                if (vertices[i].m.a11==1 && vertices[i].m.a21==0 && vertices[i].m.a22==1){
    832                                         Real8 a,b,c;         
     832                                        double a,b,c;       
    833833                                        a=bamgopts->metric[i*3+0];
    834834                                        b=bamgopts->metric[i*3+1];
    … …  
    867867                double errg     =bamgopts->errg;
    868868
    869                 Real8 ss[2]={0.00001,0.99999};
    870                 Real8 errC = 2*sqrt(2*errg);
    871                 Real8 hmax = Gh.MaximalHmax();
    872                 Real8 hmin = Gh.MinimalHmin();
     869                double ss[2]={0.00001,0.99999};
     870                double errC = 2*sqrt(2*errg);
     871                double hmax = Gh.MaximalHmax();
     872                double hmin = Gh.MinimalHmin();
    873873
    874874                //check that hmax is positive
    … …  
    884884
    885885                //loop over all the vertices on edges
    886                 for (Int4  i=0;i<nbe;i++){
     886                for (long  i=0;i<nbe;i++){
    887887                        for (int j=0;j<2;j++){
    888888
    … …  
    892892
    893893                                GeometricalEdge * eg = GV;
    894                                 Real8 s = GV;
     894                                double s = GV;
    895895                                R2 tg;
    896                                 Real8  R1= eg->R1tg(s,tg);
    897                                 Real8  ht=hmax;
     896                                double  R1= eg->R1tg(s,tg);
     897                                double  ht=hmax;
    898898                                // err relative to the length of the edge
    899899                                if (R1>1.0e-20) { 
    900900                                        ht = Min(Max(errC/R1,hmin),hmax);
    901901                                }
    902                                 Real8 hn=Min(hmax,ht*anisomax);
     902                                double hn=Min(hmax,ht*anisomax);
    903903                                if (ht<=0 || hn<=0){
    904904                                        throw ErrorException(__FUNCT__,exprintf("ht<=0 || hn<=0"));
    … …  
    10721072        /*}}}1*/
    10731073        /*FUNCTION Triangles::BoundAnisotropy{{{1*/
    1074         void  Triangles::BoundAnisotropy(Real8 anisomax,Real8 hminaniso) {
     1074        void  Triangles::BoundAnisotropy(double anisomax,double hminaniso) {
    10751075
    10761076                long int verbosity=0;
    … …  
    10801080                if (verbosity > 1)  printf("   BoundAnisotropy by %g\n",anisomax);
    10811081
    1082                 Real8 h1=1.e30,h2=1e-30;
    1083                 Real8 coef = 1./(anisomax*anisomax);
    1084                 Real8 hn1=1.e30,hn2=1e-30,rnx =1.e-30,rx=0; 
     1082                double h1=1.e30,h2=1e-30;
     1083                double coef = 1./(anisomax*anisomax);
     1084                double hn1=1.e30,hn2=1e-30,rnx =1.e-30,rx=0; 
    10851085
    10861086                //loop over all vertices
    1087                 for (Int4 i=0;i<nbv;i++){
     1087                for (long i=0;i<nbv;i++){
    10881088                        MatVVP2x2 Vp(vertices[i]);
    10891089                        double lmax=Vp.lmax();
    … …  
    11401140                //initialize st and edge4
    11411141                SetOfEdges4* edge4= new SetOfEdges4(nbt*3,nbv);
    1142                 Int4*        st   = new Int4[nbt*3];
     1142                long*        st   = new long[nbt*3];
    11431143
    11441144                //initialize st as -1 (chaining algorithm)
    … …  
    11541154                }
    11551155                //keep nbe in nbeold
    1156                 Int4 nbeold = nbe;
     1156                long nbeold = nbe;
    11571157
    11581158                //Go through the triangles and ass the edges in edge4 if they are not there yet
    … …  
    11611161                        for  (j=0;j<3;j++) {
    11621162                                //Add Edge to edge4 (k=numberofedges in edge4)
    1163                                 Int4 k =edge4->SortAndAdd(Number(triangles[i][VerticesOfTriangularEdge[j][0]]), Number(triangles[i][VerticesOfTriangularEdge[j][1]]));
    1164                                 Int4 invisible = triangles[i].Hidden(j);
     1163                                long k =edge4->SortAndAdd(Number(triangles[i][VerticesOfTriangularEdge[j][0]]), Number(triangles[i][VerticesOfTriangularEdge[j][1]]));
     1164                                long invisible = triangles[i].Hidden(j);
    11651165
    11661166                                //if st[k] has not been changed yet, add 3*i+j (= vertex position in the index)
    … …  
    11951195
    11961196                //delete edge4
    1197                 Int4 nbedges = edge4->nb(); // the total number of edges
     1197                long nbedges = edge4->nb(); // the total number of edges
    11981198                delete edge4; edge4=NULL;
    11991199
    … …  
    12391239
    12401240                        for (i=0;i<nbedges;i++){
    1241                                 Int4  add= -1;
     1241                                long  add= -1;
    12421242
    12431243                                //internal edge (belongs to two triangles)
    … …  
    13001300                                Vertex* v=edges[i].v[j];
    13011301                                //get vertex color (i0)
    1302                                 Int4 i0=v->color,j0;
     1302                                long i0=v->color,j0;
    13031303
    13041304                                //if color<0 (first time), no adjacent edge
    … …  
    13381338
    13391339                //color the subdomains
    1340                 Int4* colorT= new Int4[nbt];
     1340                long* colorT= new long[nbt];
    13411341                Triangle *tt,*t;
    13421342
    … …  
    13801380
    13811381                //build subdomains
    1382                 Int4 isd;
     1382                long isd;
    13831383                subdomains = new SubDomain[NbSubDomains];
    13841384
    … …  
    14101410
    14111411                //build colorV -1 for all vertex and 0 for the vertices belonging to edges
    1412                 Int4* colorV = new Int4[nbv];
     1412                long* colorV = new long[nbv];
    14131413                for (i=0;i<nbv;i++) colorV[i]=-1;
    14141414                for (i=0;i<nbe;i++){
    … …  
    14721472                //initialize edge4 again
    14731473                edge4= new SetOfEdges4(nbe,nbv); 
    1474                 Real8 hmin = HUGE_VAL;
     1474                double hmin = HUGE_VAL;
    14751475                int kreq=0;
    14761476                for (i=0;i<nbe;i++){
    14771477
    1478                         Int4 i0 = Number(edges[i][0]);
    1479                         Int4 i1 = Number(edges[i][1]);
    1480                         Int4 j0 = colorV[i0];
    1481                         Int4 j1 = colorV[i1];
     1478                        long i0 = Number(edges[i][0]);
     1479                        long i1 = Number(edges[i][1]);
     1480                        long j0 = colorV[i0];
     1481                        long j1 = colorV[i1];
    14821482
    14831483                        Gh.edges[i].v[0] = Gh.vertices +  j0;
    … …  
    14991499
    15001500                        R2 x12 = Gh.vertices[j0].r-Gh.vertices[j1].r;
    1501                         Real8 l12=Norme2(x12);       
     1501                        double l12=Norme2(x12);       
    15021502                        hmin = Min(hmin,l12);
    15031503
    … …  
    15301530                        it = Number(subdomains[i].head);
    15311531                        j = subdomains[i].sens;
    1532                         Int4 i0 = Number(triangles[it][VerticesOfTriangularEdge[j][0]]);
    1533                         Int4 i1 = Number(triangles[it][VerticesOfTriangularEdge[j][1]]);
     1532                        long i0 = Number(triangles[it][VerticesOfTriangularEdge[j][0]]);
     1533                        long i1 = Number(triangles[it][VerticesOfTriangularEdge[j][1]]);
    15341534                        k = edge4->SortAndFind(i0,i1);
    15351535                        if(k>=0){
    … …  
    15621562                const int dim = 2;
    15631563                double* s=NULL;
    1564                 Int4    nbsol;
     1564                long    nbsol;
    15651565                int     verbosity;
    15661566
    … …  
    15781578                double* ss=(double*)s;
    15791579                double  sA,sB,sC;
    1580                 Real8*  detT = new Real8[nbt];
    1581                 Real8*  sumareas = new Real8[nbv];
    1582                 Real8*  alpha= new Real8[nbt*3];
    1583                 Real8*  beta = new Real8[nbt*3];
    1584                 Real8*  dx_elem    = new Real8[nbt];
    1585                 Real8*  dy_elem    = new Real8[nbt];
    1586                 Real8*  dx_vertex  = new Real8[nbv];
    1587                 Real8*  dy_vertex  = new Real8[nbv];
    1588                 Real8*  dxdx_elem  = new Real8[nbt];
    1589                 Real8*  dxdy_elem  = new Real8[nbt];
    1590                 Real8*  dydy_elem  = new Real8[nbt];
    1591                 Real8*  dxdx_vertex= new Real8[nbv];
    1592                 Real8*  dxdy_vertex= new Real8[nbv];
    1593                 Real8*  dydy_vertex= new Real8[nbv];
     1580                double*  detT = new double[nbt];
     1581                double*  sumareas = new double[nbv];
     1582                double*  alpha= new double[nbt*3];
     1583                double*  beta = new double[nbt*3];
     1584                double*  dx_elem    = new double[nbt];
     1585                double*  dy_elem    = new double[nbt];
     1586                double*  dx_vertex  = new double[nbv];
     1587                double*  dy_vertex  = new double[nbv];
     1588                double*  dxdx_elem  = new double[nbt];
     1589                double*  dxdy_elem  = new double[nbt];
     1590                double*  dydy_elem  = new double[nbt];
     1591                double*  dxdx_vertex= new double[nbv];
     1592                double*  dxdy_vertex= new double[nbv];
     1593                double*  dydy_vertex= new double[nbv];
    15941594
    15951595                //display infos
    … …  
    16231623
    16241624                                //compute triangle determinant (2*Area)
    1625                                 Real8 dett = bamg::Area2(A,B,C);
     1625                                double dett = bamg::Area2(A,B,C);
    16261626                                detT[i]=dett;
    16271627
    … …  
    16551655
    16561656                //for all Solutions
    1657                 for (Int4 nusol=0;nusol<nbsol;nusol++) {
    1658                         Real8 smin=ss[nusol],smax=ss[nusol];
     1657                for (long nusol=0;nusol<nbsol;nusol++) {
     1658                        double smin=ss[nusol],smax=ss[nusol];
    16591659
    16601660                        //get min(s), max(s) and initialize Hessian (dxdx,dxdy,dydy)
    … …  
    16631663                                smax=Max(smax,ss[iv*nbsol+nusol]);
    16641664                        }
    1665                         Real8 sdelta=smax-smin;
    1666                         Real8 absmax=Max(Abs(smin),Abs(smax));
     1665                        double sdelta=smax-smin;
     1666                        double absmax=Max(Abs(smin),Abs(smax));
    16671667
    16681668                        //display info
    … …  
    17011701                                for(p=head_s[i];p!=-1;p=next_p[p]){
    17021702                                        //Get triangle number
    1703                                         k=(Int4)(p/3);
     1703                                        k=(long)(p/3);
    17041704                                        dx_vertex[i]+=dx_elem[k]*detT[k]/sumareas[i];
    17051705                                        dy_vertex[i]+=dy_elem[k]*detT[k]/sumareas[i];
    … …  
    17261726                                for(p=head_s[i];p!=-1;p=next_p[p]){
    17271727                                        //Get triangle number
    1728                                         k=(Int4)(p/3);
     1728                                        k=(long)(p/3);
    17291729                                        dxdx_vertex[i]+=dxdx_elem[k]*detT[k]/sumareas[i];
    17301730                                        dxdy_vertex[i]+=dxdy_elem[k]*detT[k]/sumareas[i];
    … …  
    17651765                const int dim = 2;
    17661766                double* s=NULL;
    1767                 Int4 nbsol;
     1767                long nbsol;
    17681768                int NbJacobi;
    17691769                int verbosity;
    … …  
    17781778
    17791779                //initialization of some variables
    1780                 Int4    i,k,iA,iB,iC,iv;
     1780                long    i,k,iA,iB,iC,iv;
    17811781                R2      O(0,0);
    17821782                double* ss=(double*)s;
    17831783                double  sA,sB,sC;
    1784                 Real8*  detT = new Real8[nbt];
    1785                 Real8*  Mmass= new Real8[nbv];
    1786                 Real8*  Mmassxx= new Real8[nbv];
    1787                 Real8*  dxdx= new Real8[nbv];
    1788                 Real8*  dxdy= new Real8[nbv];
    1789                 Real8*  dydy= new Real8[nbv];
    1790                 Real8*  workT= new Real8[nbt];
    1791                 Real8*  workV= new Real8[nbv];
     1784                double*  detT = new double[nbt];
     1785                double*  Mmass= new double[nbv];
     1786                double*  Mmassxx= new double[nbv];
     1787                double*  dxdx= new double[nbv];
     1788                double*  dxdy= new double[nbv];
     1789                double*  dydy= new double[nbv];
     1790                double*  workT= new double[nbt];
     1791                double*  workV= new double[nbv];
    17921792                int*    OnBoundary = new int[nbv];
    17931793
    … …  
    18241824
    18251825                                //compute triangle determinant (2*Area)
    1826                                 Real8 dett = bamg::Area2(A,B,C);
     1826                                double dett = bamg::Area2(A,B,C);
    18271827                                detT[i]=dett;
    18281828                                dett /= 6;
    … …  
    18611861
    18621862                //for all Solution 
    1863                 for (Int4 nusol=0;nusol<nbsol;nusol++) {
    1864 
    1865                         Real8 smin=ss[nusol],smax=ss[nusol];
    1866                         Real8 h1=1.e30,h2=1e-30,rx=0;
    1867                         Real8 hn1=1.e30,hn2=1e-30,rnx =1.e-30; 
     1863                for (long nusol=0;nusol<nbsol;nusol++) {
     1864
     1865                        double smin=ss[nusol],smax=ss[nusol];
     1866                        double h1=1.e30,h2=1e-30,rx=0;
     1867                        double hn1=1.e30,hn2=1e-30,rnx =1.e-30; 
    18681868
    18691869                        //get min(s), max(s) and initialize Hessian (dxdx,dxdy,dydy)
    … …  
    18731873                                smax=Max(smax,ss[iv*nbsol+nusol]);
    18741874                        }
    1875                         Real8 sdelta=smax-smin;
    1876                         Real8 absmax=Max(Abs(smin),Abs(smax));
     1875                        double sdelta=smax-smin;
     1876                        double absmax=Max(Abs(smin),Abs(smax));
    18771877
    18781878                        //display info
    … …  
    19671967                                }
    19681968
    1969                                 Int4 kk=0;
     1969                                long kk=0;
    19701970                                for ( iv=0,k=0 ; iv<nbv; iv++){
    19711971                                        if(Mmassxx[iv]>0){
    … …  
    19881988                                // correction of second derivative
    19891989                                // by a laplacien
    1990                                 Real8* d2[3] = {dxdx, dxdy, dydy};
    1991                                 Real8* dd;
     1990                                double* d2[3] = {dxdx, dxdy, dydy};
     1991                                double* dd;
    19921992                                for (int xy = 0;xy<3;xy++) {
    19931993                                        dd = d2[xy];
    … …  
    20002000                                                         iB = Number(triangles[i][1]);
    20012001                                                         iC = Number(triangles[i][2]);
    2002                                                          Real8 cc=3;
     2002                                                         double cc=3;
    20032003                                                         if(ijacobi==0)
    2004                                                           cc = Max((Real8) ((Mmassxx[iA]>0)+(Mmassxx[iB]>0)+(Mmassxx[iC]>0)),1.);
     2004                                                          cc = Max((double) ((Mmassxx[iA]>0)+(Mmassxx[iB]>0)+(Mmassxx[iC]>0)),1.);
    20052005                                                         workT[i] = (dd[iA]+dd[iB]+dd[iC])/cc;
    20062006                                                 }
    … …  
    20132013                                                                iB = Number(triangles[i][1]);
    20142014                                                                iC = Number(triangles[i][2]);
    2015                                                                 Real8 cc =  workT[i]*detT[i];
     2015                                                                double cc =  workT[i]*detT[i];
    20162016                                                                workV[iA] += cc;
    20172017                                                                workV[iB] += cc;
    … …  
    21572157                        if (nbnewv)
    21582158                          { //
    2159                                 Int4 n = nbnewv+NbVerticesOnGeomVertex;
    2160                                 Int4 i,j,k;
     2159                                long n = nbnewv+NbVerticesOnGeomVertex;
     2160                                long i,j,k;
    21612161                                VertexOnGeom * vog = new VertexOnGeom[n];
    21622162                                for ( i =0; i<NbVerticesOnGeomVertex;i++)
    … …  
    21752175                                                 if ( v >=  LastOld)
    21762176                                                        { // a new vertex
    2177                                                          Int4 old = v->ReferenceNumber ; // the old same vertex
    2178                                                          Int4 i  = ( v - LastOld);
     2177                                                         long old = v->ReferenceNumber ; // the old same vertex
     2178                                                         long i  = ( v - LastOld);
    21792179                                                         //  if the old is on vertex => warning
    21802180                                                         // else the old is on edge => ok
    … …  
    22082208
    22092209                        //check that there is no triangle with 0 determinant
    2210                         for (Int4 t = 0; t < nbt; t++){
     2210                        for (long t = 0; t < nbt; t++){
    22112211                                if (!triangles[t].det) k++;
    22122212                        }
    … …  
    22172217                        //Force Edges
    22182218                        TriangleAdjacent ta(0,0);
    2219                         for (Int4 i = 0; i < nbe; i++){
     2219                        for (long i = 0; i < nbe; i++){
    22202220
    22212221                                //Force edge i
    … …  
    22262226                                if (nbswp) nbfe++;
    22272227                                if ( nbswp < 0 && k < 5){
    2228                                         for (Int4 j = 0; j < nbe; j++){
     2228                                        for (long j = 0; j < nbe; j++){
    22292229                                                printf("Edge %i: %i %i\n",j,Number(edges[j][0]),Number(edges[j][1]));
    22302230                                        }
    … …  
    22382238                                throw ErrorException(__FUNCT__,exprintf("There are %i lost edges, the boundary might be crossing",k));
    22392239                        }
    2240                         for (Int4 j=0;j<nbv;j++){
     2240                        for (long j=0;j<nbv;j++){
    22412241                                Nbswap +=  vertices[j].Optim(1,0);
    22422242                        }
    … …  
    22552255                Triangle  **  HeapTriangle = new Triangle*  [nbt];
    22562256                Triangle *t,*t1;
    2257                 Int4 k,it;
    2258 
    2259                 for (Int4 itt=0;itt<nbt;itt++)
     2257                long k,it;
     2258
     2259                for (long itt=0;itt<nbt;itt++)
    22602260                 triangles[itt].link=0; // par defaut pas de couleur
    22612261
    2262                 Int4  NbSubDomTot =0;
     2262                long  NbSubDomTot =0;
    22632263                for ( it=0;it<nbt;it++)  {
    22642264                        if ( ! triangles[it].link  ) {
    22652265                                t = triangles + it;
    22662266                                NbSubDomTot++;; // new composante connexe
    2267                                 Int4 i = 0; // niveau de la pile
     2267                                long i = 0; // niveau de la pile
    22682268                                t->link = t ; // sd forme d'un triangle cicular link
    22692269
    … …  
    23242324                        if (OutSide|| !Gh.subdomains || !Gh.NbSubDomains )
    23252325                          { // No geom sub domain
    2326                                 Int4 i;
     2326                                long i;
    23272327                                if (subdomains) delete [] subdomains;
    23282328                                subdomains = new SubDomain[ NbSubDomTot];
    … …  
    23322332                                        subdomains[i].ref=i+1;
    23332333                                }
    2334                                 Int4 * mark = new Int4[nbt];
     2334                                long * mark = new long[nbt];
    23352335                                for (it=0;it<nbt;it++)
    23362336                                 mark[it]=triangles[it].link ? -1 : -2;
    … …  
    23592359                                                        //  because in this case we have only the true boundary edge
    23602360                                                        // so teh boundary is manifold
    2361                                                         Int4 nbk = NbSubDomains;
     2361                                                        long nbk = NbSubDomains;
    23622362                                                        while (nbk)
    23632363                                                         for (it=0;it<nbt && nbk ;it++)
    … …  
    23652365                                                                 {
    23662366                                                                  Triangle *ta = triangles[it].TriangleAdj(na);
    2367                                                                   Int4 kl = ta ? mark[Number(ta)] : -2;
    2368                                                                   Int4 kr = mark[it];
     2367                                                                  long kl = ta ? mark[Number(ta)] : -2;
     2368                                                                  long kr = mark[it];
    23692369                                                                  if(kr !=kl) {
    23702370                                                                          if (kl >=0 && subdomains[kl].ref <0 && kr >=0 && subdomains[kr].ref>=0)
    … …  
    23782378                                                                  }
    23792379                                                                 }
    2380                                                         Int4  j=0;
     2380                                                        long  j=0;
    23812381                                                        for ( i=0;i<NbSubDomains;i++)
    23822382                                                         if((-subdomains[i].ref) %2) { // good
    … …  
    24072407                                 subdomains = new SubDomain[ Gh.NbSubDomains];
    24082408                                NbSubDomains =Gh.NbSubDomains;
    2409                                 Int4 err=0;
     2409                                long err=0;
    24102410                                ReMakeTriangleContainingTheVertex();
    2411                                 Int4 * mark = new Int4[nbt];
     2411                                long * mark = new long[nbt];
    24122412                                Edge **GeometricalEdgetoEdge = MakeGeometricalEdgeToEdge();
    24132413
    24142414                                for (it=0;it<nbt;it++)
    24152415                                 mark[it]=triangles[it].link ? -1 : -2;
    2416                                 Int4 inew =0;
    2417                                 for (Int4 i=0;i<NbSubDomains;i++) {
     2416                                long inew =0;
     2417                                for (long i=0;i<NbSubDomains;i++) {
    24182418                                        GeometricalEdge &eg = *Gh.subdomains[i].edge;
    24192419                                        subdomains[i].ref = Gh.subdomains[i].ref;
    … …  
    24502450                                                                throw ErrorException(__FUNCT__,exprintf("bad definition of SubSomain %i",i));
    24512451                                                        }
    2452                                                         Int4 it = Number(t);
     2452                                                        long it = Number(t);
    24532453                                                        if (mark[it] >=0) {
    24542454                                                                break;
    … …  
    24582458                                                        inew++;
    24592459                                                        Triangle *tt=t;
    2460                                                         Int4 kkk=0;
     2460                                                        long kkk=0;
    24612461                                                        do
    24622462                                                          {
    … …  
    25952595
    25962596                // find extrema coordinates of vertices pmin,pmax
    2597                 Int4 i;
     2597                long i;
    25982598                if(verbosity>2) printf("      Filling holes in mesh of %i vertices\n",nbv);
    25992599
    … …  
    26112611
    26122612                //initialize st
    2613                 Int4* st = new Int4[nbt*3];
     2613                long* st = new long[nbt*3];
    26142614                for (i=0;i<nbt*3;i++) st[i]=-1;
    26152615
    26162616                //check number of edges
    2617                 Int4 kk =0;
     2617                long kk =0;
    26182618                for (i=0;i<nbe;i++){
    26192619                        kk=kk+(i == edge4->SortAndAdd(Number(edges[i][0]),Number(edges[i][1])));
    … …  
    26262626                for (i=0;i<nbt;i++){
    26272627                        for (int j=0;j<3;j++) {
    2628                                 Int4 k =edge4->SortAndAdd(Number(triangles[i][VerticesOfTriangularEdge[j][0]]),
     2628                                long k =edge4->SortAndAdd(Number(triangles[i][VerticesOfTriangularEdge[j][0]]),
    26292629                                                        Number(triangles[i][VerticesOfTriangularEdge[j][1]]));
    2630                                 Int4 invisible = triangles[i].Hidden(j);
     2630                                long invisible = triangles[i].Hidden(j);
    26312631                                if(st[k]==-1){
    26322632                                        st[k]=3*i+j;
    … …  
    26602660
    26612661                // check the consistant of edge[].adj and the geometrical required  vertex
    2662                 Int4 k=0;
     2662                long k=0;
    26632663                for (i=0;i<edge4->nb();i++){
    26642664                        if (st[i] >=0){ // edge alone
    26652665                                if (i < nbe) {
    2666                                         Int4 i0=edge4->i(i);
     2666                                        long i0=edge4->i(i);
    26672667                                        ordre[i0] = vertices+i0;
    2668                                         Int4 i1=edge4->j(i);
     2668                                        long i1=edge4->j(i);
    26692669                                        ordre[i1] = vertices+i1;
    26702670                                }
    … …  
    26822682
    26832683                /* mesh generation with boundary points*/
    2684                 Int4 nbvb = 0;
     2684                long nbvb = 0;
    26852685                for (i=0;i<nbv;i++){
    26862686                        vertices[i].t=0;
    … …  
    26922692
    26932693                Triangle* savetriangles= triangles;
    2694                 Int4 savenbt=nbt;
    2695                 Int4 savenbtx=nbtx;
     2694                long savenbt=nbt;
     2695                long savenbtx=nbtx;
    26962696                SubDomain * savesubdomains = subdomains;
    26972697                subdomains = 0;
    26982698
    2699                 Int4  Nbtriafillhole = 2*nbvb;
     2699                long  Nbtriafillhole = 2*nbvb;
    27002700                Triangle* triafillhole =new Triangle[Nbtriafillhole];
    27012701                triangles =  triafillhole;
    … …  
    27442744
    27452745                // We add the vertices one by one
    2746                 Int4 NbSwap=0;
    2747                 for (Int4 icount=2; icount<nbvb; icount++) {
     2746                long NbSwap=0;
     2747                for (long icount=2; icount<nbvb; icount++) {
    27482748                        Vertex *vi  = ordre[icount];
    27492749                        Icoor2 dete[3];
    … …  
    27562756                // inforce the boundary
    27572757                TriangleAdjacent ta(0,0);
    2758                 Int4 nbloss = 0,knbe=0;
     2758                long nbloss = 0,knbe=0;
    27592759                for ( i = 0; i < nbe; i++){
    27602760                        if (st[i] >=0){  // edge alone => on border ...  FH oct 2009
    … …  
    27752775                // remove all the hole
    27762776                // remove all the good sub domain
    2777                 Int4 krm =0;
     2777                long krm =0;
    27782778                for (i=0;i<nbt;i++){
    27792779                        if (triangles[i].link){ // remove triangles
    … …  
    27882788                                                Vertex *v0= ta.EdgeVertex(0);
    27892789                                                Vertex *v1= ta.EdgeVertex(1);
    2790                                                 Int4 k =edge4->SortAndAdd(v0?Number(v0):nbv,v1? Number(v1):nbv);
     2790                                                long k =edge4->SortAndAdd(v0?Number(v0):nbv,v1? Number(v1):nbv);
    27912791                                                if (st[k]<0){
    27922792                                                        throw ErrorException(__FUNCT__,exprintf("st[k]<0"));
    … …  
    27992799                        }
    28002800                }
    2801                 Int4 NbTfillHoll =0;
     2801                long NbTfillHoll =0;
    28022802                for (i=0;i<nbt;i++){
    28032803                        if (triangles[i].link) {
    … …  
    28422842                  }
    28432843                //       OutSidesTriangles = triangles;
    2844                 //      Int4 NbOutSidesTriangles = nbt;
     2844                //      long NbOutSidesTriangles = nbt;
    28452845
    28462846                // restore triangles;
    … …  
    28732873        /*}}}1*/
    28742874        /*FUNCTION Triangles::GeomToTriangles0{{{1*/
    2875         void Triangles::GeomToTriangles0(Int4 inbvx,BamgOpts* bamgopts) {
     2875        void Triangles::GeomToTriangles0(long inbvx,BamgOpts* bamgopts) {
    28762876                /*Generate mesh from geometry*/
    28772877
    … …  
    28802880                int i,j,k;
    28812881                int NbOfCurves=0,NbNewPoints,NbEdgeCurve;
    2882                 Real8 lcurve,lstep,s;
     2882                double lcurve,lstep,s;
    28832883                const int MaxSubEdge = 10;
    28842884
    … …  
    29512951
    29522952                        //initialize number of edges and number of edges max
    2953                         Int4 nbex=0;
     2953                        long nbex=0;
    29542954                        nbe=0;
    2955                         Int4 NbVerticesOnGeomEdge0=NbVerticesOnGeomEdge;
     2955                        long NbVerticesOnGeomEdge0=NbVerticesOnGeomEdge;
    29562956                        Gh.UnMarkEdges();       
    29572957                        NbOfCurves = 0;
    … …  
    29702970                                                if (!ei.Mark() && ei[j].Required()) {
    29712971                                                        // warning ei.Mark() can be change in loop for(j=0;j<2;j++)
    2972                                                         Int4 nbvend=0;
     2972                                                        long nbvend=0;
    29732973                                                        Edge* PreviousNewEdge=NULL;
    29742974
    … …  
    30313031                                                                                Metric MA = background ? BTh.MetricAt(a->r) :a->m ;  //Get metric associated to A
    30323032                                                                                Metric MB =  background ? BTh.MetricAt(b->r) :b->m ; //Get metric associated to B
    3033                                                                                 Real8 ledge = (MA(AB) + MB(AB))/2;                   //Get edge length in metric
     3033                                                                                double ledge = (MA(AB) + MB(AB))/2;                   //Get edge length in metric
    30343034
    30353035                                                                                /* We are now creating the edges of the mesh from the
    … …  
    30433043
    30443044                                                                                //initialize lSubEdge, holding the length of each subedge (cannot be higher than 10)
    3045                                                                                 Real8 lSubEdge[MaxSubEdge];
     3045                                                                                double lSubEdge[MaxSubEdge];
    30463046
    30473047                                                                                //Build Subedges according to the edge length
    … …  
    30573057                                                                                        Metric MAs=MA,MBs;
    30583058                                                                                        ledge=0;
    3059                                                                                         Real8 x =0, xstep= 1./NbSubEdge;
     3059                                                                                        double x =0, xstep= 1./NbSubEdge;
    30603060                                                                                        for (int kk=0; kk < NbSubEdge; kk++,A=B,MAs=MBs ) {
    30613061                                                                                                x += xstep;
    … …  
    30673067                                                                                }
    30683068
    3069                                                                                 Real8 lcurveb = lcurve+ ledge ;
     3069                                                                                double lcurveb = lcurve+ ledge ;
    30703070
    30713071                                                                                //Now, create corresponding points
    … …  
    30733073                                                                                while (lcurve<=s && s <= lcurveb && nbv < nbvend){
    30743074
    3075                                                                                         Real8 ss = s-lcurve;
     3075                                                                                        double ss = s-lcurve;
    30763076
    30773077                                                                                        /*Find the SubEdge containing ss using Dichotomy*/
    30783078
    30793079                                                                                        int kk0=-1,kk1=NbSubEdge-1,kkk;
    3080                                                                                         Real8 ll0=0,ll1=ledge,llk;
     3080                                                                                        double ll0=0,ll1=ledge,llk;
    30813081                                                                                        while (kk1-kk0>1){
    30823082                                                                                                if (ss < (llk=lSubEdge[kkk=(kk0+kk1)/2]))
    … …  
    30893089                                                                                        }
    30903090
    3091                                                                                         Real8 sbb = (ss-ll0  )/(ll1-ll0);
    3092                                                                                         Real8 bb = (kk1+sbb)/NbSubEdge, aa=1-bb;
     3091                                                                                        double sbb = (ss-ll0  )/(ll1-ll0);
     3092                                                                                        double bb = (kk1+sbb)/NbSubEdge, aa=1-bb;
    30933093
    30943094                                                                                        // new vertex on edge
    … …  
    30973097                                                                                        vb->ReferenceNumber = e->ref;
    30983098                                                                                        vb->DirOfSearch =NoDirOfSearch;
    3099                                                                                         Real8 abcisse = k ? bb : aa;
     3099                                                                                        double abcisse = k ? bb : aa;
    31003100                                                                                        vb->r =  e->F( abcisse );
    31013101                                                                                        VerticesOnGeomEdge[NbVerticesOnGeomEdge++]= VertexOnGeom(*vb,*e,abcisse);       
    … …  
    31253125                                                                        }// for(;;)
    31263126                                                                        vb = b->to;
    3127                                                                         NbEdgeCurve = Max((Int4) (lcurve +0.5), (Int4) 1);
     3127                                                                        NbEdgeCurve = Max((long) (lcurve +0.5), (long) 1);
    31283128                                                                        NbNewPoints = NbEdgeCurve-1;
    31293129                                                                        if(!kstep){
    … …  
    31913191        /*}}}1*/
    31923192        /*FUNCTION Triangles::GeomToTriangles1{{{1*/
    3193         void Triangles::GeomToTriangles1(Int4 inbvx,BamgOpts* bamgopts,int KeepVertices){
     3193        void Triangles::GeomToTriangles1(long inbvx,BamgOpts* bamgopts,int KeepVertices){
    31943194
    31953195                /*Get options*/
    … …  
    32313231                //  and if you do the loop in background we have the pointeur on geometry
    32323232                // so do the walk on  background
    3233                 //  Int4 NbVerticesOnGeomVertex;
     3233                //  long NbVerticesOnGeomVertex;
    32343234                //  VertexOnGeom * VerticesOnGeomVertex; 
    3235                 //  Int4 NbVerticesOnGeomEdge;
     3235                //  long NbVerticesOnGeomEdge;
    32363236                //  VertexOnGeom * VerticesOnGeomEdge;
    32373237
    … …  
    33143314                //  1.0)  recompute the length
    33153315                //  1.1)   compute the  vertex
    3316                 Int4 nbex=0,NbVerticesOnGeomEdgex=0;
     3316                long nbex=0,NbVerticesOnGeomEdgex=0;
    33173317                for (int step=0; step <2;step++)
    33183318                  {
    3319                         Int4 NbOfNewPoints=0;
    3320                         Int4 NbOfNewEdge=0;
    3321                         Int4 iedge;
     3319                        long NbOfNewPoints=0;
     3320                        long NbOfNewEdge=0;
     3321                        long iedge;
    33223322                        Gh.UnMarkEdges();       
    3323                         Real8 L=0;
     3323                        double L=0;
    33243324                        for (int icurve=0;icurve<Gh.NbOfCurves;icurve++)
    33253325                          {
    … …  
    33323332                                // new curve 
    33333333                                // good the find a starting edge
    3334                                 Real8 Lstep=0,Lcurve=0;// step between two points   (phase==1)
    3335                                 Int4 NbCreatePointOnCurve=0;// Nb of new points on curve     (phase==1)
     3334                                double Lstep=0,Lcurve=0;// step between two points   (phase==1)
     3335                                long NbCreatePointOnCurve=0;// Nb of new points on curve     (phase==1)
    33363336
    33373337                                for(int phase=0;phase<=step;phase++)
    … …  
    33553355                                                GeometricalEdge *ongequi = peequi->onGeometry;
    33563356
    3357                                                 Real8 sNew=Lstep;// abcisse of the new points (phase==1)
     3357                                                double sNew=Lstep;// abcisse of the new points (phase==1)
    33583358                                                L=0;// length of the curve
    3359                                                 Int4 i=0;// index of new points on the curve
     3359                                                long i=0;// index of new points on the curve
    33603360                                                register GeometricalVertex * GA0 = *(*peequi)[k0equi].onGeometry;
    33613361                                                Vertex *A0;
    … …  
    33863386                                                         Vertex & v0=ee[0], & v1=ee[1];
    33873387                                                         R2 AB= (R2) v1 - (R2) v0;
    3388                                                          Real8 L0=L,LAB;
     3388                                                         double L0=L,LAB;
    33893389                                                         LAB =  LengthInterpole(v0.m,v1.m,AB);
    33903390                                                         L+= LAB;   
    … …  
    34103410                                                                         GA1=VerticesOnGeomEdge+NbVerticesOnGeomEdge;
    34113411                                                                         Edge *e = edges + nbe++;
    3412                                                                          Real8 se= (sNew-L0)/LAB;
     3412                                                                         double se= (sNew-L0)/LAB;
    34133413                                                                         if (se<0 || se>=1.000000001){
    34143414                                                                                 throw ErrorException(__FUNCT__,exprintf("se<0 || se>=1.000000001"));
    … …  
    34843484
    34853485                                        if (!phase)  { //
    3486                                                 Int4 NbSegOnCurve = Max((Int4)(L+0.5),(Int4) 1);// nb of seg
     3486                                                long NbSegOnCurve = Max((long)(L+0.5),(long) 1);// nb of seg
    34873487                                                Lstep = L/NbSegOnCurve;
    34883488                                                Lcurve = L;
    … …  
    35733573                 *  [0 nbv[ all distincts*/
    35743574                for (i=0;i<nbv;i++) ordre[i]= &vertices[i] ;
    3575                 const Int4 PrimeNumber= AGoodNumberPrimeWith(nbv) ;
     3575                const long PrimeNumber= AGoodNumberPrimeWith(nbv) ;
    35763576                int   k0=rand()%nbv;
    35773577                for (int is3=0; is3<nbv; is3++){
    … …  
    36303630                /*Now, add the vertices One by One*/
    36313631
    3632                 Int4 NbSwap=0;
     3632                long NbSwap=0;
    36333633                if (verbosity>3) printf("   Begining of insertion process...\n");
    36343634
    3635                 for (Int4 icount=2; icount<nbv; icount++) {
     3635                for (long icount=2; icount<nbv; icount++) {
    36363636
    36373637                        //Get new vertex
    … …  
    36653665
    36663666                for(int Nbloop=0;Nbloop<NBLOOPOPTIM;Nbloop++){
    3667                         Int4  NbSwap = 0;
     3667                        long  NbSwap = 0;
    36683668                        for (int is1=0; is1<nbv; is1++)
    36693669                         NbSwap += ordre[is1]->Optim(0,0);
    … …  
    36803680        /*}}}1*/
    36813681        /*FUNCTION Triangles::InsertNewPoints{{{1*/
    3682         Int4 Triangles::InsertNewPoints(Int4 nbvold,Int4 & NbTSwap) {
     3682        long Triangles::InsertNewPoints(long nbvold,long & NbTSwap) {
    36833683
    36843684                long int verbosity=0;
    3685                 Real8 seuil= 1.414/2 ;// for two close point
    3686                 Int4 i;
    3687                 Int4 NbSwap=0;
     3685                double seuil= 1.414/2 ;// for two close point
     3686                long i;
     3687                long NbSwap=0;
    36883688                Icoor2 dete[3];
    36893689
    36903690                //number of new points
    3691                 const Int4 nbvnew=nbv-nbvold;
     3691                const long nbvnew=nbv-nbvold;
    36923692
    36933693                //display info if required
    … …  
    36983698
    36993699                /*construction of a random order*/
    3700                 const Int4 PrimeNumber= AGoodNumberPrimeWith(nbv)  ;
     3700                const long PrimeNumber= AGoodNumberPrimeWith(nbv)  ;
    37013701                //remainder of the division of rand() by nbvnew
    3702                 Int4 k3 = rand()%nbvnew;
     3702                long k3 = rand()%nbvnew;
    37033703                //loop over the new points
    3704                 for (Int4 is3=0; is3<nbvnew; is3++){
    3705                         register Int4 j=nbvold +(k3 = (k3+PrimeNumber)%nbvnew);
    3706                         register Int4 i=nbvold+is3;
     3704                for (long is3=0; is3<nbvnew; is3++){
     3705                        register long j=nbvold +(k3 = (k3+PrimeNumber)%nbvnew);
     3706                        register long i=nbvold+is3;
    37073707                        ordre[i]= vertices + j;
    37083708                        ordre[i]->ReferenceNumber=i;
    … …  
    37103710
    37113711                // for all the new point
    3712                 Int4 iv=nbvold;
     3712                long iv=nbvold;
    37133713                for (i=nbvold;i<nbv;i++){
    37143714                        Vertex &vi=*ordre[i];
    … …  
    37213721                                // a good new point
    37223722                                Vertex &vj = vertices[iv];
    3723                                 Int4  j=vj.ReferenceNumber;
     3723                                long  j=vj.ReferenceNumber;
    37243724                                if (&vj!=ordre[j]){
    37253725                                        throw ErrorException(__FUNCT__,exprintf("&vj!= ordre[j]"));
    … …  
    37623762        Edge **e= new (Edge* [Gh.nbe]);
    37633763
    3764         Int4 i;
     3764        long i;
    37653765        for ( i=0;i<Gh.nbe ; i++)
    37663766         e[i]=NULL;
    … …  
    38073807
    38083808
    3809                         Int4 nbqq = (nbt*3)/2;
    3810                         DoubleAndInt4  *qq = new DoubleAndInt4[nbqq];
    3811 
    3812                         Int4 i,ij;
     3809                        long nbqq = (nbt*3)/2;
     3810                        DoubleAndInt4 *qq = new DoubleAndInt4[nbqq];
     3811
     3812                        long i,ij;
    38133813                        int j;
    3814                         Int4 k=0;
     3814                        long k=0;
    38153815                        for (i=0;i<nbt;i++)
    38163816                         for (j=0;j<3;j++)
    … …  
    38203820                        HeapSort(qq,k);
    38213821
    3822                         Int4 kk=0;
     3822                        long kk=0;
    38233823                        for (ij=0;ij<k;ij++) {
    38243824                                i=qq[ij].i3j/3;
    … …  
    38453845/*}}}1*/
    38463846/*FUNCTION Triangles::MaxSubDivision{{{1*/
    3847 void  Triangles::MaxSubDivision(Real8 maxsubdiv) {
     3847void  Triangles::MaxSubDivision(double maxsubdiv) {
    38483848        long int verbosity=0;
    38493849
    3850         const  Real8 maxsubdiv2 = maxsubdiv*maxsubdiv;
     3850        const  double maxsubdiv2 = maxsubdiv*maxsubdiv;
    38513851        if(verbosity>1) printf("   Limit the subdivision of a edges in the new mesh by %g\n",maxsubdiv);
    38523852        // for all the edges
    38533853        // if the len of the edge is to long
    3854         Int4 it,nbchange=0;   
    3855         Real8 lmax=0;
     3854        long it,nbchange=0;   
     3855        double lmax=0;
    38563856        for (it=0;it<nbt;it++)
    38573857          {
    … …  
    38663866                                R2 AB= (R2) v1-(R2) v0;
    38673867                                Metric M = v0;
    3868                                 Real8 l = M(AB,AB);
     3868                                double l = M(AB,AB);
    38693869                                lmax = Max(lmax,l);
    38703870                                if(l> maxsubdiv2)
    38713871                                  { R2 AC = M.Orthogonal(AB);// the ortogonal vector of AB in M
    3872                                         Real8 lc = M(AC,AC);
     3872                                        double lc = M(AC,AC);
    38733873                                        D2xD2 Rt(AB,AC);// Rt.x = AB , Rt.y = AC;
    38743874                                        D2xD2 Rt1(Rt.inv());
    … …  
    38833883                                if(l> maxsubdiv2)
    38843884                                  { R2 AC = M.Orthogonal(AB);// the ortogonal vector of AB in M
    3885                                         Real8 lc = M(AC,AC);
     3885                                        double lc = M(AC,AC);
    38863886                                        D2xD2 Rt(AB,AC);// Rt.x = AB , Rt.y = AC;
    38873887                                        D2xD2 Rt1(Rt.inv());
    … …  
    39113911                        return Metric(ba,*edge.EdgeVertex(0),bb,*edge.EdgeVertex(1));}
    39123912                else { // inside
    3913                         Real8   aa[3];
    3914                         Real8 s = deta[0]+deta[1]+deta[2];
     3913                        double   aa[3];
     3914                        double s = deta[0]+deta[1]+deta[2];
    39153915                        aa[0]=deta[0]/s;
    39163916                        aa[1]=deta[1]/s;
    … …  
    39293929
    39303930                int i,j,k;
    3931                 Int4 NbTSwap=0;
    3932                 Int4 nbtold=nbt;
    3933                 Int4 nbvold=nbv;
    3934                 Int4 Headt=0;
    3935                 Int4 next_t;
    3936                 Int4* first_np_or_next_t=new Int4[nbtx];
     3931                long NbTSwap=0;
     3932                long nbtold=nbt;
     3933                long nbvold=nbv;
     3934                long Headt=0;
     3935                long next_t;
     3936                long* first_np_or_next_t=new long[nbtx];
    39373937                Triangle* t=NULL;
    39383938
    … …  
    40184018                                TriangleAdjacent ta(s->t, EdgesVertexTriangle[s->vint][1]);
    40194019                                Triangle*        tbegin= (Triangle*) ta;
    4020                                 Int4 kt;
     4020                                long kt;
    40214021                                do {
    40224022                                        kt = Number((Triangle*) ta);
    … …  
    40364036                delete []  first_np_or_next_t;
    40374037
    4038                 Int4 NbSwapf =0,NbSwp;
     4038                long NbSwapf =0,NbSwp;
    40394039
    40404040                NbSwp = NbSwapf;
    … …  
    40454045        /*}}}1*/
    40464046/*FUNCTION Triangles::PreInit{{{1*/
    4047 void Triangles::PreInit(Int4 inbvx) {
     4047void Triangles::PreInit(long inbvx) {
    40484048        long int verbosity=0;
    40494049
    … …  
    41034103        /*FUNCTION Triangles::ProjectOnCurve{{{1*/
    41044104        GeometricalEdge*   Triangles::ProjectOnCurve( Edge & BhAB, Vertex &  vA, Vertex & vB,
    4105                                 Real8 theta,Vertex & R,VertexOnEdge &  BR,VertexOnGeom & GR) {
     4105                                double theta,Vertex & R,VertexOnEdge &  BR,VertexOnGeom & GR) {
    41064106                void *pA=0,*pB=0;
    4107                 Real8 tA=0,tB=0;
     4107                double tA=0,tB=0;
    41084108                R2 A=vA,B=vB;
    41094109                Vertex * pvA=&vA, * pvB=&vB;
    … …  
    41664166                R2 AB=B-A;
    41674167
    4168                 Real8 cosE01AB = (( (R2) (*e)[1] - (R2) (*e)[0] ) , AB);
     4168                double cosE01AB = (( (R2) (*e)[1] - (R2) (*e)[0] ) , AB);
    41694169                int kkk=0;
    41704170                int sens = (cosE01AB>0) ? 1 : 0;
    41714171
    4172                 //   Real8 l=0; // length of the edge AB
    4173                 Real8 abscisse = -1;
     4172                //   double l=0; // length of the edge AB
     4173                double abscisse = -1;
    41744174
    41754175                for (int cas=0;cas<2;cas++){
    … …  
    41804180                        Vertex  *v0=pvA,*v1;
    41814181                        Edge *neee,*eee;
    4182                         Real8 lg =0; // length of the curve
    4183                         Real8 te0;
     4182                        double lg =0; // length of the curve
     4183                        double te0;
    41844184                        // we suppose take the curve's abcisse
    41854185                        for ( eee=e,iii=sens,te0=tA;
    … …  
    41944194                                        throw ErrorException(__FUNCT__,exprintf("!eee"));
    41954195                                }
    4196                                 Real8 lg0 = lg;
    4197                                 Real8 dp = LengthInterpole(v0->m,v1->m,(R2) *v1 - (R2) *v0);
     4196                                double lg0 = lg;
     4197                                double dp = LengthInterpole(v0->m,v1->m,(R2) *v1 - (R2) *v0);
    41984198                                lg += dp;
    41994199                                if (cas && abscisse <= lg) { // ok we find the geom edge
    4200                                         Real8 sss  =   (abscisse-lg0)/dp;
    4201                                         Real8 thetab = te0*(1-sss)+ sss*iii;
     4200                                        double sss  =   (abscisse-lg0)/dp;
     4201                                        double thetab = te0*(1-sss)+ sss*iii;
    42024202                                        if (thetab<0 || thetab>1){
    42034203                                                throw ErrorException(__FUNCT__,exprintf("thetab<0 || thetab>1"));
    … …  
    42124212                                 tB = iii;
    42134213
    4214                                 Real8 lg0 = lg;
     4214                                double lg0 = lg;
    42154215                                if (!eee){
    42164216                                        throw ErrorException(__FUNCT__,exprintf("!eee"));
    42174217                                }
    42184218                                v1 = pvB;
    4219                                 Real8 dp = LengthInterpole(v0->m,v1->m,(R2) *v1 - (R2) *v0);
     4219                                double dp = LengthInterpole(v0->m,v1->m,(R2) *v1 - (R2) *v0);
    42204220                                lg += dp;       
    42214221                                abscisse = lg*theta;
    42224222                                if (abscisse <= lg && abscisse >= lg0 ) // small optimisation we know the lenght because end
    42234223                                  { // ok we find the geom edge
    4224                                         Real8 sss  =   (abscisse-lg0)/dp;
    4225                                         Real8 thetab = te0*(1-sss)+ sss*tB;
     4224                                        double sss  =   (abscisse-lg0)/dp;
     4225                                        double thetab = te0*(1-sss)+ sss*tB;
    42264226                                        if (thetab<0 || thetab>1){
    42274227                                                throw ErrorException(__FUNCT__,exprintf("thetab<0 || thetab>1"));
    … …  
    43214321        void Triangles::ReNumberingTheTriangleBySubDomain(bool justcompress) {
    43224322                long int verbosity=0;
    4323                 Int4 *renu= new Int4[nbt];
     4323                long *renu= new long[nbt];
    43244324                register Triangle *t0,*t,*te=triangles+nbt;
    4325                 register Int4 k=0,it,i,j;
     4325                register long k=0,it,i,j;
    43264326
    43274327                for ( it=0;it<nbt;it++)
    … …  
    43344334                        }
    43354335                        do {
    4336                                 Int4 kt = Number(t);
     4336                                long kt = Number(t);
    43374337                                if (kt<0 || kt >= nbt ){
    43384338                                        throw ErrorException(__FUNCT__,exprintf("kt<0 || kt >= nbt"));
    … …  
    43874387        /*}}}1*/
    43884388        /*FUNCTION Triangles::ReNumberingVertex{{{1*/
    4389         void Triangles::ReNumberingVertex(Int4 * renu) {
     4389        void Triangles::ReNumberingVertex(long * renu) {
    43904390                // warning be carfull because pointeur
    43914391                // from on mesh to over mesh
    43924392                //  --  so do ReNumbering a the beginning
    43934393                Vertex * ve = vertices+nbv;
    4394                 Int4 it,ie,i;
     4394                long it,ie,i;
    43954395
    43964396                for ( it=0;it<nbt;it++)
    … …  
    44304430                // move the Vertices without a copy of the array
    44314431                // be carefull not trivial code
    4432                 Int4 j;
     4432                long j;
    44334433                for ( it=0;it<nbv;it++) // for all sub cycles of the permutation renu
    44344434                 if (renu[it] >= 0) // a new sub cycle
    … …  
    44614461        pmin =  vertices[0].r;
    44624462        pmax =  vertices[0].r;
    4463         Int4 i;
     4463        long i;
    44644464        for (i=0;i<nbv;i++) {
    44654465                pmin.x = Min(pmin.x,vertices[i].r.x);
    … …  
    45114511/*FUNCTION Triangles::ShowRegulaty{{{1*/
    45124512void  Triangles::ShowRegulaty() const {
    4513         const  Real8  sqrt32=sqrt(3.)*0.5;
    4514         const Real8  aireKh=sqrt32*0.5;
     4513        const  double  sqrt32=sqrt(3.)*0.5;
     4514        const double  aireKh=sqrt32*0.5;
    45154515        D2  Beq(1,0),Heq(0.5,sqrt32);
    45164516        D2xD2 Br(D2xD2(Beq,Heq).t());
    … …  
    45224522        double  alpha2=0;
    45234523        double area=0,Marea=0;
    4524         // Real8 cf= Real8(coefIcoor);
    4525         // Real8 cf2= 6.*cf*cf;
     4524        // double cf= double(coefIcoor);
     4525        // double cf2= 6.*cf*cf;
    45264526        int nt=0;
    45274527        for (int it=0;it<nbt;it++)
    … …  
    45304530                 nt++;
    45314531                 Triangle &K=triangles[it];
    4532                  Real8  area3= Area2((R2) K[0],(R2) K[1],(R2) K[2])/6.;
     4532                 double  area3= Area2((R2) K[0],(R2) K[1],(R2) K[2])/6.;
    45334533                 area+= area3;
    45344534                 D2xD2 B_Kt(K[0],K[1],K[2]);
    … …  
    45404540                 MatVVP2x2 VMK(MK);
    45414541                 alpha2 = Max(alpha2,Max(VMK.lambda1/VMK.lambda2,VMK.lambda2/VMK.lambda1));
    4542                  Real8 betaK=0;
     4542                 double betaK=0;
    45434543
    45444544                 for (int j=0;j<3;j++)
    45454545                        {
    4546                          Real8 he= Norme2(R2(K[j],K[(j+1)%3]));
     4546                         double he= Norme2(R2(K[j],K[(j+1)%3]));
    45474547                         hmin=Min(hmin,he);
    45484548                         hmax=Max(hmax,he);
    … …  
    45764576void  Triangles::ShowHistogram() const {
    45774577
    4578         const Int4 kmax=10;
    4579         const Real8 llmin = 0.5,llmax=2;
    4580         const Real8 lmin=log(llmin),lmax=log(llmax),delta= kmax/(lmax-lmin);
    4581         Int4 histo[kmax+1];
    4582         Int4 i,it,k, nbedges =0;
     4578        const long kmax=10;
     4579        const double llmin = 0.5,llmax=2;
     4580        const double lmin=log(llmin),lmax=log(llmax),delta= kmax/(lmax-lmin);
     4581        long histo[kmax+1];
     4582        long i,it,k, nbedges =0;
    45834583        for (i=0;i<=kmax;i++) histo[i]=0;
    45844584        for (it=0;it<nbt;it++)
    … …  
    45954595                                 if ( !& vP || !&vQ) continue;
    45964596                                 R2 PQ = vQ.r - vP.r;
    4597                                  Real8 l = log(LengthInterpole(vP,vQ,PQ));
     4597                                 double l = log(LengthInterpole(vP,vQ,PQ));
    45984598                                 nbedges++;
    45994599                                 k = (int) ((l - lmin)*delta);
    … …  
    46184618/*}}}1*/
    46194619/*FUNCTION Triangles::SmoothingVertex{{{1*/
    4620 void Triangles::SmoothingVertex(int nbiter,Real8 omega ) {
     4620void Triangles::SmoothingVertex(int nbiter,double omega ) {
    46214621        long int verbosity=0;
    46224622        //  if quatree exist remove it end reconstruct
    … …  
    46264626        Triangle vide; // a triangle to mark the boundary vertex
    46274627        Triangle   ** tstart= new Triangle* [nbv];
    4628         Int4 i,j,k;
     4628        long i,j,k;
    46294629        //   attention si Background == Triangle alors on ne peut pas utiliser la rechech rapide
    46304630        if ( this == & BTh)
    … …  
    46414641        for (k=0;k<nbiter;k++)
    46424642          {
    4643                 Int4 i,NbSwap =0;
    4644                 Real8 delta =0;
     4643                long i,NbSwap =0;
     4644                double delta =0;
    46454645                for ( i=0;i<nbv;i++)
    46464646                 if (tstart[i] != &vide) // not a boundary vertex
    … …  
    46584658/*}}}1*/
    46594659/*FUNCTION Triangles::SmoothMetric{{{1*/
    4660 void Triangles::SmoothMetric(Real8 raisonmax) {
     4660void Triangles::SmoothMetric(double raisonmax) {
    46614661        long int verbosity=0;
    46624662
    … …  
    46644664        if(verbosity > 1) printf("   Triangles::SmoothMetric raisonmax = %g\n",raisonmax);
    46654665        ReMakeTriangleContainingTheVertex();
    4666         Int4 i,j,kch,kk,ip;
    4667         Int4 *first_np_or_next_t0 = new Int4[nbv];
    4668         Int4 *first_np_or_next_t1 = new Int4[nbv];
    4669         Int4 Head0 =0,Head1=-1;
    4670         Real8 logseuil= log(raisonmax);
     4666        long i,j,kch,kk,ip;
     4667        long *first_np_or_next_t0 = new long[nbv];
     4668        long *first_np_or_next_t1 = new long[nbv];
     4669        long Head0 =0,Head1=-1;
     4670        double logseuil= log(raisonmax);
    46714671
    46724672        for(i=0;i<nbv-1;i++)
    … …  
    46994699                                        }
    47004700                                        R2 Aij = (R2) vj - (R2) vi;
    4701                                         Real8 ll =  Norme2(Aij);
     4701                                        double ll =  Norme2(Aij);
    47024702                                        if (0) { 
    4703                                                 Real8 hi = ll/vi.m(Aij);
    4704                                                 Real8 hj = ll/vj.m(Aij);
     4703                                                double hi = ll/vi.m(Aij);
     4704                                                double hj = ll/vj.m(Aij);
    47054705                                                if(hi < hj)
    47064706                                                  {
    4707                                                         Real8 dh=(hj-hi)/ll;
     4707                                                        double dh=(hj-hi)/ll;
    47084708                                                        if (dh>logseuil) {
    47094709                                                                vj.m.IntersectWith(vi.m/(1 +logseuil*ll/hi));
    … …  
    47154715                                        else
    47164716                                          {
    4717                                                 Real8 li = vi.m(Aij);
     4717                                                double li = vi.m(Aij);
    47184718                                                if( vj.m.IntersectWith(vi.m/(1 +logseuil*li)) )
    47194719                                                 if(first_np_or_next_t1[j]<0) // if the metrix change
    … …  
    47424742                ReNumberingTheTriangleBySubDomain();
    47434743                //int nswap =0;
    4744                 const Int4 nfortria( choice ? 4 : 6);
     4744                const long nfortria( choice ? 4 : 6);
    47454745                if(withBackground)
    47464746                  {
    … …  
    47514751                 BTh.SetVertexFieldOn();
    47524752
    4753                 Int4 newnbt=0,newnbv=0;
    4754                 Int4 * kedge = 0;
    4755                 Int4 newNbOfQuad=NbOfQuad;
    4756                 Int4 * ksplit= 0, * ksplitarray=0;
    4757                 Int4 kkk=0;
     4753                long newnbt=0,newnbv=0;
     4754                long * kedge = 0;
     4755                long newNbOfQuad=NbOfQuad;
     4756                long * ksplit= 0, * ksplitarray=0;
     4757                long kkk=0;
    47584758                int ret =0;
    47594759                if (nbvx<nbv+nbe) return 1;//   
    47604760                // 1) create  the new points by spliting the internal edges
    47614761                // set the
    4762                 Int4 nbvold = nbv;
    4763                 Int4 nbtold = nbt;
    4764                 Int4 NbOutTold  = NbOutT;
    4765                 Int4  NbEdgeOnGeom=0;
    4766                 Int4 i;
     4762                long nbvold = nbv;
     4763                long nbtold = nbt;
     4764                long NbOutTold  = NbOutT;
     4765                long  NbEdgeOnGeom=0;
     4766                long i;
    47674767
    47684768                nbt = nbt - NbOutT; // remove all the  the ouside triangles
    4769                 Int4 nbtsave = nbt;
     4769                long nbtsave = nbt;
    47704770                Triangle * lastT = triangles + nbt;
    47714771                for (i=0;i<nbe;i++)
    47724772                 if(edges[i].onGeometry) NbEdgeOnGeom++;
    4773                 Int4 newnbe=nbe+nbe;
    4774                 //  Int4 newNbVerticesOnGeomVertex=NbVerticesOnGeomVertex;
    4775                 Int4 newNbVerticesOnGeomEdge=NbVerticesOnGeomEdge+NbEdgeOnGeom;
    4776                 // Int4 newNbVertexOnBThVertex=NbVertexOnBThVertex;
    4777                 Int4 newNbVertexOnBThEdge=withBackground ? NbVertexOnBThEdge+NbEdgeOnGeom:0;
     4773                long newnbe=nbe+nbe;
     4774                //  long newNbVerticesOnGeomVertex=NbVerticesOnGeomVertex;
     4775                long newNbVerticesOnGeomEdge=NbVerticesOnGeomEdge+NbEdgeOnGeom;
     4776                // long newNbVertexOnBThVertex=NbVertexOnBThVertex;
     4777                long newNbVertexOnBThEdge=withBackground ? NbVertexOnBThEdge+NbEdgeOnGeom:0;
    47784778
    47794779                // do allocation for pointeur to the geometry and background
    … …  
    47874787                //  memcpy(newedges,edges,sizeof(Edge)*nbe);
    47884788                SetOfEdges4 * edge4= new SetOfEdges4(nbe,nbv);
    4789                 Int4 k=nbv;
    4790                 Int4 kk=0;
    4791                 Int4 kvb = NbVertexOnBThEdge;
    4792                 Int4 kvg = NbVerticesOnGeomEdge;
    4793                 Int4 ie =0;
     4789                long k=nbv;
     4790                long kk=0;
     4791                long kvb = NbVertexOnBThEdge;
     4792                long kvg = NbVerticesOnGeomEdge;
     4793                long ie =0;
    47944794                Edge ** edgesGtoB=0;
    47954795                if (withBackground)
    47964796                 edgesGtoB= BTh.MakeGeometricalEdgeToEdge();
    4797                 Int4 ferr=0;
     4797                long ferr=0;
    47984798                for (i=0;i<nbe;i++)
    47994799                 newedges[ie].onGeometry=0;
    … …  
    48284828                                        ;
    48294829                                        // get the Info on background mesh
    4830                                         Real8 s =        newVertexOnBThEdge[kvb];
     4830                                        double s =        newVertexOnBThEdge[kvb];
    48314831                                        Vertex &  bv0  = newVertexOnBThEdge[kvb][0];
    48324832                                        Vertex &  bv1  = newVertexOnBThEdge[kvb][1];
    … …  
    48784878
    48794879
    4880                 kedge = new Int4[3*nbt+1];
    4881                 ksplitarray = new Int4[nbt+1];
     4880                kedge = new long[3*nbt+1];
     4881                ksplitarray = new long[nbt+1];
    48824882                ksplit = ksplitarray +1; // because ksplit[-1] == ksplitarray[0]
    48834883
    … …  
    49004900                                const Vertex & v0 = t[VerticesOfTriangularEdge[j][0]];
    49014901                                const Vertex & v1 = t[VerticesOfTriangularEdge[j][1]];
    4902                                 Int4  ke =edge4->SortAndFind(Number(v0),Number(v1));
     4902                                long  ke =edge4->SortAndFind(Number(v0),Number(v1));
    49034903                                if (ke>0)
    49044904                                  {
    4905                                         Int4 ii = Number(tt);
     4905                                        long ii = Number(tt);
    49064906                                        int  jj = ta;
    4907                                         Int4 ks = ke + nbvold;
     4907                                        long ks = ke + nbvold;
    49084908                                        kedge[3*i+j] = ks;
    49094909                                        if (ii<nbt) // good triangle
    49104910                                         kedge[3*ii+jj] = ks;
    49114911                                        Vertex &A=vertices[ks];
    4912                                         Real8 aa,bb,cc,dd;
     4912                                        double aa,bb,cc,dd;
    49134913                                        if ((dd=Area2(v0.r,v1.r,A.r)) >=0){
    49144914                                                // warning PB roundoff error
    … …  
    49514951                                if ( kedge[3*i+j] < 0)
    49524952                                  {
    4953                                         Int4  ke =edge4->SortAndFind(Number(v0),Number(v1));
     4953                                        long  ke =edge4->SortAndFind(Number(v0),Number(v1));
    49544954                                        if (ke<0) // new
    49554955                                          {
    49564956                                                if (&tt) // internal triangles all the boundary
    49574957                                                  { // new internal edges
    4958                                                         Int4 ii = Number(tt);
     4958                                                        long ii = Number(tt);
    49594959                                                        int  jj = ta;
    49604960
    … …  
    50105010                for (i=0;i<nbtsave;i++){
    50115011                        int  nbmkadj=0;
    5012                         Int4 mkadj [100];
     5012                        long mkadj [100];
    50135013                        mkadj[0]=i;
    5014                         Int4 kk=ksplit[i]/10;
     5014                        long kk=ksplit[i]/10;
    50155015                        int  ke=(int) (ksplit[i]%10);
    50165016                        if (kk>=7 || kk<=0){
    … …  
    51405140                                                                        vertices[nbv].DirOfSearch =NoDirOfSearch;
    51415141                                                                        //vertices[nbv].i = toI2(vertices[nbv].r);
    5142                                                                         Real8 a3[]={1./3.,1./3.,1./3.};
     5142                                                                        double a3[]={1./3.,1./3.,1./3.};
    51435143                                                                        vertices[nbv].m = Metric(a3,v0->m,v1->m,v2->m);
    51445144                                                                        Vertex * vc =  vertices +nbv++;
    … …  
    51585158                        // save all the new triangles
    51595159                        mkadj[nbmkadj++]=i;
    5160                         Int4 jj;
     5160                        long jj;
    51615161                        if (t0.link)
    51625162                         for (jj=nbt;jj<kkk;jj++)
    … …  
    52015201                for (i=0;i<NbSubDomains;i++)
    52025202                  {
    5203                         Int4 k = subdomains[i].edge- edges;
     5203                        long k = subdomains[i].edge- edges;
    52045204                        subdomains[i].edge =  edges+2*k; // spilt all edge in 2
    52055205                  }
    … …  
    52425242        /*}}}1*/
    52435243/*FUNCTION Triangles::SplitInternalEdgeWithBorderVertices{{{1*/
    5244 Int4  Triangles::SplitInternalEdgeWithBorderVertices(){
    5245         Int4 NbSplitEdge=0;
     5244long  Triangles::SplitInternalEdgeWithBorderVertices(){
     5245        long NbSplitEdge=0;
    52465246        SetVertexFieldOn(); 
    5247         Int4 it;
    5248         Int4 nbvold=nbv;
     5247        long it;
     5248        long nbvold=nbv;
    52495249        long int verbosity=2;
    52505250        for (it=0;it<nbt;it++){
    … …  
    52735273        ReMakeTriangleContainingTheVertex();   
    52745274        if (nbvold!=nbv){
    5275                 Int4  iv = nbvold;
    5276                 Int4 NbSwap = 0;
     5275                long  iv = nbvold;
     5276                long NbSwap = 0;
    52775277                Icoor2 dete[3]; 
    5278                 for (Int4 i=nbvold;i<nbv;i++) {// for all the new point
     5278                for (long i=nbvold;i<nbv;i++) {// for all the new point
    52795279                        Vertex & vi = vertices[i];
    52805280                        vi.i = toI2(vi.r);
    … …  
    53115311/*}}}1*/
    53125312/*FUNCTION Triangles::TriangleReferenceList{{{1*/
    5313 Int4  Triangles::TriangleReferenceList(Int4* reft) const {
     5313long  Triangles::TriangleReferenceList(long* reft) const {
    53145314        long int verbosity=0;
    53155315        register Triangle *t0,*t;
    5316         register Int4 k=0, num;   
     5316        register long k=0, num;   
    53175317
    53185318        //initialize all triangles as -1 (outside)
    5319         for (Int4 it=0;it<nbt;it++) reft[it]=-1;
     5319        for (long it=0;it<nbt;it++) reft[it]=-1;
    53205320
    53215321        //loop over all subdomains
    5322         for (Int4 i=0;i<NbSubDomains;i++){
     5322        for (long i=0;i<NbSubDomains;i++){
    53235323
    53245324                //first triangle of the subdomain i
    … …  
    55915591        /*}}}1*/
    55925592        /*FUNCTION AGoodNumberPrimeWith{{{1*/
    5593         Int4 AGoodNumberPrimeWith(Int4 n){
     5593        long AGoodNumberPrimeWith(long n){
    55945594
    55955595                //list of big prime numbers
    5596                 const Int4 BigPrimeNumber[] ={ 567890359L,
     5596                const long BigPrimeNumber[] ={ 567890359L,
    55975597                        567890431L,  567890437L,  567890461L,  567890471L,
    55985598                        567890483L,  567890489L,  567890497L,  567890507L,
    … …  
    56005600
    56015601                //initialize o and pi
    5602                 Int4 o =0;
    5603                 Int4 pi=BigPrimeNumber[1];
     5602                long o =0;
     5603                long pi=BigPrimeNumber[1];
    56045604
    56055605                //loop until BigPrimeNumber[i]==0 (end of BigPrimeNumber)
    … …  
    56075607
    56085608                        //compute r, rest of the remainder of the division of BigPrimeNumber[i] by n
    5609                         Int4 r = BigPrimeNumber[i] % n;
     5609                        long r = BigPrimeNumber[i] % n;
    56105610
    56115611                        /*compute oo = min ( r , n-r , |n - 2r|, |n-3r|)*/
    5612                         Int4 oo = Min(Min(r,n-r),Min(Abs(n-2*r),Abs(n-3*r)));
     5612                        long oo = Min(Min(r,n-r),Min(Abs(n-2*r),Abs(n-3*r)));
    56135613                        if ( o < oo){
    56145614                                o=oo;

  • issm/trunk/src/c/Bamgx/objects/Triangles.h

    r3232 r3243  
    3838                        Geometry & Gh;   // Geometry
    3939                        Triangles & BTh; // Background Mesh Bth==*this =>no  background
    40                         Int4 NbRef;      // counter of ref on the this class if 0 we can delete
    41                         Int4 nbvx,nbtx;  // nombre max  de sommets , de  triangles
    42                         Int4 nt,nbv,nbt,nbiv,nbe; // nb of legal triangles, nb of vertex, of triangles, of initial vertices, of edges with reference,
    43                         Int4 NbOfQuad;  // nb of quadrangle
    44                         Int4 NbSubDomains;
    45                         Int4 NbOutT;    // Nb of oudeside triangle
    46                         Int4 NbOfTriangleSearchFind;
    47                         Int4 NbOfSwapTriangle;
     40                        long NbRef;      // counter of ref on the this class if 0 we can delete
     41                        long nbvx,nbtx;  // nombre max  de sommets , de  triangles
     42                        long nt,nbv,nbt,nbiv,nbe; // nb of legal triangles, nb of vertex, of triangles, of initial vertices, of edges with reference,
     43                        long NbOfQuad;  // nb of quadrangle
     44                        long NbSubDomains;
     45                        long NbOutT;    // Nb of oudeside triangle
     46                        long NbOfTriangleSearchFind;
     47                        long NbOfSwapTriangle;
    4848                        Vertex* vertices;
    49                         Int4 NbVerticesOnGeomVertex;
     49                        long NbVerticesOnGeomVertex;
    5050                        VertexOnGeom * VerticesOnGeomVertex;
    51                         Int4 NbVerticesOnGeomEdge;
     51                        long NbVerticesOnGeomEdge;
    5252                        VertexOnGeom * VerticesOnGeomEdge;
    53                         Int4 NbVertexOnBThVertex;
     53                        long NbVertexOnBThVertex;
    5454                        VertexOnVertex *VertexOnBThVertex;
    55                         Int4 NbVertexOnBThEdge;
     55                        long NbVertexOnBThEdge;
    5656                        VertexOnEdge *VertexOnBThEdge;
    57                         Int4 NbCrackedVertices;
    58                         Int4 NbCrackedEdges;
     57                        long NbCrackedVertices;
     58                        long NbCrackedEdges;
    5959                        CrackedEdge *CrackedEdges;
    6060                        R2 pmin,pmax;    // extrema
    61                         Real8 coefIcoor; // coef to integer Icoor1;
     61                        double coefIcoor; // coef to integer Icoor1;
    6262                        Triangle* triangles;
    6363                        Edge* edges;
    … …  
    7070                        Triangles(BamgMesh* bamgmesh,BamgOpts* bamgopts);
    7171                        Triangles(double* index,double* x,double* y,int nods,int nels);
    72                         Triangles(Triangles &,Geometry * pGh=0,Triangles* pBTh=0,Int4 nbvxx=0 ); //copy operator
     72                        Triangles(Triangles &,Geometry * pGh=0,Triangles* pBTh=0,long nbvxx=0 ); //copy operator
    7373                        Triangles(const Triangles &,const int *flag,const int *bb,BamgOpts* bamgopts); // truncature
    74                         Triangles(Int4 nbvx,Triangles & BT,BamgOpts* bamgopts,int keepBackVertices=1) :Gh(BT.Gh),BTh(BT) {
     74                        Triangles(long nbvx,Triangles & BT,BamgOpts* bamgopts,int keepBackVertices=1) :Gh(BT.Gh),BTh(BT) {
    7575                                try {GeomToTriangles1(nbvx,bamgopts,keepBackVertices);}
    7676                                catch(...) { this->~Triangles(); throw; }
    7777                        }
    78                         Triangles(Int4 nbvx,Geometry & G,BamgOpts* bamgopts) :Gh(G),BTh(*this){
     78                        Triangles(long nbvx,Geometry & G,BamgOpts* bamgopts) :Gh(G),BTh(*this){
    7979                                try { GeomToTriangles0(nbvx,bamgopts);}
    8080                                catch(...) { this->~Triangles(); throw; }
    … …  
    8383
    8484                        //Operators
    85                         const Vertex & operator[]  (Int4 i) const { return vertices[i];};
    86                         Vertex & operator[](Int4 i) { return vertices[i];};
    87                         const Triangle & operator()  (Int4 i) const { return triangles[i];};
    88                         Triangle & operator()(Int4 i) { return triangles[i];};
     85                        const Vertex & operator[]  (long i) const { return vertices[i];};
     86                        Vertex & operator[](long i) { return vertices[i];};
     87                        const Triangle & operator()  (long i) const { return triangles[i];};
     88                        Triangle & operator()(long i) { return triangles[i];};
    8989
    9090                        //Methods
    9191                        void SetIntCoor(const char * from =0);
    92                         Real8 MinimalHmin() {return 2.0/coefIcoor;}
    93                         Real8 MaximalHmax() {return Max(pmax.x-pmin.x,pmax.y-pmin.y);}
     92                        double MinimalHmin() {return 2.0/coefIcoor;}
     93                        double MaximalHmax() {return Max(pmax.x-pmin.x,pmax.y-pmin.y);}
    9494                        I2 toI2(const R2 & P) const {
    9595                                return  I2( (Icoor1) (coefIcoor*(P.x-pmin.x))
    … …  
    103103                        void Renumber(BamgOpts* bamgopts);
    104104                        void FindSubDomain(int OutSide=0);
    105                         Int4 TriangleReferenceList(Int4 *) const;
     105                        long TriangleReferenceList(long *) const;
    106106                        void ShowHistogram() const;
    107107                        void ShowRegulaty() const;
    108108                        void ReMakeTriangleContainingTheVertex();
    109109                        void UnMarkUnSwapTriangle();
    110                         void SmoothMetric(Real8 raisonmax) ;
    111                         void BoundAnisotropy(Real8 anisomax,double hminaniso= 1e-100) ;
    112                         void MaxSubDivision(Real8 maxsubdiv);
     110                        void SmoothMetric(double raisonmax) ;
     111                        void BoundAnisotropy(double anisomax,double hminaniso= 1e-100) ;
     112                        void MaxSubDivision(double maxsubdiv);
    113113                        Edge** MakeGeometricalEdgeToEdge();
    114114                        void SetVertexFieldOn(); 
    115115                        void SetVertexFieldOnBTh();
    116                         Int4 SplitInternalEdgeWithBorderVertices();
     116                        long SplitInternalEdgeWithBorderVertices();
    117117                        void MakeQuadrangles(double costheta);
    118118                        int  SplitElement(int choice);
    119119                        void MakeQuadTree();
    120120                        void NewPoints(Triangles &,BamgOpts* bamgopts,int KeepVertices=1);
    121                         Int4 InsertNewPoints(Int4 nbvold,Int4 & NbTSwap) ;
     121                        long InsertNewPoints(long nbvold,long & NbTSwap) ;
    122122                        void ReNumberingTheTriangleBySubDomain(bool justcompress=false);
    123                         void ReNumberingVertex(Int4 * renu);
    124                         void SmoothingVertex(int =3,Real8=0.3);
     123                        void ReNumberingVertex(long * renu);
     124                        void SmoothingVertex(int =3,double=0.3);
    125125                        Metric MetricAt (const R2 &) const;
    126                         GeometricalEdge* ProjectOnCurve( Edge & AB, Vertex &  A, Vertex & B,Real8 theta, Vertex & R,VertexOnEdge & BR,VertexOnGeom & GR);
    127                         Int4 Number(const Triangle & t) const  { return &t - triangles;}
    128                         Int4 Number(const Triangle * t) const  { return t - triangles;}
    129                         Int4 Number(const Vertex & t) const  { return &t - vertices;}
    130                         Int4 Number(const Vertex * t) const  { return t - vertices;}
    131                         Int4 Number(const Edge & t) const  { return &t - edges;}
    132                         Int4 Number(const Edge * t) const  { return t - edges;}
    133                         Int4 Number2(const Triangle * t) const  {
     126                        GeometricalEdge* ProjectOnCurve( Edge & AB, Vertex &  A, Vertex & B,double theta, Vertex & R,VertexOnEdge & BR,VertexOnGeom & GR);
     127                        long Number(const Triangle & t) const  { return &t - triangles;}
     128                        long Number(const Triangle * t) const  { return t - triangles;}
     129                        long Number(const Vertex & t) const  { return &t - vertices;}
     130                        long Number(const Vertex * t) const  { return t - vertices;}
     131                        long Number(const Edge & t) const  { return &t - edges;}
     132                        long Number(const Edge * t) const  { return t - edges;}
     133                        long Number2(const Triangle * t) const  {
    134134                                return t - triangles;
    135135                        }
    … …  
    139139                        void ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts);
    140140                        void WriteMesh(BamgMesh* bamgmesh,BamgOpts* bamgopts);
    141                         void ReadMetric(BamgOpts* bamgopts,const Real8 hmin,const Real8 hmax,const Real8 coef);
     141                        void ReadMetric(BamgOpts* bamgopts,const double hmin,const double hmax,const double coef);
    142142                        void WriteMetric(BamgOpts* bamgopts);
    143143                        void AddMetric(BamgOpts* bamgopts);
    … …  
    153153
    154154                private:
    155                         void GeomToTriangles1(Int4 nbvx,BamgOpts* bamgopts,int KeepVertices=1);// the real constructor mesh adaption
    156                         void GeomToTriangles0(Int4 nbvx,BamgOpts* bamgopts);// the real constructor mesh generator
    157                         void PreInit(Int4);
     155                        void GeomToTriangles1(long nbvx,BamgOpts* bamgopts,int KeepVertices=1);// the real constructor mesh adaption
     156                        void GeomToTriangles0(long nbvx,BamgOpts* bamgopts);// the real constructor mesh generator
     157                        void PreInit(long);
    158158
    159159        };

  • issm/trunk/src/c/Bamgx/objects/Vertex.cpp

    r3236 r3243  
    1414        /*Methods*/
    1515        /*FUNCTION Vertex::Smoothing{{{1*/
    16         Real8  Vertex::Smoothing(Triangles &Th,const Triangles &BTh,Triangle* &tstart ,Real8 omega){
     16        double  Vertex::Smoothing(Triangles &Th,const Triangles &BTh,Triangle* &tstart ,double omega){
    1717
    1818                register Vertex* s=this;
    … …  
    3030
    3131                                R2 Q = vQ,QP(P-Q);
    32                                 Real8 lQP = LengthInterpole(vP,vQ,QP);
     32                                double lQP = LengthInterpole(vP,vQ,QP);
    3333                                PNew += Q+QP/Max(lQP,1e-20);
    3434                                kk ++;
    … …  
    4343                } while ( tbegin != tria);
    4444                if (kk<4) return 0;
    45                 PNew = PNew/(Real8)kk;
     45                PNew = PNew/(double)kk;
    4646                R2 Xmove((PNew-P)*omega);
    4747                PNew = P+Xmove;
    48                 Real8 delta=Norme2_2(Xmove);
     48                double delta=Norme2_2(Xmove);
    4949
    5050                Icoor2 deta[3];
    … …  
    6060                }
    6161                else { // inside
    62                         Real8   aa[3];
    63                         Real8 s = deta[0]+deta[1]+deta[2];
     62                        double   aa[3];
     63                        double s = deta[0]+deta[1]+deta[2];
    6464                        aa[0]=deta[0]/s;
    6565                        aa[1]=deta[1]/s;
    … …  
    9090                                          {
    9191                                                vP = vPsave;
    92                                                 Real8 qold =QuadQuality(*v0,*v1,*v2,*v3);
     92                                                double qold =QuadQuality(*v0,*v1,*v2,*v3);
    9393                                                vP = vPnew;
    94                                                 Real8 qnew =QuadQuality(*v0,*v1,*v2,*v3);
     94                                                double qnew =QuadQuality(*v0,*v1,*v2,*v3);
    9595                                                if (qnew<qold) ok = 1;
    9696                                          }

  • issm/trunk/src/c/Bamgx/objects/Vertex.h

    r3242 r3243  
    2525                        R2 r;  // real coordinates
    2626                        Metric m;
    27                         Int4 ReferenceNumber;
     27                        long ReferenceNumber;
    2828                        Direction DirOfSearch;
    2929                        short vint;  // the vertex number in triangle; varies between 0 and 2 in t
    3030                        union {
    3131                                Triangle* t; // one triangle which is containing the vertex
    32                                 Int4 color;
     32                                long color;
    3333                                Vertex* to;  // use in geometry Vertex to now the Mesh Vertex associed
    3434                                VertexOnGeom* onGeometry;       // if vint == 8; // set with Triangles::SetVertexFieldOn()
    … …  
    4141                        operator  const R2 & () const {return r;}    // Cast operator
    4242                        operator Metric () const {return m;}         // Cast operator
    43                         Real8 operator()(R2 x) const { return m(x);} // Get x in the metric m
     43                        double operator()(R2 x) const { return m(x);} // Get x in the metric m
    4444
    4545                        //methods (No constructor and no destructors...)
    46                         Real8 Smoothing(Triangles & ,const Triangles & ,Triangle  * & ,Real8 =1);
     46                        double Smoothing(Triangles & ,const Triangles & ,Triangle  * & ,double =1);
    4747                        void  MetricFromHessian(const double Hxx,const double Hyx, const double Hyy, const double smin,const double smax,const double s,const double err,BamgOpts* bamgopts);
    4848                        void  Echo();
    … …  
    5050
    5151                        //inline functions
    52                         inline Int4 Optim(int =1,int =0);
     52                        inline long Optim(int =1,int =0);
    5353                        inline void Set(const Vertex & rec,const Triangles &,Triangles &);
    5454        };

  • issm/trunk/src/c/Bamgx/objects/VertexOnEdge.h

    r3232 r3243  
    2121                        Vertex* v;
    2222                        Edge*   be;
    23                         Real8 abcisse;
     23                        double abcisse;
    2424
    2525                        //Constructors
    26                         VertexOnEdge( Vertex * w, Edge *bw,Real8 s) :v(w),be(bw),abcisse(s) {}
     26                        VertexOnEdge( Vertex * w, Edge *bw,double s) :v(w),be(bw),abcisse(s) {}
    2727                        VertexOnEdge(){}
    2828
    2929                        //Operators
    30                         operator Real8 () const { return abcisse;}
     30                        operator double () const { return abcisse;}
    3131                        operator Vertex* () const { return v;} 
    3232                        operator Edge* () const { return be;} 
    … …  
    3737
    3838                        //Inline methods
    39                         inline void Set(const Triangles &,Int4,Triangles &); 
     39                        inline void Set(const Triangles &,long,Triangles &); 
    4040        };
    4141

  • issm/trunk/src/c/Bamgx/objects/VertexOnGeom.h

    r3232 r3243  
    2222
    2323                        Vertex* mv;
    24                         Real8 abscisse; 
     24                        double abscisse; 
    2525                        union{
    2626                                GeometricalVertex * gv; // if abscisse <0;
    … …  
    3131                        VertexOnGeom(): mv(0),abscisse(0){gv=0;}
    3232                        VertexOnGeom(Vertex & m,GeometricalVertex &g) : mv(&m),abscisse(-1){gv=&g;}
    33                         VertexOnGeom(Vertex & m,GeometricalEdge &g,Real8 s) : mv(&m),abscisse(s){ge=&g;}
     33                        VertexOnGeom(Vertex & m,GeometricalEdge &g,double s) : mv(&m),abscisse(s){ge=&g;}
    3434
    3535                        //Operators
    … …  
    3737                        operator GeometricalVertex * () const  {return gv;}
    3838                        operator GeometricalEdge * () const  {return ge;}
    39                         operator const Real8 & () const {return abscisse;}
     39                        operator const double & () const {return abscisse;}
    4040
    4141                        //Methods
    … …  
    4646
    4747                        //Inline methods
    48                         inline void Set(const Triangles &,Int4,Triangles &);
     48                        inline void Set(const Triangles &,long,Triangles &);
    4949                        inline void Set(const VertexOnGeom&,const Triangles &,Triangles &); 
    5050

  • issm/trunk/src/c/Bamgx/objects/VertexOnVertex.h

    r3232 r3243  
    2929
    3030                        //Inline methods
    31                         inline void Set(const Triangles &,Int4,Triangles &);
     31                        inline void Set(const Triangles &,long,Triangles &);
    3232        };
    3333
Note: See TracChangeset for help on using the changeset viewer.