Changeset 3246


Ignore:
Timestamp:
03/10/10 11:17:57 (15 years ago)
Author:
Mathieu Morlighem
Message:

Added ariginal file location

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

Legend:

Unmodified
Added
Removed

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

    r3243 r3246  
    1717        /*Methods*/
    1818        /*FUNCTION GeometricalEdge::R1tg{{{1*/
    19         double GeometricalEdge::R1tg(double theta,R2 & t) const // 1/R of radius of cuvature
    20           { R2 A=v[0]->r,B=v[1]->r;
     19        double GeometricalEdge::R1tg(double theta,R2 & t) const{
     20                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/R1tg)*/
     21                // 1/R of radius of cuvature
     22
     23                R2 A=v[0]->r,B=v[1]->r;
    2124                double dca,dcb,dcta,dctb;
    2225                double ddca,ddcb,ddcta,ddctb;
    … …  
    9093        /*}}}1*/
    9194        /*FUNCTION GeometricalEdge::F{{{1*/
    92         R2 GeometricalEdge::F(double theta) const // parametrization of the curve edge
    93           { R2 A=v[0]->r,B=v[1]->r;
     95        R2 GeometricalEdge::F(double theta) const{
     96                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/F)*/
     97                // parametrization of the curve edge
     98
     99           R2 A=v[0]->r,B=v[1]->r;
    94100                double ca,cb,cta,ctb;
    95101                if ( theta<-1e-12){

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

    r3243 r3246  
    1616        /*FUNCTION  Geometry::Geometry(const Geometry & Gh){{{1*/
    1717        Geometry::Geometry(const Geometry & Gh) {
     18                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/Geometry)*/
     19
    1820                long i;
    1921                *this = Gh;
    … …  
    4042        /*FUNCTION Geometry::~Geometry(){{{1*/
    4143        Geometry::~Geometry() {
     44                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/~Geometry)*/
     45
    4246                long int verbosity=0;
    4347
    … …  
    491495        /*FUNCTION  Geometry::AfterRead(){{{1*/
    492496        void Geometry::AfterRead(){
     497                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/AfterRead)*/
     498
    493499                long int verbosity=0;
    494500
    … …  
    846852        }
    847853        /*}}}1*/
    848         /*FUNCTION  Geometry::Contening{{{1*/
    849         GeometricalEdge* Geometry::Contening(const R2 P,  GeometricalEdge * start) const {
     854        /*FUNCTION  Geometry::Containing{{{1*/
     855        GeometricalEdge* Geometry::Containing(const R2 P,  GeometricalEdge * start) const {
     856                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/Contening)*/
     857
    850858                GeometricalEdge* on =start,* pon=0;
    851859                // walk with the cos on geometry
    … …  
    901909        /*FUNCTION  Geometry::EmptyGeometry(){{{1*/
    902910        void Geometry::EmptyGeometry() {
     911                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/EmptyGeometry)*/
     912
    903913                NbRef=0;
    904914                quadtree=0;
    … …  
    921931        /*FUNCTION  Geometry::ProjectOnCurve {{{1*/
    922932        GeometricalEdge* Geometry::ProjectOnCurve(const Edge & e,double s,Vertex &V,VertexOnGeom &GV ) const {
     933                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/ProjectOnCurve)*/
     934
    923935                double save_s=s;
    924936                int NbTry=0;

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

    r3245 r3246  
    7171                        void UnMarkEdges() {for (int i=0;i<nbe;i++) edges[i].SetUnMark();}
    7272                        GeometricalEdge *  ProjectOnCurve(const Edge & ,double,Vertex &,VertexOnGeom &) const ;
    73                         GeometricalEdge *  Contening(const R2 P,  GeometricalEdge * start) const;
     73                        GeometricalEdge *  Containing(const R2 P,  GeometricalEdge * start) const;
    7474                        void WriteGeometry(BamgGeom* bamggeom, BamgOpts* bamgopts);
    7575        };

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

    r3243 r3246  
    1515        /*FUNCTION ListofIntersectionTriangles::SplitEdge{{{1*/
    1616        void ListofIntersectionTriangles::SplitEdge(const Triangles & Bh, const R2 &A,const R2  &B,int nbegin) {
     17                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ListofIntersectionTriangles)*/
     18
    1719                Triangle *tbegin, *t;
    1820
    … …  
    218220        /*FUNCTION ListofIntersectionTriangles::NewItem(Triangle * tt,double d0,double d1,double d2) {{{1*/
    219221        int  ListofIntersectionTriangles::NewItem(Triangle * tt,double d0,double d1,double d2) {
     222                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewItem)*/
     223
    220224                register int n;
    221225                R2 x(0,0);
    … …  
    244248        /*FUNCTION ListofIntersectionTriangles::NewItem(R2 A,const Metric & mm){{{1*/
    245249        int ListofIntersectionTriangles::NewItem(R2 A,const Metric & mm) {
     250                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewItem)*/
     251
    246252                register int n;
    247253                if(!Size ||  Norme2_2(lIntTria[Size-1].x-A)) {
    … …  
    258264        /*FUNCTION ListofIntersectionTriangles::Length{{{1*/
    259265        double  ListofIntersectionTriangles::Length(){
     266                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Length)*/
     267
    260268                // computation of the length
    261269
    … …  
    304312        /*FUNCTION ListofIntersectionTriangles::NewPoints{{{1*/
    305313        long ListofIntersectionTriangles::NewPoints(Vertex* vertices,long &nbv,long nbvx){
     314                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewPoints)*/
    306315
    307316                //If length<1.5, do nothing

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

    r3232 r3246  
    1414        /*FUNCTION MatVVP2x2::MatVVP2x2(const Metric M){{{1*/
    1515        MatVVP2x2::MatVVP2x2(const Metric M){
     16                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/MatVVP2x2)*/
     17
    1618                double a11=M.a11,a21=M.a21,a22=M.a22;
    1719                const double eps = 1.e-5;
    … …  
    4547        /*Methods*/
    4648        /*FUNCTION MatVVP2x2::Echo {{{1*/
    47 
    4849        void MatVVP2x2::Echo(void){
    4950

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

    r3243 r3246  
    1818        /*FUNCTION Metric::Metric(const double  a[3],const  Metric m0, const  Metric m1,const  Metric  m2 ){{{1*/
    1919        Metric::Metric(const double  a[3],const  Metric m0, const  Metric m1,const  Metric m2 ){
     20                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/Metric)*/
     21
    2022                Metric mab(a[0]*m0.a11 + a[1]*m1.a11 + a[2]*m2.a11,
    2123                                        a[0]*m0.a21 + a[1]*m1.a21 + a[2]*m2.a21,
    … …  
    3739        /*FUNCTION Metric::Metric( double  a,const  Metric ma, double  b,const  Metric mb){{{1*/
    3840        Metric::Metric( double  a,const  Metric ma, double  b,const  Metric mb) {
     41                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/MatVVP2x2)*/
     42
    3943                Metric mab(a*ma.a11+b*mb.a11,a*ma.a21+b*mb.a21,a*ma.a22+b*mb.a22);
    4044                MatVVP2x2 vab(mab);
    … …  
    5458        /*Methods*/
    5559        /*FUNCTION Metric::Echo {{{1*/
    56 
    5760        void Metric::Echo(void){
    5861
    … …  
    6568        /*FUNCTION Metric::IntersectWith{{{1*/
    6669        int Metric::IntersectWith(const Metric M2) {
     70                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/IntersectWith)*/
     71
    6772                /*Get a new metric from an existing metric (M1=this)
    6873                 * and a new metric given in input M2 using a
    … …  
    118123        /*FUNCTION LengthInterpole{{{1*/
    119124        double LengthInterpole(const Metric Ma,const  Metric Mb, R2 AB) {
     125                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/LengthInterpole)*/
     126
    120127                double k=1./2.;
    121128                int level=0;
    … …  
    184191        /*FUNCTION SimultaneousMatrixReduction{{{1*/
    185192        void SimultaneousMatrixReduction( Metric M1,  Metric M2, D2xD2 &V) {
     193                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/ReductionSimultanee)*/
     194
    186195                /*In this routine we must return a matrix V that is composed of the
    187196                 * eigen vectors of N=inv(M1) M2.
    … …  
    287296        /*FUNCTION abscisseInterpole{{{1*/
    288297        double abscisseInterpole(const Metric Ma,const  Metric Mb, R2 AB,double s,int optim) {
     298                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/abscisseInterpole)*/
     299
    289300                if(!optim)  LengthInterpole(Ma,Mb,AB);
    290301                double l  = s* LastMetricInterpole.lab,r;

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

    r3245 r3246  
    8181        /*FUNCTION QuadTree::QuadTree(Triangles * t,long nbv){{{1*/
    8282        QuadTree::QuadTree(Triangles * t,long nbv) :
     83                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/QuadTree)*/
     84
    8385                lenStorageQuadTreeBox(t->nbvx/8+10),
    8486                th(t),
    … …  
    100102        /*FUNCTION QuadTree::QuadTree(){{{1*/
    101103        QuadTree::QuadTree() :
     104                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/QuadTree)*/
     105
    102106                lenStorageQuadTreeBox(100), // by default 100 vertices by box
    103107                th(0),                      // initial mesh = NULL
    … …  
    114118        /*FUNCTION QuadTree::~QuadTree(){{{1*/
    115119        QuadTree::~QuadTree() {
     120                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/~QuadTree)*/
     121
    116122                delete sb;
    117123                root=0;
    … …  
    122128        /*FUNCTION QuadTree::Add{{{1*/
    123129        void  QuadTree::Add(Vertex &w){
     130                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/Add)*/
     131
    124132                QuadTreeBox** pb;
    125133                QuadTreeBox*  b;
    … …  
    205213        /*FUNCTION QuadTree::NearestVertex{{{1*/
    206214        Vertex*  QuadTree::NearestVertex(Icoor1 i,Icoor1 j) {
     215                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/NearestVertex)*/
    207216
    208217                /*Build QuadTree*/
    … …  
    343352        /*FUNCTION QuadTree::NearestVertexWithNormal{{{1*/
    344353        Vertex*  QuadTree::NearestVertexWithNormal(Icoor1 i,Icoor1 j) {
     354                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/NearestVertexWithNormal)*/
     355
    345356                QuadTreeBox * pb[ MaxDeep ];
    346357                int  pi[ MaxDeep  ];
    … …  
    453464        /*FUNCTION QuadTree::StorageQuadTreeBox::StorageQuadTreeBox{{{1*/
    454465        QuadTree::StorageQuadTreeBox::StorageQuadTreeBox(long ll,StorageQuadTreeBox *nn) {
     466                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/StorageQuadTreeBox)*/
     467
    455468                len = ll;
    456469                n = nn;
    … …  
    467480        /*FUNCTION QuadTree::ToClose {{{1*/
    468481        Vertex *   QuadTree::ToClose(Vertex & v,double seuil,Icoor1 hx,Icoor1 hy){
     482                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/ToClose)*/
     483
    469484                const Icoor1 i=v.i.x;
    470485                const Icoor1 j=v.i.y;

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

    r3243 r3246  
     1/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.h)*/
    12#ifndef _QUADTREE_H
    23#define _QUADTREE_H

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

    r3241 r3246  
     1/*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, R2.h)*/
    12#ifndef _R2_H
    23#define _R2_H

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

    r3245 r3246  
    1111        /*FUNCTION  SetOfEdges4::SetOfEdges4(long mmx,long nnx){{{1*/
    1212        SetOfEdges4::SetOfEdges4(long mmx,long nnx){
     13                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, SetOfEdges4.cpp/SetOfEdges4)*/
    1314
    1415                /*Intermediary*/
    … …  
    3132        /*FUNCTION  SetOfEdges4::find {{{1*/
    3233        long SetOfEdges4::find(long ii,long jj) {
     34                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, SetOfEdges4.cpp/find)*/
    3335
    3436                /*Intermediary*/
    … …  
    5961        /*FUNCTION  SetOfEdges4::add{{{1*/
    6062        long SetOfEdges4::add(long ii,long jj) {
     63                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, SetOfEdges4.cpp/add)*/
    6164
    6265                /*Intermediary*/

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

    r3243 r3246  
    1515        /*FUNCTION Triangle::FindBoundaryEdge{{{1*/
    1616        TriangleAdjacent Triangle::FindBoundaryEdge(int i) const{
     17                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FindBoundaryEdge)*/
    1718
    1819                /*Intermediary*/
    … …  
    6061        /*}}}1*/
    6162        /*FUNCTION Triangle::Echo {{{1*/
    62 
    6363        void Triangle::Echo(void){
    6464
    … …  
    9393        /*FUNCTION Triangle::Optim{{{1*/
    9494        long  Triangle::Optim(short i,int koption) {
     95                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Optim)*/
     96
    9597                // turn around (positive direction)
    9698                Triangle *t=this;
    … …  
    124126        /*FUNCTION Triangle::swap{{{1*/
    125127        int Triangle::swap(short a,int koption){
     128                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
     129
    126130                if(a/4 !=0) return 0;// arete lock or MarkUnSwap
    127131

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

    r3245 r3246  
    2020        /*FUNCTION Triangles::Triangles(BamgMesh* bamgmesh, BamgOpts* bamgopts){{{1*/
    2121        Triangles::Triangles(BamgMesh* bamgmesh, BamgOpts* bamgopts):Gh(*(new Geometry())),BTh(*this){
    22 
    2322                PreInit(0);
    2423                ReadMesh(bamgmesh,bamgopts);
    … …  
    3837        /*FUNCTION Triangles::Triangles(const Triangles & Tho,const int *flag ,const int *bb){{{1*/
    3938        Triangles::Triangles(const Triangles & Tho,const int *flag ,const int *bb,BamgOpts* bamgopts) : Gh(*(new Geometry())), BTh(*this) {
     39                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Triangles)*/
    4040
    4141                  int i,k,itadj;
    … …  
    141141        Triangles::Triangles(Triangles & Th,Geometry * pGh,Triangles * pBth,long nbvxx)
    142142          : Gh(*(pGh?pGh:&Th.Gh)), BTh(*(pBth?pBth:this)) {
     143                  /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Triangles)*/
    143144                  Gh.NbRef++;
    144145                  nbvxx = Max(nbvxx,Th.nbv);
    … …  
    206207        /*FUNCTION Triangles::~Triangles(){{{1*/
    207208        Triangles::~Triangles() {
     209                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Triangles)*/
     210
    208211                long int verbosity=2;
    209212                //if(vertices)  delete [] vertices; //TEST  crash if not commented
    … …  
    861864        /*FUNCTION Triangles::AddGeometryMetric{{{1*/
    862865        void Triangles::AddGeometryMetric(BamgOpts* bamgopts){
     866                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/IntersectGeomMetric)*/
    863867
    864868                /*Get options*/
    … …  
    933937        /*FUNCTION Triangles::AddVertex{{{1*/
    934938        void Triangles::AddVertex( Vertex &s,Triangle* t, Icoor2* det3) {
     939                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Add)*/
    935940                // -------------------------------------------
    936941                //             s2
    … …  
    10731078        /*FUNCTION Triangles::BoundAnisotropy{{{1*/
    10741079        void  Triangles::BoundAnisotropy(double anisomax,double hminaniso) {
     1080                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/BoundAnisotropy)*/
    10751081
    10761082                long int verbosity=0;
    … …  
    11121118        /*FUNCTION Triangles::BuildGeometryFromMesh{{{1*/
    11131119        void Triangles::BuildGeometryFromMesh(BamgOpts* bamgopts){
     1120                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/ConsGeometry)*/
     1121
    11141122                /*Reconstruct Geometry from Mesh*/
    11151123
    … …  
    17611769        /*FUNCTION Triangles::BuildMetric1 (Green formula){{{1*/
    17621770        void Triangles::BuildMetric1(BamgOpts* bamgopts){
     1771                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/IntersectConsMetric)*/
    17631772
    17641773                /*Options*/
    … …  
    20492058                /*FUNCTION Triangles::Crack{{{1*/
    20502059                int  Triangles::Crack() {
     2060                        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Crack)*/
    20512061                        if (NbCrackedEdges!=0 && NbCrackedVertices<=0);{
    20522062                                throw ErrorException(__FUNCT__,exprintf("NbCrackedEdges!=0 && NbCrackedVertices<=0"));
    … …  
    20582068                /*FUNCTION Triangles::CrackMesh{{{1*/
    20592069                int Triangles::CrackMesh() {
     2070                        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CrackMesh)*/
    20602071
    20612072                        int verbosity=0;
    … …  
    22002211        /*FUNCTION Triangles::ForceBoundary{{{1*/
    22012212                void Triangles::ForceBoundary() {
     2213                        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceBoundary)*/
     2214
    22022215                        long int verbosity=2;
    22032216                        int k=0;
    … …  
    22462259        /*FUNCTION Triangles::FindSubDomain{{{1*/
    22472260        void Triangles::FindSubDomain(int OutSide) {
     2261                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FindSubDomain)*/
     2262
    22482263                long int verbosity=0;
    22492264
    … …  
    24962511        /*FUNCTION Triangles::FindTriangleContaining{{{1*/
    24972512        Triangle * Triangles::FindTriangleContaining(const I2 & B,Icoor2 dete[3], Triangle *tstart) const {
     2513                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FindTriangleContening)*/
     2514
    24982515                Triangle * t=0;
    24992516                int j,jp,jn,jj;
    … …  
    25072524                        if (!a || !a->t ) {
    25082525                                if (a) {
    2509                                         printf("TriangleConteningTheVertex vertex number %i, another call to ReMakeTriangleContainingTheVertex was required\n", Number(a));
     2526                                        printf("TriangleContaining vertex number %i, another call to ReMakeTriangleContainingTheVertex was required\n", Number(a));
    25102527                                }
    25112528                                throw ErrorException(__FUNCT__,exprintf("problem in Triangles::FindTriangleContaining"));
    … …  
    25892606        /*FUNCTION Triangles::GenerateMeshProperties{{{1*/
    25902607        void Triangles::GenerateMeshProperties() {
     2608                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FillHoleInMesh)*/
    25912609
    25922610                int verbosity=0;
    … …  
    28742892        /*FUNCTION Triangles::GeomToTriangles0{{{1*/
    28752893        void Triangles::GeomToTriangles0(long inbvx,BamgOpts* bamgopts) {
     2894                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/GeomToTriangles0)*/
     2895
    28762896                /*Generate mesh from geometry*/
    28772897
    … …  
    31923212        /*FUNCTION Triangles::GeomToTriangles1{{{1*/
    31933213        void Triangles::GeomToTriangles1(long inbvx,BamgOpts* bamgopts,int KeepVertices){
     3214                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/GeomToTriangles1)*/
    31943215
    31953216                /*Get options*/
    … …  
    35313552        /*FUNCTION Triangles::Insert{{{1*/
    35323553        void Triangles::Insert() {
     3554                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Insert)*/
     3555
    35333556                /*Insert points in the existing Geometry*/
    35343557
    … …  
    36813704        /*FUNCTION Triangles::InsertNewPoints{{{1*/
    36823705        long Triangles::InsertNewPoints(long nbvold,long & NbTSwap) {
     3706                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/InsertNewPoints)*/
    36833707
    36843708                long int verbosity=0;
    … …  
    37553779        }
    37563780        /*}}}1*/
    3757 /*FUNCTION Triangles::MakeGeometricalEdgeToEdge{{{1*/
    3758 Edge** Triangles::MakeGeometricalEdgeToEdge() {
    3759         if (!Gh.nbe){
    3760                 throw ErrorException(__FUNCT__,exprintf("!Gh.nbe"));
     3781        /*FUNCTION Triangles::MakeGeometricalEdgeToEdge{{{1*/
     3782        Edge** Triangles::MakeGeometricalEdgeToEdge() {
     3783                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MakeGeometricalEdgeToEdge)*/
     3784
     3785                if (!Gh.nbe){
     3786                        throw ErrorException(__FUNCT__,exprintf("!Gh.nbe"));
     3787                }
     3788                Edge **e= new (Edge* [Gh.nbe]);
     3789
     3790                long i;
     3791                for ( i=0;i<Gh.nbe ; i++)
     3792                 e[i]=NULL;
     3793                for ( i=0;i<nbe ; i++)
     3794                  {
     3795                        Edge * ei = edges+i;
     3796                        GeometricalEdge *onGeometry = ei->onGeometry;
     3797                        e[Gh.Number(onGeometry)] = ei;   
     3798                  }
     3799                for ( i=0;i<nbe ; i++)
     3800                 for (int ii=0;ii<2;ii++) {
     3801                         Edge * ei = edges+i;
     3802                         GeometricalEdge *onGeometry = ei->onGeometry;
     3803                         int j= ii;
     3804                         while (!(*onGeometry)[j].Required()) {
     3805                                 Adj(onGeometry,j); // next geom edge
     3806                                 j=1-j;
     3807                                 if (e[Gh.Number(onGeometry)])  break; // optimisation
     3808                                 e[Gh.Number(onGeometry)] = ei;
     3809                         }
     3810                 }
     3811
     3812                int kk=0;
     3813                for ( i=0;i<Gh.nbe ; i++){
     3814                        if (!e[i]){
     3815                                kk++;
     3816                                if(kk<10) printf("BUG: the geometrical edge %i is on no edge curve\n",i);
     3817                        }
     3818                }
     3819                if(kk) throw ErrorException(__FUNCT__,exprintf("See above"));
     3820
     3821                return e;
    37613822        }
    3762         Edge **e= new (Edge* [Gh.nbe]);
    3763 
    3764         long i;
    3765         for ( i=0;i<Gh.nbe ; i++)
    3766          e[i]=NULL;
    3767         for ( i=0;i<nbe ; i++)
    3768           {
    3769                 Edge * ei = edges+i;
    3770                 GeometricalEdge *onGeometry = ei->onGeometry;
    3771                 e[Gh.Number(onGeometry)] = ei;   
    3772           }
    3773         for ( i=0;i<nbe ; i++)
    3774          for (int ii=0;ii<2;ii++) {
    3775                  Edge * ei = edges+i;
    3776                  GeometricalEdge *onGeometry = ei->onGeometry;
    3777                  int j= ii;
    3778                  while (!(*onGeometry)[j].Required()) {
    3779                          Adj(onGeometry,j); // next geom edge
    3780                          j=1-j;
    3781                          if (e[Gh.Number(onGeometry)])  break; // optimisation
    3782                          e[Gh.Number(onGeometry)] = ei;
    3783                  }
    3784          }
    3785 
    3786         int kk=0;
    3787         for ( i=0;i<Gh.nbe ; i++){
    3788                 if (!e[i]){
    3789                         kk++;
    3790                         if(kk<10) printf("BUG: the geometrical edge %i is on no edge curve\n",i);
    3791                 }
    3792         }
    3793         if(kk) throw ErrorException(__FUNCT__,exprintf("See above"));
    3794 
    3795         return e;
    3796 }
    3797 /*}}}1*/
     3823        /*}}}1*/
    37983824        /*FUNCTION Triangles::MakeQuadrangles{{{1*/
    37993825        void Triangles::MakeQuadrangles(double costheta){
     3826                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MakeQuadrangles)*/
     3827
    38003828                long int verbosity=0;
    38013829
    … …  
    38373865        }
    38383866        /*}}}1*/
    3839 /*FUNCTION Triangles::MakeQuadTree{{{1*/
    3840 void Triangles::MakeQuadTree() { 
    3841         long int verbosity=0;
    3842         if (  !quadtree )  quadtree = new QuadTree(this);
    3843 
    3844 }
    3845 /*}}}1*/
    3846 /*FUNCTION Triangles::MaxSubDivision{{{1*/
    3847 void  Triangles::MaxSubDivision(double maxsubdiv) {
    3848         long int verbosity=0;
    3849 
    3850         const  double maxsubdiv2 = maxsubdiv*maxsubdiv;
    3851         if(verbosity>1) printf("   Limit the subdivision of a edges in the new mesh by %g\n",maxsubdiv);
    3852         // for all the edges
    3853         // if the len of the edge is to long
    3854         long it,nbchange=0;   
    3855         double lmax=0;
    3856         for (it=0;it<nbt;it++)
    3857           {
    3858                 Triangle &t=triangles[it];
    3859                 for (int j=0;j<3;j++)
     3867        /*FUNCTION Triangles::MakeQuadTree{{{1*/
     3868        void Triangles::MakeQuadTree() { 
     3869                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MakeQuadTree)*/
     3870
     3871                long int verbosity=0;
     3872                if (  !quadtree )  quadtree = new QuadTree(this);
     3873
     3874        }
     3875        /*}}}1*/
     3876        /*FUNCTION Triangles::MaxSubDivision{{{1*/
     3877        void  Triangles::MaxSubDivision(double maxsubdiv) {
     3878                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/MaxSubDivision)*/
     3879
     3880                long int verbosity=0;
     3881
     3882                const  double maxsubdiv2 = maxsubdiv*maxsubdiv;
     3883                if(verbosity>1) printf("   Limit the subdivision of a edges in the new mesh by %g\n",maxsubdiv);
     3884                // for all the edges
     3885                // if the len of the edge is to long
     3886                long it,nbchange=0;   
     3887                double lmax=0;
     3888                for (it=0;it<nbt;it++)
    38603889                  {
    3861                         Triangle &tt = *t.TriangleAdj(j);
    3862                         if ( ! &tt ||  it < Number(tt) && ( tt.link || t.link))
     3890                        Triangle &t=triangles[it];
     3891                        for (int j=0;j<3;j++)
    38633892                          {
    3864                                 Vertex &v0 = t[VerticesOfTriangularEdge[j][0]];
    3865                                 Vertex &v1 = t[VerticesOfTriangularEdge[j][1]];
    3866                                 R2 AB= (R2) v1-(R2) v0;
    3867                                 Metric M = v0;
    3868                                 double l = M(AB,AB);
    3869                                 lmax = Max(lmax,l);
    3870                                 if(l> maxsubdiv2)
    3871                                   { R2 AC = M.Orthogonal(AB);// the ortogonal vector of AB in M
    3872                                         double lc = M(AC,AC);
    3873                                         D2xD2 Rt(AB,AC);// Rt.x = AB , Rt.y = AC;
    3874                                         D2xD2 Rt1(Rt.inv());
    3875                                         D2xD2 D(maxsubdiv2,0,0,lc);
    3876                                         D2xD2 MM = Rt1*D*Rt1.t();
    3877                                         v0.m =  M = Metric(MM.x.x,MM.y.x,MM.y.y);
    3878                                         nbchange++;
     3893                                Triangle &tt = *t.TriangleAdj(j);
     3894                                if ( ! &tt ||  it < Number(tt) && ( tt.link || t.link))
     3895                                  {
     3896                                        Vertex &v0 = t[VerticesOfTriangularEdge[j][0]];
     3897                                        Vertex &v1 = t[VerticesOfTriangularEdge[j][1]];
     3898                                        R2 AB= (R2) v1-(R2) v0;
     3899                                        Metric M = v0;
     3900                                        double l = M(AB,AB);
     3901                                        lmax = Max(lmax,l);
     3902                                        if(l> maxsubdiv2)
     3903                                          { R2 AC = M.Orthogonal(AB);// the ortogonal vector of AB in M
     3904                                                double lc = M(AC,AC);
     3905                                                D2xD2 Rt(AB,AC);// Rt.x = AB , Rt.y = AC;
     3906                                                D2xD2 Rt1(Rt.inv());
     3907                                                D2xD2 D(maxsubdiv2,0,0,lc);
     3908                                                D2xD2 MM = Rt1*D*Rt1.t();
     3909                                                v0.m =  M = Metric(MM.x.x,MM.y.x,MM.y.y);
     3910                                                nbchange++;
     3911                                          }
     3912                                        M = v1;
     3913                                        l = M(AB,AB);
     3914                                        lmax = Max(lmax,l);
     3915                                        if(l> maxsubdiv2)
     3916                                          { R2 AC = M.Orthogonal(AB);// the ortogonal vector of AB in M
     3917                                                double lc = M(AC,AC);
     3918                                                D2xD2 Rt(AB,AC);// Rt.x = AB , Rt.y = AC;
     3919                                                D2xD2 Rt1(Rt.inv());
     3920                                                D2xD2 D(maxsubdiv2,0,0,lc);
     3921                                                D2xD2  MM = Rt1*D*Rt1.t();
     3922                                                v1.m =  M = Metric(MM.x.x,MM.y.x,MM.y.y);
     3923                                                nbchange++;
     3924                                          }
     3925
     3926
    38793927                                  }
    3880                                 M = v1;
    3881                                 l = M(AB,AB);
    3882                                 lmax = Max(lmax,l);
    3883                                 if(l> maxsubdiv2)
    3884                                   { R2 AC = M.Orthogonal(AB);// the ortogonal vector of AB in M
    3885                                         double lc = M(AC,AC);
    3886                                         D2xD2 Rt(AB,AC);// Rt.x = AB , Rt.y = AC;
    3887                                         D2xD2 Rt1(Rt.inv());
    3888                                         D2xD2 D(maxsubdiv2,0,0,lc);
    3889                                         D2xD2  MM = Rt1*D*Rt1.t();
    3890                                         v1.m =  M = Metric(MM.x.x,MM.y.x,MM.y.y);
    3891                                         nbchange++;
    3892                                   }
    3893 
    3894 
    38953928                          }
    38963929                  }
    3897           }
    3898         if(verbosity>3){
    3899                 printf("      number of metric changes = %i, maximum number of subdivision of a edges before change = %g\n",nbchange,pow(lmax,0.5));
     3930                if(verbosity>3){
     3931                        printf("      number of metric changes = %i, maximum number of subdivision of a edges before change = %g\n",nbchange,pow(lmax,0.5));
     3932                }
    39003933        }
    3901 }
    3902 /*}}}1*/
     3934        /*}}}1*/
    39033935        /*FUNCTION Triangles::MetricAt{{{1*/
    39043936        Metric Triangles::MetricAt(const R2 & A) const {
     3937                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MetricAt)*/
     3938
    39053939                I2 a = toI2(A);
    39063940                Icoor2 deta[3];
    … …  
    39223956/*FUNCTION Triangles::NearestVertex{{{1*/
    39233957Vertex * Triangles::NearestVertex(Icoor1 i,Icoor1 j) {
     3958        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NearestVertex)*/
    39243959        return  quadtree->NearestVertex(i,j);
    39253960}
    … …  
    39273962        /*FUNCTION Triangles::NewPoints{{{1*/
    39283963        void  Triangles::NewPoints(Triangles & Bh,BamgOpts* bamgopts,int KeepVertices){
     3964                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewPoints)*/
    39293965
    39303966                int i,j,k;
    … …  
    40464082/*FUNCTION Triangles::PreInit{{{1*/
    40474083void Triangles::PreInit(long inbvx) {
     4084        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/PreInit)*/
     4085
    40484086        long int verbosity=0;
    40494087
    … …  
    41044142        GeometricalEdge*   Triangles::ProjectOnCurve( Edge & BhAB, Vertex &  vA, Vertex & vB,
    41054143                                double theta,Vertex & R,VertexOnEdge &  BR,VertexOnGeom & GR) {
     4144                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/ProjectOnCurve)*/
     4145
    41064146                void *pA=0,*pB=0;
    41074147                double tA=0,tB=0;
    … …  
    43204360        /*FUNCTION Triangles::ReNumberingTheTriangleBySubDomain{{{1*/
    43214361        void Triangles::ReNumberingTheTriangleBySubDomain(bool justcompress) {
     4362                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ReNumberingTheTriangleBySubDomain)*/
     4363
    43224364                long int verbosity=0;
    43234365                long *renu= new long[nbt];
    … …  
    43884430        /*FUNCTION Triangles::ReNumberingVertex{{{1*/
    43894431        void Triangles::ReNumberingVertex(long * renu) {
     4432                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ReNumberingVertex)*/
     4433
    43904434                // warning be carfull because pointeur
    43914435                // from on mesh to over mesh
    … …  
    44564500/*FUNCTION Triangles::SetIntCoor{{{1*/
    44574501void Triangles::SetIntCoor(const char * strfrom) {
     4502        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SetIntCoor)*/
     4503
    44584504        /*Set integer coordinate for existing vertices*/
    44594505
    … …  
    45114557/*FUNCTION Triangles::ShowRegulaty{{{1*/
    45124558void  Triangles::ShowRegulaty() const {
     4559        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr>*/
     4560
    45134561        const  double  sqrt32=sqrt(3.)*0.5;
    45144562        const double  aireKh=sqrt32*0.5;
    … …  
    45754623/*FUNCTION Triangles::ShowHistogram{{{1*/
    45764624void  Triangles::ShowHistogram() const {
     4625        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ShowHistogram)*/
    45774626
    45784627        const long kmax=10;
    … …  
    46194668/*FUNCTION Triangles::SmoothingVertex{{{1*/
    46204669void Triangles::SmoothingVertex(int nbiter,double omega ) {
     4670        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SmoothingVertex)*/
     4671
    46214672        long int verbosity=0;
    46224673        //  if quatree exist remove it end reconstruct
    … …  
    46594710/*FUNCTION Triangles::SmoothMetric{{{1*/
    46604711void Triangles::SmoothMetric(double raisonmax) {
     4712        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/SmoothMetric)*/
     4713
    46614714        long int verbosity=0;
    46624715
    … …  
    47354788        /*FUNCTION Triangles::SplitElement{{{1*/
    47364789        int  Triangles::SplitElement(int choice){
     4790                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/SplitElement)*/
     4791
    47374792                long int verbosity=0;
    47384793
    … …  
    48584913                        vertices[k].DirOfSearch = NoDirOfSearch;
    48594914
    4860                         newedges[ie].onGeometry = Gh.Contening(AA,ong);
     4915                        newedges[ie].onGeometry = Gh.Containing(AA,ong);
    48614916                        newedges[ie++].v[1]=vertices+k;
    48624917
    … …  
    48644919                        newedges[ie].adj[0]=newedges + ie -1;
    48654920                        newedges[ie].adj[1]=newedges+(edges[i].adj[1]-edges) ;
    4866                         newedges[ie].onGeometry =  Gh.Contening(BB,ong);
     4921                        newedges[ie].onGeometry =  Gh.Containing(BB,ong);
    48674922                        newedges[ie++].v[0]=vertices+k;
    48684923                        k++;
    … …  
    52435298/*FUNCTION Triangles::SplitInternalEdgeWithBorderVertices{{{1*/
    52445299long  Triangles::SplitInternalEdgeWithBorderVertices(){
     5300        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SplitInternalEdgeWithBorderVertices)*/
     5301
    52455302        long NbSplitEdge=0;
    52465303        SetVertexFieldOn(); 
    … …  
    53125369/*FUNCTION Triangles::TriangleReferenceList{{{1*/
    53135370long  Triangles::TriangleReferenceList(long* reft) const {
     5371        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ConsRefTriangle)*/
     5372
    53145373        long int verbosity=0;
    53155374        register Triangle *t0,*t;
    … …  
    53505409/*FUNCTION Triangles::UnCrack{{{1*/
    53515410int Triangles::UnCrack() {
     5411        /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/UnCrack)*/
     5412
    53525413        if (NbCrackedEdges!=0 && NbCrackedVertices<=0);{
    53535414                throw ErrorException(__FUNCT__,exprintf("NbCrackedEdges ==0 || NbCrackedVertices >0"));
    … …  
    53625423        /*FUNCTION swap{{{1*/
    53635424        void  swap(Triangle *t1,short a1, Triangle *t2,short a2, Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2){
     5425                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
    53645426                // --------------------------------------------------------------
    53655427                // short a2=aa[a];// les 2 numero de l arete dans les 2 triangles
    … …  
    54065468        /*FUNCTION CloseBoundaryEdge{{{1*/
    54075469        TriangleAdjacent CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) {
     5470                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CloseBoundaryEdge)*/
     5471
    54085472                int k=(*t)(0) ?  ((  (*t)(1) ? ( (*t)(2) ? -1 : 2) : 1  )) : 0;
    54095473                int dir=0;
    … …  
    54445508        /*FUNCTION CloseBoundaryEdgeV2{{{1*/
    54455509        TriangleAdjacent CloseBoundaryEdgeV2(I2 C,Triangle *t, double &a,double &b) {
     5510                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CloseBoundaryEdgeV2)*/
    54465511                // walk around the vertex
    54475512                // version 2 for remove the probleme if we fill the hole
    … …  
    55925657        /*FUNCTION AGoodNumberPrimeWith{{{1*/
    55935658        long AGoodNumberPrimeWith(long n){
     5659                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/AGoodNumberPrimeWith)*/
    55945660
    55955661                //list of big prime numbers
    … …  
    56215687        /*FUNCTION SwapForForcingEdge{{{1*/
    56225688        int SwapForForcingEdge(Vertex   *  & pva ,Vertex  * &   pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
     5689                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SwapForForcingEdge)*/
    56235690                // l'arete ta coupe l'arete pva pvb
    56245691                // de cas apres le swap sa coupe toujours
    … …  
    57075774        /*}}}1*/
    57085775        /*FUNCTION ForceEdge{{{1*/
    5709 
    57105776        int ForceEdge(Vertex &a, Vertex & b,TriangleAdjacent & taret)  {
     5777                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
     5778
    57115779                int NbSwap =0;
    57125780                if (!a.t || !b.t){ // the 2 vertex is in a mesh

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

    r3243 r3246  
    1515        /*FUNCTION Vertex::Smoothing{{{1*/
    1616        double  Vertex::Smoothing(Triangles &Th,const Triangles &BTh,Triangle* &tstart ,double omega){
     17                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Smoothing)*/
    1718
    1819                register Vertex* s=this;
    … …  
    212213        /*FUNCTION QuadQuality{{{1*/
    213214        double QuadQuality(const Vertex & a,const Vertex &b,const Vertex &c,const Vertex &d) {
     215                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/QuadQuality)*/
     216
    214217                // calcul de 4 angles --
    215218                R2 A((R2)a),B((R2)b),C((R2)c),D((R2)d);

  • issm/trunk/src/c/Bamgx/shared/FindTriangleAdjacent.h

    r3237 r3246  
    88
    99        inline TriangleAdjacent FindTriangleAdjacent(Edge &E){
     10                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
     11
    1012                Vertex * a = E.v[0];
    1113                Vertex * b = E.v[1];

  • issm/trunk/src/c/Bamgx/shared/TheVertex.h

    r3236 r3246  
    88
    99        inline Vertex* TheVertex(Vertex * a){// for remove crak in mesh
     10                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp)*/
     11
    1012                // give a unique vertex with smallest number
    1113                // in case on crack in mesh
Note: See TracChangeset for help on using the changeset viewer.