Changeset 18064


Ignore:
Timestamp:
05/26/14 21:40:16 (11 years ago)
Author:
Mathieu Morlighem
Message:

DEL: removed all FUNCTIONs

Location:
issm/trunk-jpl/src/c
Files:
92 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/bamg/AdjacentTriangle.cpp

    r16233 r18064  
    1313
    1414        /*Methods*/
    15         /*FUNCTION AdjacentTriangle::Locked {{{*/
    16         int  AdjacentTriangle::Locked() const {
     15        int  AdjacentTriangle::Locked() const {/*{{{*/
    1716                return t->AdjEdgeIndex[a] & 4;
    1817        }
    1918        /*}}}*/
    20         /*FUNCTION AdjacentTriangle::GetAllFlag_UnSwap {{{*/
    21         int  AdjacentTriangle::GetAllFlag_UnSwap() const {
     19        int  AdjacentTriangle::GetAllFlag_UnSwap() const {/*{{{*/
    2220                // take all flag except MarkUnSwap
    2321                return t->AdjEdgeIndex[a] & 1012;
    2422        }
    2523        /*}}}*/
    26         /*FUNCTION AdjacentTriangle::SetLock {{{*/
    27         void AdjacentTriangle::SetLock(){
     24        void AdjacentTriangle::SetLock(){/*{{{*/
    2825                t->SetLocked(a);
    2926        }
    3027        /*}}}*/
    31         /*FUNCTION AdjacentTriangle::Adj {{{*/
    32         AdjacentTriangle AdjacentTriangle::Adj() const {
     28        AdjacentTriangle AdjacentTriangle::Adj() const {/*{{{*/
    3329                return  t->Adj(a);
    3430        }
    3531        /*}}}*/
    36         /*FUNCTION AdjacentTriangle::EdgeVertex {{{*/
    37         BamgVertex* AdjacentTriangle::EdgeVertex(const int & i) const {
     32        BamgVertex* AdjacentTriangle::EdgeVertex(const int & i) const {/*{{{*/
    3833                return t->vertices[VerticesOfTriangularEdge[a][i]];
    3934        }
    4035        /*}}}*/
    41         /*FUNCTION AdjacentTriangle::det {{{*/
    42         Icoor2 & AdjacentTriangle::det() const {
     36        Icoor2 & AdjacentTriangle::det() const {/*{{{*/
    4337                return t->det;
    4438        }
    4539        /*}}}*/
    46         /*FUNCTION AdjacentTriangle::swap {{{*/
    47         int AdjacentTriangle::swap(){
     40        int AdjacentTriangle::swap(){/*{{{*/
    4841                return  t->swap(a);
    4942        }
    5043        /*}}}*/
    51         /*FUNCTION AdjacentTriangle::SetAdj2 {{{*/
    52         void AdjacentTriangle::SetAdj2(const AdjacentTriangle & ta, int l  ){
     44        void AdjacentTriangle::SetAdj2(const AdjacentTriangle & ta, int l  ){/*{{{*/
    5345                //set Adjacent Triangle of a triangle
    5446                if(t) {

  • issm/trunk-jpl/src/c/bamg/BamgGeom.cpp

    r15066 r18064  
    33
    44/*Constructors/Destructors*/
    5 /*FUNCTION BamgGeom::BamgGeom(){{{*/
    6 BamgGeom::BamgGeom(){
     5BamgGeom::BamgGeom(){/*{{{*/
    76
    87        this->VerticesSize[0]=0,          this->VerticesSize[1]=0;          this->Vertices=NULL;
    … …  
    1716}
    1817/*}}}*/
    19 /*FUNCTION BamgGeom::~BamgGeom(){{{*/
    20 BamgGeom::~BamgGeom(){
     18BamgGeom::~BamgGeom(){/*{{{*/
    2119
    2220        xDelete<double>(this->Vertices);

  • issm/trunk-jpl/src/c/bamg/BamgMesh.cpp

    r15066 r18064  
    33
    44/*Constructors/Destructors*/
    5 /*FUNCTION BamgMesh::BamgMesh(){{{*/
    6 BamgMesh::BamgMesh(){
     5BamgMesh::BamgMesh(){/*{{{*/
    76
    87        this->VerticesSize[0]=0,                  this->VerticesSize[1]=0;                 this->Vertices=NULL;
    … …  
    2827}
    2928/*}}}*/
    30 /*FUNCTION BamgMesh::~BamgMesh(){{{*/
    31 BamgMesh::~BamgMesh(){
     29BamgMesh::~BamgMesh(){/*{{{*/
    3230
    3331        xDelete<double>(this->Vertices);

  • issm/trunk-jpl/src/c/bamg/BamgOpts.cpp

    r16967 r18064  
    33
    44/*Constructors/Destructors*/
    5 /*FUNCTION BamgOpts::BamgOpts() {{{*/
    6 BamgOpts::BamgOpts(){
     5BamgOpts::BamgOpts(){/*{{{*/
    76
    87        this->anisomax=0;
    … …  
    3938}
    4039/*}}}*/
    41 /*FUNCTION BamgOpts::~BamgOpts() {{{*/
    42 BamgOpts::~BamgOpts(){
     40BamgOpts::~BamgOpts(){/*{{{*/
    4341
    4442        xDelete<double>(this->hminVertices);
    … …  
    5351
    5452/*Methods*/
    55 /*FUNCTION BamgOpts::Check{{{*/
    56 void BamgOpts::Check(void){
     53void BamgOpts::Check(void){/*{{{*/
    5754
    5855        int i;

  • issm/trunk-jpl/src/c/bamg/BamgQuadtree.cpp

    r17507 r18064  
    9898
    9999        /*Constructors/Destructors*/
    100         /*FUNCTION BamgQuadtree::BamgQuadtree(){{{*/
    101         BamgQuadtree::BamgQuadtree(){
     100        BamgQuadtree::BamgQuadtree(){/*{{{*/
    102101
    103102                /*Number of boxes and vertices*/
    … …  
    113112                }
    114113        /*}}}*/
    115         /*FUNCTION BamgQuadtree::BamgQuadtree(Mesh * t,long nbv){{{*/
    116         BamgQuadtree::BamgQuadtree(Mesh * t,long nbv){
     114        BamgQuadtree::BamgQuadtree(Mesh * t,long nbv){ /*{{{*/
    117115
    118116                /*Number of boxes and vertices*/
    … …  
    135133        }
    136134        /*}}}*/
    137         /*FUNCTION BamgQuadtree::~BamgQuadtree(){{{*/
    138         BamgQuadtree::~BamgQuadtree() {
     135        BamgQuadtree::~BamgQuadtree() {/*{{{*/
    139136                delete boxcontainer;
    140137                root=NULL;
    … …  
    143140
    144141        /*Methods*/
    145         /*FUNCTION BamgQuadtree::Add{{{*/
    146         void  BamgQuadtree::Add(BamgVertex &w){
     142        void  BamgQuadtree::Add(BamgVertex &w){/*{{{*/
    147143                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, BamgQuadtree.cpp/Add)*/
    148144                BamgQuadtreeBox** pb=NULL;
    … …  
    232228        }
    233229        /*}}}*/
    234         /*FUNCTION BamgQuadtree::NearestVertex{{{*/
    235         BamgVertex*  BamgQuadtree::NearestVertex(Icoor1 i,Icoor1 j) {
     230        BamgVertex*  BamgQuadtree::NearestVertex(Icoor1 i,Icoor1 j) {/*{{{*/
    236231                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, BamgQuadtree.cpp/NearestVertex)*/
    237232
    … …  
    391386        }
    392387        /*}}}*/
    393         /*FUNCTION BamgQuadtree::NewBamgQuadtreeBox {{{*/
    394         BamgQuadtree::BamgQuadtreeBox* BamgQuadtree::NewBamgQuadtreeBox(void){
     388        BamgQuadtree::BamgQuadtreeBox* BamgQuadtree::NewBamgQuadtreeBox(void){/*{{{*/
    395389
    396390                /*Output*/
    … …  
    414408                return newbox;
    415409        }/*}}}*/
    416         /*FUNCTION BamgQuadtree::ToClose {{{*/
    417         BamgVertex*   BamgQuadtree::ToClose(BamgVertex & v,double seuil,Icoor1 hx,Icoor1 hy){
     410        BamgVertex*   BamgQuadtree::ToClose(BamgVertex & v,double seuil,Icoor1 hx,Icoor1 hy){/*{{{*/
    418411                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, BamgQuadtree.cpp/ToClose)*/
    419412

  • issm/trunk-jpl/src/c/bamg/BamgVertex.cpp

    r17507 r18064  
    1111
    1212        /*Methods*/
    13         /*FUNCTION BamgVertex::Echo {{{*/
    14 
    15         void BamgVertex::Echo(void){
     13        void BamgVertex::Echo(void){/*{{{*/
    1614
    1715                _printf_("Vertex:\n");
    … …  
    2422        }
    2523        /*}}}*/
    26         /*FUNCTION BamgVertex::GetReferenceNumber{{{*/
    27         int  BamgVertex::GetReferenceNumber() const {
     24        int  BamgVertex::GetReferenceNumber() const { /*{{{*/
    2825                return ReferenceNumber;
    2926        }
    3027        /*}}}*/
    31         /*FUNCTION BamgVertex::MetricFromHessian{{{*/
    32         void BamgVertex::MetricFromHessian(const double Hxx,const double Hyx, const double Hyy,const double smin,const double smax,const double s,double err,BamgOpts* bamgopts){
     28        void BamgVertex::MetricFromHessian(const double Hxx,const double Hyx, const double Hyy,const double smin,const double smax,const double s,double err,BamgOpts* bamgopts){/*{{{*/
    3329                /*Compute Metric from Hessian*/
    3430
    … …  
    108104        }
    109105        /*}}}*/
    110         /*FUNCTION BamgVertex::Optim {{{*/
    111         long BamgVertex::Optim(int i,int koption){
     106        long BamgVertex::Optim(int i,int koption){ /*{{{*/
    112107                long ret=0;
    113108                if ( t && (IndexInTriangle >= 0 ) && (IndexInTriangle <3) ){
    … …  
    121116        }
    122117        /*}}}*/
    123         /*FUNCTION BamgVertex::Smoothing{{{*/
    124         double  BamgVertex::Smoothing(Mesh &Th,const Mesh &BTh,Triangle* &tstart ,double omega){
     118        double  BamgVertex::Smoothing(Mesh &Th,const Mesh &BTh,Triangle* &tstart ,double omega){/*{{{*/
    125119                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Smoothing)*/
    126120
    … …  
    227221
    228222        /*Intermediary*/
    229         /*FUNCTION QuadQuality{{{*/
    230         double QuadQuality(const BamgVertex & a,const BamgVertex &b,const BamgVertex &c,const BamgVertex &d) {
     223        double QuadQuality(const BamgVertex & a,const BamgVertex &b,const BamgVertex &c,const BamgVertex &d) {/*{{{*/
    231224                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/QuadQuality)*/
    232225

  • issm/trunk-jpl/src/c/bamg/CrackedEdge.cpp

    r12821 r18064  
    99
    1010        /*Constructors/Destructors*/
    11         /*FUNCTION CrackedEdge() {{{*/
    12         CrackedEdge::CrackedEdge() {
     11        CrackedEdge::CrackedEdge() {/*{{{*/
    1312                a=NULL;
    1413                b=NULL;

  • issm/trunk-jpl/src/c/bamg/Curve.cpp

    r16231 r18064  
    1010
    1111        /*Constructors/Destructors*/
    12         /*FUNCTION Curve::Curve(){{{*/
    13         Curve::Curve(){
     12        Curve::Curve(){/*{{{*/
    1413                FirstEdge=NULL;
    1514                LastEdge=NULL;
    … …  
    2019
    2120        /*Methods*/
    22         /*FUNCTION Curve::Set {{{*/
    23         void Curve::Set(const Curve & rec,const Geometry & Gh ,Geometry & GhNew){
     21        void Curve::Set(const Curve & rec,const Geometry & Gh ,Geometry & GhNew){/*{{{*/
    2422                *this = rec;
    2523                FirstEdge = GhNew.edges + Gh.GetId(FirstEdge);   

  • issm/trunk-jpl/src/c/bamg/Direction.cpp

    r16158 r18064  
    99
    1010        /*Constructors/Destructors*/
    11         /*FUNCTION Direction() {{{*/
    12         Direction::Direction():
     11        Direction::Direction():/*{{{*/
    1312                dir(MaxICoor){
    1413
    1514        }/*}}}*/
    16         /*FUNCTION Direction(Icoor1 i,Icoor1 j) {{{*/
    17         Direction::Direction(Icoor1 i,Icoor1 j) {
     15        Direction::Direction(Icoor1 i,Icoor1 j) {/*{{{*/
    1816                Icoor2 n2 = 2*(Abs(i)+Abs(j)); 
    1917                Icoor2 r  = MaxICoor* (Icoor2) i;
    … …  
    2321
    2422        /*Methods*/
    25         /*FUNCTION Direction::direction{{{*/
    26         int Direction::direction(Icoor1 i,Icoor1 j) {
     23        int Direction::direction(Icoor1 i,Icoor1 j) {/*{{{*/
    2724                int r =1;
    2825                if (dir!= MaxICoor) {

  • issm/trunk-jpl/src/c/bamg/Edge.cpp

    r15104 r18064  
    1414
    1515        /*Methods*/
    16         /*FUNCTION Edge::Set {{{*/
    17         void Edge::Set(const Mesh & Th ,long i,Mesh & ThNew){
     16        void Edge::Set(const Mesh & Th ,long i,Mesh & ThNew){ /*{{{*/
    1817                *this = Th.edges[i];
    1918                v[0] = ThNew.vertices + Th.GetId(v[0]);   
    … …  
    2524        }
    2625        /*}}}*/
    27         /*FUNCTION Edge::Echo {{{*/
    28         void Edge::Echo(void){
     26        void Edge::Echo(void){ /*{{{*/
    2927                _printf_("Edge:\n");
    3028                _printf_("   pointers towards two vertices: " << v[0] << " " << v[1] << "\n");
    … …  
    3432        }
    3533        /*}}}*/
    36         /*FUNCTION Edge::Renumbering{{{*/
    37         void Edge::Renumbering(BamgVertex *vb,BamgVertex *ve, long *renu){
     34        void Edge::Renumbering(BamgVertex *vb,BamgVertex *ve, long *renu){/*{{{*/
    3835
    3936                if (v[0] >=vb && v[0] <ve) v[0] = vb + renu[v[0]-vb];
    … …  
    4239        }
    4340        /*}}}*/
    44         /*FUNCTION Edge::Intersection{{{*/
    45         int Edge::Intersection(const  Edge & e){
     41        int Edge::Intersection(const  Edge & e){ /*{{{*/
    4642
    4743                /*some shecks*/

  • issm/trunk-jpl/src/c/bamg/EigenMetric.cpp

    r16237 r18064  
    1010
    1111        /*Constructor*/
    12         /*FUNCTION EigenMetric::EigenMetric(const Metric M){{{*/
    13         EigenMetric::EigenMetric(const Metric& M){
     12        EigenMetric::EigenMetric(const Metric& M){/*{{{*/
    1413                /*From a metric (a11,a21,a22), get eigen values lambda1 and lambda2 and one eigen vector v*/
    1514
    … …  
    8988        }
    9089        /*}}}*/
    91         /*FUNCTION EigenMetric::EigenMetric(double r1,double r2,const D2 vp1){{{*/
    92         EigenMetric::EigenMetric(double r1,double r2,const D2& vp1): lambda1(r1),lambda2(r2),v(vp1){
     90        EigenMetric::EigenMetric(double r1,double r2,const D2& vp1): lambda1(r1),lambda2(r2),v(vp1){/*{{{*/
    9391
    9492        }/*}}}*/
    9593
    9694        /*Methods*/
    97         /*FUNCTION EigenMetric::Abs{{{*/
    98         void   EigenMetric::Abs(){
     95        void   EigenMetric::Abs(){/*{{{*/
    9996                lambda1=bamg::Abs(lambda1),lambda2=bamg::Abs(lambda2);
    10097        }/*}}}*/
    101         /*FUNCTION EigenMetric::Aniso2{{{*/
    102         double EigenMetric::Aniso2() const  {
     98        double EigenMetric::Aniso2() const  { /*{{{*/
    10399                return lmax()/lmin();
    104100        }/*}}}*/
    105         /*FUNCTION EigenMetric::Echo {{{*/
    106         void EigenMetric::Echo(void){
     101        void EigenMetric::Echo(void){/*{{{*/
    107102
    108103                _printf_("EigenMetric:\n");
    … …  
    115110        }
    116111        /*}}}*/
    117         /*FUNCTION EigenMetric::hmin{{{*/
    118         double EigenMetric::hmin() const {
     112        double EigenMetric::hmin() const {/*{{{*/
    119113                return sqrt(1/bamg::Max3(lambda1,lambda2,1e-30));
    120114        }/*}}}*/
    121         /*FUNCTION EigenMetric::hmax{{{*/
    122         double EigenMetric::hmax() const {
     115        double EigenMetric::hmax() const {/*{{{*/
    123116                return sqrt(1/bamg::Max(bamg::Min(lambda1,lambda2),1e-30));
    124117        }/*}}}*/
    125         /*FUNCTION EigenMetric::lmax{{{*/
    126         double EigenMetric::lmax() const {
     118        double EigenMetric::lmax() const {/*{{{*/
    127119                return bamg::Max3(lambda1,lambda2,1e-30);
    128120        }/*}}}*/
    129         /*FUNCTION EigenMetric::lmin{{{*/
    130         double EigenMetric::lmin() const {
     121        double EigenMetric::lmin() const {/*{{{*/
    131122                return bamg::Max(bamg::Min(lambda1,lambda2),1e-30);
    132123        }/*}}}*/
    133         /*FUNCTION EigenMetric::Min{{{*/
    134         void   EigenMetric::Min(double a) {
     124        void   EigenMetric::Min(double a) { /*{{{*/
    135125                lambda1=bamg::Min(a,lambda1); lambda2=bamg::Min(a,lambda2) ;
    136126        }/*}}}*/
    137         /*FUNCTION EigenMetric::Max{{{*/
    138         void   EigenMetric::Max(double a) {
     127        void   EigenMetric::Max(double a) { /*{{{*/
    139128                //change eigen values
    140129                lambda1=bamg::Max(a,lambda1); lambda2=bamg::Max(a,lambda2) ;
    141130        }/*}}}*/
    142         /*FUNCTION EigenMetric::Minh{{{*/
    143         void   EigenMetric::Minh(double h) {
     131        void   EigenMetric::Minh(double h) {/*{{{*/
    144132                Min(1.0/(h*h));
    145133        }/*}}}*/
    146         /*FUNCTION EigenMetric::Maxh{{{*/
    147         void   EigenMetric::Maxh(double h) {
     134        void   EigenMetric::Maxh(double h) {/*{{{*/
    148135                //Call Max function
    149136                Max(1.0/(h*h));
    150137        }/*}}}*/
    151         /*FUNCTION EigenMetric::pow{{{*/
    152         void   EigenMetric::pow(double p){
     138        void   EigenMetric::pow(double p){/*{{{*/
    153139                lambda1=::pow(lambda1,p);lambda2=::pow(lambda2,p);
    154140        }/*}}}*/

  • issm/trunk-jpl/src/c/bamg/GeomEdge.cpp

    r16231 r18064  
    1515
    1616        /*Methods*/
    17         /*FUNCTION GeomEdge::Cracked{{{*/
    18         int    GeomEdge::Cracked() const  {
     17        int    GeomEdge::Cracked() const  {/*{{{*/
    1918                return type &1; 
    2019        }/*}}}*/
    21         /*FUNCTION GeomEdge::F{{{*/
    22         R2 GeomEdge::F(double theta) const{
     20        R2 GeomEdge::F(double theta) const{/*{{{*/
    2321                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/F)*/
    2422                // parametrization of the curve edge
    … …  
    6260          }
    6361        /*}}}*/
    64         /*FUNCTION GeomEdge::Mark{{{*/
    65         int    GeomEdge::Mark()    const  {
     62        int    GeomEdge::Mark()    const  {/*{{{*/
    6663                return type &16;
    6764        }/*}}}*/
    68         /*FUNCTION GeomEdge::R1tg{{{*/
    69         double GeomEdge::R1tg(double theta,R2 & t) const{
     65        double GeomEdge::R1tg(double theta,R2 & t) const{/*{{{*/
    7066                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/R1tg)*/
    7167                // 1/R of radius of cuvature
    … …  
    138134        }
    139135        /*}}}*/
    140         /*FUNCTION GeomEdge::Required{{{*/
    141         int    GeomEdge::Required()       {
     136        int    GeomEdge::Required()       {/*{{{*/
    142137                return type &64;
    143138        }/*}}}*/
    144         /*FUNCTION GeomEdge::Set {{{*/
    145         void GeomEdge::Set(const GeomEdge & rec,const Geometry & Gh ,Geometry & GhNew){
     139        void GeomEdge::Set(const GeomEdge & rec,const Geometry & Gh ,Geometry & GhNew){ /*{{{*/
    146140                *this = rec;
    147141                v[0] = GhNew.vertices + Gh.GetId(v[0]);   
    … …  
    151145        }
    152146        /*}}}*/
    153         /*FUNCTION GeomEdge::SetCracked{{{*/
    154         void   GeomEdge::SetCracked()     {
     147        void   GeomEdge::SetCracked()     { /*{{{*/
    155148                type |= 1;/*=>1st digit to 1*/
    156149        }/*}}}*/
    157         /*FUNCTION GeomEdge::SetTgA{{{*/
    158         void   GeomEdge::SetTgA()         {
     150        void   GeomEdge::SetTgA()         { /*{{{*/
    159151                type |=4; /*=>2d digit to 1*/
    160152        }/*}}}*/
    161         /*FUNCTION GeomEdge::SetTgB{{{*/
    162         void   GeomEdge::SetTgB()         {
     153        void   GeomEdge::SetTgB()         { /*{{{*/
    163154                type |=8; /*=> 3d digit to 1*/
    164155        }/*}}}*/
    165         /*FUNCTION GeomEdge::SetMark{{{*/
    166         void   GeomEdge::SetMark()        {
     156        void   GeomEdge::SetMark()        { /*{{{*/
    167157                type |=16;/*=> 4th digiy to 1*/
    168158        }/*}}}*/
    169         /*FUNCTION GeomEdge::SetUnMark{{{*/
    170         void   GeomEdge::SetUnMark()      {
     159        void   GeomEdge::SetUnMark()      { /*{{{*/
    171160                type &= 1007 /* 1023-16 = 000111110111 => 4th digit to 0*/;
    172161        }/*}}}*/
    173         /*FUNCTION GeomEdge::SetRequired{{{*/
    174         void   GeomEdge::SetRequired()    {
     162        void   GeomEdge::SetRequired()    { /*{{{*/
    175163                type |= 64;/*=>6th digit to 1*/
    176164        }/*}}}*/
    177         /*FUNCTION GeomEdge::TgA{{{*/
    178         int    GeomEdge::TgA()     const  {
     165        int    GeomEdge::TgA()     const  {/*{{{*/
    179166                return type &4; 
    180167        }/*}}}*/
    181         /*FUNCTION GeomEdge::TgB{{{*/
    182         int    GeomEdge::TgB()     const  {
     168        int    GeomEdge::TgB()     const  {/*{{{*/
    183169                return type &8; 
    184170        }/*}}}*/

  • issm/trunk-jpl/src/c/bamg/GeomSubDomain.cpp

    r12821 r18064  
    1212
    1313        /*Methods*/
    14         /*FUNCTION GeomSubDomain::Set {{{*/
    15         void GeomSubDomain::Set(const GeomSubDomain & rec,const Geometry & Gh ,const Geometry & GhNew){
     14        void GeomSubDomain::Set(const GeomSubDomain & rec,const Geometry & Gh ,const Geometry & GhNew){/*{{{*/
    1615                *this = rec;
    1716                edge = Gh.GetId(edge) + GhNew.edges;

  • issm/trunk-jpl/src/c/bamg/GeomVertex.cpp

    r15067 r18064  
    1313
    1414        /*Methods*/
    15         /*FUNCTION GeomVertex::Corner {{{*/
    16         int  GeomVertex::Corner() const {
     15        int  GeomVertex::Corner() const {/*{{{*/
    1716                return type & 4;
    1817        }
    1918        /*}}}*/
    20         /*FUNCTION GeomVertex::Required {{{*/
    21         int  GeomVertex::Required()const {
     19        int  GeomVertex::Required()const {/*{{{*/
    2220                // a corner is required
    2321                return type & 6;
    2422        }
    2523        /*}}}*/
    26         /*FUNCTION GeomVertex::SetCorner {{{*/
    27         void GeomVertex::SetCorner(){
     24        void GeomVertex::SetCorner(){/*{{{*/
    2825                type |= 4;
    2926        }
    3027        /*}}}*/
    31         /*FUNCTION GeomVertex::SetRequired {{{*/
    32         void GeomVertex::SetRequired(){
     28        void GeomVertex::SetRequired(){/*{{{*/
    3329                type |= 2;
    3430        }

  • issm/trunk-jpl/src/c/bamg/Geometry.cpp

    r17507 r18064  
    1212
    1313        /*Constructors/Destructors*/
    14         /*FUNCTION Geometry::Geometry(){{{*/
    15         Geometry::Geometry(){
     14        Geometry::Geometry(){/*{{{*/
    1615                Init();
    1716        }
    1817        /*}}}*/
    19         /*FUNCTION Geometry::Geometry(BamgGeom* bamggeom, BamgOpts* bamgopts){{{*/
    20         Geometry::Geometry(BamgGeom* bamggeom, BamgOpts* bamgopts){
     18        Geometry::Geometry(BamgGeom* bamggeom, BamgOpts* bamgopts){/*{{{*/
    2119                Init();
    2220                ReadGeometry(bamggeom,bamgopts);
    … …  
    2422        }
    2523        /*}}}*/
    26         /*FUNCTION Geometry::Geometry(const Geometry & Gh) (COPY operator){{{*/
    27         Geometry::Geometry(const Geometry & Gh) {
     24        Geometry::Geometry(const Geometry & Gh) {/*{{{*/
    2825                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/Geometry)*/
    2926
    … …  
    4441        }
    4542        /*}}}*/
    46         /*FUNCTION Geometry::~Geometry(){{{*/
    47         Geometry::~Geometry() {
     43        Geometry::~Geometry() {/*{{{*/
    4844                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/~Geometry)*/
    4945                if(NbRef>0){   _printf_("Trying to delete geometry and NbRef>0, probably due to an error"); return;}
    … …  
    5854
    5955        /*IO*/
    60         /*FUNCTION Geometry::ReadGeometry{{{*/
    61         void Geometry::ReadGeometry(BamgGeom* bamggeom,BamgOpts* bamgopts){
     56        void Geometry::ReadGeometry(BamgGeom* bamggeom,BamgOpts* bamgopts){/*{{{*/
    6257
    6358                int verbose;
    … …  
    277272        }
    278273        /*}}}*/
    279         /*FUNCTION Geometry::WriteGeometry{{{*/
    280         void Geometry::WriteGeometry(BamgGeom* bamggeom, BamgOpts* bamgopts){
     274        void Geometry::WriteGeometry(BamgGeom* bamggeom, BamgOpts* bamgopts){/*{{{*/
    281275
    282276                int verbose;
    … …  
    394388
    395389        /*Methods*/
    396         /*FUNCTION Geometry::Echo {{{*/
    397         void Geometry::Echo(void){
     390        void Geometry::Echo(void){/*{{{*/
    398391
    399392                _printf_("Geometry:\n");
    … …  
    415408        }
    416409        /*}}}*/
    417         /*FUNCTION Geometry::Init{{{*/
    418         void Geometry::Init(void){
     410        void Geometry::Init(void){/*{{{*/
    419411                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/EmptyGeometry)*/
    420412
    … …  
    432424        }
    433425        /*}}}*/
    434         /*FUNCTION Geometry::MinimalHmin{{{*/
    435         double Geometry::MinimalHmin() {
     426        double Geometry::MinimalHmin() {/*{{{*/
    436427                /* coeffIcoor = (2^30-1)/D
    437428                 * We cannot go beyond hmin = D/2^30 because of the quadtree
    … …  
    439430                return 2.0/coefIcoor;
    440431        }/*}}}*/
    441         /*FUNCTION Geometry::MaximalHmax{{{*/
    442         double Geometry::MaximalHmax() {
     432        double Geometry::MaximalHmax() {/*{{{*/
    443433                return Max(pmax.x-pmin.x,pmax.y-pmin.y);
    444434        }/*}}}*/
    445         /*FUNCTION Geometry::GetId(const GeomVertex &t){{{*/
    446         long Geometry::GetId(const GeomVertex & t) const  {
     435        long Geometry::GetId(const GeomVertex & t) const  {/*{{{*/
    447436                return &t - vertices;
    448437        }/*}}}*/
    449         /*FUNCTION Geometry::GetId(const GeomVertex * t){{{*/
    450         long Geometry::GetId(const GeomVertex * t) const  {
     438        long Geometry::GetId(const GeomVertex * t) const  {/*{{{*/
    451439                return t - vertices;
    452440        }/*}}}*/
    453         /*FUNCTION Geometry::GetId(const GeomEdge & t){{{*/
    454         long Geometry::GetId(const GeomEdge & t) const  {
     441        long Geometry::GetId(const GeomEdge & t) const  {/*{{{*/
    455442                return &t - edges;
    456443        }/*}}}*/
    457         /*FUNCTION Geometry::GetId(const GeomEdge * t){{{*/
    458         long Geometry::GetId(const GeomEdge * t) const  {
     444        long Geometry::GetId(const GeomEdge * t) const  {/*{{{*/
    459445                return t - edges;
    460446        }/*}}}*/
    461         /*FUNCTION Geometry::GetId(const Curve * c){{{*/
    462         long Geometry::GetId(const Curve * c) const  {
     447        long Geometry::GetId(const Curve * c) const  {/*{{{*/
    463448                return c - curves;
    464449        }/*}}}*/
    465         /*FUNCTION Geometry::PostRead{{{*/
    466         void Geometry::PostRead(){
     450        void Geometry::PostRead(){/*{{{*/
    467451                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/AfterRead)*/
    468452
    … …  
    785769        }
    786770        /*}}}*/
    787         /*FUNCTION Geometry::ProjectOnCurve {{{*/
    788         GeomEdge* Geometry::ProjectOnCurve(const Edge &e,double s,BamgVertex &V,VertexOnGeom &GV) const {
     771        GeomEdge* Geometry::ProjectOnCurve(const Edge &e,double s,BamgVertex &V,VertexOnGeom &GV) const {/*{{{*/
    789772                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/ProjectOnCurve)*/
    790773                /*Add a vertex on an existing geometrical edge according to the metrics of the two vertices constituting the edge*/
    … …  
    918901        }
    919902        /*}}}*/
    920         /*FUNCTION Geometry::R2ToI2{{{*/
    921         I2 Geometry::R2ToI2(const R2 & P) const {
     903        I2 Geometry::R2ToI2(const R2 & P) const {/*{{{*/
    922904                /*coefIcoor is the coefficient used for integer coordinates:
    923905                 *                       (x-pmin.x)
    … …  
    931913                return  I2( (Icoor1) (coefIcoor*(P.x-pmin.x)) ,(Icoor1) (coefIcoor*(P.y-pmin.y)) );
    932914        }/*}}}*/
    933         /*FUNCTION Geometry::UnMarkEdges{{{*/
    934         void Geometry::UnMarkEdges() {
     915        void Geometry::UnMarkEdges() {/*{{{*/
    935916                for (int i=0;i<nbe;i++) edges[i].SetUnMark();
    936917        }/*}}}*/

  • issm/trunk-jpl/src/c/bamg/ListofIntersectionTriangles.cpp

    r17507 r18064  
    1111
    1212        /*Constructors Destructors*/
    13         /*FUNCTION ListofIntersectionTriangles::ListofIntersectionTriangles{{{*/
    14         ListofIntersectionTriangles::ListofIntersectionTriangles(int n,int m)
     13        ListofIntersectionTriangles::ListofIntersectionTriangles(int n,int m)/*{{{*/
    1514          : MaxSize(n), Size(0), len(-1),state(-1),lIntTria(new IntersectionTriangles[n]) ,
    1615          NbSeg(0), MaxNbSeg(m), lSegsI(new SegInterpolation[m]){
    1716          }
    1817        /*}}}*/
    19         /*FUNCTION ListofIntersectionTriangles::~ListofIntersectionTriangles{{{*/
    20         ListofIntersectionTriangles::~ListofIntersectionTriangles(){
     18        ListofIntersectionTriangles::~ListofIntersectionTriangles(){/*{{{*/
    2119                if (lIntTria) delete [] lIntTria,lIntTria=0;
    2220                if (lSegsI) delete [] lSegsI,lSegsI=0;
    … …  
    2523
    2624        /*Methods*/
    27         /*FUNCTION ListofIntersectionTriangles::Init{{{*/
    28         void ListofIntersectionTriangles::Init(void){
     25        void ListofIntersectionTriangles::Init(void){/*{{{*/
    2926                state=0;
    3027                len=0;
    … …  
    3229        }
    3330        /*}}}*/
    34         /*FUNCTION ListofIntersectionTriangles::Length{{{*/
    35         double  ListofIntersectionTriangles::Length(){
     31        double  ListofIntersectionTriangles::Length(){/*{{{*/
    3632                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Length)*/
    3733
    … …  
    7975        }
    8076        /*}}}*/
    81         /*FUNCTION ListofIntersectionTriangles::NewItem(Triangle * tt,double d0,double d1,double d2) {{{*/
    82         int  ListofIntersectionTriangles::NewItem(Triangle * tt,double d0,double d1,double d2) {
     77        int  ListofIntersectionTriangles::NewItem(Triangle * tt,double d0,double d1,double d2) { /*{{{*/
    8378                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewItem)*/
    8479
    … …  
    107102        }
    108103        /*}}}*/
    109         /*FUNCTION ListofIntersectionTriangles::NewItem(R2 A,const Metric & mm){{{*/
    110         int ListofIntersectionTriangles::NewItem(R2 A,const Metric & mm) {
     104        int ListofIntersectionTriangles::NewItem(R2 A,const Metric & mm) {/*{{{*/
    111105                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewItem)*/
    112106
    … …  
    123117        }
    124118        /*}}}*/
    125         /*FUNCTION ListofIntersectionTriangles::NewPoints{{{*/
    126         long ListofIntersectionTriangles::NewPoints(BamgVertex* vertices,long &nbv,long maxnbv){
     119        long ListofIntersectionTriangles::NewPoints(BamgVertex* vertices,long &nbv,long maxnbv){/*{{{*/
    127120                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewPoints)*/
    128121
    … …  
    180173        }
    181174        /*}}}*/
    182         /*FUNCTION ListofIntersectionTriangles::ReShape{{{*/
    183         void ListofIntersectionTriangles::ReShape(){
     175        void ListofIntersectionTriangles::ReShape(){ /*{{{*/
    184176
    185177                int newsize = MaxSize*2;
    … …  
    196188        }
    197189        /*}}}*/
    198         /*FUNCTION ListofIntersectionTriangles::SplitEdge{{{*/
    199         void ListofIntersectionTriangles::SplitEdge(const Mesh & Bh, const R2 &A,const R2  &B,int nbegin) {
     190        void ListofIntersectionTriangles::SplitEdge(const Mesh & Bh, const R2 &A,const R2  &B,int nbegin) {/*{{{*/
    200191                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ListofIntersectionTriangles)*/
    201192

  • issm/trunk-jpl/src/c/bamg/Mesh.cpp

    r17507 r18064  
    1313
    1414        /*Constructors/Destructors*/
    15         /*FUNCTION Mesh::Mesh(BamgGeom* bamggeom,BamgMesh* bamgmesh, BamgOpts* bamgopts){{{*/
    16         Mesh::Mesh(BamgGeom* bamggeom,BamgMesh* bamgmesh, BamgOpts* bamgopts):Gh(*(new Geometry())),BTh(*this){
     15        Mesh::Mesh(BamgGeom* bamggeom,BamgMesh* bamgmesh, BamgOpts* bamgopts):Gh(*(new Geometry())),BTh(*this){ /*{{{*/
    1716
    1817                /*Initialize fields*/
    … …  
    4342        }
    4443        /*}}}*/
    45         /*FUNCTION Mesh::Mesh(int* index,double* x,double* y,int nods,int nels){{{*/
    46         Mesh::Mesh(int* index,double* x,double* y,int nods,int nels):Gh(*(new Geometry())),BTh(*this){
     44        Mesh::Mesh(int* index,double* x,double* y,int nods,int nels):Gh(*(new Geometry())),BTh(*this){/*{{{*/
    4745
    4846                Init(0);
    … …  
    5250        }
    5351        /*}}}*/
    54         /*FUNCTION Mesh::Mesh(double* x,double* y,int nods){{{*/
    55         Mesh::Mesh(double* x,double* y,int nods):Gh(*(new Geometry())),BTh(*this){
     52        Mesh::Mesh(double* x,double* y,int nods):Gh(*(new Geometry())),BTh(*this){/*{{{*/
    5653                Triangulate(x,y,nods);
    5754        }
    5855        /*}}}*/
    59         /*FUNCTION Mesh::Mesh(const Mesh & Tho,const int *flag ,const int *bb){{{*/
    60         Mesh::Mesh(const Mesh & Tho,const int *flag ,const int *bb,BamgOpts* bamgopts) : Gh(*(new Geometry())), BTh(*this) {
     56        Mesh::Mesh(const Mesh & Tho,const int *flag ,const int *bb,BamgOpts* bamgopts) : Gh(*(new Geometry())), BTh(*this) {/*{{{*/
    6157                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Triangles)*/
    6258
    … …  
    156152          }
    157153        /*}}}*/
    158         /*FUNCTION Mesh::Mesh(Mesh & Th,Geometry * pGh,Mesh * pBth,long maxnbv_in) COPY{{{*/
    159         Mesh::Mesh(Mesh & Th,Geometry * pGh,Mesh * pBth,long maxnbv_in)
     154        Mesh::Mesh(Mesh & Th,Geometry * pGh,Mesh * pBth,long maxnbv_in)/*{{{*/
    160155          : Gh(*(pGh?pGh:&Th.Gh)), BTh(*(pBth?pBth:this)) {
    161156                  /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Triangles)*/
    … …  
    219214          }
    220215        /*}}}*/
    221         /*FUNCTION Mesh::Mesh(long maxnbv,Mesh & BT,BamgOpts* bamgopts,int keepBackVertices){{{*/
    222         Mesh::Mesh(long imaxnbv,Mesh & BT,BamgOpts* bamgopts,int keepBackVertices) :Gh(BT.Gh),BTh(BT) {
     216        Mesh::Mesh(long imaxnbv,Mesh & BT,BamgOpts* bamgopts,int keepBackVertices) :Gh(BT.Gh),BTh(BT) {/*{{{*/
    223217                this->Init(imaxnbv);
    224218                TriangulateFromGeom1(bamgopts,keepBackVertices);
    225219        }
    226220        /*}}}*/
    227         /*FUNCTION Mesh::Mesh(long maxnbv,Geometry & G,BamgOpts* bamgopts){{{*/
    228         Mesh::Mesh(long imaxnbv,Geometry & G,BamgOpts* bamgopts):Gh(G),BTh(*this){
     221        Mesh::Mesh(long imaxnbv,Geometry & G,BamgOpts* bamgopts):Gh(G),BTh(*this){/*{{{*/
    229222                Init(imaxnbv);
    230223                TriangulateFromGeom0(bamgopts);
    231224        }
    232225        /*}}}*/
    233         /*FUNCTION Mesh::~Mesh(){{{*/
    234         Mesh::~Mesh() {
     226        Mesh::~Mesh() {/*{{{*/
    235227                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Triangles)*/
    236228
    … …  
    259251
    260252        /*IO*/
    261         /*FUNCTION Mesh::ReadMesh(int* index,double* x,double* y,int nods,int nels){{{*/
    262         void Mesh::ReadMesh(int* index,double* x,double* y,int nods,int nels){
     253        void Mesh::ReadMesh(int* index,double* x,double* y,int nods,int nels){/*{{{*/
    263254
    264255                long i1,i2,i3;
    … …  
    322313        }
    323314        /*}}}*/
    324         /*FUNCTION Mesh::ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts){{{*/
    325         void Mesh::ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts){
     315        void Mesh::ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts){/*{{{*/
    326316
    327317                int    verbose;
    … …  
    525515        }
    526516        /*}}}*/
    527         /*FUNCTION Mesh::WriteMesh {{{*/
    528         void Mesh::WriteMesh(BamgMesh* bamgmesh,BamgOpts* bamgopts){
     517        void Mesh::WriteMesh(BamgMesh* bamgmesh,BamgOpts* bamgopts){/*{{{*/
    529518
    530519                /*Intermediary*/
    … …  
    952941        }
    953942        /*}}}*/
    954         /*FUNCTION Mesh::ReadMetric{{{*/
    955         void Mesh::ReadMetric(const BamgOpts* bamgopts) {
     943        void Mesh::ReadMetric(const BamgOpts* bamgopts) {/*{{{*/
    956944
    957945                /*Intermediary*/
    … …  
    990978        }
    991979        /*}}}*/
    992         /*FUNCTION Mesh::WriteMetric{{{*/
    993         void Mesh::WriteMetric(BamgOpts* bamgopts) {
     980        void Mesh::WriteMetric(BamgOpts* bamgopts) {/*{{{*/
    994981                int i;
    995982                xDelete<double>(bamgopts->metric);
    … …  
    1002989        }
    1003990        /*}}}*/
    1004         /*FUNCTION Mesh::WriteIndex{{{*/
    1005         void Mesh::WriteIndex(int** pindex,int* pnels){
     991        void Mesh::WriteIndex(int** pindex,int* pnels){/*{{{*/
    1006992
    1007993                /*Intermediary*/
    … …  
    10421028
    10431029        /*Methods*/
    1044         /*FUNCTION Mesh::AddGeometryMetric{{{*/
    1045         void Mesh::AddGeometryMetric(BamgOpts* bamgopts){
     1030        void Mesh::AddGeometryMetric(BamgOpts* bamgopts){/*{{{*/
    10461031                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/IntersectGeomMetric)*/
    10471032
    … …  
    10941079        }
    10951080        /*}}}*/
    1096         /*FUNCTION Mesh::AddMetric{{{*/
    1097         void Mesh::AddMetric(BamgOpts* bamgopts){
     1081        void Mesh::AddMetric(BamgOpts* bamgopts){/*{{{*/
    10981082                //  Hessiantype = 0 =>  H is computed using double L2 projection
    10991083                //  Hessiantype = 1 =>  H is computed with green formula
    … …  
    11131097        }
    11141098        /*}}}*/
    1115         /*FUNCTION Mesh::AddVertex{{{*/
    1116         void Mesh::AddVertex( BamgVertex &s,Triangle* t, Icoor2* det3) {
     1099        void Mesh::AddVertex( BamgVertex &s,Triangle* t, Icoor2* det3) {/*{{{*/
    11171100                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Add)*/
    11181101                // -------------------------------
    … …  
    12491232        }
    12501233        /*}}}*/
    1251         /*FUNCTION Mesh::BoundAnisotropy{{{*/
    1252         void  Mesh::BoundAnisotropy(double anisomax,double hminaniso) {
     1234        void  Mesh::BoundAnisotropy(double anisomax,double hminaniso) {/*{{{*/
    12531235                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/BoundAnisotropy)*/
    12541236
    … …  
    12891271        }
    12901272        /*}}}*/
    1291         /*FUNCTION Mesh::BuildGeometryFromMesh{{{*/
    1292         void Mesh::BuildGeometryFromMesh(BamgOpts* bamgopts){
     1273        void Mesh::BuildGeometryFromMesh(BamgOpts* bamgopts){/*{{{*/
    12931274                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/ConsGeometry)*/
    12941275
    … …  
    17391720        }
    17401721        /*}}}*/
    1741         /*FUNCTION Mesh::BuildMetric0 (double L2 projection){{{*/
    1742         void Mesh::BuildMetric0(BamgOpts* bamgopts){
     1722        void Mesh::BuildMetric0(BamgOpts* bamgopts){/*{{{*/
    17431723
    17441724                /*Options*/
    … …  
    19441924        }
    19451925        /*}}}*/
    1946         /*FUNCTION Mesh::BuildMetric1 (Green formula){{{*/
    1947         void Mesh::BuildMetric1(BamgOpts* bamgopts){
     1926        void Mesh::BuildMetric1(BamgOpts* bamgopts){/*{{{*/
    19481927                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/IntersectConsMetric)*/
    19491928
    … …  
    22372216        }
    22382217        /*}}}*/
    2239         /*FUNCTION Mesh::CrackMesh{{{*/
    2240         void Mesh::CrackMesh(BamgOpts* bamgopts) {
     2218        void Mesh::CrackMesh(BamgOpts* bamgopts) {/*{{{*/
    22412219                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CrackMesh)*/
    22422220
    … …  
    23852363        }
    23862364        /*}}}*/
    2387         /*FUNCTION Mesh::Echo{{{*/
    2388         void Mesh::Echo(void) {
     2365        void Mesh::Echo(void) {/*{{{*/
    23892366
    23902367                int i;
    … …  
    24092386        }
    24102387        /*}}}*/
    2411         /*FUNCTION Mesh::ForceBoundary{{{*/
    2412                 void Mesh::ForceBoundary() {
    2413                         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceBoundary)*/
    2414 
    2415                         long int verbose=2;
    2416                         int k=0;
    2417                         int nbfe=0,nbswp=0,Nbswap=0;
    2418 
    2419                         //display
    2420                         if (verbose > 2) _printf_("   ForceBoundary  nb of edge: " << nbe << "\n");
    2421 
    2422                         //check that there is no triangle with 0 determinant
    2423                         for (int t = 0; t < nbt; t++){
    2424                                 if (!triangles[t].det) k++;
    2425                         }
    2426                         if (k!=0) {
    2427                                 _error_("there is " << k << " triangles of mes = 0");
    2428                         }
    2429 
    2430                         //Force Edges
    2431                         AdjacentTriangle ta(0,0);
    2432                         for (int i = 0; i < nbe; i++){
    2433 
    2434                                 //Force edge i
    2435                                 nbswp =  ForceEdge(edges[i][0],edges[i][1],ta);
    2436                                 if (nbswp<0) k++;
    2437                                 else Nbswap += nbswp;
    2438 
    2439                                 if (nbswp) nbfe++;
    2440                                 if ( nbswp < 0 && k < 5){
    2441                                         _error_("Missing Edge " << i << ", v0=" << GetId(edges[i][0]) << ",v1=" << GetId(edges[i][1]));
    2442                                 }
    2443                         }
    2444 
    2445                         if (k!=0) {
    2446                                 _error_("There are " << k << " lost edges, the boundary might be crossing");
    2447                         }
    2448                         for (int j=0;j<nbv;j++){
    2449                                 Nbswap +=  vertices[j].Optim(1,0);
    2450                         }
    2451                         if (verbose > 3) _printf_("      number of inforced edge = " << nbfe << ", number of swap= " << Nbswap << "\n");
    2452                 }
    2453         /*}}}*/
    2454         /*FUNCTION Mesh::FindSubDomain{{{*/
    2455         void Mesh::FindSubDomain(int OutSide) {
     2388        void Mesh::ForceBoundary() {/*{{{*/
     2389                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceBoundary)*/
     2390
     2391                long int verbose=2;
     2392                int k=0;
     2393                int nbfe=0,nbswp=0,Nbswap=0;
     2394
     2395                //display
     2396                if (verbose > 2) _printf_("   ForceBoundary  nb of edge: " << nbe << "\n");
     2397
     2398                //check that there is no triangle with 0 determinant
     2399                for (int t = 0; t < nbt; t++){
     2400                        if (!triangles[t].det) k++;
     2401                }
     2402                if (k!=0) {
     2403                        _error_("there is " << k << " triangles of mes = 0");
     2404                }
     2405
     2406                //Force Edges
     2407                AdjacentTriangle ta(0,0);
     2408                for (int i = 0; i < nbe; i++){
     2409
     2410                        //Force edge i
     2411                        nbswp =  ForceEdge(edges[i][0],edges[i][1],ta);
     2412                        if (nbswp<0) k++;
     2413                        else Nbswap += nbswp;
     2414
     2415                        if (nbswp) nbfe++;
     2416                        if ( nbswp < 0 && k < 5){
     2417                                _error_("Missing Edge " << i << ", v0=" << GetId(edges[i][0]) << ",v1=" << GetId(edges[i][1]));
     2418                        }
     2419                }
     2420
     2421                if (k!=0) {
     2422                        _error_("There are " << k << " lost edges, the boundary might be crossing");
     2423                }
     2424                for (int j=0;j<nbv;j++){
     2425                        Nbswap +=  vertices[j].Optim(1,0);
     2426                }
     2427                if (verbose > 3) _printf_("      number of inforced edge = " << nbfe << ", number of swap= " << Nbswap << "\n");
     2428        }
     2429        /*}}}*/
     2430        void Mesh::FindSubDomain(int OutSide) {/*{{{*/
    24562431                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FindSubDomain)*/
    24572432
    … …  
    26952670        }
    26962671        /*}}}*/
    2697         /*FUNCTION Mesh::GetId(const Triangle & t) const{{{*/
    2698         long Mesh::GetId(const Triangle & t) const  {
     2672        long Mesh::GetId(const Triangle & t) const  { /*{{{*/
    26992673                return &t - triangles;
    27002674        }
    27012675        /*}}}*/
    2702         /*FUNCTION Mesh::GetId(const Triangle * t) const{{{*/
    2703         long Mesh::GetId(const Triangle * t) const  {
     2676        long Mesh::GetId(const Triangle * t) const  { /*{{{*/
    27042677                return t - triangles;
    27052678        }
    27062679        /*}}}*/
    2707         /*FUNCTION Mesh::GetId(const BamgVertex & t) const{{{*/
    2708         long Mesh::GetId(const BamgVertex & t) const  {
     2680        long Mesh::GetId(const BamgVertex & t) const  { /*{{{*/
    27092681                return &t - vertices;
    27102682        }
    27112683        /*}}}*/
    2712         /*FUNCTION Mesh::GetId(const BamgVertex * t) const{{{*/
    2713         long Mesh::GetId(const BamgVertex * t) const  {
     2684        long Mesh::GetId(const BamgVertex * t) const  { /*{{{*/
    27142685                return t - vertices;
    27152686        }
    27162687        /*}}}*/
    2717         /*FUNCTION Mesh::GetId(const Edge & t) const{{{*/
    2718         long Mesh::GetId(const Edge & t) const  {
     2688        long Mesh::GetId(const Edge & t) const  { /*{{{*/
    27192689                return &t - edges;
    27202690        }
    27212691        /*}}}*/
    2722         /*FUNCTION Mesh::GetId(const Edge * t) const{{{*/
    2723         long Mesh::GetId(const Edge * t) const  {
     2692        long Mesh::GetId(const Edge * t) const  { /*{{{*/
    27242693                return t - edges;
    27252694        }
    27262695        /*}}}*/
    2727         /*FUNCTION Mesh::Init{{{*/
    2728         void Mesh::Init(long maxnbv_in) {
     2696        void Mesh::Init(long maxnbv_in) {/*{{{*/
    27292697                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/PreInit)*/
    27302698
    … …  
    27742742        }
    27752743        /*}}}*/
    2776         /*FUNCTION Mesh::Insert{{{*/
    2777         void Mesh::Insert(bool random) {
     2744        void Mesh::Insert(bool random) {/*{{{*/
    27782745                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Insert)*/
    27792746
    … …  
    29072874        }
    29082875        /*}}}*/
    2909         /*FUNCTION Mesh::InsertNewPoints{{{*/
    2910         long Mesh::InsertNewPoints(long nbvold,long & NbTSwap,bool random) {
     2876        long Mesh::InsertNewPoints(long nbvold,long & NbTSwap,bool random) {/*{{{*/
    29112877                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/InsertNewPoints)*/
    29122878
    … …  
    29852951        }
    29862952        /*}}}*/
    2987         /*FUNCTION Mesh::MakeGeomEdgeToEdge{{{*/
    2988         Edge** Mesh::MakeGeomEdgeToEdge() {
     2953        Edge** Mesh::MakeGeomEdgeToEdge() {/*{{{*/
    29892954                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MakeGeomEdgeToEdge)*/
    29902955
    … …  
    30282993        }
    30292994        /*}}}*/
    3030         /*FUNCTION Mesh::MakeQuadrangles{{{*/
    3031         void Mesh::MakeQuadrangles(double costheta){
     2995        void Mesh::MakeQuadrangles(double costheta){/*{{{*/
    30322996                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MakeQuadrangles)*/
    30332997
    … …  
    30703034        }
    30713035        /*}}}*/
    3072         /*FUNCTION Mesh::MakeBamgQuadtree{{{*/
    3073         void Mesh::MakeBamgQuadtree() { 
     3036        void Mesh::MakeBamgQuadtree() {  /*{{{*/
    30743037                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MakeBamgQuadtree)*/
    30753038                if(!quadtree) quadtree = new BamgQuadtree(this);
    30763039        }
    30773040        /*}}}*/
    3078         /*FUNCTION Mesh::MaxinalHmax{{{*/
    3079         double Mesh::MaximalHmax() {
     3041        double Mesh::MaximalHmax() {/*{{{*/
    30803042                return Max(pmax.x-pmin.x,pmax.y-pmin.y);
    30813043        }
    30823044        /*}}}*/
    3083         /*FUNCTION Mesh::MaxSubDivision{{{*/
    3084         void  Mesh::MaxSubDivision(double maxsubdiv) {
     3045        void  Mesh::MaxSubDivision(double maxsubdiv) {/*{{{*/
    30853046                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/MaxSubDivision)*/
    30863047
    … …  
    31353096        }
    31363097        /*}}}*/
    3137         /*FUNCTION Mesh::MetricAt{{{*/
    3138         Metric Mesh::MetricAt(const R2 & A) const {
     3098        Metric Mesh::MetricAt(const R2 & A) const { /*{{{*/
    31393099                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MetricAt)*/
    31403100
    … …  
    31563116        }
    31573117        /*}}}*/
    3158         /*FUNCTION Mesh::MininalHmin{{{*/
    3159         double Mesh::MinimalHmin() {
     3118        double Mesh::MinimalHmin() {/*{{{*/
    31603119                return 2.0/coefIcoor;
    31613120        }
    31623121        /*}}}*/
    3163 /*FUNCTION Mesh::NearestVertex{{{*/
    3164 BamgVertex* Mesh::NearestVertex(Icoor1 i,Icoor1 j) {
    3165         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NearestVertex)*/
    3166         return  quadtree->NearestVertex(i,j);
    3167 }
    3168 /*}}}*/
    3169         /*FUNCTION Mesh::NewPoints{{{*/
    3170         void  Mesh::NewPoints(Mesh & Bh,BamgOpts* bamgopts,int KeepVertices){
     3122        BamgVertex* Mesh::NearestVertex(Icoor1 i,Icoor1 j) {/*{{{*/
     3123                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NearestVertex)*/
     3124                return  quadtree->NearestVertex(i,j);
     3125        }
     3126        /*}}}*/
     3127        void  Mesh::NewPoints(Mesh & Bh,BamgOpts* bamgopts,int KeepVertices){/*{{{*/
    31713128                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewPoints)*/
    31723129
    … …  
    32493206                                        lIntTria.SplitEdge(Bh,A,B);
    32503207                                        lIntTria.NewPoints(vertices,nbv,maxnbv);
    3251                                   } // end loop for each edge
    3252                           }// for triangle   
     3208                                } // end loop for each edge
     3209                        }// for triangle   
    32533210
    32543211                        if (!InsertNewPoints(nbvold,NbTSwap,bamgopts->random)) break;
    … …  
    32813238                for(i=0;i<nbv;i++) NbSwapf += vertices[i].Optim(0);
    32823239        }/*}}}*/
    3283         /*FUNCTION Mesh::ProjectOnCurve{{{*/
    3284         GeomEdge*   Mesh::ProjectOnCurve( Edge & BhAB, BamgVertex &  vA, BamgVertex & vB,
     3240        GeomEdge*   Mesh::ProjectOnCurve( Edge & BhAB, BamgVertex &  vA, BamgVertex & vB,/*{{{*/
    32853241                                double theta,BamgVertex & R,VertexOnEdge &  BR,VertexOnGeom & GR) {
    32863242                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/ProjectOnCurve)*/
    … …  
    33433299                else{ // do the search by walking
    33443300                        _error_("case not supported yet");
    3345                   }
     3301                }
    33463302
    33473303                // find the direction of walking with direction of edge and pA,PB;
    … …  
    33813337                                        BR = VertexOnEdge(&R,eee,thetab);
    33823338                                        return  Gh.ProjectOnCurve(*eee,thetab,R,GR);
    3383                                   }
    3384                           }
     3339                                }
     3340                        }
    33853341                        // we find the end
    33863342                        if (v1 != pvB){
    … …  
    34023358                                        return  Gh.ProjectOnCurve(*eee,thetab,R,GR);
    34033359                                  }
    3404                           }
     3360                        }
    34053361                        abscisse = lg*theta;
    34063362
    3407                   }
     3363                }
    34083364                _error_("Big bug...");
    34093365                return 0; // just for the compiler
    34103366        }                 
    34113367        /*}}}*/
    3412 /*FUNCTION Mesh::ReconstructExistingMesh{{{*/
    3413 void Mesh::ReconstructExistingMesh(){
    3414         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FillHoleInMesh)*/
    3415 
    3416         /*This routine reconstruct an existing mesh to make it CONVEX:
    3417          * -all the holes are filled
    3418          * -concave boundaries are filled
    3419          * A convex mesh is required for a lot of operations. This is why every mesh
    3420          * goes through this process.
    3421          * This routine also generates mesh properties such as adjencies,...
    3422          */
    3423 
    3424         /*Intermediary*/
    3425         int verbose=0;
    3426 
    3427         // generation of the integer coordinate
    3428 
    3429         // find extrema coordinates of vertices pmin,pmax
    3430         long i;
    3431         if(verbose>2) _printf_("      Reconstruct mesh of " << nbv << " vertices\n");
    3432 
    3433         //initialize orderedvertices
    3434         _assert_(orderedvertices);
    3435         for (i=0;i<nbv;i++) orderedvertices[i]=0;
    3436 
    3437         //Initialize nbsubdomains
    3438         nbsubdomains =0;
    3439 
    3440         /* generation of triangles adjacency*/
    3441 
    3442         //First add existing edges
    3443         long kk =0;
    3444         SetOfEdges4* edge4= new SetOfEdges4(nbt*3,nbv);
    3445         for (i=0;i<nbe;i++){
    3446                 kk=kk+(i==edge4->SortAndAdd(GetId(edges[i][0]),GetId(edges[i][1])));
    3447         }
    3448         if (kk != nbe){
    3449                 _error_("There are " << kk-nbe << " double edges in the mesh");
    3450         }
    3451 
    3452         //Add edges of all triangles in existing mesh
    3453         long* st = new long[nbt*3];
    3454         for (i=0;i<nbt*3;i++) st[i]=-1;
    3455         for (i=0;i<nbt;i++){
    3456                 for (int j=0;j<3;j++){
    3457 
    3458                         //Add current triangle edge to edge4
    3459                         long k =edge4->SortAndAdd(GetId(triangles[i][VerticesOfTriangularEdge[j][0]]),GetId(triangles[i][VerticesOfTriangularEdge[j][1]]));
    3460 
    3461                         long invisible=triangles[i].Hidden(j);
    3462 
    3463                         //If the edge has not been added to st, add it
    3464                         if(st[k]==-1) st[k]=3*i+j;
    3465 
    3466                         //If the edge already exists, add adjacency
    3467                         else if(st[k]>=0) {
    3468                                 _assert_(!triangles[i].TriangleAdj(j));
    3469                                 _assert_(!triangles[st[k]/3].TriangleAdj((int) (st[k]%3)));
    3470 
    3471                                 triangles[i].SetAdj2(j,triangles+st[k]/3,(int)(st[k]%3));
    3472                                 if (invisible) triangles[i].SetHidden(j);
    3473                                 if (k<nbe)     triangles[i].SetLocked(j);
    3474 
    3475                                 //Make st[k] negative so that it will throw an error message if it is found again
    3476                                 st[k]=-2-st[k];
    3477                         }
    3478 
    3479                         //An edge belongs to 2 triangles
    3480                         else {
    3481                                 _error_("The edge (" << GetId(triangles[i][VerticesOfTriangularEdge[j][0]]) << " , " << GetId(triangles[i][VerticesOfTriangularEdge[j][1]]) << ") belongs to more than 2 triangles");
    3482                         }
    3483                 }
    3484         }
    3485 
    3486         //Display info if required
    3487         if(verbose>5) {
    3488                 _printf_("         info of Mesh:\n");
    3489                 _printf_("            - number of vertices    = " << nbv << " \n");
    3490                 _printf_("            - number of triangles   = " << nbt << " \n");
    3491                 _printf_("            - number of given edges = " << nbe << " \n");
    3492                 _printf_("            - number of all edges   = " << edge4->nb() << "\n");
    3493                 _printf_("            - Euler number 1 - nb of holes = " << nbt-edge4->nb()+nbv << "\n");
    3494         }
    3495 
    3496         //check the consistency of edge[].adj and the geometrical required vertex
    3497         long k=0;
    3498         for (i=0;i<edge4->nb();i++){
    3499                 if (st[i]>=0){ // edge alone
    3500                         if (i<nbe){
    3501                                 long i0=edge4->i(i);
    3502                                 orderedvertices[i0] = vertices+i0;
    3503                                 long i1=edge4->j(i);
    3504                                 orderedvertices[i1] = vertices+i1;
    3505                         }
    3506                         else {
    3507                                 k=k+1;
    3508                                 if (k<10) {
    3509                                         //print only 10 edges
    3510                                         _printf_("Lost boundary edges " << i << " : " << edge4->i(i) << " " << edge4->j(i) << "\n");
    3511                                 }
    3512                                 else if (k==10){
    3513                                         _printf_("Other lost boundary edges not shown...\n");
    3514                                 }
    3515                         }
    3516                 }
    3517         }
    3518         if(k) {
    3519                 _error_(k << " boundary edges (from the geometry) are not defined as mesh edges");
    3520         }
    3521 
    3522         /* mesh generation with boundary points*/
    3523         long nbvb=0;
    3524         for (i=0;i<nbv;i++){
    3525                 vertices[i].t=0;
    3526                 vertices[i].IndexInTriangle=0;
    3527                 if (orderedvertices[i]) orderedvertices[nbvb++]=orderedvertices[i];
    3528         }
    3529 
    3530         Triangle* savetriangles=triangles;
    3531         long savenbt=nbt;
    3532         long savemaxnbt=maxnbt;
    3533         SubDomain* savesubdomains=subdomains;
    3534         subdomains=0;
    3535 
    3536         long  Nbtriafillhole=2*nbvb;
    3537         Triangle* triafillhole=new Triangle[Nbtriafillhole];
    3538         triangles = triafillhole;
    3539 
    3540         nbt=2;
    3541         maxnbt= Nbtriafillhole;
    3542 
    3543         //Find a vertex that is not aligned with vertices 0 and 1
    3544         for (i=2;det(orderedvertices[0]->i,orderedvertices[1]->i,orderedvertices[i]->i)==0;)
    3545          if  (++i>=nbvb) {
    3546                  _error_("ReconstructExistingMesh: All the vertices are aligned");
    3547          }
    3548         //Move this vertex (i) to the 2d position in orderedvertices
    3549         Exchange(orderedvertices[2], orderedvertices[i]);
    3550 
    3551         /*Reconstruct mesh beginning with 2 triangles*/
    3552         BamgVertex *  v0=orderedvertices[0], *v1=orderedvertices[1];
    3553 
    3554         triangles[0](0) = NULL; // Infinite vertex
    3555         triangles[0](1) = v0;
    3556         triangles[0](2) = v1;
    3557 
    3558         triangles[1](0) = NULL;// Infinite vertex
    3559         triangles[1](2) = v0;
    3560         triangles[1](1) = v1;
    3561         const int e0 = OppositeEdge[0];
    3562         const int e1 = NextEdge[e0];
    3563         const int e2 = PreviousEdge[e0];
    3564         triangles[0].SetAdj2(e0, &triangles[1] ,e0);
    3565         triangles[0].SetAdj2(e1, &triangles[1] ,e2);
    3566         triangles[0].SetAdj2(e2, &triangles[1] ,e1);
    3567 
    3568         triangles[0].det = -1;  // boundary triangles
    3569         triangles[1].det = -1;  // boundary triangles
    3570 
    3571         triangles[0].SetSingleVertexToTriangleConnectivity();
    3572         triangles[1].SetSingleVertexToTriangleConnectivity();
    3573 
    3574         triangles[0].link=&triangles[1];
    3575         triangles[1].link=&triangles[0];
    3576 
    3577         if (!quadtree) delete quadtree; //ReInitialise;
    3578         quadtree = new BamgQuadtree(this,0);
    3579         quadtree->Add(*v0);
    3580         quadtree->Add(*v1);
    3581 
    3582         // vertices are added one by one
    3583         long NbSwap=0;
    3584         for (int icount=2; icount<nbvb; icount++) {
    3585                 BamgVertex *vi  = orderedvertices[icount];
    3586                 Icoor2 det3[3];
    3587                 Triangle *tcvi = TriangleFindFromCoord(vi->i,det3);
    3588                 quadtree->Add(*vi);
    3589                 AddVertex(*vi,tcvi,det3);
    3590                 NbSwap += vi->Optim(1,1);
    3591         }
    3592 
    3593         //enforce the boundary
    3594         AdjacentTriangle ta(0,0);
    3595         long nbloss = 0,knbe=0;
    3596         for ( i = 0; i < nbe; i++){
    3597                 if (st[i] >=0){ //edge alone => on border
    3598                         BamgVertex &a=edges[i][0], &b=edges[i][1];
    3599                         if (a.t && b.t){
    3600                                 knbe++;
    3601                                 if (ForceEdge(a,b,ta)<0) nbloss++;
    3602                         }
    3603                 }
    3604         }
    3605         if(nbloss) {
    3606                 _error_("we lost " << nbloss << " existing edges other " << knbe);
    3607         }
    3608 
    3609         FindSubDomain(1);
    3610         // remove all the hole
    3611         // remove all the good sub domain
    3612         long krm =0;
    3613         for (i=0;i<nbt;i++){
    3614                 if (triangles[i].link){ // remove triangles
    3615                         krm++;
     3368        void Mesh::ReconstructExistingMesh(){/*{{{*/
     3369                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FillHoleInMesh)*/
     3370
     3371                /*This routine reconstruct an existing mesh to make it CONVEX:
     3372                 * -all the holes are filled
     3373                 * -concave boundaries are filled
     3374                 * A convex mesh is required for a lot of operations. This is why every mesh
     3375                 * goes through this process.
     3376                 * This routine also generates mesh properties such as adjencies,...
     3377                 */
     3378
     3379                /*Intermediary*/
     3380                int verbose=0;
     3381
     3382                // generation of the integer coordinate
     3383
     3384                // find extrema coordinates of vertices pmin,pmax
     3385                long i;
     3386                if(verbose>2) _printf_("      Reconstruct mesh of " << nbv << " vertices\n");
     3387
     3388                //initialize orderedvertices
     3389                _assert_(orderedvertices);
     3390                for (i=0;i<nbv;i++) orderedvertices[i]=0;
     3391
     3392                //Initialize nbsubdomains
     3393                nbsubdomains =0;
     3394
     3395                /* generation of triangles adjacency*/
     3396
     3397                //First add existing edges
     3398                long kk =0;
     3399                SetOfEdges4* edge4= new SetOfEdges4(nbt*3,nbv);
     3400                for (i=0;i<nbe;i++){
     3401                        kk=kk+(i==edge4->SortAndAdd(GetId(edges[i][0]),GetId(edges[i][1])));
     3402                }
     3403                if (kk != nbe){
     3404                        _error_("There are " << kk-nbe << " double edges in the mesh");
     3405                }
     3406
     3407                //Add edges of all triangles in existing mesh
     3408                long* st = new long[nbt*3];
     3409                for (i=0;i<nbt*3;i++) st[i]=-1;
     3410                for (i=0;i<nbt;i++){
    36163411                        for (int j=0;j<3;j++){
    3617                                 AdjacentTriangle ta =  triangles[i].Adj(j);
    3618                                 Triangle &tta = *(Triangle*)ta;
    3619                                 //if edge between remove and not remove
    3620                                 if(! tta.link){
    3621                                         // change the link of ta;
    3622                                         int ja = ta;
    3623                                         BamgVertex *v0= ta.EdgeVertex(0);
    3624                                         BamgVertex *v1= ta.EdgeVertex(1);
    3625                                         long k =edge4->SortAndAdd(v0?GetId(v0):nbv,v1? GetId(v1):nbv);
    3626 
    3627                                         _assert_(st[k]>=0);
    3628                                         tta.SetAdj2(ja,savetriangles + st[k] / 3,(int) (st[k]%3));
    3629                                         ta.SetLock();
     3412
     3413                                //Add current triangle edge to edge4
     3414                                long k =edge4->SortAndAdd(GetId(triangles[i][VerticesOfTriangularEdge[j][0]]),GetId(triangles[i][VerticesOfTriangularEdge[j][1]]));
     3415
     3416                                long invisible=triangles[i].Hidden(j);
     3417
     3418                                //If the edge has not been added to st, add it
     3419                                if(st[k]==-1) st[k]=3*i+j;
     3420
     3421                                //If the edge already exists, add adjacency
     3422                                else if(st[k]>=0) {
     3423                                        _assert_(!triangles[i].TriangleAdj(j));
     3424                                        _assert_(!triangles[st[k]/3].TriangleAdj((int) (st[k]%3)));
     3425
     3426                                        triangles[i].SetAdj2(j,triangles+st[k]/3,(int)(st[k]%3));
     3427                                        if (invisible) triangles[i].SetHidden(j);
     3428                                        if (k<nbe)     triangles[i].SetLocked(j);
     3429
     3430                                        //Make st[k] negative so that it will throw an error message if it is found again
    36303431                                        st[k]=-2-st[k];
    36313432                                }
    3632                         }
    3633                 }
    3634         }
    3635         long NbTfillHoll =0;
    3636         for (i=0;i<nbt;i++){
    3637                 if (triangles[i].link) {
    3638                         triangles[i]=Triangle((BamgVertex *) NULL,(BamgVertex *) NULL,(BamgVertex *) NULL);
    3639                         triangles[i].color=-1;
    3640                 }
    3641                 else{
    3642                         triangles[i].color= savenbt+ NbTfillHoll++;
    3643                 }
    3644         }
    3645         _assert_(savenbt+NbTfillHoll<=savemaxnbt);
    3646 
    3647         // copy of the outside triangles in saveMesh
    3648         for (i=0;i<nbt;i++){
    3649                 if(triangles[i].color>=0) {
    3650                         savetriangles[savenbt]=triangles[i];
    3651                         savetriangles[savenbt].link=0;
    3652                         savenbt++;
    3653                 }
    3654         }
    3655         // gestion of the adj
    3656         k =0;
    3657         Triangle * tmax = triangles + nbt;
    3658         for (i=0;i<savenbt;i++) {
    3659                 Triangle & ti = savetriangles[i];
    3660                 for (int j=0;j<3;j++){
    3661                         Triangle * ta = ti.TriangleAdj(j);
    3662                         int aa = ti.NuEdgeTriangleAdj(j);
    3663                         int lck = ti.Locked(j);
    3664                         if (!ta) k++; // bug
    3665                         else if ( ta >= triangles && ta < tmax){
    3666                                 ta= savetriangles + ta->color;
    3667                                 ti.SetAdj2(j,ta,aa);
    3668                                 if(lck) ti.SetLocked(j);
    3669                         }
    3670                 }
    3671         }
    3672 
    3673         // restore triangles;
    3674         nbt=savenbt;
    3675         maxnbt=savemaxnbt;
    3676         delete [] triangles;
    3677         delete [] subdomains;
    3678         triangles = savetriangles;
    3679         subdomains = savesubdomains;
    3680         if (k) {
    3681                 _error_("number of triangles edges alone = " << k);
    3682         }
    3683         FindSubDomain();
    3684 
    3685         delete edge4;
    3686         delete [] st;
    3687         for (i=0;i<nbv;i++) quadtree->Add(vertices[i]);
    3688 
    3689         SetVertexFieldOn();
    3690 
    3691         /*Check requirements consistency*/
    3692         for (i=0;i<nbe;i++){
    3693         /*If the current mesh edge is on Geometry*/
    3694                 if(edges[i].GeomEdgeHook){
    3695                         for(int j=0;j<2;j++){
    3696                                 /*Go through the edges adjacent to current edge (if on the same curve)*/
    3697                                 if (!edges[i].adj[j]){
    3698                                         /*The edge is on Geometry and does not have 2 adjacent edges... (not on a closed curve)*/
    3699                                         /*Check that the 2 vertices are on geometry AND required*/
    3700                                         if(!edges[i][j].GeomEdgeHook->IsRequiredVertex()){
    3701                                                 _printf_("ReconstructExistingMesh error message: problem with the edge number " << i+1 << ": [" << GetId(edges[i][0])+1 << " " << GetId(edges[i][1])+1 << "]\n");
    3702                                                 _printf_("This edge is on geometrical edge number " << Gh.GetId(edges[i].GeomEdgeHook)+1 << "\n");
    3703                                                 if (edges[i][j].GeomEdgeHook->OnGeomVertex())
    3704                                                  _printf_("the vertex number " << GetId(edges[i][j])+1 << " of this edge is a geometric BamgVertex number " << Gh.GetId(edges[i][j].GeomEdgeHook->gv)+1 << "\n");
    3705                                                 else if (edges[i][j].GeomEdgeHook->OnGeomEdge())
    3706                                                  _printf_("the vertex number " << GetId(edges[i][j])+1 << " of this edge is a geometric Edge number " << Gh.GetId(edges[i][j].GeomEdgeHook->ge)+1 << "\n");
    3707                                                 else
    3708                                                  _printf_("Its pointer is " << edges[i][j].GeomEdgeHook << "\n");
    3709 
    3710                                                 _printf_("This edge is on geometry and has no adjacent edge (open curve) and one of the tip is not required\n");
    3711                                                 _error_("See above (might be cryptic...)");
     3433
     3434                                //An edge belongs to 2 triangles
     3435                                else {
     3436                                        _error_("The edge (" << GetId(triangles[i][VerticesOfTriangularEdge[j][0]]) << " , " << GetId(triangles[i][VerticesOfTriangularEdge[j][1]]) << ") belongs to more than 2 triangles");
     3437                                }
     3438                        }
     3439                }
     3440
     3441                //Display info if required
     3442                if(verbose>5) {
     3443                        _printf_("         info of Mesh:\n");
     3444                        _printf_("            - number of vertices    = " << nbv << " \n");
     3445                        _printf_("            - number of triangles   = " << nbt << " \n");
     3446                        _printf_("            - number of given edges = " << nbe << " \n");
     3447                        _printf_("            - number of all edges   = " << edge4->nb() << "\n");
     3448                        _printf_("            - Euler number 1 - nb of holes = " << nbt-edge4->nb()+nbv << "\n");
     3449                }
     3450
     3451                //check the consistency of edge[].adj and the geometrical required vertex
     3452                long k=0;
     3453                for (i=0;i<edge4->nb();i++){
     3454                        if (st[i]>=0){ // edge alone
     3455                                if (i<nbe){
     3456                                        long i0=edge4->i(i);
     3457                                        orderedvertices[i0] = vertices+i0;
     3458                                        long i1=edge4->j(i);
     3459                                        orderedvertices[i1] = vertices+i1;
     3460                                }
     3461                                else {
     3462                                        k=k+1;
     3463                                        if (k<10) {
     3464                                                //print only 10 edges
     3465                                                _printf_("Lost boundary edges " << i << " : " << edge4->i(i) << " " << edge4->j(i) << "\n");
    37123466                                        }
    3713                                 }
    3714                         }
    3715                 }
    3716         }
    3717 }
    3718 /*}}}*/
    3719         /*FUNCTION Mesh::TrianglesRenumberBySubDomain{{{*/
    3720         void Mesh::TrianglesRenumberBySubDomain(bool justcompress){
     3467                                        else if (k==10){
     3468                                                _printf_("Other lost boundary edges not shown...\n");
     3469                                        }
     3470                                }
     3471                        }
     3472                }
     3473                if(k) {
     3474                        _error_(k << " boundary edges (from the geometry) are not defined as mesh edges");
     3475                }
     3476
     3477                /* mesh generation with boundary points*/
     3478                long nbvb=0;
     3479                for (i=0;i<nbv;i++){
     3480                        vertices[i].t=0;
     3481                        vertices[i].IndexInTriangle=0;
     3482                        if (orderedvertices[i]) orderedvertices[nbvb++]=orderedvertices[i];
     3483                }
     3484
     3485                Triangle* savetriangles=triangles;
     3486                long savenbt=nbt;
     3487                long savemaxnbt=maxnbt;
     3488                SubDomain* savesubdomains=subdomains;
     3489                subdomains=0;
     3490
     3491                long  Nbtriafillhole=2*nbvb;
     3492                Triangle* triafillhole=new Triangle[Nbtriafillhole];
     3493                triangles = triafillhole;
     3494
     3495                nbt=2;
     3496                maxnbt= Nbtriafillhole;
     3497
     3498                //Find a vertex that is not aligned with vertices 0 and 1
     3499                for (i=2;det(orderedvertices[0]->i,orderedvertices[1]->i,orderedvertices[i]->i)==0;)
     3500                 if  (++i>=nbvb) {
     3501                         _error_("ReconstructExistingMesh: All the vertices are aligned");
     3502                 }
     3503                //Move this vertex (i) to the 2d position in orderedvertices
     3504                Exchange(orderedvertices[2], orderedvertices[i]);
     3505
     3506                /*Reconstruct mesh beginning with 2 triangles*/
     3507                BamgVertex *  v0=orderedvertices[0], *v1=orderedvertices[1];
     3508
     3509                triangles[0](0) = NULL; // Infinite vertex
     3510                triangles[0](1) = v0;
     3511                triangles[0](2) = v1;
     3512
     3513                triangles[1](0) = NULL;// Infinite vertex
     3514                triangles[1](2) = v0;
     3515                triangles[1](1) = v1;
     3516                const int e0 = OppositeEdge[0];
     3517                const int e1 = NextEdge[e0];
     3518                const int e2 = PreviousEdge[e0];
     3519                triangles[0].SetAdj2(e0, &triangles[1] ,e0);
     3520                triangles[0].SetAdj2(e1, &triangles[1] ,e2);
     3521                triangles[0].SetAdj2(e2, &triangles[1] ,e1);
     3522
     3523                triangles[0].det = -1;  // boundary triangles
     3524                triangles[1].det = -1;  // boundary triangles
     3525
     3526                triangles[0].SetSingleVertexToTriangleConnectivity();
     3527                triangles[1].SetSingleVertexToTriangleConnectivity();
     3528
     3529                triangles[0].link=&triangles[1];
     3530                triangles[1].link=&triangles[0];
     3531
     3532                if (!quadtree) delete quadtree; //ReInitialise;
     3533                quadtree = new BamgQuadtree(this,0);
     3534                quadtree->Add(*v0);
     3535                quadtree->Add(*v1);
     3536
     3537                // vertices are added one by one
     3538                long NbSwap=0;
     3539                for (int icount=2; icount<nbvb; icount++) {
     3540                        BamgVertex *vi  = orderedvertices[icount];
     3541                        Icoor2 det3[3];
     3542                        Triangle *tcvi = TriangleFindFromCoord(vi->i,det3);
     3543                        quadtree->Add(*vi);
     3544                        AddVertex(*vi,tcvi,det3);
     3545                        NbSwap += vi->Optim(1,1);
     3546                }
     3547
     3548                //enforce the boundary
     3549                AdjacentTriangle ta(0,0);
     3550                long nbloss = 0,knbe=0;
     3551                for ( i = 0; i < nbe; i++){
     3552                        if (st[i] >=0){ //edge alone => on border
     3553                                BamgVertex &a=edges[i][0], &b=edges[i][1];
     3554                                if (a.t && b.t){
     3555                                        knbe++;
     3556                                        if (ForceEdge(a,b,ta)<0) nbloss++;
     3557                                }
     3558                        }
     3559                }
     3560                if(nbloss) {
     3561                        _error_("we lost " << nbloss << " existing edges other " << knbe);
     3562                }
     3563
     3564                FindSubDomain(1);
     3565                // remove all the hole
     3566                // remove all the good sub domain
     3567                long krm =0;
     3568                for (i=0;i<nbt;i++){
     3569                        if (triangles[i].link){ // remove triangles
     3570                                krm++;
     3571                                for (int j=0;j<3;j++){
     3572                                        AdjacentTriangle ta =  triangles[i].Adj(j);
     3573                                        Triangle &tta = *(Triangle*)ta;
     3574                                        //if edge between remove and not remove
     3575                                        if(! tta.link){
     3576                                                // change the link of ta;
     3577                                                int ja = ta;
     3578                                                BamgVertex *v0= ta.EdgeVertex(0);
     3579                                                BamgVertex *v1= ta.EdgeVertex(1);
     3580                                                long k =edge4->SortAndAdd(v0?GetId(v0):nbv,v1? GetId(v1):nbv);
     3581
     3582                                                _assert_(st[k]>=0);
     3583                                                tta.SetAdj2(ja,savetriangles + st[k] / 3,(int) (st[k]%3));
     3584                                                ta.SetLock();
     3585                                                st[k]=-2-st[k];
     3586                                        }
     3587                                }
     3588                        }
     3589                }
     3590                long NbTfillHoll =0;
     3591                for (i=0;i<nbt;i++){
     3592                        if (triangles[i].link) {
     3593                                triangles[i]=Triangle((BamgVertex *) NULL,(BamgVertex *) NULL,(BamgVertex *) NULL);
     3594                                triangles[i].color=-1;
     3595                        }
     3596                        else{
     3597                                triangles[i].color= savenbt+ NbTfillHoll++;
     3598                        }
     3599                }
     3600                _assert_(savenbt+NbTfillHoll<=savemaxnbt);
     3601
     3602                // copy of the outside triangles in saveMesh
     3603                for (i=0;i<nbt;i++){
     3604                        if(triangles[i].color>=0) {
     3605                                savetriangles[savenbt]=triangles[i];
     3606                                savetriangles[savenbt].link=0;
     3607                                savenbt++;
     3608                        }
     3609                }
     3610                // gestion of the adj
     3611                k =0;
     3612                Triangle * tmax = triangles + nbt;
     3613                for (i=0;i<savenbt;i++) {
     3614                        Triangle & ti = savetriangles[i];
     3615                        for (int j=0;j<3;j++){
     3616                                Triangle * ta = ti.TriangleAdj(j);
     3617                                int aa = ti.NuEdgeTriangleAdj(j);
     3618                                int lck = ti.Locked(j);
     3619                                if (!ta) k++; // bug
     3620                                else if ( ta >= triangles && ta < tmax){
     3621                                        ta= savetriangles + ta->color;
     3622                                        ti.SetAdj2(j,ta,aa);
     3623                                        if(lck) ti.SetLocked(j);
     3624                                }
     3625                        }
     3626                }
     3627
     3628                // restore triangles;
     3629                nbt=savenbt;
     3630                maxnbt=savemaxnbt;
     3631                delete [] triangles;
     3632                delete [] subdomains;
     3633                triangles = savetriangles;
     3634                subdomains = savesubdomains;
     3635                if (k) {
     3636                        _error_("number of triangles edges alone = " << k);
     3637                }
     3638                FindSubDomain();
     3639
     3640                delete edge4;
     3641                delete [] st;
     3642                for (i=0;i<nbv;i++) quadtree->Add(vertices[i]);
     3643
     3644                SetVertexFieldOn();
     3645
     3646                /*Check requirements consistency*/
     3647                for (i=0;i<nbe;i++){
     3648                        /*If the current mesh edge is on Geometry*/
     3649                        if(edges[i].GeomEdgeHook){
     3650                                for(int j=0;j<2;j++){
     3651                                        /*Go through the edges adjacent to current edge (if on the same curve)*/
     3652                                        if (!edges[i].adj[j]){
     3653                                                /*The edge is on Geometry and does not have 2 adjacent edges... (not on a closed curve)*/
     3654                                                /*Check that the 2 vertices are on geometry AND required*/
     3655                                                if(!edges[i][j].GeomEdgeHook->IsRequiredVertex()){
     3656                                                        _printf_("ReconstructExistingMesh error message: problem with the edge number " << i+1 << ": [" << GetId(edges[i][0])+1 << " " << GetId(edges[i][1])+1 << "]\n");
     3657                                                        _printf_("This edge is on geometrical edge number " << Gh.GetId(edges[i].GeomEdgeHook)+1 << "\n");
     3658                                                        if (edges[i][j].GeomEdgeHook->OnGeomVertex())
     3659                                                         _printf_("the vertex number " << GetId(edges[i][j])+1 << " of this edge is a geometric BamgVertex number " << Gh.GetId(edges[i][j].GeomEdgeHook->gv)+1 << "\n");
     3660                                                        else if (edges[i][j].GeomEdgeHook->OnGeomEdge())
     3661                                                         _printf_("the vertex number " << GetId(edges[i][j])+1 << " of this edge is a geometric Edge number " << Gh.GetId(edges[i][j].GeomEdgeHook->ge)+1 << "\n");
     3662                                                        else
     3663                                                         _printf_("Its pointer is " << edges[i][j].GeomEdgeHook << "\n");
     3664
     3665                                                        _printf_("This edge is on geometry and has no adjacent edge (open curve) and one of the tip is not required\n");
     3666                                                        _error_("See above (might be cryptic...)");
     3667                                                }
     3668                                        }
     3669                                }
     3670                        }
     3671                }
     3672        }
     3673        /*}}}*/
     3674        void Mesh::TrianglesRenumberBySubDomain(bool justcompress){/*{{{*/
    37213675                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ReNumberingTheTriangleBySubDomain)*/
    37223676
    … …  
    37853739        }
    37863740        /*}}}*/
    3787 /*FUNCTION Mesh::SetIntCoor{{{*/
    3788 void Mesh::SetIntCoor(const char * strfrom) {
    3789         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SetIntCoor)*/
    3790 
    3791         /*Set integer coordinate for existing vertices*/
    3792 
    3793         //Get extrema coordinates of the existing vertices
    3794         pmin =  vertices[0].r;
    3795         pmax =  vertices[0].r;
    3796         long i;
    3797         for (i=0;i<nbv;i++) {
    3798                 pmin.x = Min(pmin.x,vertices[i].r.x);
    3799                 pmin.y = Min(pmin.y,vertices[i].r.y);
    3800                 pmax.x = Max(pmax.x,vertices[i].r.x);
    3801                 pmax.y = Max(pmax.y,vertices[i].r.y);
    3802         }
    3803         R2 DD = (pmax-pmin)*0.05;
    3804         pmin = pmin-DD;
    3805         pmax = pmax+DD;
    3806 
    3807         //Compute coefIcoor
    3808         coefIcoor= (MaxICoor)/(Max(pmax.x-pmin.x,pmax.y-pmin.y));
    3809         if (coefIcoor<=0){
    3810                 _error_("coefIcoor should be positive, a problem in the geometry is likely");
    3811         }
    3812 
    3813         // generation of integer coord 
    3814         for (i=0;i<nbv;i++) {
    3815                 vertices[i].i = R2ToI2(vertices[i].r);   
    3816         }
    3817 
    3818         // computation of the det
    3819         int number_of_errors=0;
    3820         for (i=0;i<nbt;i++) {
    3821                 BamgVertex & v0 = triangles[i][0];
    3822                 BamgVertex & v1 = triangles[i][1];
    3823                 BamgVertex & v2 = triangles[i][2];
    3824 
    3825                 //If this is not a boundary triangle
    3826                 if ( &v0 && &v1 &&  &v2 ){
    3827 
    3828                         /*Compute determinant*/
    3829                         triangles[i].det= det(v0,v1,v2);
    3830 
    3831                         /*Check that determinant is positive*/
    3832                         if (triangles[i].det <=0){
    3833 
    3834                                 /*increase number_of_errors and print error only for the first 20 triangles*/
    3835                                 number_of_errors++;
    3836                                 if (number_of_errors<20){
    3837                                         _printf_("Area of Triangle " << i+1 << " < 0 (det=" << triangles[i].det << ")\n");
    3838                                 }
    3839                         }
    3840                 }
    3841 
    3842                 //else, set as -1
    3843                 else triangles[i].det=-1;
    3844         }
    3845 
    3846         if (number_of_errors) _error_("Fatal error: some triangles have negative areas, see above");
    3847 }
    3848 /*}}}*/
    3849 /*FUNCTION Mesh::SmoothingVertex{{{*/
    3850 void Mesh::SmoothingVertex(int nbiter,double omega ) {
    3851         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SmoothingVertex)*/
    3852 
    3853         long int verbose=0;
    3854         //  if quatree exist remove it end reconstruct
    3855         if (quadtree) delete quadtree;
    3856         quadtree=0;
    3857         CreateSingleVertexToTriangleConnectivity();
    3858         Triangle vide; // a triangle to mark the boundary vertex
    3859         Triangle   ** tstart= new Triangle* [nbv];
    3860         long i,j,k;
    3861         //   attention si Background == Triangle alors on ne peut pas utiliser la rechech rapide
    3862         if ( this == & BTh)
    3863          for ( i=0;i<nbv;i++)
    3864           tstart[i]=vertices[i].t;     
    3865         else
    3866          for ( i=0;i<nbv;i++)
    3867           tstart[i]=0;
    3868         for ( j=0;j<NbVerticesOnGeomVertex;j++ )
    3869          tstart[ GetId(VerticesOnGeomVertex[j].meshvertex)]=&vide;
    3870         for ( k=0;k<NbVerticesOnGeomEdge;k++ )
    3871          tstart[ GetId(VerticesOnGeomEdge[k].meshvertex)]=&vide;
    3872         if(verbose>2) _printf_("   SmoothingVertex: nb Iteration = " << nbiter << ", Omega=" << omega << "\n");
    3873         for (k=0;k<nbiter;k++)
    3874           {
    3875                 long i,NbSwap =0;
    3876                 double delta =0;
    3877                 for ( i=0;i<nbv;i++)
    3878                  if (tstart[i] != &vide) // not a boundary vertex
    3879                   delta=Max(delta,vertices[i].Smoothing(*this,BTh,tstart[i],omega));
    3880                 if (!nbq)
     3741        void Mesh::SetIntCoor(const char * strfrom) {/*{{{*/
     3742                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SetIntCoor)*/
     3743
     3744                /*Set integer coordinate for existing vertices*/
     3745
     3746                //Get extrema coordinates of the existing vertices
     3747                pmin =  vertices[0].r;
     3748                pmax =  vertices[0].r;
     3749                long i;
     3750                for (i=0;i<nbv;i++) {
     3751                        pmin.x = Min(pmin.x,vertices[i].r.x);
     3752                        pmin.y = Min(pmin.y,vertices[i].r.y);
     3753                        pmax.x = Max(pmax.x,vertices[i].r.x);
     3754                        pmax.y = Max(pmax.y,vertices[i].r.y);
     3755                }
     3756                R2 DD = (pmax-pmin)*0.05;
     3757                pmin = pmin-DD;
     3758                pmax = pmax+DD;
     3759
     3760                //Compute coefIcoor
     3761                coefIcoor= (MaxICoor)/(Max(pmax.x-pmin.x,pmax.y-pmin.y));
     3762                if (coefIcoor<=0){
     3763                        _error_("coefIcoor should be positive, a problem in the geometry is likely");
     3764                }
     3765
     3766                // generation of integer coord 
     3767                for (i=0;i<nbv;i++) {
     3768                        vertices[i].i = R2ToI2(vertices[i].r);   
     3769                }
     3770
     3771                // computation of the det
     3772                int number_of_errors=0;
     3773                for (i=0;i<nbt;i++) {
     3774                        BamgVertex & v0 = triangles[i][0];
     3775                        BamgVertex & v1 = triangles[i][1];
     3776                        BamgVertex & v2 = triangles[i][2];
     3777
     3778                        //If this is not a boundary triangle
     3779                        if ( &v0 && &v1 &&  &v2 ){
     3780
     3781                                /*Compute determinant*/
     3782                                triangles[i].det= det(v0,v1,v2);
     3783
     3784                                /*Check that determinant is positive*/
     3785                                if (triangles[i].det <=0){
     3786
     3787                                        /*increase number_of_errors and print error only for the first 20 triangles*/
     3788                                        number_of_errors++;
     3789                                        if (number_of_errors<20){
     3790                                                _printf_("Area of Triangle " << i+1 << " < 0 (det=" << triangles[i].det << ")\n");
     3791                                        }
     3792                                }
     3793                        }
     3794
     3795                        //else, set as -1
     3796                        else triangles[i].det=-1;
     3797                }
     3798
     3799                if (number_of_errors) _error_("Fatal error: some triangles have negative areas, see above");
     3800        }
     3801        /*}}}*/
     3802        void Mesh::SmoothingVertex(int nbiter,double omega ) { /*{{{*/
     3803                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SmoothingVertex)*/
     3804
     3805                long int verbose=0;
     3806                //  if quatree exist remove it end reconstruct
     3807                if (quadtree) delete quadtree;
     3808                quadtree=0;
     3809                CreateSingleVertexToTriangleConnectivity();
     3810                Triangle vide; // a triangle to mark the boundary vertex
     3811                Triangle   ** tstart= new Triangle* [nbv];
     3812                long i,j,k;
     3813                //   attention si Background == Triangle alors on ne peut pas utiliser la rechech rapide
     3814                if ( this == & BTh)
    38813815                 for ( i=0;i<nbv;i++)
    3882                   if (tstart[i] != &vide) // not a boundary vertex
    3883                         NbSwap += vertices[i].Optim(1);
    3884                 if (verbose>3) _printf_("      move max = " << pow(delta,0.5) << ", iteration = " << k << ", nb of swap = " << NbSwap << "\n");
    3885           }
    3886 
    3887         delete [] tstart;
    3888         if (quadtree) quadtree= new BamgQuadtree(this);
    3889 }
    3890 /*}}}*/
    3891 /*FUNCTION Mesh::SmoothMetric{{{*/
    3892 void Mesh::SmoothMetric(double raisonmax) {
    3893         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/SmoothMetric)*/
    3894 
    3895         long int verbose=0;
    3896 
    3897         if(raisonmax<1.1) return;
    3898         if(verbose > 1) _printf_("   Mesh::SmoothMetric raisonmax = " << raisonmax << "\n");
    3899         CreateSingleVertexToTriangleConnectivity();
    3900         long i,j,kch,kk,ip;
    3901         long *first_np_or_next_t0 = new long[nbv];
    3902         long *first_np_or_next_t1 = new long[nbv];
    3903         long Head0 =0,Head1=-1;
    3904         double logseuil= log(raisonmax);
    3905 
    3906         for(i=0;i<nbv-1;i++)
    3907          first_np_or_next_t0[i]=i+1;
    3908         first_np_or_next_t0[nbv-1]=-1;// end;
    3909         for(i=0;i<nbv;i++)
    3910          first_np_or_next_t1[i]=-1;
    3911         kk=0;
    3912         while(Head0>=0&& kk++<100){
    3913                 kch=0;
    3914                 for(i=Head0;i>=0;i=first_np_or_next_t0[ip=i],first_np_or_next_t0[ip]=-1) {
    3915                         //  pour tous les triangles autour du sommet s
    3916                         Triangle* t= vertices[i].t;
    3917                         if (!t){
    3918                                 _error_("!t");
    3919                         }
    3920                         BamgVertex & vi = vertices[i];
    3921                         AdjacentTriangle ta(t,EdgesVertexTriangle[vertices[i].IndexInTriangle][0]);
    3922                         BamgVertex *pvj0 = ta.EdgeVertex(0);
    3923                         while (1) {
    3924                                 ta=Previous(Adj(ta));
    3925                                 if (vertices+i != ta.EdgeVertex(1)){
    3926                                         _error_("vertices+i != ta.EdgeVertex(1)");
    3927                                 }
    3928                                 BamgVertex & vj = *(ta.EdgeVertex(0));
    3929                                 if ( &vj ) {
    3930                                         j= &vj-vertices;
    3931                                         if (j<0 || j >= nbv){
    3932                                                 _error_("j<0 || j >= nbv");
     3816                  tstart[i]=vertices[i].t;     
     3817                else
     3818                 for ( i=0;i<nbv;i++)
     3819                  tstart[i]=0;
     3820                for ( j=0;j<NbVerticesOnGeomVertex;j++ )
     3821                 tstart[ GetId(VerticesOnGeomVertex[j].meshvertex)]=&vide;
     3822                for ( k=0;k<NbVerticesOnGeomEdge;k++ )
     3823                 tstart[ GetId(VerticesOnGeomEdge[k].meshvertex)]=&vide;
     3824                if(verbose>2) _printf_("   SmoothingVertex: nb Iteration = " << nbiter << ", Omega=" << omega << "\n");
     3825                for (k=0;k<nbiter;k++)
     3826                  {
     3827                        long i,NbSwap =0;
     3828                        double delta =0;
     3829                        for ( i=0;i<nbv;i++)
     3830                         if (tstart[i] != &vide) // not a boundary vertex
     3831                          delta=Max(delta,vertices[i].Smoothing(*this,BTh,tstart[i],omega));
     3832                        if (!nbq)
     3833                         for ( i=0;i<nbv;i++)
     3834                          if (tstart[i] != &vide) // not a boundary vertex
     3835                                NbSwap += vertices[i].Optim(1);
     3836                        if (verbose>3) _printf_("      move max = " << pow(delta,0.5) << ", iteration = " << k << ", nb of swap = " << NbSwap << "\n");
     3837                  }
     3838
     3839                delete [] tstart;
     3840                if (quadtree) quadtree= new BamgQuadtree(this);
     3841        }
     3842        /*}}}*/
     3843        void Mesh::SmoothMetric(double raisonmax) { /*{{{*/
     3844                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/SmoothMetric)*/
     3845
     3846                long int verbose=0;
     3847
     3848                if(raisonmax<1.1) return;
     3849                if(verbose > 1) _printf_("   Mesh::SmoothMetric raisonmax = " << raisonmax << "\n");
     3850                CreateSingleVertexToTriangleConnectivity();
     3851                long i,j,kch,kk,ip;
     3852                long *first_np_or_next_t0 = new long[nbv];
     3853                long *first_np_or_next_t1 = new long[nbv];
     3854                long Head0 =0,Head1=-1;
     3855                double logseuil= log(raisonmax);
     3856
     3857                for(i=0;i<nbv-1;i++)
     3858                 first_np_or_next_t0[i]=i+1;
     3859                first_np_or_next_t0[nbv-1]=-1;// end;
     3860                for(i=0;i<nbv;i++)
     3861                 first_np_or_next_t1[i]=-1;
     3862                kk=0;
     3863                while(Head0>=0&& kk++<100){
     3864                        kch=0;
     3865                        for(i=Head0;i>=0;i=first_np_or_next_t0[ip=i],first_np_or_next_t0[ip]=-1) {
     3866                                //  pour tous les triangles autour du sommet s
     3867                                Triangle* t= vertices[i].t;
     3868                                if (!t){
     3869                                        _error_("!t");
     3870                                }
     3871                                BamgVertex & vi = vertices[i];
     3872                                AdjacentTriangle ta(t,EdgesVertexTriangle[vertices[i].IndexInTriangle][0]);
     3873                                BamgVertex *pvj0 = ta.EdgeVertex(0);
     3874                                while (1) {
     3875                                        ta=Previous(Adj(ta));
     3876                                        if (vertices+i != ta.EdgeVertex(1)){
     3877                                                _error_("vertices+i != ta.EdgeVertex(1)");
    39333878                                        }
    3934                                         R2 Aij = (R2) vj - (R2) vi;
    3935                                         double ll =  Norme2(Aij);
    3936                                         if (0) { 
    3937                                                 double hi = ll/vi.m(Aij);
    3938                                                 double hj = ll/vj.m(Aij);
    3939                                                 if(hi < hj)
     3879                                        BamgVertex & vj = *(ta.EdgeVertex(0));
     3880                                        if ( &vj ) {
     3881                                                j= &vj-vertices;
     3882                                                if (j<0 || j >= nbv){
     3883                                                        _error_("j<0 || j >= nbv");
     3884                                                }
     3885                                                R2 Aij = (R2) vj - (R2) vi;
     3886                                                double ll =  Norme2(Aij);
     3887                                                if (0) { 
     3888                                                        double hi = ll/vi.m(Aij);
     3889                                                        double hj = ll/vj.m(Aij);
     3890                                                        if(hi < hj)
     3891                                                          {
     3892                                                                double dh=(hj-hi)/ll;
     3893                                                                if (dh>logseuil) {
     3894                                                                        vj.m.IntersectWith(vi.m/(1 +logseuil*ll/hi));
     3895                                                                        if(first_np_or_next_t1[j]<0)
     3896                                                                         kch++,first_np_or_next_t1[j]=Head1,Head1=j;
     3897                                                                }
     3898                                                          }
     3899                                                }
     3900                                                else
    39403901                                                  {
    3941                                                         double dh=(hj-hi)/ll;
    3942                                                         if (dh>logseuil) {
    3943                                                                 vj.m.IntersectWith(vi.m/(1 +logseuil*ll/hi));
    3944                                                                 if(first_np_or_next_t1[j]<0)
    3945                                                                  kch++,first_np_or_next_t1[j]=Head1,Head1=j;
    3946                                                         }
     3902                                                        double li = vi.m(Aij);
     3903                                                        if( vj.m.IntersectWith(vi.m/(1 +logseuil*li)) )
     3904                                                         if(first_np_or_next_t1[j]<0) // if the metrix change
     3905                                                          kch++,first_np_or_next_t1[j]=Head1,Head1=j;
    39473906                                                  }
    3948                                         }
    3949                                         else
    3950                                           {
    3951                                                 double li = vi.m(Aij);
    3952                                                 if( vj.m.IntersectWith(vi.m/(1 +logseuil*li)) )
    3953                                                  if(first_np_or_next_t1[j]<0) // if the metrix change
    3954                                                   kch++,first_np_or_next_t1[j]=Head1,Head1=j;
     3907                                        }
     3908                                        if  ( &vj ==  pvj0 ) break;
     3909                                }
     3910                        }
     3911                        Head0 = Head1;
     3912                        Head1 = -1;
     3913                        Exchange(first_np_or_next_t0,first_np_or_next_t1);
     3914                }
     3915                if(verbose>2) _printf_("      number of iterations = " << kch << "\n");
     3916                delete [] first_np_or_next_t0;
     3917                delete [] first_np_or_next_t1;
     3918        }
     3919        /*}}}*/
     3920        long  Mesh::SplitInternalEdgeWithBorderVertices(){/*{{{*/
     3921                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SplitInternalEdgeWithBorderVertices)*/
     3922
     3923                long NbSplitEdge=0;
     3924                SetVertexFieldOn(); 
     3925                long it;
     3926                long nbvold=nbv;
     3927                long int verbose=2;
     3928                for (it=0;it<nbt;it++){
     3929                        Triangle &t=triangles[it];
     3930                        if (t.link)
     3931                         for (int j=0;j<3;j++)
     3932                          if(!t.Locked(j) && !t.Hidden(j)){
     3933                                  Triangle &tt = *t.TriangleAdj(j);
     3934                                  if ( &tt && tt.link && it < GetId(tt))
     3935                                         { // an internal edge
     3936                                          BamgVertex &v0 = t[VerticesOfTriangularEdge[j][0]];
     3937                                          BamgVertex &v1 = t[VerticesOfTriangularEdge[j][1]];
     3938                                          if (v0.GeomEdgeHook && v1.GeomEdgeHook){
     3939                                                  R2 P= ((R2) v0 + (R2) v1)*0.5;
     3940                                                  if ( nbv<maxnbv) {
     3941                                                          vertices[nbv].r = P;
     3942                                                          vertices[nbv++].m = Metric(0.5,v0.m,0.5,v1.m);
     3943                                                          vertices[nbv].ReferenceNumber=0;
     3944                                                          vertices[nbv].DirOfSearch = NoDirOfSearch ;
     3945                                                  }
     3946                                                  NbSplitEdge++;
    39553947                                          }
    3956                                 }
    3957                                 if  ( &vj ==  pvj0 ) break;
    3958                         }
    3959                 }
    3960                 Head0 = Head1;
    3961                 Head1 = -1;
    3962                 Exchange(first_np_or_next_t0,first_np_or_next_t1);
    3963         }
    3964         if(verbose>2) _printf_("      number of iterations = " << kch << "\n");
    3965         delete [] first_np_or_next_t0;
    3966         delete [] first_np_or_next_t1;
    3967 }
    3968 /*}}}*/
    3969 /*FUNCTION Mesh::SplitInternalEdgeWithBorderVertices{{{*/
    3970 long  Mesh::SplitInternalEdgeWithBorderVertices(){
    3971         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SplitInternalEdgeWithBorderVertices)*/
    3972 
    3973         long NbSplitEdge=0;
    3974         SetVertexFieldOn(); 
    3975         long it;
    3976         long nbvold=nbv;
    3977         long int verbose=2;
    3978         for (it=0;it<nbt;it++){
    3979                 Triangle &t=triangles[it];
    3980                 if (t.link)
    3981                  for (int j=0;j<3;j++)
    3982                   if(!t.Locked(j) && !t.Hidden(j)){
    3983                           Triangle &tt = *t.TriangleAdj(j);
    3984                           if ( &tt && tt.link && it < GetId(tt))
    3985                                  { // an internal edge
    3986                                   BamgVertex &v0 = t[VerticesOfTriangularEdge[j][0]];
    3987                                   BamgVertex &v1 = t[VerticesOfTriangularEdge[j][1]];
    3988                                   if (v0.GeomEdgeHook && v1.GeomEdgeHook){
    3989                                           R2 P= ((R2) v0 + (R2) v1)*0.5;
    3990                                           if ( nbv<maxnbv) {
    3991                                                   vertices[nbv].r = P;
    3992                                                   vertices[nbv++].m = Metric(0.5,v0.m,0.5,v1.m);
    3993                                                   vertices[nbv].ReferenceNumber=0;
    3994                                                   vertices[nbv].DirOfSearch = NoDirOfSearch ;
    3995                                           }
    3996                                           NbSplitEdge++;
    3997                                   }
    3998                                  }
    3999                   }
    4000         }
    4001         CreateSingleVertexToTriangleConnectivity();   
    4002         if (nbvold!=nbv){
    4003                 long  iv = nbvold;
    4004                 long NbSwap = 0;
    4005                 Icoor2 det3[3]; 
    4006                 for (int i=nbvold;i<nbv;i++) {// for all the new point
    4007                         BamgVertex & vi = vertices[i];
    4008                         vi.i = R2ToI2(vi.r);
    4009                         vi.r = I2ToR2(vi.i);
    4010 
    4011                         // a good new point
    4012                         vi.ReferenceNumber=0;
    4013                         vi.DirOfSearch =NoDirOfSearch;
    4014                         Triangle *tcvi = TriangleFindFromCoord(vi.i,det3);
    4015                         if (tcvi && !tcvi->link) {
    4016                                 _printf_("problem inserting point in SplitInternalEdgeWithBorderVertices (tcvj && !tcvj->link)\n");
    4017                         }
    4018 
    4019                         quadtree->Add(vi);
    4020                         if (!tcvi || tcvi->det<0){// internal
    4021                                 _error_("!tcvi || tcvi->det < 0");
    4022                         }
    4023                         AddVertex(vi,tcvi,det3);
    4024                         NbSwap += vi.Optim(1);         
    4025                         iv++;
    4026                 }
    4027                 if (verbose>3) {
    4028                         _printf_("   number of points: " << iv << "\n");
    4029                         _printf_("   number of swap to  split internal edges with border vertices: " << NbSwap << "\n");
    4030                         nbv = iv;
    4031                 }
    4032         }
    4033         if (NbSplitEdge>nbv-nbvold) _printf_("WARNING: not enough vertices  to split all internal edges, we lost " << NbSplitEdge - ( nbv-nbvold) << " edges...\n");
    4034         if (verbose>2) _printf_("SplitInternalEdgeWithBorderVertices: Number of splited edge " << NbSplitEdge << "\n");
    4035 
    4036         return  NbSplitEdge;
    4037 }
    4038 /*}}}*/
    4039 /*FUNCTION Mesh::ToI2{{{*/
    4040 I2 Mesh::R2ToI2(const R2 & P) const {
    4041         return  I2( (Icoor1) (coefIcoor*(P.x-pmin.x)),(Icoor1) (coefIcoor*(P.y-pmin.y)) );
    4042 }
    4043 /*}}}*/
    4044 /*FUNCTION Mesh::ToR2{{{*/
    4045 R2 Mesh::I2ToR2(const I2 & P) const {
    4046         return  R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y);
    4047 }
    4048 /*}}}*/
    4049 /*FUNCTION Mesh::TriangleFindFromCoord{{{*/
    4050 Triangle * Mesh::TriangleFindFromCoord(const I2 & B,Icoor2 det3[3], Triangle *tstart) const {
    4051         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FindTriangleContening)*/
    4052 
    4053         Triangle * t=0;
    4054         int j,jp,jn,jj;
    4055         int counter;
    4056 
    4057         /*Get starting triangle. Take tsart if provided*/
    4058         if (tstart) t=tstart;
    4059 
    4060         /*Else find the closest Triangle using the quadtree*/
    4061         else {
    4062 
    4063                 /*Check that the quadtree does exist*/
    4064                 if (!quadtree) _error_("no starting triangle provided and no quadtree available");
    4065 
    4066                 /*Call NearestVertex*/
    4067                 BamgVertex *a = quadtree->NearestVertex(B.x,B.y) ;
    4068 
    4069                 /*Check output (Vertex a)*/
    4070                 if (!a)    _error_("problem while trying to find nearest vertex from a given point. No output found");
    4071                 if (!a->t) _error_("no triangle is associated to vertex number " << GetId(a)+1 << " (orphan?)");
    4072                 _assert_(a>=vertices && a<vertices+nbv);
    4073 
    4074                 /*Get starting triangle*/
    4075                 t = a->t;
    4076                 _assert_(t>=triangles && t<triangles+nbt);
    4077         }
    4078 
    4079         Icoor2  detop ;
    4080 
    4081         /*initialize number of test triangle*/
    4082         counter=0;
    4083 
    4084         /*The initial triangle might be outside*/
    4085         while (t->det < 0){
    4086 
    4087                 /*Get a real vertex from this triangle (k0)*/
    4088                 int k0=(*t)(0)?(((*t)(1)?((*t)(2)?-1:2):1)):0;
    4089                 _assert_(k0>=0);// k0 the NULL vertex
    4090                 int k1=NextVertex[k0],k2=PreviousVertex[k0];
    4091                 det3[k0]=det(B,(*t)[k1],(*t)[k2]);
    4092                 det3[k1]=det3[k2]=-1;     
    4093                 if (det3[k0] > 0) // outside B
    4094                  return t;
    4095                 t = t->TriangleAdj(OppositeEdge[k0]);
    4096                 counter++;
    4097                 _assert_(counter<2);
    4098         }
    4099 
    4100         jj=0;
    4101         detop = det(*(*t)(VerticesOfTriangularEdge[jj][0]),*(*t)(VerticesOfTriangularEdge[jj][1]),B);
    4102 
    4103         while(t->det>0){
    4104 
    4105                 /*Increase counter*/
    4106                 if (++counter>=10000) _error_("Maximum number of iteration reached (threshold = " << counter << ").");
    4107 
    4108                 j= OppositeVertex[jj];
    4109                 det3[j] = detop;  //det(*b,*s1,*s2);
    4110                 jn = NextVertex[j];
    4111                 jp = PreviousVertex[j];
    4112                 det3[jp]= det(*(*t)(j),*(*t)(jn),B);
    4113                 det3[jn] = t->det-det3[j] -det3[jp];
    4114 
    4115                 // count the number k of  det3 <0
    4116                 int k=0,ii[3];
    4117                 if (det3[0] < 0 ) ii[k++]=0;
    4118                 if (det3[1] < 0 ) ii[k++]=1;
    4119                 if (det3[2] < 0 ) ii[k++]=2;
    4120                 // 0 => ok
    4121                 // 1 => go in way 1
    4122                 // 2 => two way go in way 1 or 2 randomly
    4123 
    4124                 if (k==0) break;
    4125                 if (k==2 && BinaryRand()) Exchange(ii[0],ii[1]);
    4126                 _assert_(k<3);
    4127                 AdjacentTriangle t1 = t->Adj(jj=ii[0]);
    4128                 if ((t1.det() < 0 ) && (k == 2))
    4129                  t1 = t->Adj(jj=ii[1]);
    4130                 t=t1;
    4131                 j=t1;// for optimisation we now the -det[OppositeVertex[j]];
    4132                 detop = -det3[OppositeVertex[jj]];
    4133                 jj = j;
    4134         }
    4135 
    4136         if (t->det<0) // outside triangle
    4137          det3[0]=det3[1]=det3[2]=-1,det3[OppositeVertex[jj]]=detop;
    4138         return t;
    4139 }
    4140 /*}}}*/
    4141 /*FUNCTION Mesh::TriangleIntNumbering{{{*/
    4142 void Mesh::TriangleIntNumbering(long* renumbering){
    4143 
    4144         long num=0;
    4145         for (int i=0;i<nbt;i++){
    4146                 if (triangles[i].det>0) renumbering[i]=num++;
    4147                 else renumbering[i]=-1;
    4148         }
    4149         return;   
    4150 }
    4151 /*}}}*/
    4152 /*FUNCTION Mesh::TriangleReferenceList{{{*/
    4153 long  Mesh::TriangleReferenceList(long* reft) const {
    4154         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ConsRefTriangle)*/
    4155 
    4156         Triangle *t0,*t;
    4157         long k=0, num;   
    4158 
    4159         //initialize all triangles as -1 (outside)
    4160         for (int it=0;it<nbt;it++) reft[it]=-1;
    4161 
    4162         //loop over all subdomains
    4163         for (int i=0;i<nbsubdomains;i++){
    4164 
    4165                 //first triangle of the subdomain i
    4166                 t=t0=subdomains[i].head;
    4167 
    4168                 //check that the subdomain is not empty
    4169                 if (!t0){ _error_("At least one subdomain is empty");}
    4170 
    4171                 //loop
    4172                 do{
    4173                         k++;
    4174 
    4175                         //get current triangle number
    4176                         num = GetId(t);
    4177 
    4178                         //check that num is in [0 nbt[
    4179                         _assert_(num>=0 && num<nbt);
    4180 
    4181                         //reft of this triangle is the subdomain number
    4182                         reft[num]=i;
    4183 
    4184                 } while (t0 != (t=t->link));
    4185                 //stop when all triangles of subdomains have been tagged
    4186 
    4187         }
    4188         return k;   
    4189 }
    4190 /*}}}*/
    4191 /*FUNCTION Mesh::Triangulate{{{*/
    4192 void Mesh::Triangulate(double* x,double* y,int nods){
    4193 
    4194         int verbose=0;
    4195         int i;
    4196         Metric M1(1);
    4197 
    4198         /*Initialize mesh*/
    4199         Init(nods);//this resets nbv to 0
    4200         nbv=nods;
    4201 
    4202         //Vertices
    4203         if(verbose) _printf_("Reading vertices (" << nbv << ")\n");
    4204         for(i=0;i<nbv;i++){
    4205                 vertices[i].r.x=x[i];
    4206                 vertices[i].r.y=y[i];
    4207                 vertices[i].ReferenceNumber=1;
    4208                 vertices[i].DirOfSearch =NoDirOfSearch;
    4209                 vertices[i].m=M1;
    4210                 vertices[i].color=0;
    4211         }
    4212         maxnbt=2*maxnbv-2; // for filling The Holes and quadrilaterals
    4213 
    4214         /*Insert Vertices*/
    4215         Insert(true);
    4216 }
    4217 /*}}}*/
    4218         /*FUNCTION Mesh::TriangulateFromGeom0{{{*/
    4219         void Mesh::TriangulateFromGeom0(BamgOpts* bamgopts){
     3948                                         }
     3949                          }
     3950                }
     3951                CreateSingleVertexToTriangleConnectivity();   
     3952                if (nbvold!=nbv){
     3953                        long  iv = nbvold;
     3954                        long NbSwap = 0;
     3955                        Icoor2 det3[3]; 
     3956                        for (int i=nbvold;i<nbv;i++) {// for all the new point
     3957                                BamgVertex & vi = vertices[i];
     3958                                vi.i = R2ToI2(vi.r);
     3959                                vi.r = I2ToR2(vi.i);
     3960
     3961                                // a good new point
     3962                                vi.ReferenceNumber=0;
     3963                                vi.DirOfSearch =NoDirOfSearch;
     3964                                Triangle *tcvi = TriangleFindFromCoord(vi.i,det3);
     3965                                if (tcvi && !tcvi->link) {
     3966                                        _printf_("problem inserting point in SplitInternalEdgeWithBorderVertices (tcvj && !tcvj->link)\n");
     3967                                }
     3968
     3969                                quadtree->Add(vi);
     3970                                if (!tcvi || tcvi->det<0){// internal
     3971                                        _error_("!tcvi || tcvi->det < 0");
     3972                                }
     3973                                AddVertex(vi,tcvi,det3);
     3974                                NbSwap += vi.Optim(1);         
     3975                                iv++;
     3976                        }
     3977                        if (verbose>3) {
     3978                                _printf_("   number of points: " << iv << "\n");
     3979                                _printf_("   number of swap to  split internal edges with border vertices: " << NbSwap << "\n");
     3980                                nbv = iv;
     3981                        }
     3982                }
     3983                if (NbSplitEdge>nbv-nbvold) _printf_("WARNING: not enough vertices  to split all internal edges, we lost " << NbSplitEdge - ( nbv-nbvold) << " edges...\n");
     3984                if (verbose>2) _printf_("SplitInternalEdgeWithBorderVertices: Number of splited edge " << NbSplitEdge << "\n");
     3985
     3986                return  NbSplitEdge;
     3987        }
     3988        /*}}}*/
     3989        I2 Mesh::R2ToI2(const R2 & P) const {/*{{{*/
     3990                return  I2( (Icoor1) (coefIcoor*(P.x-pmin.x)),(Icoor1) (coefIcoor*(P.y-pmin.y)) );
     3991        }
     3992        /*}}}*/
     3993        R2 Mesh::I2ToR2(const I2 & P) const {/*{{{*/
     3994                return  R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y);
     3995        }
     3996        /*}}}*/
     3997        Triangle * Mesh::TriangleFindFromCoord(const I2 & B,Icoor2 det3[3], Triangle *tstart) const {/*{{{*/
     3998                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/FindTriangleContening)*/
     3999
     4000                Triangle * t=0;
     4001                int j,jp,jn,jj;
     4002                int counter;
     4003
     4004                /*Get starting triangle. Take tsart if provided*/
     4005                if (tstart) t=tstart;
     4006
     4007                /*Else find the closest Triangle using the quadtree*/
     4008                else {
     4009
     4010                        /*Check that the quadtree does exist*/
     4011                        if (!quadtree) _error_("no starting triangle provided and no quadtree available");
     4012
     4013                        /*Call NearestVertex*/
     4014                        BamgVertex *a = quadtree->NearestVertex(B.x,B.y) ;
     4015
     4016                        /*Check output (Vertex a)*/
     4017                        if (!a)    _error_("problem while trying to find nearest vertex from a given point. No output found");
     4018                        if (!a->t) _error_("no triangle is associated to vertex number " << GetId(a)+1 << " (orphan?)");
     4019                        _assert_(a>=vertices && a<vertices+nbv);
     4020
     4021                        /*Get starting triangle*/
     4022                        t = a->t;
     4023                        _assert_(t>=triangles && t<triangles+nbt);
     4024                }
     4025
     4026                Icoor2  detop ;
     4027
     4028                /*initialize number of test triangle*/
     4029                counter=0;
     4030
     4031                /*The initial triangle might be outside*/
     4032                while (t->det < 0){
     4033
     4034                        /*Get a real vertex from this triangle (k0)*/
     4035                        int k0=(*t)(0)?(((*t)(1)?((*t)(2)?-1:2):1)):0;
     4036                        _assert_(k0>=0);// k0 the NULL vertex
     4037                        int k1=NextVertex[k0],k2=PreviousVertex[k0];
     4038                        det3[k0]=det(B,(*t)[k1],(*t)[k2]);
     4039                        det3[k1]=det3[k2]=-1;     
     4040                        if (det3[k0] > 0) // outside B
     4041                         return t;
     4042                        t = t->TriangleAdj(OppositeEdge[k0]);
     4043                        counter++;
     4044                        _assert_(counter<2);
     4045                }
     4046
     4047                jj=0;
     4048                detop = det(*(*t)(VerticesOfTriangularEdge[jj][0]),*(*t)(VerticesOfTriangularEdge[jj][1]),B);
     4049
     4050                while(t->det>0){
     4051
     4052                        /*Increase counter*/
     4053                        if (++counter>=10000) _error_("Maximum number of iteration reached (threshold = " << counter << ").");
     4054
     4055                        j= OppositeVertex[jj];
     4056                        det3[j] = detop;  //det(*b,*s1,*s2);
     4057                        jn = NextVertex[j];
     4058                        jp = PreviousVertex[j];
     4059                        det3[jp]= det(*(*t)(j),*(*t)(jn),B);
     4060                        det3[jn] = t->det-det3[j] -det3[jp];
     4061
     4062                        // count the number k of  det3 <0
     4063                        int k=0,ii[3];
     4064                        if (det3[0] < 0 ) ii[k++]=0;
     4065                        if (det3[1] < 0 ) ii[k++]=1;
     4066                        if (det3[2] < 0 ) ii[k++]=2;
     4067                        // 0 => ok
     4068                        // 1 => go in way 1
     4069                        // 2 => two way go in way 1 or 2 randomly
     4070
     4071                        if (k==0) break;
     4072                        if (k==2 && BinaryRand()) Exchange(ii[0],ii[1]);
     4073                        _assert_(k<3);
     4074                        AdjacentTriangle t1 = t->Adj(jj=ii[0]);
     4075                        if ((t1.det() < 0 ) && (k == 2))
     4076                         t1 = t->Adj(jj=ii[1]);
     4077                        t=t1;
     4078                        j=t1;// for optimisation we now the -det[OppositeVertex[j]];
     4079                        detop = -det3[OppositeVertex[jj]];
     4080                        jj = j;
     4081                }
     4082
     4083                if (t->det<0) // outside triangle
     4084                 det3[0]=det3[1]=det3[2]=-1,det3[OppositeVertex[jj]]=detop;
     4085                return t;
     4086        }
     4087        /*}}}*/
     4088        void Mesh::TriangleIntNumbering(long* renumbering){/*{{{*/
     4089
     4090                long num=0;
     4091                for (int i=0;i<nbt;i++){
     4092                        if (triangles[i].det>0) renumbering[i]=num++;
     4093                        else renumbering[i]=-1;
     4094                }
     4095                return;   
     4096        }
     4097        /*}}}*/
     4098        long  Mesh::TriangleReferenceList(long* reft) const {/*{{{*/
     4099                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ConsRefTriangle)*/
     4100
     4101                Triangle *t0,*t;
     4102                long k=0, num;   
     4103
     4104                //initialize all triangles as -1 (outside)
     4105                for (int it=0;it<nbt;it++) reft[it]=-1;
     4106
     4107                //loop over all subdomains
     4108                for (int i=0;i<nbsubdomains;i++){
     4109
     4110                        //first triangle of the subdomain i
     4111                        t=t0=subdomains[i].head;
     4112
     4113                        //check that the subdomain is not empty
     4114                        if (!t0){ _error_("At least one subdomain is empty");}
     4115
     4116                        //loop
     4117                        do{
     4118                                k++;
     4119
     4120                                //get current triangle number
     4121                                num = GetId(t);
     4122
     4123                                //check that num is in [0 nbt[
     4124                                _assert_(num>=0 && num<nbt);
     4125
     4126                                //reft of this triangle is the subdomain number
     4127                                reft[num]=i;
     4128
     4129                        } while (t0 != (t=t->link));
     4130                        //stop when all triangles of subdomains have been tagged
     4131
     4132                }
     4133                return k;   
     4134        }
     4135        /*}}}*/
     4136        void Mesh::Triangulate(double* x,double* y,int nods){/*{{{*/
     4137
     4138                int verbose=0;
     4139                int i;
     4140                Metric M1(1);
     4141
     4142                /*Initialize mesh*/
     4143                Init(nods);//this resets nbv to 0
     4144                nbv=nods;
     4145
     4146                //Vertices
     4147                if(verbose) _printf_("Reading vertices (" << nbv << ")\n");
     4148                for(i=0;i<nbv;i++){
     4149                        vertices[i].r.x=x[i];
     4150                        vertices[i].r.y=y[i];
     4151                        vertices[i].ReferenceNumber=1;
     4152                        vertices[i].DirOfSearch =NoDirOfSearch;
     4153                        vertices[i].m=M1;
     4154                        vertices[i].color=0;
     4155                }
     4156                maxnbt=2*maxnbv-2; // for filling The Holes and quadrilaterals
     4157
     4158                /*Insert Vertices*/
     4159                Insert(true);
     4160        }
     4161        /*}}}*/
     4162        void Mesh::TriangulateFromGeom0(BamgOpts* bamgopts){/*{{{*/
    42204163                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/GeomToTriangles0)*/
    42214164                /*Generate mesh from geometry*/
    … …  
    45314474        }
    45324475        /*}}}*/
    4533         /*FUNCTION Mesh::TriangulateFromGeom1{{{*/
    4534         void Mesh::TriangulateFromGeom1(BamgOpts* bamgopts,int KeepVertices){
     4476        void Mesh::TriangulateFromGeom1(BamgOpts* bamgopts,int KeepVertices){ /*{{{*/
    45354477                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/GeomToTriangles1)*/
    45364478
    … …  
    45664508
    45674509                /* There are 2 ways to make the loop
    4568                 * 1) on the geometry
    4569                 * 2) on the background mesh
    4570                 *  if you do the loop on geometry, we don't have the pointeur on background,
    4571                 *  and if you do the loop in background we have the pointeur on geometry
    4572                 * so do the walk on  background */
     4510                 * 1) on the geometry
     4511                 * 2) on the background mesh
     4512                 *  if you do the loop on geometry, we don't have the pointeur on background,
     4513                 *  and if you do the loop in background we have the pointeur on geometry
     4514                 * so do the walk on  background */
    45734515
    45744516                NbVerticesOnGeomVertex=0;
    … …  
    48614803
    48624804        /*Intermediary*/
    4863         /*FUNCTION CloseBoundaryEdge{{{*/
    4864         AdjacentTriangle CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) {
     4805        AdjacentTriangle CloseBoundaryEdge(I2 A,Triangle *t, double &a,double &b) {/*{{{*/
    48654806                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/CloseBoundaryEdge)*/
    48664807
    … …  
    48984839                                                        b= IJ_IA/IJ2;
    48994840                                                        return edge;
    4900                   }
    4901         }
    4902         /*}}}*/
    4903 /*FUNCTION ForceEdge{{{*/
    4904 int ForceEdge(BamgVertex &a, BamgVertex & b,AdjacentTriangle & taret)  {
    4905         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
    4906 
    4907         int NbSwap =0;
    4908         if (!a.t || !b.t){ // the 2 vertex is in a mesh
    4909                 _error_("!a.t || !b.t");
    4910         }
    4911         int k=0;
    4912         taret=AdjacentTriangle(0,0); // erreur
    4913 
    4914         AdjacentTriangle tta(a.t,EdgesVertexTriangle[a.IndexInTriangle][0]);
    4915         BamgVertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
    4916         // we turn around a in the  direct direction 
    4917 
    4918         Icoor2 det2 = v2 ? det(*v2,a,b): -1 , det1;
    4919         if(v2) // normal case
    4920          det2 = det(*v2,a,b);
    4921         else { // no chance infini vertex try the next
    4922                 tta= Previous(Adj(tta));
    4923                 v2 = tta.EdgeVertex(0);
    4924                 vbegin =v2;
    4925                 if (!v2){
    4926                         _error_("!v2");
    4927                 }
    4928                 det2 = det(*v2,a,b);
    4929         }
    4930 
    4931         while (v2 != &b) {
    4932                 AdjacentTriangle tc = Previous(Adj(tta));   
    4933                 v1 = v2;
    4934                 v2 = tc.EdgeVertex(0);
    4935                 det1 = det2;
    4936                 det2 =  v2 ? det(*v2,a,b): det2;
    4937 
    4938                 if((det1 < 0) && (det2 >0)) {
    4939                         // try to force the edge
    4940                         BamgVertex * va = &a, *vb = &b;
    4941                         tc = Previous(tc);
    4942                         if (!v1 || !v2){
    4943                                 _error_("!v1 || !v2");
    4944                         }
    4945                         Icoor2 detss = 0,l=0;
    4946                         while ((SwapForForcingEdge(  va,  vb, tc, detss, det1,det2,NbSwap)))
    4947                          if(l++ > 10000000) {
    4948                                  _error_("Loop in forcing Egde, nb de swap=" << NbSwap << ", nb of try swap (" << l << ") too big");
    4949                          }
    4950                         BamgVertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
    4951                         if (((aa == &a ) && (bb == &b)) ||((bb ==  &a ) && (aa == &b))){
    4952                                 tc.SetLock();
    4953                                 a.Optim(1,0);
    4954                                 b.Optim(1,0);
    4955                                 taret = tc;
    4956                                 return NbSwap;
    4957                         }
    4958                         else
    4959                           {
    4960                                 taret = tc;
    4961                                 return -2; // error  boundary is crossing
    4962                           }
    4963                 }
    4964                 tta = tc;
    4965                 k++;
    4966                 if (k>=2000){
    4967                         _error_("k>=2000");
    4968                 }
    4969                 if ( vbegin == v2 ) return -1;// error
    4970         }
    4971 
    4972         tta.SetLock();
    4973         taret=tta;
    4974         a.Optim(1,0);
    4975         b.Optim(1,0);
    4976         return NbSwap;
    4977 }
    4978 /*}}}*/
    4979 /*FUNCTION swap{{{*/
    4980 void  swap(Triangle *t1,short a1, Triangle *t2,short a2, BamgVertex *s1,BamgVertex *s2,Icoor2 det1,Icoor2 det2){
    4981         /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
    4982         // --------------------------------------------------------------
    4983         // short a2=aa[a];// les 2 numero de l arete dans les 2 triangles
    4984         //                               
    4985         //               sb                     sb   
    4986         //             / | \                   /   \                      !
    4987         //         as1/  |  \                 /a2   \                     !
    4988         //           /   |   \               /    t2 \                    !
    4989         //       s1 /t1  | t2 \s2  -->   s1 /___as2___\s2                 !
    4990         //          \  a1|a2  /             \   as1   / 
    4991         //           \   |   /               \ t1    /   
    4992         //            \  |  / as2             \   a1/   
    4993         //             \ | /                   \   /     
    4994         //              sa                       sa   
    4995         //  -------------------------------------------------------------
    4996         int as1 = NextEdge[a1];
    4997         int as2 = NextEdge[a2];
    4998         int ap1 = PreviousEdge[a1];
    4999         int ap2 = PreviousEdge[a2];
    5000         (*t1)(VerticesOfTriangularEdge[a1][1]) = s2 ; // avant sb
    5001         (*t2)(VerticesOfTriangularEdge[a2][1]) = s1  ; // avant sa
    5002         // mise a jour des 2 adjacences externes
    5003         AdjacentTriangle taas1 = t1->Adj(as1),
    5004                                                   taas2 = t2->Adj(as2),
    5005                                                   tas1(t1,as1), tas2(t2,as2),
    5006                                                   ta1(t1,a1),ta2(t2,a2);
    5007         // externe haut gauche
    5008         taas1.SetAdj2(ta2, taas1.GetAllFlag_UnSwap());
    5009         // externe bas droite
    5010         taas2.SetAdj2(ta1, taas2.GetAllFlag_UnSwap());
    5011         // remove the Mark  UnMarkSwap
    5012         t1->SetUnMarkUnSwap(ap1);
    5013         t2->SetUnMarkUnSwap(ap2);
    5014         // interne
    5015         tas1.SetAdj2(tas2);
    5016 
    5017         t1->det = det1;
    5018         t2->det = det2;
    5019 
    5020         t1->SetSingleVertexToTriangleConnectivity();
    5021         t2->SetSingleVertexToTriangleConnectivity();
    5022 } // end swap
    5023 /*}}}*/
    5024         /*FUNCTION SwapForForcingEdge{{{*/
    5025         int SwapForForcingEdge(BamgVertex   *  & pva ,BamgVertex  * &   pvb ,AdjacentTriangle & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {
     4841                }
     4842        }
     4843        /*}}}*/
     4844        int ForceEdge(BamgVertex &a, BamgVertex & b,AdjacentTriangle & taret)  { /*{{{*/
     4845                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/
     4846
     4847                int NbSwap =0;
     4848                if (!a.t || !b.t){ // the 2 vertex is in a mesh
     4849                        _error_("!a.t || !b.t");
     4850                }
     4851                int k=0;
     4852                taret=AdjacentTriangle(0,0); // erreur
     4853
     4854                AdjacentTriangle tta(a.t,EdgesVertexTriangle[a.IndexInTriangle][0]);
     4855                BamgVertex   *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;
     4856                // we turn around a in the  direct direction 
     4857
     4858                Icoor2 det2 = v2 ? det(*v2,a,b): -1 , det1;
     4859                if(v2) // normal case
     4860                 det2 = det(*v2,a,b);
     4861                else { // no chance infini vertex try the next
     4862                        tta= Previous(Adj(tta));
     4863                        v2 = tta.EdgeVertex(0);
     4864                        vbegin =v2;
     4865                        if (!v2){
     4866                                _error_("!v2");
     4867                        }
     4868                        det2 = det(*v2,a,b);
     4869                }
     4870
     4871                while (v2 != &b) {
     4872                        AdjacentTriangle tc = Previous(Adj(tta));   
     4873                        v1 = v2;
     4874                        v2 = tc.EdgeVertex(0);
     4875                        det1 = det2;
     4876                        det2 =  v2 ? det(*v2,a,b): det2;
     4877
     4878                        if((det1 < 0) && (det2 >0)) {
     4879                                // try to force the edge
     4880                                BamgVertex * va = &a, *vb = &b;
     4881                                tc = Previous(tc);
     4882                                if (!v1 || !v2){
     4883                                        _error_("!v1 || !v2");
     4884                                }
     4885                                Icoor2 detss = 0,l=0;
     4886                                while ((SwapForForcingEdge(  va,  vb, tc, detss, det1,det2,NbSwap)))
     4887                                 if(l++ > 10000000) {
     4888                                         _error_("Loop in forcing Egde, nb de swap=" << NbSwap << ", nb of try swap (" << l << ") too big");
     4889                                 }
     4890                                BamgVertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
     4891                                if (((aa == &a ) && (bb == &b)) ||((bb ==  &a ) && (aa == &b))){
     4892                                        tc.SetLock();
     4893                                        a.Optim(1,0);
     4894                                        b.Optim(1,0);
     4895                                        taret = tc;
     4896                                        return NbSwap;
     4897                                }
     4898                                else
     4899                                  {
     4900                                        taret = tc;
     4901                                        return -2; // error  boundary is crossing
     4902                                  }
     4903                        }
     4904                        tta = tc;
     4905                        k++;
     4906                        if (k>=2000){
     4907                                _error_("k>=2000");
     4908                        }
     4909                        if ( vbegin == v2 ) return -1;// error
     4910                }
     4911
     4912                tta.SetLock();
     4913                taret=tta;
     4914                a.Optim(1,0);
     4915                b.Optim(1,0);
     4916                return NbSwap;
     4917        }
     4918        /*}}}*/
     4919        void  swap(Triangle *t1,short a1, Triangle *t2,short a2, BamgVertex *s1,BamgVertex *s2,Icoor2 det1,Icoor2 det2){ /*{{{*/
     4920                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
     4921                // --------------------------------------------------------------
     4922                // short a2=aa[a];// les 2 numero de l arete dans les 2 triangles
     4923                //                               
     4924                //               sb                     sb   
     4925                //             / | \                   /   \                      !
     4926                //         as1/  |  \                 /a2   \                     !
     4927                //           /   |   \               /    t2 \                    !
     4928                //       s1 /t1  | t2 \s2  -->   s1 /___as2___\s2                 !
     4929                //          \  a1|a2  /             \   as1   / 
     4930                //           \   |   /               \ t1    /   
     4931                //            \  |  / as2             \   a1/   
     4932                //             \ | /                   \   /     
     4933                //              sa                       sa   
     4934                //  -------------------------------------------------------------
     4935                int as1 = NextEdge[a1];
     4936                int as2 = NextEdge[a2];
     4937                int ap1 = PreviousEdge[a1];
     4938                int ap2 = PreviousEdge[a2];
     4939                (*t1)(VerticesOfTriangularEdge[a1][1]) = s2 ; // avant sb
     4940                (*t2)(VerticesOfTriangularEdge[a2][1]) = s1  ; // avant sa
     4941                // mise a jour des 2 adjacences externes
     4942                AdjacentTriangle taas1 = t1->Adj(as1),
     4943                                                          taas2 = t2->Adj(as2),
     4944                                                          tas1(t1,as1), tas2(t2,as2),
     4945                                                          ta1(t1,a1),ta2(t2,a2);
     4946                // externe haut gauche
     4947                taas1.SetAdj2(ta2, taas1.GetAllFlag_UnSwap());
     4948                // externe bas droite
     4949                taas2.SetAdj2(ta1, taas2.GetAllFlag_UnSwap());
     4950                // remove the Mark  UnMarkSwap
     4951                t1->SetUnMarkUnSwap(ap1);
     4952                t2->SetUnMarkUnSwap(ap2);
     4953                // interne
     4954                tas1.SetAdj2(tas2);
     4955
     4956                t1->det = det1;
     4957                t2->det = det2;
     4958
     4959                t1->SetSingleVertexToTriangleConnectivity();
     4960                t2->SetSingleVertexToTriangleConnectivity();
     4961        } // end swap
     4962        /*}}}*/
     4963        int SwapForForcingEdge(BamgVertex   *  & pva ,BamgVertex  * &   pvb ,AdjacentTriangle & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {/*{{{*/
    50264964                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SwapForForcingEdge)*/
    50274965                // l'arete ta coupe l'arete pva pvb
    … …  
    50925030
    50935031                        if(ToSwap){
    5094                          if (dets2 < 0) {// haut
    5095                                  dets1 = (ToSwap ? dets1 : detsa) ;
    5096                                  detsa = dets2;
    5097                                  tt1 =  Previous(tt2) ;}
    5098                          else if(dets2 > 0){// bas
    5099                                  dets1 = (ToSwap ? dets1 : detsb) ;
    5100                                  detsb =  dets2;
    5101                                  if(!ToSwap) tt1 =  Next(tt2);
    5102                          }
    5103                          else {// on a fin ???
    5104                                  tt1 = Next(tt2);
    5105                                  ret =0;}
     5032                                if (dets2 < 0) {// haut
     5033                                        dets1 = (ToSwap ? dets1 : detsa) ;
     5034                                        detsa = dets2;
     5035                                        tt1 =  Previous(tt2) ;}
     5036                                else if(dets2 > 0){// bas
     5037                                        dets1 = (ToSwap ? dets1 : detsb) ;
     5038                                        detsb =  dets2;
     5039                                        if(!ToSwap) tt1 =  Next(tt2);
     5040                                }
     5041                                else {// on a fin ???
     5042                                        tt1 = Next(tt2);
     5043                                        ret =0;}
    51065044                        }
    51075045
    … …  
    51105048        }
    51115049        /*}}}*/
    5112 
    51135050}

  • issm/trunk-jpl/src/c/bamg/Metric.cpp

    r15104 r18064  
    1313
    1414        /*Constructor/Destructor*/
    15         /*FUNCTION Metric::Metric(double a){{{*/
    16         Metric::Metric(double a): a11(1/(a*a)),a21(0),a22(1/(a*a)){
     15        Metric::Metric(double a): a11(1/(a*a)),a21(0),a22(1/(a*a)){/*{{{*/
    1716
    1817        }/*}}}*/
    19         /*FUNCTION Metric::Metric(double a,double b,double c){{{*/
    20         Metric::Metric(double a,double b,double c) :a11(a),a21(b),a22(c){
     18        Metric::Metric(double a,double b,double c) :a11(a),a21(b),a22(c){/*{{{*/
    2119
    2220        }/*}}}*/
    23         /*FUNCTION Metric::Metric(const double  a[3],const  Metric& m0, const  Metric& m1,const  Metric&  m2 ){{{*/
    24         Metric::Metric(const double  a[3],const  Metric& m0, const  Metric& m1,const  Metric& m2 ){
     21        Metric::Metric(const double  a[3],const  Metric& m0, const  Metric& m1,const  Metric& m2 ){/*{{{*/
    2522                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/Metric)*/
    2623
    … …  
    4239        }
    4340        /*}}}*/
    44         /*FUNCTION Metric::Metric(double  a,const  Metric& ma, double  b,const  Metric& mb){{{*/
    45         Metric::Metric(double  a,const  Metric& ma, double  b,const  Metric& mb) {
     41        Metric::Metric(double  a,const  Metric& ma, double  b,const  Metric& mb) { /*{{{*/
    4642                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/EigenMetric)*/
    4743
    … …  
    6460
    6561        /*Methods*/
    66         /*FUNCTION Metric::det{{{*/
    67         double Metric::det() const {
     62        double Metric::det() const {/*{{{*/
    6863                return a11*a22-a21*a21;
    6964        }  /*}}}*/
    70         /*FUNCTION Metric::Echo {{{*/
    71         void Metric::Echo(void){
     65        void Metric::Echo(void){/*{{{*/
    7266
    7367                _printf_("Metric:\n");
    … …  
    7771        }
    7872        /*}}}*/
    79         /*FUNCTION Metric::IntersectWith{{{*/
    80         int Metric::IntersectWith(const Metric& M2) {
     73        int Metric::IntersectWith(const Metric& M2) {/*{{{*/
    8174                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/IntersectWith)*/
    8275
    … …  
    130123        }
    131124        /*}}}*/
    132         /*FUNCTION Metric::mul{{{*/
    133         R2     Metric::mul(const R2 x)const {
     125        R2     Metric::mul(const R2 x)const {/*{{{*/
    134126                return R2(a11*x.x+a21*x.y,a21*x.x+a22*x.y);
    135127        }/*}}}*/
    136128
    137129        /*Intermediary*/
    138         /*FUNCTION LengthInterpole{{{*/
    139         double LengthInterpole(const Metric& Ma,const  Metric& Mb, R2 AB) {
     130        double LengthInterpole(const Metric& Ma,const  Metric& Mb, R2 AB) {/*{{{*/
    140131                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/LengthInterpole)*/
    141132
    … …  
    204195        }
    205196        /*}}}*/
    206         /*FUNCTION SimultaneousMatrixReduction{{{*/
    207         void SimultaneousMatrixReduction( Metric M1,  Metric M2, D2xD2 &V) {
     197        void SimultaneousMatrixReduction( Metric M1,  Metric M2, D2xD2 &V) {/*{{{*/
    208198                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/ReductionSimultanee)*/
    209199
    … …  
    307297        }
    308298        /*}}}*/
    309         /*FUNCTION abscisseInterpole{{{*/
    310         double abscisseInterpole(const Metric& Ma,const  Metric& Mb, R2 AB,double s,int optim) {
     299        double abscisseInterpole(const Metric& Ma,const  Metric& Mb, R2 AB,double s,int optim) { /*{{{*/
    311300                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Metric.cpp/abscisseInterpole)*/
    312301

  • issm/trunk-jpl/src/c/bamg/SetOfE4.cpp

    r16228 r18064  
    55
    66        /*Constructor*/
    7         /*FUNCTION  SetOfEdges4::SetOfEdges4(long mmx,long nnx){{{*/
    8         SetOfEdges4::SetOfEdges4(long mmx,long nnx){
     7        SetOfEdges4::SetOfEdges4(long mmx,long nnx){/*{{{*/
    98                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, SetOfEdges4.cpp/SetOfEdges4)*/
    109
    … …  
    2625
    2726        /*Methods*/
    28         /*FUNCTION  SetOfEdges4::add{{{*/
    29         long SetOfEdges4::add(long ii,long jj) {
     27        long SetOfEdges4::add(long ii,long jj) {/*{{{*/
    3028                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, SetOfEdges4.cpp/add)*/
    3129
    … …  
    6159        }
    6260        /*}}}*/
    63         /*FUNCTION  SetOfEdges4::find {{{*/
    64         long SetOfEdges4::find(long ii,long jj) {
     61        long SetOfEdges4::find(long ii,long jj) { /*{{{*/
    6562                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, SetOfEdges4.cpp/find)*/
    6663
    … …  
    8885        }
    8986        /*}}}*/
    90         /*FUNCTION  SetOfEdges4::i{{{*/
    91         long SetOfEdges4::i(long k){
     87        long SetOfEdges4::i(long k){/*{{{*/
    9288                return Edges[k].i;
    9389        }
    9490        /*}}}*/
    95         /*FUNCTION  SetOfEdges4::j{{{*/
    96         long SetOfEdges4::j(long k){
     91        long SetOfEdges4::j(long k){/*{{{*/
    9792                return Edges[k].j;
    9893        }
    9994        /*}}}*/
    100         /*FUNCTION  SetOfEdges4::nb{{{*/
    101         long SetOfEdges4::nb(){
     95        long SetOfEdges4::nb(){/*{{{*/
    10296                return NbOfEdges;
    10397        }
    10498        /*}}}*/
    105         /*FUNCTION  SetOfEdges4::SortAndAdd{{{*/
    106         long SetOfEdges4::SortAndAdd (long ii,long jj) {
     99        long SetOfEdges4::SortAndAdd (long ii,long jj) {/*{{{*/
    107100                return ii <=jj ? add (ii,jj)  : add (jj,ii) ;
    108101        }
    109102        /*}}}*/
    110         /*FUNCTION  SetOfEdges4::SortAndFind{{{*/
    111         long SetOfEdges4::SortAndFind (long ii,long jj) {
     103        long SetOfEdges4::SortAndFind (long ii,long jj) {/*{{{*/
    112104                return ii <=jj ? find (ii,jj)  : find (jj,ii) ;
    113105        }

  • issm/trunk-jpl/src/c/bamg/SubDomain.cpp

    r16546 r18064  
    1212
    1313        /*Methods*/
    14         /*FUNCTION SubDomain::Set {{{*/
    15         void SubDomain::Set(const Mesh & Th ,long i,Mesh & ThNew){
     14        void SubDomain::Set(const Mesh & Th ,long i,Mesh & ThNew){/*{{{*/
    1615                *this = Th.subdomains[i];
    1716                if( head-Th.triangles<0 || head-Th.triangles>=Th.nbt){

  • issm/trunk-jpl/src/c/bamg/Triangle.cpp

    r17507 r18064  
    1111
    1212        /*Constructors/Destructors*/
    13         /*FUNCTION Triangle(){{{*/
    14         Triangle::Triangle(void){
    15 
    16         }
    17         /*}}}*/
    18         /*FUNCTION Triangle(Mesh *Th,long i,long j,long k) {{{*/
    19         Triangle::Triangle(Mesh *Th,long i,long j,long k) {
     13        Triangle::Triangle(void){/*{{{*/
     14
     15        }
     16        /*}}}*/
     17        Triangle::Triangle(Mesh *Th,long i,long j,long k) {/*{{{*/
    2018                BamgVertex *v=Th->vertices;
    2119                long nbv = Th->nbv;
    … …  
    3432        }
    3533        /*}}}*/
    36         /*FUNCTION Triangle(BamgVertex *v0,BamgVertex *v1,BamgVertex *v2) {{{*/
    37         Triangle::Triangle(BamgVertex *v0,BamgVertex *v1,BamgVertex *v2){
     34        Triangle::Triangle(BamgVertex *v0,BamgVertex *v1,BamgVertex *v2){/*{{{*/
    3835                vertices[0]=v0;
    3936                vertices[1]=v1;
    … …  
    4946
    5047        /*Methods*/
    51         /*FUNCTION Triangle::Adj{{{*/
    52         AdjacentTriangle Triangle::Adj(int i)  const {
     48        AdjacentTriangle Triangle::Adj(int i)  const {/*{{{*/
    5349                return AdjacentTriangle(adj[i],AdjEdgeIndex[i]&3);
    5450        };/*}}}*/
    55         /*FUNCTION Triangle::Length{{{*/
    56         double Triangle::Length() const{
     51        double Triangle::Length() const{/*{{{*/
    5752
    5853                double l;
    … …  
    7570                return l;
    7671        };/*}}}*/
    77         /*FUNCTION Triangle::Echo {{{*/
    78         void Triangle::Echo(void){
     72        void Triangle::Echo(void){/*{{{*/
    7973
    8074                int i;
    … …  
    106100        }
    107101        /*}}}*/
    108         /*FUNCTION Triangle::GetAllflag{{{*/
    109         int    Triangle::GetAllflag(int a){
     102        int    Triangle::GetAllflag(int a){/*{{{*/
    110103                return AdjEdgeIndex[a] & 1020;
    111104        }/*}}}*/
    112         /*FUNCTION Triangle::Hidden{{{*/
    113         int    Triangle::Hidden(int a)const {
     105        int    Triangle::Hidden(int a)const {/*{{{*/
    114106                return AdjEdgeIndex[a]&16;
    115107        } /*}}}*/
    116         /*FUNCTION Triangle::Locked{{{*/
    117         int    Triangle::Locked(int a)const {
     108        int    Triangle::Locked(int a)const {/*{{{*/
    118109                return AdjEdgeIndex[a]&4;
    119110        } /*}}}*/
    120         /*FUNCTION Triangle::NuEdgeTriangleAdj{{{*/
    121         short  Triangle::NuEdgeTriangleAdj(int i) const {
     111        short  Triangle::NuEdgeTriangleAdj(int i) const {/*{{{*/
    122112                /*Number of the  adjacent edge in adj tria (make sure it is between 0 and 2*/
    123113                return AdjEdgeIndex[i&3]&3;
    124114        }/*}}}*/
    125         /*FUNCTION Triangle::Optim{{{*/
    126         long  Triangle::Optim(short i,int koption) {
     115        long  Triangle::Optim(short i,int koption) {/*{{{*/
    127116                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Optim)*/
    128117
    … …  
    156145        }
    157146        /*}}}*/
    158         /*FUNCTION Triangle::Quadrangle {{{*/
    159         Triangle* Triangle::Quadrangle(BamgVertex * & v0,BamgVertex * & v1,BamgVertex * & v2,BamgVertex * & v3) const{
     147        Triangle* Triangle::Quadrangle(BamgVertex * & v0,BamgVertex * & v1,BamgVertex * & v2,BamgVertex * & v3) const{/*{{{*/
    160148                // return the other triangle of the quad if a quad or 0 if not a quat
    161149                Triangle * t =0;
    … …  
    177165        }
    178166        /*}}}*/
    179         /*FUNCTION Triangle::QualityQuad {{{*/
    180         double   Triangle::QualityQuad(int a,int option) const{
     167        double   Triangle::QualityQuad(int a,int option) const{/*{{{*/
    181168                double q;
    182169                if (!link || AdjEdgeIndex[a] &4)
    … …  
    200187        }
    201188        /*}}}*/
    202         /*FUNCTION Triangle::Renumbering(Triangle *tb,Triangle *te, long *renu){{{*/
    203         void  Triangle::Renumbering(Triangle *tb,Triangle *te, long *renu){
     189        void  Triangle::Renumbering(Triangle *tb,Triangle *te, long *renu){/*{{{*/
    204190
    205191                if (link  >=tb && link  <te) link  = tb + renu[link -tb];
    … …  
    208194                if (adj[2] >=tb && adj[2] <te) adj[2] = tb + renu[adj[2]-tb];   
    209195        }/*}}}*/
    210         /*FUNCTION Triangle::Renumbering(BamgVertex *vb,BamgVertex *ve, long *renu){{{*/
    211         void Triangle::Renumbering(BamgVertex *vb,BamgVertex *ve, long *renu){
     196        void Triangle::Renumbering(BamgVertex *vb,BamgVertex *ve, long *renu){/*{{{*/
    212197                if (vertices[0] >=vb && vertices[0] <ve) vertices[0] = vb + renu[vertices[0]-vb];
    213198                if (vertices[1] >=vb && vertices[1] <ve) vertices[1] = vb + renu[vertices[1]-vb];
    214199                if (vertices[2] >=vb && vertices[2] <ve) vertices[2] = vb + renu[vertices[2]-vb];   
    215200        }/*}}}*/
    216         /*FUNCTION Triangle::Set {{{*/
    217         void Triangle::Set(const Triangle & rec,const Mesh & Th ,Mesh & ThNew){
     201        void Triangle::Set(const Triangle & rec,const Mesh & Th ,Mesh & ThNew){ /*{{{*/
    218202                *this = rec;
    219203                if ( vertices[0] ) vertices[0] = ThNew.vertices +  Th.GetId(vertices[0]);
    … …  
    227211        }
    228212        /*}}}*/
    229         /*FUNCTION Triangle::SetAdjAdj{{{*/
    230         void Triangle::SetAdjAdj(short a){
     213        void Triangle::SetAdjAdj(short a){/*{{{*/
    231214                // Copy all the mark
    232215                a &= 3;
    … …  
    239222                }
    240223        }/*}}}*/
    241         /*FUNCTION Triangle::SetAdj2{{{*/
    242         void Triangle::SetAdj2(short a,Triangle *t,short aat){
     224        void Triangle::SetAdj2(short a,Triangle *t,short aat){/*{{{*/
    243225                /*For current triangle:
    244226                 * - a is the index of the edge were the adjency is set (in [0 2])
    … …  
    252234                }
    253235        }/*}}}*/
    254         /*FUNCTION Triangle::SetHidden{{{*/
    255         void Triangle::SetHidden(int a){
     236        void Triangle::SetHidden(int a){/*{{{*/
    256237                //Get Adjacent Triangle number a
    257238                Triangle* t = adj[a];
    … …  
    261242                AdjEdgeIndex[a] |= 16;
    262243        }/*}}}*/
    263         /*FUNCTION Triangle::SetLocked{{{*/
    264         void Triangle::SetLocked(int a){
     244        void Triangle::SetLocked(int a){/*{{{*/
    265245                //mark the edge as on Boundary
    266246                Triangle * t = adj[a];
    … …  
    268248                AdjEdgeIndex[a] |= 4;
    269249        }/*}}}*/
    270         /*FUNCTION Triangle::SetMarkUnSwap{{{*/
    271         void Triangle::SetMarkUnSwap(int a){
     250        void Triangle::SetMarkUnSwap(int a){/*{{{*/
    272251                Triangle * t = adj[a];
    273252                t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] |=8;
    274253                AdjEdgeIndex[a] |=8 ;
    275254        }/*}}}*/
    276         /*FUNCTION Triangle::SetSingleVertexToTriangleConnectivity{{{*/
    277         void Triangle::SetSingleVertexToTriangleConnectivity() {
     255        void Triangle::SetSingleVertexToTriangleConnectivity() { /*{{{*/
    278256                if (vertices[0]) (vertices[0]->t=this,vertices[0]->IndexInTriangle=0);
    279257                if (vertices[1]) (vertices[1]->t=this,vertices[1]->IndexInTriangle=1);
    280258                if (vertices[2]) (vertices[2]->t=this,vertices[2]->IndexInTriangle=2);
    281259        }/*}}}*/
    282         /*FUNCTION Triangle::SetUnMarkUnSwap{{{*/
    283         void Triangle::SetUnMarkUnSwap(int a){
     260        void Triangle::SetUnMarkUnSwap(int a){ /*{{{*/
    284261                Triangle * t = adj[a];
    285262                t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] &=55; // 23 + 32
    286263                AdjEdgeIndex[a] &=55 ;
    287264        }/*}}}*/
    288         /*FUNCTION Triangle::swap{{{*/
    289         int Triangle::swap(short a,int koption){
     265        int Triangle::swap(short a,int koption){/*{{{*/
    290266                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/
    291267
    … …  
    400376        }
    401377        /*}}}*/
    402         /*FUNCTION Triangle::TriangleAdj{{{*/
    403         Triangle* Triangle::TriangleAdj(int i) const {
     378        Triangle* Triangle::TriangleAdj(int i) const {/*{{{*/
    404379                return adj[i&3];
    405380        }/*}}}*/

  • issm/trunk-jpl/src/c/bamg/VertexOnEdge.cpp

    r12821 r18064  
    1010
    1111        /*Methods*/
    12         /*FUNCTION VertexOnEdge::Set {{{*/
    13         void VertexOnEdge::Set(const Mesh & Th ,long i,Mesh & ThNew){
     12        void VertexOnEdge::Set(const Mesh & Th ,long i,Mesh & ThNew){/*{{{*/
    1413                *this = Th.VertexOnBThEdge[i]; 
    1514                v = ThNew.vertices + Th.GetId(v);
    1615        }
    1716        /*}}}*/
    18         /*FUNCTION VertexOnEdge::SetOnBTh{{{*/
    19         void VertexOnEdge::SetOnBTh(){
     17        void VertexOnEdge::SetOnBTh(){/*{{{*/
    2018                v->BackgroundEdgeHook=this;
    2119                v->IndexInTriangle=IsVertexOnEdge; 

  • issm/trunk-jpl/src/c/bamg/VertexOnGeom.cpp

    r16546 r18064  
    1111
    1212        /*Constructors/Destructors*/
    13         /*FUNCTION VertexOnGeom::VertexOnGeom(){{{*/
    14         VertexOnGeom::VertexOnGeom(){
     13        VertexOnGeom::VertexOnGeom(){/*{{{*/
    1514                meshvertex=NULL;
    1615                curvilincoord=0;
    … …  
    1817        }
    1918        /*}}}*/
    20         /*FUNCTION VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomVertex &g){{{*/
    21         VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomVertex &g){
     19        VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomVertex &g){/*{{{*/
    2220                meshvertex=&m;
    2321                curvilincoord=-1;
    … …  
    2523        }
    2624        /*}}}*/
    27         /*FUNCTION VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomEdge &g,double s){{{*/
    28         VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomEdge &g,double s){
     25        VertexOnGeom::VertexOnGeom(BamgVertex & m,GeomEdge &g,double s){/*{{{*/
    2926                meshvertex=&m;
    3027                curvilincoord=s;
    … …  
    3431
    3532        /*Methods*/
    36         /*FUNCTION VertexOnGeom::Set {{{*/
    37         void VertexOnGeom::Set(const VertexOnGeom & rec,const Mesh & Th ,Mesh & ThNew){
     33        void VertexOnGeom::Set(const VertexOnGeom & rec,const Mesh & Th ,Mesh & ThNew){/*{{{*/
    3834                *this = rec; 
    3935                meshvertex = ThNew.vertices + Th.GetId(meshvertex);
    … …  
    4743        }
    4844        /*}}}*/
    49         /*FUNCTION VertexOnGeom::OnGeomVertex{{{*/
    50         int VertexOnGeom::OnGeomVertex()const{
     45        int VertexOnGeom::OnGeomVertex()const{/*{{{*/
    5146                return this? curvilincoord <0 :0;
    5247        }
    5348        /*}}}*/
    54         /*FUNCTION VertexOnGeom::OnGeomEdge{{{*/
    55         int VertexOnGeom::OnGeomEdge() const{
     49        int VertexOnGeom::OnGeomEdge() const{/*{{{*/
    5650                return this? curvilincoord >=0 :0;
    5751        }
    5852        /*}}}*/
    59         /*FUNCTION VertexOnGeom::IsRequiredVertex{{{*/
    60         int VertexOnGeom::IsRequiredVertex() {
     53        int VertexOnGeom::IsRequiredVertex() {/*{{{*/
    6154                return this? ((curvilincoord<0 ? (gv?gv->Required():0):0 )) : 0;
    6255        }
    6356        /*}}}*/
    64         /*FUNCTION VertexOnGeom::SetOn{{{*/
    65         void VertexOnGeom::SetOn(){
     57        void VertexOnGeom::SetOn(){/*{{{*/
    6658                meshvertex->GeomEdgeHook=this;
    6759                meshvertex->IndexInTriangle=IsVertexOnGeom;

  • issm/trunk-jpl/src/c/bamg/VertexOnVertex.cpp

    r13622 r18064  
    1010
    1111        /*Constructors/Destructors*/
    12         /*FUNCTION VertexOnVertex::VertexOnVertex(){{{*/
    13         VertexOnVertex::VertexOnVertex() {
     12        VertexOnVertex::VertexOnVertex() {/*{{{*/
    1413                v=NULL;
    1514                bv=NULL;
    1615        };/*}}}*/
    17         /*FUNCTION VertexOnVertex::VertexOnVertex(BamgVertex * w,BamgVertex *bw){{{*/
    18         VertexOnVertex::VertexOnVertex(BamgVertex * w,BamgVertex *bw) :v(w),bv(bw){
     16        VertexOnVertex::VertexOnVertex(BamgVertex * w,BamgVertex *bw) :v(w),bv(bw){/*{{{*/
    1917
    2018        }/*}}}*/
    2119
    2220        /*Methods*/
    23         /*FUNCTION VertexOnVertex::Set{{{*/
    24         void VertexOnVertex::Set(const Mesh &Th ,long i,Mesh &ThNew) {
     21        void VertexOnVertex::Set(const Mesh &Th ,long i,Mesh &ThNew) { /*{{{*/
    2522                *this = Th.VertexOnBThVertex[i]; 
    2623                v     = ThNew.vertices + Th.GetId(v);
    2724        }
    2825        /*}}}*/
    29         /*FUNCTION VertexOnVertex::SetOnBTh{{{*/
    30         void VertexOnVertex::SetOnBTh(){
     26        void VertexOnVertex::SetOnBTh(){/*{{{*/
    3127                v->BackgroundVertexHook=bv;v->IndexInTriangle=IsVertexOnVertex;
    3228        }/*}}}*/

  • issm/trunk-jpl/src/c/classes/Constraints/Constraints.cpp

    r15838 r18064  
    1919
    2020/*Numerics: */
    21 /*FUNCTION Constraints::NumberOfConstraints{{{*/
    22 int Constraints::NumberOfConstraints(void){
     21int Constraints::NumberOfConstraints(void){/*{{{*/
    2322
    2423        int localconstraints;

  • issm/trunk-jpl/src/c/classes/Constraints/Constraints.h

    r15067 r18064  
    1616
    1717                /*Object constructors and destructor*/
    18                 /*FUNCTION Constraints::Constraints(){{{*/
    19                 Constraints(){
     18                Constraints(){/*{{{*/
    2019                        enum_type=ConstraintsEnum;
    2120                        return;
    2221                }
    2322                /*}}}*/
    24                 /*FUNCTION Constraints::~Constraints(){{{*/
    25                 ~Constraints(){
     23                ~Constraints(){/*{{{*/
    2624                        return;
    2725                }

  • issm/trunk-jpl/src/c/classes/Constraints/SpcDynamic.cpp

    r17600 r18064  
    1414
    1515/*SpcDynamic constructors and destructor*/
    16 /*FUNCTION SpcDynamic::SpcDynamic(){{{*/
    17 SpcDynamic::SpcDynamic(){
     16SpcDynamic::SpcDynamic(){/*{{{*/
    1817        return;
    1918}
    2019/*}}}*/
    21 /*FUNCTION SpcDynamic::SpcDynamic(int spc_sid,int spc_nodeid,...){{{*/
    22 SpcDynamic::SpcDynamic(int spc_sid,int spc_nodeid, int spc_dof,int spc_analysis_type){
     20SpcDynamic::SpcDynamic(int spc_sid,int spc_nodeid, int spc_dof,int spc_analysis_type){/*{{{*/
    2321
    2422        sid=spc_sid;
    … …  
    3230}
    3331/*}}}*/
    34 /*FUNCTION SpcDynamic::~SpcDynamic{{{*/
    35 SpcDynamic::~SpcDynamic(){
     32SpcDynamic::~SpcDynamic(){/*{{{*/
    3633        return;
    3734}
    … …  
    3936
    4037/*Object virtual functions definitions:*/
    41 /*FUNCTION SpcDynamic::Echo {{{*/
    42 void SpcDynamic::Echo(void){
     38void SpcDynamic::Echo(void){/*{{{*/
    4339
    4440        _printf_("SpcDynamic:\n");
    … …  
    5248}
    5349/*}}}*/
    54 /*FUNCTION SpcDynamic::DeepEcho {{{*/
    55 void SpcDynamic::DeepEcho(void){
     50void SpcDynamic::DeepEcho(void){/*{{{*/
    5651
    5752        this->Echo();
    … …  
    5954}               
    6055/*}}}*/
    61 /*FUNCTION SpcDynamic::Id {{{*/
    62 int    SpcDynamic::Id(void){ return sid; }
     56int    SpcDynamic::Id(void){ return sid; }/*{{{*/
    6357/*}}}*/
    64 /*FUNCTION SpcDynamic::ObjectEnum{{{*/
    65 int SpcDynamic::ObjectEnum(void){
     58int SpcDynamic::ObjectEnum(void){/*{{{*/
    6659
    6760        return SpcDynamicEnum;
    … …  
    6962}
    7063/*}}}*/
    71 /*FUNCTION SpcDynamic::copy {{{*/
    72 Object* SpcDynamic::copy() {
     64Object* SpcDynamic::copy() {/*{{{*/
    7365        return new SpcDynamic(*this);
    7466}
    … …  
    7668
    7769/*Constraint virtual functions definitions: */
    78 /*FUNCTION SpcDynamic::InAnalysis{{{*/
    79 bool SpcDynamic::InAnalysis(int in_analysis_type){
     70bool SpcDynamic::InAnalysis(int in_analysis_type){/*{{{*/
    8071        if (in_analysis_type==this->analysis_type) return true;
    8172        else return false;
    8273}
    8374/*}}}*/
    84 /*FUNCTION SpcDynamic::ConstrainNode{{{*/
    85 void SpcDynamic::ConstrainNode(Nodes* nodes,Parameters* parameters){
     75void SpcDynamic::ConstrainNode(Nodes* nodes,Parameters* parameters){/*{{{*/
    8676
    8777        Node* node=NULL;
    … …  
    10090
    10191/*SpcDynamic functions*/
    102 /*FUNCTION SpcDynamic::GetDof {{{*/
    103 int SpcDynamic::GetDof(){
     92int SpcDynamic::GetDof(){/*{{{*/
    10493        return dof;
    10594}
    10695/*}}}*/
    107 /*FUNCTION SpcDynamic::GetNodeId {{{*/
    108 int   SpcDynamic::GetNodeId(){
     96int   SpcDynamic::GetNodeId(){/*{{{*/
    10997
    11098        return nodeid;
    11199}
    112100/*}}}*/
    113 /*FUNCTION SpcDynamic::GetValue {{{*/
    114 IssmDouble SpcDynamic::GetValue(){
     101IssmDouble SpcDynamic::GetValue(){/*{{{*/
    115102        _assert_(this->isset);
    116103        _assert_(!xIsNan<IssmDouble>(value));
    … …  
    118105}
    119106/*}}}*/
    120 /*FUNCTION SpcDynamic::SetDynamicConstraint {{{*/
    121 void SpcDynamic::SetDynamicConstraint(Nodes* nodes,IssmDouble* yg_serial){
     107void SpcDynamic::SetDynamicConstraint(Nodes* nodes,IssmDouble* yg_serial){/*{{{*/
    122108
    123109        int pos;

  • issm/trunk-jpl/src/c/classes/Constraints/SpcStatic.cpp

    r15448 r18064  
    1414
    1515/*SpcStatic constructors and destructor*/
    16 /*FUNCTION SpcStatic::SpcStatic(){{{*/
    17 SpcStatic::SpcStatic(){
     16SpcStatic::SpcStatic(){/*{{{*/
    1817        return;
    1918}
    2019/*}}}*/
    21 /*FUNCTION SpcStatic::SpcStatic(int spc_sid,int spc_nodeid,...){{{*/
    22 SpcStatic::SpcStatic(int spc_sid,int spc_nodeid, int spc_dof,IssmDouble spc_value,int spc_analysis_type){
     20SpcStatic::SpcStatic(int spc_sid,int spc_nodeid, int spc_dof,IssmDouble spc_value,int spc_analysis_type){/*{{{*/
    2321
    2422        sid           = spc_sid;
    … …  
    3129}
    3230/*}}}*/
    33 /*FUNCTION SpcStatic::~SpcStatic{{{*/
    34 SpcStatic::~SpcStatic(){
     31SpcStatic::~SpcStatic(){/*{{{*/
    3532        return;
    3633}
    … …  
    3835
    3936/*Object virtual functions definitions:*/
    40 /*FUNCTION SpcStatic::Echo {{{*/
    41 void SpcStatic::Echo(void){
     37void SpcStatic::Echo(void){/*{{{*/
    4238
    4339        _printf_("SpcStatic:\n");
    … …  
    5046}
    5147/*}}}*/
    52 /*FUNCTION SpcStatic::DeepEcho {{{*/
    53 void SpcStatic::DeepEcho(void){
     48void SpcStatic::DeepEcho(void){/*{{{*/
    5449
    5550        _printf_("SpcStatic:\n");
    … …  
    6257}               
    6358/*}}}*/
    64 /*FUNCTION SpcStatic::Id {{{*/
    65 int    SpcStatic::Id(void){ return sid; }
     59int    SpcStatic::Id(void){ return sid; }/*{{{*/
    6660/*}}}*/
    67 /*FUNCTION SpcStatic::ObjectEnum{{{*/
    68 int SpcStatic::ObjectEnum(void){
     61int SpcStatic::ObjectEnum(void){/*{{{*/
    6962
    7063        return SpcStaticEnum;
    … …  
    7265}
    7366/*}}}*/
    74 /*FUNCTION SpcStatic::copy {{{*/
    75 Object* SpcStatic::copy() {
     67Object* SpcStatic::copy() {/*{{{*/
    7668        return new SpcStatic(*this);
    7769}
    … …  
    7971
    8072/*Constraint virtual functions definitions: */
    81 /*FUNCTION SpcStatic::InAnalysis{{{*/
    82 bool SpcStatic::InAnalysis(int in_analysis_type){
     73bool SpcStatic::InAnalysis(int in_analysis_type){/*{{{*/
    8374        if (in_analysis_type==this->analysis_type) return true;
    8475        else return false;
    8576}
    8677/*}}}*/
    87 /*FUNCTION SpcStatic::ConstrainNode{{{*/
    88 void SpcStatic::ConstrainNode(Nodes* nodes,Parameters* parameters){
     78void SpcStatic::ConstrainNode(Nodes* nodes,Parameters* parameters){/*{{{*/
    8979
    9080        Node* node=NULL;
    … …  
    10191
    10292/*SpcStatic functions*/
    103 /*FUNCTION SpcStatic::GetDof {{{*/
    104 int SpcStatic::GetDof(){
     93int SpcStatic::GetDof(){/*{{{*/
    10594        return dof;
    10695}
    10796/*}}}*/
    108 /*FUNCTION SpcStatic::GetNodeId {{{*/
    109 int   SpcStatic::GetNodeId(){
     97int   SpcStatic::GetNodeId(){/*{{{*/
    11098
    11199        return nodeid;
    112100}
    113101/*}}}*/
    114 /*FUNCTION SpcStatic::GetValue {{{*/
    115 IssmDouble SpcStatic::GetValue(){
     102IssmDouble SpcStatic::GetValue(){/*{{{*/
    116103        _assert_(!xIsNan<IssmDouble>(value));
    117104        return value;

  • issm/trunk-jpl/src/c/classes/Constraints/SpcTransient.cpp

    r15862 r18064  
    1414
    1515/*SpcTransient constructors and destructor*/
    16 /*FUNCTION SpcTransient::SpcTransient(){{{*/
    17 SpcTransient::SpcTransient(){
     16SpcTransient::SpcTransient(){/*{{{*/
    1817        sid=-1;
    1918        nodeid=-1;
    … …  
    2625}
    2726/*}}}*/
    28 /*FUNCTION SpcTransient::SpcTransient(int spc_sid,int spc_nodeid,...){{{*/
    29 SpcTransient::SpcTransient(int spc_sid,int spc_nodeid, int spc_dof,int spc_nsteps, IssmDouble* spc_times, IssmDouble* spc_values,int spc_analysis_type){
     27SpcTransient::SpcTransient(int spc_sid,int spc_nodeid, int spc_dof,int spc_nsteps, IssmDouble* spc_times, IssmDouble* spc_values,int spc_analysis_type){/*{{{*/
    3028
    3129        sid=spc_sid;
    … …  
    4341}
    4442/*}}}*/
    45 /*FUNCTION SpcTransient::~SpcTransient{{{*/
    46 SpcTransient::~SpcTransient(){
     43SpcTransient::~SpcTransient(){/*{{{*/
    4744        xDelete<IssmDouble>(times);
    4845        xDelete<IssmDouble>(values);
    … …  
    5249
    5350/*Object virtual functions definitions:*/
    54 /*FUNCTION SpcTransient::Echo {{{*/
    55 void SpcTransient::Echo(void){
     51void SpcTransient::Echo(void){/*{{{*/
    5652
    5753        int i;
    … …  
    6965}
    7066/*}}}*/
    71 /*FUNCTION SpcTransient::DeepEcho {{{*/
    72 void SpcTransient::DeepEcho(void){
     67void SpcTransient::DeepEcho(void){/*{{{*/
    7368        this->Echo();
    7469}               
    7570/*}}}*/
    76 /*FUNCTION SpcTransient::Id {{{*/
    77 int    SpcTransient::Id(void){ return sid; }
     71int    SpcTransient::Id(void){ return sid; }/*{{{*/
    7872/*}}}*/
    79 /*FUNCTION SpcTransient::ObjectEnum{{{*/
    80 int SpcTransient::ObjectEnum(void){
     73int SpcTransient::ObjectEnum(void){/*{{{*/
    8174
    8275        return SpcTransientEnum;
    … …  
    8477}
    8578/*}}}*/
    86 /*FUNCTION SpcTransient::copy {{{*/
    87 Object* SpcTransient::copy() {
     79Object* SpcTransient::copy() {/*{{{*/
    8880        return new SpcTransient(sid,nodeid,dof,nsteps,times,values,analysis_type);
    8981}
    … …  
    9183
    9284/*Constraint virtual functions definitions:*/
    93 /*FUNCTION SpcTransient::InAnalysis{{{*/
    94 bool SpcTransient::InAnalysis(int in_analysis_type){
     85bool SpcTransient::InAnalysis(int in_analysis_type){/*{{{*/
    9586
    9687        if (in_analysis_type==this->analysis_type) return true;
    … …  
    9889}
    9990/*}}}*/
    100 /*FUNCTION SpcTransient::ConstrainNode{{{*/
    101 void SpcTransient::ConstrainNode(Nodes* nodes,Parameters* parameters){
     91void SpcTransient::ConstrainNode(Nodes* nodes,Parameters* parameters){/*{{{*/
    10292
    10393        Node       *node  = NULL;
    … …  
    149139
    150140/*SpcTransient functions*/
    151 /*FUNCTION SpcTransient::GetDof {{{*/
    152 int SpcTransient::GetDof(){
     141int SpcTransient::GetDof(){/*{{{*/
    153142        return dof;
    154143}
    155144/*}}}*/
    156 /*FUNCTION SpcTransient::GetNodeId {{{*/
    157 int   SpcTransient::GetNodeId(){
     145int   SpcTransient::GetNodeId(){/*{{{*/
    158146
    159147        return nodeid;
    160148}
    161149/*}}}*/
    162 /*FUNCTION SpcTransient::GetValue {{{*/
    163 IssmDouble SpcTransient::GetValue(){
     150IssmDouble SpcTransient::GetValue(){/*{{{*/
    164151        return values[0];
    165152}

  • issm/trunk-jpl/src/c/classes/Contour.h

    r15104 r18064  
    2424
    2525                /*Contour constructors, destructors :*/
    26                 /*FUNCTION Contour() {{{*/
    27                 Contour(){
     26                Contour(){/*{{{*/
    2827                        this->id     = 0;
    2928                        this->nods   = 0;
    … …  
    3332                }
    3433                /*}}}*/
    35                 /*FUNCTION Contour(int pid, int nods, doubletype* x, doubletype* y,bool closed) {{{*/
    36                 Contour(int pid,int pnods, doubletype* px, doubletype* py,bool pclosed){
     34                Contour(int pid,int pnods, doubletype* px, doubletype* py,bool pclosed){/*{{{*/
    3735
    3836                        this->id     = pid;
    … …  
    4745                }
    4846                /*}}}*/
    49                 /*FUNCTION ~Contour() {{{*/
    50                 ~Contour(){
     47                ~Contour(){/*{{{*/
    5148                        xDelete<doubletype>(this->x);
    5249                        xDelete<doubletype>(this->y);
    … …  
    5552
    5653                /*Object virtual function resolutoin: */
    57                 /*FUNCTION Echo(){{{*/
    58                 void Echo(void){
     54                void Echo(void){/*{{{*/
    5955                        _printf_(" Contour: " << id << "\n");
    6056                        _printf_("    nods: " << nods << "\n");
    … …  
    6864                }
    6965                /*}}}*/
    70                 /*FUNCTION DeepEcho(){{{*/
    71                 void DeepEcho(void){
     66                void DeepEcho(void){/*{{{*/
    7267                        this->Echo();
    7368                }
    7469                /*}}}*/
    75                 /*FUNCTION Id(){{{*/
    76                 int Id(void){
     70                int Id(void){/*{{{*/
    7771                        return id;
    7872                }
    7973                /*}}}*/
    80                 /*FUNCTION ObjectEnum{{{*/
    81                 int ObjectEnum(void){
     74                int ObjectEnum(void){/*{{{*/
    8275                        return ContourEnum;
    8376                }
    8477                /*}}}*/
    85                 /*FUNCTION copy {{{*/
    86                 Object* copy() {
     78                Object* copy() {/*{{{*/
    8779                        return new Contour(*this);
    8880                }

  • issm/trunk-jpl/src/c/classes/Contours.cpp

    r15049 r18064  
    1919
    2020/*Object constructors and destructor*/
    21 /*FUNCTION Contours::Contours(){{{*/
    22 Contours::Contours(){
     21Contours::Contours(){/*{{{*/
    2322        enum_type=ContoursEnum;
    2423        return;
    2524}
    2625/*}}}*/
    27 /*FUNCTION Contours::~Contours(){{{*/
    28 Contours::~Contours(){
     26Contours::~Contours(){/*{{{*/
    2927        return;
    3028}

  • issm/trunk-jpl/src/c/classes/DependentObject.cpp

    r16402 r18064  
    1414
    1515/*DependentObject constructors and destructor*/
    16 /*FUNCTION DependentObject::DependentObject(){{{*/
    17 DependentObject::DependentObject(){
     16DependentObject::DependentObject(){/*{{{*/
    1817        this->name=NULL;
    1918        this->type=0;
    … …  
    2120}
    2221/*}}}*/
    23 /*FUNCTION DependentObject::DependentObject(int in_name, int in_type, int in_index){{{*/
    24 DependentObject::DependentObject(char* in_name, int in_type,int in_index){
     22DependentObject::DependentObject(char* in_name, int in_type,int in_index){/*{{{*/
    2523
    2624        this->name=xNew<char>(strlen(in_name)+1); xMemCpy<char>(this->name,in_name,strlen(in_name)+1);
    … …  
    3230}
    3331/*}}}*/
    34 /*FUNCTION DependentObject::~DependentObject() {{{*/
    35 DependentObject::~DependentObject(){ //destructor
     32DependentObject::~DependentObject(){ //destructor/*{{{*/
    3633        xDelete<char>(this->name);
    3734}
    … …  
    3936
    4037/*Object virtual functions definitions:*/
    41 /*FUNCTION DependentObject::Echo{{{*/
    42 void DependentObject::Echo(void){
     38void DependentObject::Echo(void){/*{{{*/
    4339
    4440        _printf_("DependentObject:\n");
    … …  
    5349}
    5450/*}}}*/
    55 /*FUNCTION DependentObject::DeepEcho{{{*/
    56 void DependentObject::DeepEcho(void){
     51void DependentObject::DeepEcho(void){/*{{{*/
    5752        this->Echo();
    5853}
    5954/*}}}*/
    60 /*FUNCTION DependentObject::Id{{{*/
    61 int    DependentObject::Id(void){ return -1; }
     55int    DependentObject::Id(void){ return -1; }/*{{{*/
    6256/*}}}*/
    63 /*FUNCTION DependentObject::ObjectEnum{{{*/
    64 int DependentObject::ObjectEnum(void){
     57int DependentObject::ObjectEnum(void){/*{{{*/
    6558
    6659        return DependentObjectEnum;
    … …  
    6861}
    6962/*}}}*/
    70 /*FUNCTION DependentObject::copy{{{*/
    71 Object* DependentObject::copy(void) {
     63Object* DependentObject::copy(void) { /*{{{*/
    7264        return new DependentObject(name,type,index);
    7365} /*}}}*/
    7466
    7567/*DependentObject methods: */
    76 /*FUNCTION DependentObject::NumDependents{{{*/
    77 int  DependentObject::NumDependents(void){
     68int  DependentObject::NumDependents(void){/*{{{*/
    7869
    7970        /*Branch according to the type of variable: */
    … …  
    8778}
    8879/*}}}*/
    89 /*FUNCTION DependentObject::Responsex{{{*/
    90 void  DependentObject::Responsex(IssmDouble* poutput_value,FemModel* femmodel){
     80void  DependentObject::Responsex(IssmDouble* poutput_value,FemModel* femmodel){/*{{{*/
    9181
    9282        /*Is this some special type of response for which we need to go in the output definitions? :*/

  • issm/trunk-jpl/src/c/classes/DofIndexing.cpp

    r15645 r18064  
    2020
    2121/*DofIndexing constructors and destructor*/
    22 /*FUNCTION DofIndexing::DofIndexing(){{{*/
    23 DofIndexing::DofIndexing(){
     22DofIndexing::DofIndexing(){/*{{{*/
    2423
    2524        this->gsize    = UNDEF;
    … …  
    3837}
    3938/*}}}*/
    40 /*FUNCTION DofIndexing::DofIndexing(int gsize){{{*/
    41 DofIndexing::DofIndexing(int in_gsize){
     39DofIndexing::DofIndexing(int in_gsize){/*{{{*/
    4240
    4341        this->Init(in_gsize,NULL);
    … …  
    4543}
    4644/*}}}*/
    47 /*FUNCTION DofIndexing::DofIndexing(DofIndexing* in)  -> copy{{{*/
    48 DofIndexing::DofIndexing(DofIndexing* in){ //copy constructor
     45DofIndexing::DofIndexing(DofIndexing* in){ //copy constructor/*{{{*/
    4946
    5047        this->gsize  = in->gsize;
    … …  
    8380}
    8481/*}}}*/
    85 /*FUNCTION DofIndexing::~DofIndexing() {{{*/
    86 DofIndexing::~DofIndexing(){ //destructor
     82DofIndexing::~DofIndexing(){ //destructor/*{{{*/
    8783
    8884        xDelete<bool>(f_set);
    … …  
    9692}
    9793/*}}}*/
    98 /*FUNCTION DofIndexing::Init{{{*/
    99 void DofIndexing::Init(int in_gsize,int* in_doftype){
     94void DofIndexing::Init(int in_gsize,int* in_doftype){/*{{{*/
    10095
    10196        this->gsize = in_gsize;
    … …  
    127122}
    128123/*}}}*/
    129 /*FUNCTION DofIndexing::InitSet{{{*/
    130 void DofIndexing::InitSet(int setenum){
     124void DofIndexing::InitSet(int setenum){/*{{{*/
    131125
    132126        int i;
    … …  
    162156
    163157/*Some of the Object functionality: */
    164 /*FUNCTION DofIndexing::Echo{{{*/
    165 void DofIndexing::Echo(void){
     158void DofIndexing::Echo(void){/*{{{*/
    166159
    167160        _printf_("DofIndexing:\n");
    … …  
    173166}
    174167/*}}}*/
    175 /*FUNCTION DofIndexing::DeepEcho{{{*/
    176 void DofIndexing::DeepEcho(void){
     168void DofIndexing::DeepEcho(void){/*{{{*/
    177169
    178170        int i;
    … …  
    224216}               
    225217/*}}}*/
    226 /*FUNCTION DofIndexing::Deactivate{{{*/
    227 void DofIndexing::Deactivate(void){
     218void DofIndexing::Deactivate(void){/*{{{*/
    228219        this->active = false;
    229220
    … …  
    237228}
    238229/*}}}*/
    239 /*FUNCTION DofIndexing::Activate{{{*/
    240 void DofIndexing::Activate(void){
     230void DofIndexing::Activate(void){/*{{{*/
    241231        this->active = true;
    242232

  • issm/trunk-jpl/src/c/classes/ExternalResults/Results.cpp

    r16498 r18064  
    2020
    2121/*Object constructors and destructor*/
    22 /*FUNCTION Results::Results(){{{*/
    23 Results::Results(){
     22Results::Results(){/*{{{*/
    2423        enum_type=ResultsEnum;
    2524        return;
    2625}
    2726/*}}}*/
    28 /*FUNCTION Results::~Results(){{{*/
    29 Results::~Results(){
     27Results::~Results(){/*{{{*/
    3028        return;
    3129}
    … …  
    3331
    3432/*Object management*/
    35 /*FUNCTION Results::Write{{{*/
    36 void Results::Write(Parameters* parameters){
     33void Results::Write(Parameters* parameters){/*{{{*/
    3734
    3835        FILE       *fid  = NULL;
    … …  
    5047}
    5148/*}}}*/
    52 /*FUNCTION Results::AddResult(ExternalResult* in_result){{{*/
    53 int Results::AddResult(ExternalResult* in_result){
     49int Results::AddResult(ExternalResult* in_result){/*{{{*/
    5450
    5551        /*First, go through dataset of inputs and check whether any input
    … …  
    8278}
    8379/*}}}*/
    84 /*FUNCTION Results::DeleteResult(ExternalResult* in_result){{{*/
    85 int Results::DeleteResult(int result_enum,int result_step){
     80int Results::DeleteResult(int result_enum,int result_step){/*{{{*/
    8681
    8782        for(int i=0;i<this->Size();i++){

  • issm/trunk-jpl/src/c/classes/FemModel.cpp

    r18056 r18064  
    4343
    4444/*Object constructors and destructor*/
    45 /*FUNCTION FemModel::FemModel(int argc,char** argv,ISSM_MPI_Comm incomm){{{*/
    46 FemModel::FemModel(int argc,char** argv,ISSM_MPI_Comm incomm){
     45FemModel::FemModel(int argc,char** argv,ISSM_MPI_Comm incomm){/*{{{*/
    4746
    4847        /*configuration: */
    … …  
    9493}
    9594/*}}}*/
    96 /*FUNCTION FemModel::FemModel(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, const int in_solution_type,const int* analyses,const int nummodels){{{*/
    97 FemModel::FemModel(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, const int in_solution_type,const int* analyses,const int nummodels){
     95FemModel::FemModel(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, const int in_solution_type,const int* analyses,const int nummodels){/*{{{*/
    9896
    9997        /*Call InitFromFiles. This constructor is just a wrapper: */
    … …  
    102100}
    103101/*}}}*/
    104 /*FUNCTION FemModel::~FemModel{{{*/
    105 FemModel::~FemModel(){
     102FemModel::~FemModel(){/*{{{*/
    106103
    107104        /*Intermediary*/
    … …  
    163160
    164161/*Object management*/
    165 /*FUNCTION FemModel::Echo {{{*/
    166 void FemModel::Echo(void){
     162void FemModel::Echo(void){/*{{{*/
    167163
    168164        _printf_("FemModel echo: \n");
    … …  
    175171}
    176172/*}}}*/
    177 /*FUNCTION FemModel::InitFromFiles(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, const int in_solution_type,const int* analyses,const int nummodels){{{*/
    178 void FemModel::InitFromFiles(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, const int in_solution_type,const int* analyses,const int nummodels){
     173void FemModel::InitFromFiles(char* rootpath, char* inputfilename, char* outputfilename, char* toolkitsfilename, char* lockfilename, const int in_solution_type,const int* analyses,const int nummodels){/*{{{*/
    179174
    180175        /*intermediary*/
    … …  
    246241        }
    247242/*}}}*/
    248 /*FUNCTION FemModel::SetStaticComm {{{*/
    249 void FemModel::SetStaticComm(void){
     243void FemModel::SetStaticComm(void){/*{{{*/
    250244
    251245        /*This routine sets the global communicator variable hidden inside the IssmComm
    … …  
    255249}
    256250/*}}}*/
    257 /*FUNCTION FemModel::SetCurrentConfiguration(int configuration_type,int analysis_type){{{*/
    258 void FemModel::SetCurrentConfiguration(int configuration_type,int analysis_type){
     251void FemModel::SetCurrentConfiguration(int configuration_type,int analysis_type){/*{{{*/
    259252
    260253        /*Use configuration_type to setup the analysis counter, the configurations of objects etc ... but use
    … …  
    290283}
    291284/*}}}*/
    292 /*FUNCTION FemModel::SetCurrentConfiguration(int configuration_type){{{*/
    293 void FemModel::SetCurrentConfiguration(int configuration_type){
     285void FemModel::SetCurrentConfiguration(int configuration_type){/*{{{*/
    294286        this->SetCurrentConfiguration(configuration_type,configuration_type);
    295287}
    296288/*}}}*/
    297 /*FUNCTION FemModel::Solve {{{*/
    298 void FemModel::Solve(void){
     289void FemModel::Solve(void){/*{{{*/
    299290
    300291        /*profiling: */

  • issm/trunk-jpl/src/c/classes/Hook.cpp

    r16233 r18064  
    1616
    1717/*Constructor/Destructors*/
    18 /*FUNCTION Hook::Hook(){{{*/
    19 Hook::Hook(){
     18Hook::Hook(){/*{{{*/
    2019        this->num     = 0;
    2120        this->objects = NULL;
    … …  
    2423}
    2524/*}}}*/
    26 /*FUNCTION Hook::Hook(int* ids, int num){{{*/
    27 Hook::Hook(int* in_ids, int in_num){
     25Hook::Hook(int* in_ids, int in_num){/*{{{*/
    2826
    2927        /*Get number of objects to hook*/
    … …  
    5250}
    5351/*}}}*/
    54 /*FUNCTION Hook::~Hook(){{{*/
    55 Hook::~Hook(){
     52Hook::~Hook(){/*{{{*/
    5653        xDelete<Object*>(this->objects);
    5754        xDelete<int>(this->ids);
    … …  
    6158
    6259/*Some of the Object functionality: */
    63 /*FUNCTION Hook::Echo{{{*/
    64 void Hook::Echo(void){
     60void Hook::Echo(void){/*{{{*/
    6561        _assert_(this);
    6662        int i;
    … …  
    8076}
    8177/*}}}*/
    82 /*FUNCTION Hook::DeepEcho{{{*/
    83 void Hook::DeepEcho(void){
     78void Hook::DeepEcho(void){/*{{{*/
    8479
    8580        int i;
    … …  
    108103}
    109104/*}}}*/
    110 /*FUNCTION Hook::copy {{{*/
    111 Object* Hook::copy(void){
     105Object* Hook::copy(void){/*{{{*/
    112106
    113107        /*output: */
    … …  
    136130
    137131/*Hook management: */
    138 /*FUNCTION Hook::configure{{{*/
    139 void Hook::configure(DataSet* dataset){
     132void Hook::configure(DataSet* dataset){/*{{{*/
    140133
    141134        /*intermediary: */
    … …  
    178171}
    179172/*}}}*/
    180 /*FUNCTION Hook::delivers{{{*/
    181 Object* Hook::delivers(void){
     173Object* Hook::delivers(void){/*{{{*/
    182174
    183175        /*first, check that we only have one T object in our object list: */
    … …  
    191183
    192184/*}}}*/
    193 /*FUNCTION Hook::deliverp{{{*/
    194 Object** Hook::deliverp(void){
     185Object** Hook::deliverp(void){/*{{{*/
    195186        return objects;
    196187}
    197188/*}}}*/
    198 /*FUNCTION Hook::Ids{{{*/
    199 int* Hook::Ids(void){
     189int* Hook::Ids(void){/*{{{*/
    200190        return this->ids;
    201191}
    202192/*}}}*/
    203 /*FUNCTION Hook::GetNum{{{*/
    204 int Hook::GetNum(void){
     193int Hook::GetNum(void){/*{{{*/
    205194        return this->num;
    206195}
    207196/*}}}*/
    208 /*FUNCTION Hook::Spawn{{{*/
    209 Hook* Hook::Spawn(int* indices, int numindices){
     197Hook* Hook::Spawn(int* indices, int numindices){/*{{{*/
    210198
    211199        /*output: */

  • issm/trunk-jpl/src/c/classes/IndependentObject.cpp

    r16144 r18064  
    1414
    1515/*IndependentObject constructors and destructor*/
    16 /*FUNCTION IndependentObject::IndependentObject(){{{*/
    17 IndependentObject::IndependentObject(){
     16IndependentObject::IndependentObject(){/*{{{*/
    1817        this->name=NoneEnum;
    1918        this->type=0;
    … …  
    2120}
    2221/*}}}*/
    23 /*FUNCTION IndependentObject::IndependentObject(int in_name, int in_type){{{*/
    24 IndependentObject::IndependentObject(int in_name, int in_type){
     22IndependentObject::IndependentObject(int in_name, int in_type){/*{{{*/
    2523
    2624        this->numberofindependents=0;
    … …  
    3129}
    3230/*}}}*/
    33 /*FUNCTION IndependentObject::~IndependentObject() {{{*/
    34 IndependentObject::~IndependentObject(){ //destructor
     31IndependentObject::~IndependentObject(){ //destructor/*{{{*/
    3532}
    3633/*}}}*/
    3734
    3835/*Object virtual functions definitions:*/
    39 /*FUNCTION IndependentObject::Echo{{{*/
    40 void IndependentObject::Echo(void){
     36void IndependentObject::Echo(void){/*{{{*/
    4137
    4238        _printf_("IndependentObject:\n");
    … …  
    5147}
    5248/*}}}*/
    53 /*FUNCTION IndependentObject::DeepEcho{{{*/
    54 void IndependentObject::DeepEcho(void){
     49void IndependentObject::DeepEcho(void){/*{{{*/
    5550        this->Echo();
    5651}
    5752/*}}}*/
    58 /*FUNCTION IndependentObject::Id{{{*/
    59 int    IndependentObject::Id(void){ return -1; }
     53int    IndependentObject::Id(void){ return -1; }/*{{{*/
    6054/*}}}*/
    61 /*FUNCTION IndependentObject::ObjectEnum{{{*/
    62 int IndependentObject::ObjectEnum(void){
     55int IndependentObject::ObjectEnum(void){/*{{{*/
    6356
    6457        return IndependentObjectEnum;
    … …  
    6659}
    6760/*}}}*/
    68 /*FUNCTION IndependentObject::copy{{{*/
    69 Object* IndependentObject::copy(void) {
     61Object* IndependentObject::copy(void) { /*{{{*/
    7062
    7163        IndependentObject* object=new IndependentObject();
    … …  
    7870
    7971/*IndependentObject methods: */
    80 /*FUNCTION IndependentObject::FetchIndependent{{{*/
    81 void IndependentObject::FetchIndependent(IoModel* iomodel){
     72void IndependentObject::FetchIndependent(IoModel* iomodel){/*{{{*/
    8273
    8374        int my_rank;
    … …  
    183174}
    184175/*}}}*/
    185 /*FUNCTION IndependentObject::NumIndependents{{{*/
    186 int  IndependentObject::NumIndependents(void){
     176int  IndependentObject::NumIndependents(void){/*{{{*/
    187177
    188178        return this->numberofindependents;;
    189179}
    190180/*}}}*/
    191 /*FUNCTION IndependentObject::FillIndependents{{{*/
    192 void IndependentObject::FillIndependents(IssmDouble** data, IssmDouble* xp){
     181void IndependentObject::FillIndependents(IssmDouble** data, IssmDouble* xp){/*{{{*/
    193182
    194183        int i;

  • issm/trunk-jpl/src/c/classes/Inputs/BoolInput.cpp

    r17514 r18064  
    1313
    1414/*BoolInput constructors and destructor*/
    15 /*FUNCTION BoolInput::BoolInput(){{{*/
    16 BoolInput::BoolInput(){
     15BoolInput::BoolInput(){/*{{{*/
    1716        return;
    1817}
    1918/*}}}*/
    20 /*FUNCTION BoolInput::BoolInput(int in_enum_type,bool in_value){{{*/
    21 BoolInput::BoolInput(int in_enum_type,bool in_value){
     19BoolInput::BoolInput(int in_enum_type,bool in_value){/*{{{*/
    2220
    2321        enum_type=in_enum_type;
    … …  
    2523}
    2624/*}}}*/
    27 /*FUNCTION BoolInput::~BoolInput(){{{*/
    28 BoolInput::~BoolInput(){
     25BoolInput::~BoolInput(){/*{{{*/
    2926        return;
    3027}
    … …  
    3229
    3330/*Object virtual functions definitions:*/
    34 /*FUNCTION BoolInput::Echo {{{*/
    35 void BoolInput::Echo(void){
     31void BoolInput::Echo(void){/*{{{*/
    3632        this->DeepEcho();
    3733}
    3834/*}}}*/
    39 /*FUNCTION BoolInput::DeepEcho{{{*/
    40 void BoolInput::DeepEcho(void){
     35void BoolInput::DeepEcho(void){/*{{{*/
    4136
    4237        _printf_(setw(15)<<"   BoolInput "<<setw(25)<<left<<EnumToStringx(this->enum_type)<<" "<<(value?"true":"false") << "\n");
    4338}
    4439/*}}}*/
    45 /*FUNCTION BoolInput::Id{{{*/
    46 int    BoolInput::Id(void){ return -1; }
     40int    BoolInput::Id(void){ return -1; }/*{{{*/
    4741/*}}}*/
    48 /*FUNCTION BoolInput::ObjectEnum{{{*/
    49 int BoolInput::ObjectEnum(void){
     42int BoolInput::ObjectEnum(void){/*{{{*/
    5043
    5144        return BoolInputEnum;
    … …  
    5346}
    5447/*}}}*/
    55 /*FUNCTION BoolInput::copy{{{*/
    56 Object* BoolInput::copy() {
     48Object* BoolInput::copy() {/*{{{*/
    5749
    5850        return new BoolInput(this->enum_type,this->value);
    … …  
    6254
    6355/*BoolInput management*/
    64 /*FUNCTION BoolInput::InstanceEnum{{{*/
    65 int BoolInput::InstanceEnum(void){
     56int BoolInput::InstanceEnum(void){/*{{{*/
    6657
    6758        return this->enum_type;
    … …  
    6960}
    7061/*}}}*/
    71 /*FUNCTION BoolInput::SpawnTriaInput{{{*/
    72 Input* BoolInput::SpawnTriaInput(int index1,int index2,int index3){
     62Input* BoolInput::SpawnTriaInput(int index1,int index2,int index3){/*{{{*/
    7363
    7464                /*output*/
    … …  
    8474}
    8575/*}}}*/
    86 /*FUNCTION BoolInput::SpawnSegInput{{{*/
    87 Input* BoolInput::SpawnSegInput(int index1,int index2){
     76Input* BoolInput::SpawnSegInput(int index1,int index2){/*{{{*/
    8877
    8978                /*output*/
    … …  
    10190
    10291/*Object functions*/
    103 /*FUNCTION BoolInput::GetInputValue(bool* pvalue) {{{*/
    104 void BoolInput::GetInputValue(bool* pvalue){
     92void BoolInput::GetInputValue(bool* pvalue){/*{{{*/
    10593        *pvalue=value;
    10694}
    10795/*}}}*/
    108 /*FUNCTION BoolInput::GetInputValue(int* pvalue){{{*/
    109 void BoolInput::GetInputValue(int* pvalue){_error_("not supported yet!");}
     96void BoolInput::GetInputValue(int* pvalue){_error_("not supported yet!");}/*{{{*/
    11097/*}}}*/
    111 /*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue){{{*/
    112 void BoolInput::GetInputValue(IssmDouble* pvalue){_error_("not supported yet!");}
     98void BoolInput::GetInputValue(IssmDouble* pvalue){_error_("not supported yet!");}/*{{{*/
    11399/*}}}*/
    114 /*FUNCTION BoolInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
    115 void BoolInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){_error_("not supported yet!");}
     100void BoolInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){_error_("not supported yet!");}/*{{{*/
    116101/*}}}*/
    117 /*FUNCTION BoolInput::ChangeEnum{{{*/
    118 void BoolInput::ChangeEnum(int newenumtype){
     102void BoolInput::ChangeEnum(int newenumtype){/*{{{*/
    119103        this->enum_type=newenumtype;
    120104}
    121105/*}}}*/
    122 /*FUNCTION BoolInput::SquareMin{{{*/
    123 void BoolInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
     106void BoolInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){/*{{{*/
    124107        /*square of a bool is the bool itself: */
    125108        *psquaremin=value;
    126109}
    127110/*}}}*/
    128 /*FUNCTION BoolInput::Scale{{{*/
    129 void BoolInput::Scale(IssmDouble scale_factor){
     111void BoolInput::Scale(IssmDouble scale_factor){/*{{{*/
    130112        /*a bool cannot be scaled: */
    131113}
    132114/*}}}*/
    133 /*FUNCTION BoolInput::AXPY{{{*/
    134 void BoolInput::AXPY(Input* xinput,IssmDouble scalar){
     115void BoolInput::AXPY(Input* xinput,IssmDouble scalar){/*{{{*/
    135116
    136117        BoolInput*  xboolinput=NULL;
    … …  
    152133}
    153134/*}}}*/
    154 /*FUNCTION BoolInput::Extrude{{{*/
    155 void BoolInput::Extrude(void){
     135void BoolInput::Extrude(void){/*{{{*/
    156136
    157137        /*do nothing*/
    … …  
    159139}
    160140/*}}}*/
    161 /*FUNCTION BoolInput::GetVectorFromInputs{{{*/
    162 void BoolInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){
     141void BoolInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){/*{{{*/
    163142
    164143        _error_("not supporte yet!");
    … …  
    166145}
    167146/*}}}*/
    168 /*FUNCTION BoolInput::Configure{{{*/
    169 void BoolInput::Configure(Parameters* parameters){
     147void BoolInput::Configure(Parameters* parameters){/*{{{*/
    170148        /*do nothing: */
    171149}

  • issm/trunk-jpl/src/c/classes/Inputs/ControlInput.cpp

    r17514 r18064  
    1313
    1414/*ControlInput constructors and destructor*/
    15 /*FUNCTION ControlInput::ControlInput(){{{*/
    16 ControlInput::ControlInput(){
     15ControlInput::ControlInput(){/*{{{*/
    1716        control_id  = 0;
    1817        values      = NULL;
    … …  
    2322}
    2423/*}}}*/
    25 /*FUNCTION ControlInput::ControlInput(int enum_type,int enum_input,IssmDouble* pvalues,IssmDouble* pmin,IssmDouble* pmax,int id){{{*/
    26 ControlInput::ControlInput(int in_enum_type,int enum_input,IssmDouble* pvalues,IssmDouble* pmin,IssmDouble* pmax,int id){
     24ControlInput::ControlInput(int in_enum_type,int enum_input,IssmDouble* pvalues,IssmDouble* pmin,IssmDouble* pmax,int id){/*{{{*/
    2725
    2826        control_id=id;
    … …  
    4846}
    4947/*}}}*/
    50 /*FUNCTION ControlInput::~ControlInput(){{{*/
    51 ControlInput::~ControlInput(){
     48ControlInput::~ControlInput(){/*{{{*/
    5249        delete values;
    5350        delete savedvalues;
    … …  
    5956
    6057/*Object virtual functions definitions:*/
    61                 /*FUNCTION ControlInput::Echo {{{*/
    62 void ControlInput::Echo(void){
     58void ControlInput::Echo(void){/*{{{*/
    6359        this->DeepEcho();
    6460}
    6561/*}}}*/
    66 /*FUNCTION ControlInput::DeepEcho{{{*/
    67 void ControlInput::DeepEcho(void){
     62void ControlInput::DeepEcho(void){/*{{{*/
    6863
    6964        _printf_("ControlInput:\n");
    … …  
    7671}
    7772/*}}}*/
    78 /*FUNCTION ControlInput::Id{{{*/
    79 int    ControlInput::Id(void){ return -1; }
    80 /*}}}*/
    81 /*FUNCTION ControlInput::ObjectEnum{{{*/
    82 int ControlInput::ObjectEnum(void){
     73int    ControlInput::Id(void){ return -1; }/*{{{*/
     74/*}}}*/
     75int ControlInput::ObjectEnum(void){/*{{{*/
    8376
    8477        return ControlInputEnum;
    … …  
    8679}
    8780/*}}}*/
    88 /*FUNCTION ControlInput::copy{{{*/
    89 Object* ControlInput::copy() {
     81Object* ControlInput::copy() {/*{{{*/
    9082
    9183        ControlInput* output=NULL;
    … …  
    10698
    10799/*ControlInput management*/
    108 /*FUNCTION ControlInput::InstanceEnum{{{*/
    109 int ControlInput::InstanceEnum(void){
     100int ControlInput::InstanceEnum(void){/*{{{*/
    110101
    111102        return this->enum_type;
    … …  
    115106
    116107/*Object functions*/
    117 /*FUNCTION ControlInput::AXPY(){{{*/
    118 void ControlInput::AXPY(Input* xinput,IssmDouble scalar){
     108void ControlInput::AXPY(Input* xinput,IssmDouble scalar){/*{{{*/
    119109        values->AXPY(xinput,scalar);
    120110}/*}}}*/
    121 /*FUNCTION ControlInput::Constrain(){{{*/
    122 void ControlInput::Constrain(void){
     111void ControlInput::Constrain(void){/*{{{*/
    123112
    124113        Input* newvalues=NULL;
    … …  
    129118        delete values; this->values=newvalues;
    130119}/*}}}*/
    131 /*FUNCTION ControlInput::Constrain(IssmDouble min, IssmDouble max){{{*/
    132 void ControlInput::Constrain(IssmDouble min, IssmDouble max){
     120void ControlInput::Constrain(IssmDouble min, IssmDouble max){/*{{{*/
    133121           values->Constrain(min,max);
    134122}/*}}}*/
    135 /*FUNCTION ControlInput::Extrude{{{*/
    136 void ControlInput::Extrude(void){
     123void ControlInput::Extrude(void){/*{{{*/
    137124        values->Extrude();
    138125        savedvalues->Extrude();
    139126        //gradient->Extrude();
    140127}/*}}}*/
    141 /*FUNCTION ControlInput::GetResultInterpolation{{{*/
    142 int  ControlInput::GetResultInterpolation(void){
     128int  ControlInput::GetResultInterpolation(void){/*{{{*/
    143129
    144130        return values->GetResultInterpolation();
    … …  
    146132}
    147133/*}}}*/
    148 /*FUNCTION ControlInput::GetResultNumberOfNodes{{{*/
    149 int  ControlInput::GetResultNumberOfNodes(void){
     134int  ControlInput::GetResultNumberOfNodes(void){/*{{{*/
    150135
    151136        return values->GetResultNumberOfNodes();
    … …  
    153138}
    154139/*}}}*/
    155 /*FUNCTION ControlInput::GetGradient{{{*/
    156 void ControlInput::GetGradient(Vector<IssmDouble>* gradient_vec,int* doflist){
     140void ControlInput::GetGradient(Vector<IssmDouble>* gradient_vec,int* doflist){/*{{{*/
    157141        if(gradient) gradient->GetVectorFromInputs(gradient_vec,doflist);
    158142}/*}}}*/
    159 /*FUNCTION ControlInput::ScaleGradient{{{*/
    160 void ControlInput::ScaleGradient(IssmDouble scaling_factor){
     143void ControlInput::ScaleGradient(IssmDouble scaling_factor){/*{{{*/
    161144        if(!gradient) _error_("Gradient of ControlInput " << EnumToStringx(enum_type) << " not found");
    162145        gradient->Scale(scaling_factor);
    163146}/*}}}*/
    164 /*FUNCTION ControlInput::SetGradient{{{*/
    165 void ControlInput::SetGradient(Input* gradient_in){
     147void ControlInput::SetGradient(Input* gradient_in){/*{{{*/
    166148
    167149        /*Get enum for current gradient*/
    … …  
    185167
    186168}/*}}}*/
    187 /*FUNCTION ControlInput::SetInput{{{*/
    188 void ControlInput::SetInput(Input* in_input){
     169void ControlInput::SetInput(Input* in_input){/*{{{*/
    189170
    190171        delete values; this->values=in_input;
    … …  
    192173
    193174}/*}}}*/
    194 /*FUNCTION ControlInput::SpawnTriaInput{{{*/
    195 Input* ControlInput::SpawnTriaInput(int index1,int index2,int index3){
     175Input* ControlInput::SpawnTriaInput(int index1,int index2,int index3){/*{{{*/
    196176        return values->SpawnTriaInput(index1,index2,index3);
    197177}/*}}}*/
    198 /*FUNCTION ControlInput::SpawnSegInput{{{*/
    199 Input* ControlInput::SpawnSegInput(int index1,int index2){
     178Input* ControlInput::SpawnSegInput(int index1,int index2){/*{{{*/
    200179        return values->SpawnSegInput(index1,index2);
    201180}/*}}}*/
    202 /*FUNCTION ControlInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){{{*/
    203 void ControlInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){
     181void ControlInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){/*{{{*/
    204182        values->GetVectorFromInputs(vector,doflist);
    205183}/*}}}*/
    206 /*FUNCTION ControlInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist,const char* data){{{*/
    207 void ControlInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist,const char* data){
     184void ControlInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist,const char* data){/*{{{*/
    208185         if(strcmp(data,"value")==0){
    209186                 _assert_(values);
    … …  
    226203         }
    227204}/*}}}*/
    228 /*FUNCTION ControlInput::GetInputAverage(IssmDouble* pvalue){{{*/
    229 void ControlInput::GetInputAverage(IssmDouble* pvalue){
     205void ControlInput::GetInputAverage(IssmDouble* pvalue){/*{{{*/
    230206        values->GetInputAverage(pvalue);
    231207}/*}}}*/
    232 /*FUNCTION ControlInput::GetInputValue(bool* pvalue){{{*/
    233 void ControlInput::GetInputValue(bool* pvalue){
     208void ControlInput::GetInputValue(bool* pvalue){/*{{{*/
    234209        values->GetInputValue(pvalue);
    235210}/*}}}*/
    236 /*FUNCTION ControlInput::GetInputValue(int* pvalue){{{*/
    237 void ControlInput::GetInputValue(int* pvalue){
     211void ControlInput::GetInputValue(int* pvalue){/*{{{*/
    238212        values->GetInputValue(pvalue);
    239213}/*}}}*/
    240 /*FUNCTION ControlInput::GetInputValue(IssmDouble* pvalue){{{*/
    241 void ControlInput::GetInputValue(IssmDouble* pvalue){
     214void ControlInput::GetInputValue(IssmDouble* pvalue){/*{{{*/
    242215        values->GetInputValue(pvalue);
    243216}/*}}}*/
    244 /*FUNCTION ControlInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
    245 void ControlInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
     217void ControlInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){/*{{{*/
    246218        values->GetInputValue(pvalue,gauss);
    247219}/*}}}*/
    248 /*FUNCTION ControlInput::GetGradientValue{{{*/
    249 void ControlInput::GetGradientValue(IssmDouble* pvalue,Gauss* gauss){
     220void ControlInput::GetGradientValue(IssmDouble* pvalue,Gauss* gauss){/*{{{*/
    250221        gradient->GetInputValue(pvalue,gauss);
    251222}/*}}}*/
    252 /*FUNCTION ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, Gauss* gauss){{{*/
    253 void ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, Gauss* gauss){
     223void ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, Gauss* gauss){/*{{{*/
    254224        values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
    255225}/*}}}*/
    256 /*FUNCTION ControlInput::SaveValue{{{*/
    257 void ControlInput::SaveValue(void){
     226void ControlInput::SaveValue(void){/*{{{*/
    258227        if(!values) _error_("Values of " << EnumToStringx(this->enum_type) << " not found");
    259228
    … …  
    261230        this->savedvalues=dynamic_cast<Input*>(this->values->copy());
    262231}/*}}}*/
    263 /*FUNCTION ControlInput::UpdateValue{{{*/
    264 void ControlInput::UpdateValue(IssmDouble scalar){
     232void ControlInput::UpdateValue(IssmDouble scalar){/*{{{*/
    265233        if(!gradient)    _error_("Gradient of " << EnumToStringx(this->enum_type) << " not found");
    266234        if(!savedvalues) _error_("Values of " << EnumToStringx(this->enum_type) << " not found");
    … …  
    270238        this->values->AXPY(gradient,scalar);
    271239}/*}}}*/
    272 /*FUNCTION ControlInput::VerticallyIntegrate{{{*/
    273 void ControlInput::VerticallyIntegrate(Input* thickness_input){
     240void ControlInput::VerticallyIntegrate(Input* thickness_input){/*{{{*/
    274241        values->VerticallyIntegrate(thickness_input);
    275242}/*}}}*/
    276 /*FUNCTION ControlInput::Configure{{{*/
    277 void ControlInput::Configure(Parameters* parameters){
     243void ControlInput::Configure(Parameters* parameters){/*{{{*/
    278244        /*do nothing: */
    279245}

  • issm/trunk-jpl/src/c/classes/Inputs/DatasetInput.cpp

    r17514 r18064  
    1414
    1515/*DatasetInput constructors and destructor*/
    16 /*FUNCTION DatasetInput::DatasetInput(){{{*/
    17 DatasetInput::DatasetInput(){
     16DatasetInput::DatasetInput(){/*{{{*/
    1817        enum_type = UNDEF;
    1918        inputs    = NULL;
    … …  
    2221}
    2322/*}}}*/
    24 /*FUNCTION DatasetInput::DatasetInput(int in_enum_type,int* idlist,int numids) {{{*/
    25 DatasetInput::DatasetInput(int in_enum_type){
     23DatasetInput::DatasetInput(int in_enum_type){/*{{{*/
    2624
    2725        enum_type = in_enum_type;
    … …  
    3129}
    3230/*}}}*/
    33 /*FUNCTION DatasetInput::~DatasetInput(){{{*/
    34 DatasetInput::~DatasetInput(){
     31DatasetInput::~DatasetInput(){/*{{{*/
    3532        xDelete<int>(this->ids);
    3633        delete inputs;
    … …  
    3936
    4037/*Object virtual functions definitions:*/
    41                 /*FUNCTION DatasetInput::Echo {{{*/
    42 void DatasetInput::Echo(void){
     38void DatasetInput::Echo(void){/*{{{*/
    4339        this->DeepEcho();
    4440}
    4541/*}}}*/
    46 /*FUNCTION DatasetInput::DeepEcho{{{*/
    47 void DatasetInput::DeepEcho(void){
     42void DatasetInput::DeepEcho(void){/*{{{*/
    4843
    4944        _printf_("DatasetInput:\n");
    … …  
    5651}
    5752/*}}}*/
    58 /*FUNCTION DatasetInput::Id{{{*/
    59 int    DatasetInput::Id(void){ return -1; }
     53int    DatasetInput::Id(void){ return -1; }/*{{{*/
    6054/*}}}*/
    61 /*FUNCTION DatasetInput::ObjectEnum{{{*/
    62 int DatasetInput::ObjectEnum(void){
     55int DatasetInput::ObjectEnum(void){/*{{{*/
    6356
    6457        return DatasetInputEnum;
    … …  
    6659}
    6760/*}}}*/
    68 /*FUNCTION DatasetInput::copy{{{*/
    69 Object* DatasetInput::copy() {
     61Object* DatasetInput::copy() {/*{{{*/
    7062
    7163        DatasetInput* output=NULL;
    … …  
    7870}
    7971/*}}}*/
    80 /*FUNCTION DatasetInput::SpawnTriaInput{{{*/
    81 Input* DatasetInput::SpawnTriaInput(int index1,int index2,int index3){
     72Input* DatasetInput::SpawnTriaInput(int index1,int index2,int index3){/*{{{*/
    8273
    8374        /*output*/
    … …  
    9687}
    9788/*}}}*/
    98 /*FUNCTION DatasetInput::SpawnSegInput{{{*/
    99 Input* DatasetInput::SpawnSegInput(int index1,int index2){
     89Input* DatasetInput::SpawnSegInput(int index1,int index2){/*{{{*/
    10090
    10191        /*output*/
    … …  
    116106
    117107/*DatasetInput management*/
    118 /*FUNCTION DatasetInput::AddInput{{{*/
    119 void DatasetInput::AddInput(Input* input,int id){
     108void DatasetInput::AddInput(Input* input,int id){/*{{{*/
    120109
    121110        _assert_(this->numids == this->inputs->Size());
    … …  
    144133}
    145134/*}}}*/
    146 /*FUNCTION DatasetInput::InstanceEnum{{{*/
    147 int DatasetInput::InstanceEnum(void){
     135int DatasetInput::InstanceEnum(void){/*{{{*/
    148136
    149137        return this->enum_type;
    … …  
    153141
    154142/*Object functions*/
    155 /*FUNCTION DatasetInput::Configure{{{*/
    156 void DatasetInput::Configure(Parameters* parameters){
     143void DatasetInput::Configure(Parameters* parameters){/*{{{*/
    157144        /*do nothing: */
    158145}
    159146/*}}}*/
    160 /*FUNCTION DatasetInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,int id){{{*/
    161 void DatasetInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,int id){
     147void DatasetInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,int id){/*{{{*/
    162148
    163149        int  offset = -1;

  • issm/trunk-jpl/src/c/classes/Inputs/DoubleInput.cpp

    r17514 r18064  
    1313
    1414/*DoubleInput constructors and destructor*/
    15 /*FUNCTION DoubleInput::DoubleInput(){{{*/
    16 DoubleInput::DoubleInput(){
     15DoubleInput::DoubleInput(){/*{{{*/
    1716        return;
    1817}
    1918/*}}}*/
    20 /*FUNCTION DoubleInput::DoubleInput(IssmDouble value){{{*/
    21 DoubleInput::DoubleInput(int in_enum_type,IssmDouble in_value){
     19DoubleInput::DoubleInput(int in_enum_type,IssmDouble in_value){/*{{{*/
    2220
    2321        enum_type=in_enum_type;
    … …  
    2523}
    2624/*}}}*/
    27 /*FUNCTION DoubleInput::~DoubleInput(){{{*/
    28 DoubleInput::~DoubleInput(){
     25DoubleInput::~DoubleInput(){/*{{{*/
    2926        return;
    3027}
    … …  
    3229
    3330/*Object virtual functions definitions:*/
    34                 /*FUNCTION DoubleInput::Echo {{{*/
    35 void DoubleInput::Echo(void){
     31void DoubleInput::Echo(void){/*{{{*/
    3632        this->DeepEcho();
    3733}
    3834/*}}}*/
    39 /*FUNCTION DoubleInput::DeepEcho{{{*/
    40 void DoubleInput::DeepEcho(void){
     35void DoubleInput::DeepEcho(void){/*{{{*/
    4136
    4237        _printf_(setw(15)<<"   DoubleInput "<<setw(25)<<left<<EnumToStringx(this->enum_type)<<" "<<this->value<<"\n");
    4338}
    4439/*}}}*/
    45 /*FUNCTION DoubleInput::Id{{{*/
    46 int    DoubleInput::Id(void){ return -1; }
    47 /*}}}*/
    48 /*FUNCTION DoubleInput::ObjectEnum{{{*/
    49 int DoubleInput::ObjectEnum(void){
     40int    DoubleInput::Id(void){ return -1; }/*{{{*/
     41/*}}}*/
     42int DoubleInput::ObjectEnum(void){/*{{{*/
    5043
    5144        return DoubleInputEnum;
    … …  
    5346}
    5447/*}}}*/
    55 /*FUNCTION DoubleInput::copy{{{*/
    56 Object* DoubleInput::copy() {
     48Object* DoubleInput::copy() {/*{{{*/
    5749
    5850        return new DoubleInput(this->enum_type,this->value);
    … …  
    6254
    6355/*DoubleInput management*/
    64 /*FUNCTION DoubleInput::InstanceEnum{{{*/
    65 int DoubleInput::InstanceEnum(void){
     56int DoubleInput::InstanceEnum(void){/*{{{*/
    6657
    6758        return this->enum_type;
    … …  
    6960}
    7061/*}}}*/
    71 /*FUNCTION DoubleInput::SpawnTriaInput{{{*/
    72 Input* DoubleInput::SpawnTriaInput(int index1,int index2,int index3){
     62Input* DoubleInput::SpawnTriaInput(int index1,int index2,int index3){/*{{{*/
    7363
    7464        /*output*/
    … …  
    8474}
    8575/*}}}*/
    86 /*FUNCTION DoubleInput::SpawnSegInput{{{*/
    87 Input* DoubleInput::SpawnSegInput(int index1,int index2){
     76Input* DoubleInput::SpawnSegInput(int index1,int index2){/*{{{*/
    8877
    8978        /*output*/
    … …  
    10190
    10291/*Object functions*/
    103 /*FUNCTION DoubleInput::GetInputValue(bool* pvalue) {{{*/
    104 void DoubleInput::GetInputValue(bool* pvalue){
     92void DoubleInput::GetInputValue(bool* pvalue){/*{{{*/
    10593        _error_("Double input of enum " << EnumToStringx(enum_type) << " cannot return a boolean");
    10694
    10795}
    10896/*}}}*/
    109 /*FUNCTION DoubleInput::GetInputValue(int* pvalue){{{*/
    110 void DoubleInput::GetInputValue(int* pvalue){
     97void DoubleInput::GetInputValue(int* pvalue){/*{{{*/
    11198        _error_("Double input of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an integer");
    11299
    113100}
    114101/*}}}*/
    115 /*FUNCTION DoubleInput::GetInputValue(IssmDouble* pvalue){{{*/
    116 void DoubleInput::GetInputValue(IssmDouble* pvalue){
     102void DoubleInput::GetInputValue(IssmDouble* pvalue){/*{{{*/
    117103
    118104        /*return value*/
    … …  
    120106}
    121107/*}}}*/
    122 /*FUNCTION DoubleInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
    123 void DoubleInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){*pvalue=this->value;}
    124 /*}}}*/
    125 /*FUNCTION DoubleInput::ChangeEnum{{{*/
    126 void DoubleInput::ChangeEnum(int newenumtype){
     108void DoubleInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){*pvalue=this->value;}/*{{{*/
     109/*}}}*/
     110void DoubleInput::ChangeEnum(int newenumtype){/*{{{*/
    127111        this->enum_type=newenumtype;
    128112}
    129113/*}}}*/
    130 /*FUNCTION DoubleInput::SquareMin{{{*/
    131 void DoubleInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
     114void DoubleInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){/*{{{*/
    132115
    133116        /*square min of a IssmDouble is the square of the IssmDouble itself: */
    … …  
    135118}
    136119/*}}}*/
    137 /*FUNCTION DoubleInput::Scale{{{*/
    138 void DoubleInput::Scale(IssmDouble scale_factor){
     120void DoubleInput::Scale(IssmDouble scale_factor){/*{{{*/
    139121        value=value*scale_factor;
    140122}
    141123/*}}}*/
    142 /*FUNCTION DoubleInput::ConstrainMin{{{*/
    143 void DoubleInput::ConstrainMin(IssmDouble minimum){
     124void DoubleInput::ConstrainMin(IssmDouble minimum){/*{{{*/
    144125        if (value<minimum) value=minimum;
    145126}
    146127/*}}}*/
    147 /*FUNCTION DoubleInput::AXPY{{{*/
    148 void DoubleInput::AXPY(Input* xinput,IssmDouble scalar){
     128void DoubleInput::AXPY(Input* xinput,IssmDouble scalar){/*{{{*/
    149129
    150130        DoubleInput*  xIssmDoubleinput=NULL;
    … …  
    166146}
    167147/*}}}*/
    168 /*FUNCTION DoubleInput::Constrain{{{*/
    169 void DoubleInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){
     148void DoubleInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){/*{{{*/
    170149
    171150        if(!xIsNan<IssmDouble>(cm_min)) if (this->value<cm_min)this->value=cm_min;
    … …  
    174153}
    175154/*}}}*/
    176 /*FUNCTION DoubleInput::Max{{{*/
    177 IssmDouble DoubleInput::Max(void){
     155IssmDouble DoubleInput::Max(void){/*{{{*/
    178156        return this->value;
    179157}
    180158/*}}}*/
    181 /*FUNCTION DoubleInput::MaxAbs{{{*/
    182 IssmDouble DoubleInput::MaxAbs(void){
     159IssmDouble DoubleInput::MaxAbs(void){/*{{{*/
    183160        return fabs(this->value);
    184161}
    185162/*}}}*/
    186 /*FUNCTION DoubleInput::Min{{{*/
    187 IssmDouble DoubleInput::Min(void){
     163IssmDouble DoubleInput::Min(void){/*{{{*/
    188164        return this->value;
    189165}
    190166/*}}}*/
    191 /*FUNCTION DoubleInput::MinAbs{{{*/
    192 IssmDouble DoubleInput::MinAbs(void){
     167IssmDouble DoubleInput::MinAbs(void){/*{{{*/
    193168        return fabs(this->value);
    194169}
    195170/*}}}*/
    196 /*FUNCTION DoubleInput::GetVectorFromInputs{{{*/
    197 void DoubleInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){
     171void DoubleInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){/*{{{*/
    198172
    199173        _error_("not supporte yet!");
    … …  
    201175}
    202176/*}}}*/
    203 /*FUNCTION DoubleInput::GetInputAverage{{{*/
    204 void DoubleInput::GetInputAverage(IssmDouble* pvalue){
     177void DoubleInput::GetInputAverage(IssmDouble* pvalue){/*{{{*/
    205178        *pvalue=value;
    206179}
    207180/*}}}*/
    208 /*FUNCTION DoubleInput::VerticallyIntegrate{{{*/
    209 void DoubleInput::VerticallyIntegrate(Input* thickness_input){
     181void DoubleInput::VerticallyIntegrate(Input* thickness_input){/*{{{*/
    210182
    211183        /*Intermediaries*/
    … …  
    228200}
    229201/*}}}*/
    230 /*FUNCTION DoubleInput::PointwiseDivide{{{*/
    231 Input* DoubleInput::PointwiseDivide(Input* inputB){
     202Input* DoubleInput::PointwiseDivide(Input* inputB){/*{{{*/
    232203
    233204        /*Ouput*/
    … …  
    248219}
    249220/*}}}*/
    250 /*FUNCTION DoubleInput::PointwiseMin{{{*/
    251 Input* DoubleInput::PointwiseMin(Input* input){
     221Input* DoubleInput::PointwiseMin(Input* input){/*{{{*/
    252222
    253223        /*Ouput*/
    … …  
    269239}
    270240/*}}}*/
    271 /*FUNCTION DoubleInput::PointwiseMax{{{*/
    272 Input* DoubleInput::PointwiseMax(Input* input){
     241Input* DoubleInput::PointwiseMax(Input* input){/*{{{*/
    273242
    274243        /*Ouput*/
    … …  
    290259}
    291260/*}}}*/
    292 /*FUNCTION DoubleInput::Configure{{{*/
    293 void DoubleInput::Configure(Parameters* parameters){
     261void DoubleInput::Configure(Parameters* parameters){/*{{{*/
    294262        /*do nothing: */
    295263}

  • issm/trunk-jpl/src/c/classes/Inputs/Inputs.cpp

    r17514 r18064  
    1919
    2020/*Object constructors and destructor*/
    21 /*FUNCTION Inputs::Inputs(){{{*/
    22 Inputs::Inputs(){
     21Inputs::Inputs(){/*{{{*/
    2322        return;
    2423}
    2524/*}}}*/
    26 /*FUNCTION Inputs::~Inputs(){{{*/
    27 Inputs::~Inputs(){
     25Inputs::~Inputs(){/*{{{*/
    2826        return;
    2927}
    … …  
    3129
    3230/*Object management*/
    33 /*FUNCTION Inputs::GetInputValue(bool* pvalue,int enum-type){{{*/
    34 void Inputs::GetInputValue(bool* pvalue,int enum_type){
     31void Inputs::GetInputValue(bool* pvalue,int enum_type){/*{{{*/
    3532
    3633        vector<Object*>::iterator object;
    … …  
    5956}
    6057/*}}}*/
    61 /*FUNCTION Inputs::GetInputValue(int* pvalue,int enum-type){{{*/
    62 void Inputs::GetInputValue(int* pvalue,int enum_type){
     58void Inputs::GetInputValue(int* pvalue,int enum_type){/*{{{*/
    6359
    6460        vector<Object*>::iterator object;
    … …  
    8783}
    8884/*}}}*/
    89 /*FUNCTION Inputs::GetInputValue(IssmDouble* pvalue,int enum-type){{{*/
    90 void Inputs::GetInputValue(IssmDouble* pvalue,int enum_type){
     85void Inputs::GetInputValue(IssmDouble* pvalue,int enum_type){/*{{{*/
    9186
    9287        vector<Object*>::iterator object;
    … …  
    115110}
    116111/*}}}*/
    117 /*FUNCTION Inputs::GetInputAverage{{{*/
    118 void Inputs::GetInputAverage(IssmDouble* pvalue,int enum_type){
     112void Inputs::GetInputAverage(IssmDouble* pvalue,int enum_type){/*{{{*/
    119113
    120114        vector<Object*>::iterator object;
    … …  
    143137}
    144138/*}}}*/
    145 /*FUNCTION Inputs::AddInput{{{*/
    146 int  Inputs::AddInput(Input* in_input){
     139int  Inputs::AddInput(Input* in_input){/*{{{*/
    147140
    148141        /*First, go through dataset of inputs and check whether any input
    … …  
    169162}
    170163/*}}}*/
    171 /*FUNCTION Inputs::ChangeEnum{{{*/
    172 void  Inputs::ChangeEnum(int oldenumtype,int newenumtype){
     164void  Inputs::ChangeEnum(int oldenumtype,int newenumtype){/*{{{*/
    173165
    174166        /*Go through dataset of inputs and look for input with
    … …  
    199191}
    200192/*}}}*/
    201 /*FUNCTION Inputs::ConstrainMin{{{*/
    202 void  Inputs::ConstrainMin(int constrain_enum, IssmDouble minimum){
     193void  Inputs::ConstrainMin(int constrain_enum, IssmDouble minimum){/*{{{*/
    203194
    204195        /*Find x and y inputs: */
    … …  
    212203}
    213204/*}}}*/
    214 /*FUNCTION Inputs::InfinityNorm{{{*/
    215 IssmDouble Inputs::InfinityNorm(int enumtype){
     205IssmDouble Inputs::InfinityNorm(int enumtype){/*{{{*/
    216206
    217207        /*Output*/
    … …  
    233223}
    234224/*}}}*/
    235 /*FUNCTION Inputs::Max{{{*/
    236 IssmDouble Inputs::Max(int enumtype){
     225IssmDouble Inputs::Max(int enumtype){/*{{{*/
    237226
    238227        /*Output*/
    … …  
    254243}
    255244/*}}}*/
    256 /*FUNCTION Inputs::MaxAbs{{{*/
    257 IssmDouble Inputs::MaxAbs(int enumtype){
     245IssmDouble Inputs::MaxAbs(int enumtype){/*{{{*/
    258246
    259247        /*Output*/
    … …  
    275263}
    276264/*}}}*/
    277 /*FUNCTION Inputs::Min{{{*/
    278 IssmDouble Inputs::Min(int enumtype){
     265IssmDouble Inputs::Min(int enumtype){/*{{{*/
    279266
    280267        /*Output*/
    … …  
    296283}
    297284/*}}}*/
    298 /*FUNCTION Inputs::MinAbs{{{*/
    299 IssmDouble Inputs::MinAbs(int enumtype){
     285IssmDouble Inputs::MinAbs(int enumtype){/*{{{*/
    300286
    301287        /*Output*/
    … …  
    317303}
    318304/*}}}*/
    319 /*FUNCTION Inputs::GetInput{{{*/
    320 Input* Inputs::GetInput(int enum_name){
     305Input* Inputs::GetInput(int enum_name){/*{{{*/
    321306
    322307        vector<Object*>::iterator object;
    … …  
    334319}
    335320/*}}}*/
    336 /*FUNCTION Inputs::DeleteInput{{{*/
    337 int  Inputs::DeleteInput(int enum_type){
     321int  Inputs::DeleteInput(int enum_type){/*{{{*/
    338322
    339323        vector<Object*>::iterator object;
    … …  
    354338}
    355339/*}}}*/
    356 /*FUNCTION Inputs::DuplicateInput{{{*/
    357 void  Inputs::DuplicateInput(int original_enum,int new_enum){
     340void  Inputs::DuplicateInput(int original_enum,int new_enum){/*{{{*/
    358341
    359342        /*Make a copy of the original input: */
    … …  
    369352}
    370353/*}}}*/
    371 /*FUNCTION Inputs::SpawnTriaInputs{{{*/
    372 Inputs* Inputs::SpawnTriaInputs(int index1,int index2,int index3){
     354Inputs* Inputs::SpawnTriaInputs(int index1,int index2,int index3){/*{{{*/
    373355
    374356        /*Intermediary*/
    … …  
    395377}
    396378/*}}}*/
    397 /*FUNCTION Inputs::SpawnSegInputs{{{*/
    398 Inputs* Inputs::SpawnSegInputs(int index1,int index2){
     379Inputs* Inputs::SpawnSegInputs(int index1,int index2){/*{{{*/
    399380
    400381        /*Intermediary*/
    … …  
    421402}
    422403/*}}}*/
    423 /*FUNCTION Inputs::AXPY{{{*/
    424 void  Inputs::AXPY(int inputy_enum, IssmDouble scalar, int inputx_enum){
     404void  Inputs::AXPY(int inputy_enum, IssmDouble scalar, int inputx_enum){/*{{{*/
    425405
    426406        /*Find x and y inputs: */
    … …  
    436416}
    437417/*}}}*/
    438 /*FUNCTION Inputs::Configure{{{*/
    439 void Inputs::Configure(Parameters* parameters){
     418void Inputs::Configure(Parameters* parameters){/*{{{*/
    440419
    441420        vector<Object*>::iterator object;

  • issm/trunk-jpl/src/c/classes/Inputs/IntInput.cpp

    r17514 r18064  
    1313
    1414/*IntInput constructors and destructor*/
    15 /*FUNCTION IntInput::IntInput(){{{*/
    16 IntInput::IntInput(){
     15IntInput::IntInput(){/*{{{*/
    1716        return;
    1817}
    1918/*}}}*/
    20 /*FUNCTION IntInput::IntInput(IssmDouble* values){{{*/
    21 IntInput::IntInput(int in_enum_type,IssmInt in_value){
     19IntInput::IntInput(int in_enum_type,IssmInt in_value){/*{{{*/
    2220
    2321        enum_type=in_enum_type;
    … …  
    2523}
    2624/*}}}*/
    27 /*FUNCTION IntInput::~IntInput(){{{*/
    28 IntInput::~IntInput(){
     25IntInput::~IntInput(){/*{{{*/
    2926        return;
    3027}
    … …  
    3229
    3330/*Object virtual functions definitions:*/
    34 /*FUNCTION IntInput::DeepEcho{{{*/
    35 void IntInput::DeepEcho(void){
     31void IntInput::DeepEcho(void){/*{{{*/
    3632
    3733        _printf_(setw(15)<<"   IntInput "<<setw(25)<<left<<EnumToStringx(this->enum_type)<<" "<<this->value<<"\n");
    3834}
    3935/*}}}*/
    40 /*FUNCTION IntInput::Id{{{*/
    41 int    IntInput::Id(void){ return -1; }
     36int    IntInput::Id(void){ return -1; }/*{{{*/
    4237/*}}}*/
    43 /*FUNCTION IntInput::ObjectEnum{{{*/
    44 int IntInput::ObjectEnum(void){
     38int IntInput::ObjectEnum(void){/*{{{*/
    4539
    4640        return IntInputEnum;
    … …  
    4842}
    4943/*}}}*/
    50 /*FUNCTION IntInput::copy{{{*/
    51 Object* IntInput::copy() {
     44Object* IntInput::copy() {/*{{{*/
    5245
    5346        return new IntInput(this->enum_type,this->value);
    … …  
    5750
    5851/*IntInput management*/
    59 /*FUNCTION IntInput::Echo {{{*/
    60 void IntInput::Echo(void){
     52void IntInput::Echo(void){/*{{{*/
    6153        this->DeepEcho();
    6254}
    6355/*}}}*/
    64 /*FUNCTION IntInput::InstanceEnum{{{*/
    65 int IntInput::InstanceEnum(void){
     56int IntInput::InstanceEnum(void){/*{{{*/
    6657
    6758        return this->enum_type;
    … …  
    6960}
    7061/*}}}*/
    71 /*FUNCTION IntInput::SpawnTriaInput{{{*/
    72 Input* IntInput::SpawnTriaInput(int index1,int index2,int index3){
     62Input* IntInput::SpawnTriaInput(int index1,int index2,int index3){/*{{{*/
    7363
    7464        /*output*/
    … …  
    8373}
    8474/*}}}*/
    85 /*FUNCTION IntInput::SpawnSegInput{{{*/
    86 Input* IntInput::SpawnSegInput(int index1,int index2){
     75Input* IntInput::SpawnSegInput(int index1,int index2){/*{{{*/
    8776
    8877        /*output*/
    … …  
    9988
    10089/*Object functions*/
    101 /*FUNCTION IntInput::GetInputValue(bool* pvalue) {{{*/
    102 void IntInput::GetInputValue(bool* pvalue){_error_("not supported yet!");}
     90void IntInput::GetInputValue(bool* pvalue){_error_("not supported yet!");}/*{{{*/
    10391/*}}}*/
    104 /*FUNCTION IntInput::GetInputValue(int* pvalue){{{*/
    105 void IntInput::GetInputValue(int* pvalue){
     92void IntInput::GetInputValue(int* pvalue){/*{{{*/
    10693        *pvalue=value;
    10794}
    10895/*}}}*/
    109 /*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue){{{*/
    110 void IntInput::GetInputValue(IssmDouble* pvalue){
     96void IntInput::GetInputValue(IssmDouble* pvalue){/*{{{*/
    11197        _error_("IntInput cannot return a IssmDouble in parallel");
    11298}
    11399/*}}}*/
    114 /*FUNCTION IntInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
    115 void IntInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){_error_("not supported yet!");}
     100void IntInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){_error_("not supported yet!");}/*{{{*/
    116101/*}}}*/
    117 /*FUNCTION IntInput::ChangeEnum{{{*/
    118 void IntInput::ChangeEnum(int newenumtype){
     102void IntInput::ChangeEnum(int newenumtype){/*{{{*/
    119103        this->enum_type=newenumtype;
    120104}
    121105/*}}}*/
    122 /*FUNCTION IntInput::SquareMin{{{*/
    123 void IntInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
     106void IntInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){/*{{{*/
    124107
    125108        /*square min of an integer is the square of the integer itself: */
    … …  
    127110}
    128111/*}}}*/
    129 /*FUNCTION IntInput::Scale{{{*/
    130 void IntInput::Scale(IssmDouble scale_factor){
     112void IntInput::Scale(IssmDouble scale_factor){/*{{{*/
    131113        IssmDouble dvalue=(IssmDouble)value*scale_factor;
    132114        value=reCast<int>(dvalue);
    133115}
    134116/*}}}*/
    135 /*FUNCTION IntInput::AXPY{{{*/
    136 void IntInput::AXPY(Input* xinput,IssmDouble scalar){
     117void IntInput::AXPY(Input* xinput,IssmDouble scalar){/*{{{*/
    137118
    138119        IssmDouble dvalue;
    … …  
    156137}
    157138/*}}}*/
    158 /*FUNCTION IntInput::Constrain{{{*/
    159 void IntInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){
     139void IntInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){/*{{{*/
    160140
    161141        if(!xIsNan<IssmDouble>(cm_min)) if (this->value<cm_min)this->value=reCast<int>(cm_min);
    … …  
    164144}
    165145/*}}}*/
    166 /*FUNCTION IntInput::GetVectorFromInputs{{{*/
    167 void IntInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){
     146void IntInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){/*{{{*/
    168147
    169148        _error_("not supporte yet!");
    … …  
    171150}
    172151/*}}}*/
    173 /*FUNCTION IntInput::Configure{{{*/
    174 void IntInput::Configure(Parameters* parameters){
     152void IntInput::Configure(Parameters* parameters){/*{{{*/
    175153        /*do nothing: */
    176154}

  • issm/trunk-jpl/src/c/classes/Inputs/PentaInput.cpp

    r18039 r18064  
    1313
    1414/*PentaInput constructors and destructor*/
    15 /*FUNCTION PentaInput::PentaInput(){{{*/
    16 PentaInput::PentaInput(){
     15PentaInput::PentaInput(){/*{{{*/
    1716        values = NULL;
    1817}
    1918/*}}}*/
    20 /*FUNCTION PentaInput::PentaInput(int in_enum_type,IssmDouble* values,int element_type){{{*/
    21 PentaInput::PentaInput(int in_enum_type,IssmDouble* in_values,int element_type_in)
     19PentaInput::PentaInput(int in_enum_type,IssmDouble* in_values,int element_type_in)/*{{{*/
    2220                :PentaRef(1)
    2321{
    … …  
    3533}
    3634/*}}}*/
    37 /*FUNCTION PentaInput::~PentaInput(){{{*/
    38 PentaInput::~PentaInput(){
     35PentaInput::~PentaInput(){/*{{{*/
    3936        xDelete<IssmDouble>(this->values);
    4037}
    … …  
    4239
    4340/*Object virtual functions definitions:*/
    44 /*FUNCTION PentaInput::Echo {{{*/
    45 void PentaInput::Echo(void){
     41void PentaInput::Echo(void){/*{{{*/
    4642        this->DeepEcho();
    4743}
    4844/*}}}*/
    49 /*FUNCTION PentaInput::DeepEcho{{{*/
    50 void PentaInput::DeepEcho(void){
     45void PentaInput::DeepEcho(void){/*{{{*/
    5146
    5247        _printf_(setw(15)<<"   PentaInput "<<setw(25)<<left<<EnumToStringx(this->enum_type)<<" [");
    … …  
    5550}
    5651/*}}}*/
    57 /*FUNCTION PentaInput::Id{{{*/
    58 int    PentaInput::Id(void){ return -1; }
    59 /*}}}*/
    60 /*FUNCTION PentaInput::ObjectEnum{{{*/
    61 int PentaInput::ObjectEnum(void){
     52int    PentaInput::Id(void){ return -1; }/*{{{*/
     53/*}}}*/
     54int PentaInput::ObjectEnum(void){/*{{{*/
    6255
    6356        return PentaInputEnum;
    … …  
    6558}
    6659/*}}}*/
    67 /*FUNCTION PentaInput::copy{{{*/
    68 Object* PentaInput::copy() {
     60Object* PentaInput::copy() {/*{{{*/
    6961
    7062        return new PentaInput(this->enum_type,this->values,this->element_type);
    … …  
    7466
    7567/*PentaInput management*/
    76 /*FUNCTION PentaInput::InstanceEnum{{{*/
    77 int PentaInput::InstanceEnum(void){
     68int PentaInput::InstanceEnum(void){/*{{{*/
    7869
    7970        return this->enum_type;
    … …  
    8172}
    8273/*}}}*/
    83 /*FUNCTION PentaInput::SpawnTriaInput{{{*/
    84 Input* PentaInput::SpawnTriaInput(int index1,int index2,int index3){
     74Input* PentaInput::SpawnTriaInput(int index1,int index2,int index3){/*{{{*/
    8575
    8676        /*output*/
    … …  
    112102}
    113103/*}}}*/
    114 /*FUNCTION PentaInput::SpawnSegInput{{{*/
    115 Input* PentaInput::SpawnSegInput(int index1,int index2){
     104Input* PentaInput::SpawnSegInput(int index1,int index2){/*{{{*/
    116105
    117106        _error_("not supported");
    118107}
    119108/*}}}*/
    120 /*FUNCTION PentaInput::GetResultInterpolation{{{*/
    121 int  PentaInput::GetResultInterpolation(void){
     109int  PentaInput::GetResultInterpolation(void){/*{{{*/
    122110
    123111        if(this->element_type==P0Enum){
    … …  
    128116}
    129117/*}}}*/
    130 /*FUNCTION PentaInput::GetResultNumberOfNodes{{{*/
    131 int  PentaInput::GetResultNumberOfNodes(void){
     118int  PentaInput::GetResultNumberOfNodes(void){/*{{{*/
    132119
    133120        return this->NumberofNodes();;
    … …  
    135122}
    136123/*}}}*/
    137 /*FUNCTION PentaInput::ResultToPatch{{{*/
    138 void PentaInput::ResultToPatch(IssmDouble* values,int nodesperelement,int sid){
     124void PentaInput::ResultToPatch(IssmDouble* values,int nodesperelement,int sid){/*{{{*/
    139125
    140126        int numnodes = this->NumberofNodes();
    … …  
    150136
    151137/*Object functions*/
    152 /*FUNCTION PentaInput::GetInputValue(IssmDouble* pvalue){{{*/
    153 void PentaInput::GetInputValue(IssmDouble* pvalue){
     138void PentaInput::GetInputValue(IssmDouble* pvalue){/*{{{*/
    154139
    155140        if(this->element_type==P0Enum){
    … …  
    159144}
    160145/*}}}*/
    161 /*FUNCTION PentaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
    162 void PentaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
     146void PentaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){/*{{{*/
    163147
    164148        /*Call PentaRef function*/
    … …  
    168152}
    169153/*}}}*/
    170 /*FUNCTION PentaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){{{*/
    171 void PentaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list,Gauss* gauss){
     154void PentaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
    172155
    173156        /*Call PentaRef function*/
    … …  
    176159}
    177160/*}}}*/
    178 /*FUNCTION PentaInput::ChangeEnum{{{*/
    179 void PentaInput::ChangeEnum(int newenumtype){
     161void PentaInput::ChangeEnum(int newenumtype){/*{{{*/
    180162        this->enum_type=newenumtype;
    181163}
    182164/*}}}*/
    183 /*FUNCTION PentaInput::GetInputAverage{{{*/
    184 void PentaInput::GetInputAverage(IssmDouble* pvalue){
     165void PentaInput::GetInputAverage(IssmDouble* pvalue){/*{{{*/
    185166
    186167        int        numnodes  = this->NumberofNodes();
    … …  
    196177
    197178/*Intermediary*/
    198 /*FUNCTION PentaInput::SquareMin{{{*/
    199 void PentaInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
     179void PentaInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){/*{{{*/
    200180
    201181        int        numnodes=this->NumberofNodes();
    … …  
    211191}
    212192/*}}}*/
    213 /*FUNCTION PentaInput::ConstrainMin{{{*/
    214 void PentaInput::ConstrainMin(IssmDouble minimum){
     193void PentaInput::ConstrainMin(IssmDouble minimum){/*{{{*/
    215194
    216195        int numnodes = this->NumberofNodes();
    … …  
    218197}
    219198/*}}}*/
    220 /*FUNCTION PentaInput::InfinityNorm{{{*/
    221 IssmDouble PentaInput::InfinityNorm(void){
     199IssmDouble PentaInput::InfinityNorm(void){/*{{{*/
    222200
    223201        /*Output*/
    … …  
    229207}
    230208/*}}}*/
    231 /*FUNCTION PentaInput::Max{{{*/
    232 IssmDouble PentaInput::Max(void){
     209IssmDouble PentaInput::Max(void){/*{{{*/
    233210
    234211        int  numnodes=this->NumberofNodes();
    … …  
    241218}
    242219/*}}}*/
    243 /*FUNCTION PentaInput::MaxAbs{{{*/
    244 IssmDouble PentaInput::MaxAbs(void){
     220IssmDouble PentaInput::MaxAbs(void){/*{{{*/
    245221
    246222        int  numnodes=this->NumberofNodes();
    … …  
    253229}
    254230/*}}}*/
    255 /*FUNCTION PentaInput::Min{{{*/
    256 IssmDouble PentaInput::Min(void){
     231IssmDouble PentaInput::Min(void){/*{{{*/
    257232
    258233        const int  numnodes=this->NumberofNodes();
    … …  
    265240}
    266241/*}}}*/
    267 /*FUNCTION PentaInput::MinAbs{{{*/
    268 IssmDouble PentaInput::MinAbs(void){
     242IssmDouble PentaInput::MinAbs(void){/*{{{*/
    269243
    270244        const int  numnodes=this->NumberofNodes();
    … …  
    277251}
    278252/*}}}*/
    279 /*FUNCTION PentaInput::Scale{{{*/
    280 void PentaInput::Scale(IssmDouble scale_factor){
     253void PentaInput::Scale(IssmDouble scale_factor){/*{{{*/
    281254
    282255        const int numnodes=this->NumberofNodes();
    … …  
    284257}
    285258/*}}}*/
    286 /*FUNCTION PentaInput::AXPY{{{*/
    287 void PentaInput::AXPY(Input* xinput,IssmDouble scalar){
     259void PentaInput::AXPY(Input* xinput,IssmDouble scalar){/*{{{*/
    288260
    289261        const int numnodes=this->NumberofNodes();
    … …  
    306278}
    307279/*}}}*/
    308 /*FUNCTION PentaInput::Constrain{{{*/
    309 void PentaInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){
     280void PentaInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){/*{{{*/
    310281
    311282        int i;
    … …  
    317288}
    318289/*}}}*/
    319 /*FUNCTION PentaInput::Extrude{{{*/
    320 void PentaInput::Extrude(void){
     290void PentaInput::Extrude(void){/*{{{*/
    321291
    322292        switch(this->element_type){
    … …  
    329299}
    330300/*}}}*/
    331 /*FUNCTION PentaInput::VerticallyIntegrate{{{*/
    332 void PentaInput::VerticallyIntegrate(Input* thickness_input){
     301void PentaInput::VerticallyIntegrate(Input* thickness_input){/*{{{*/
    333302
    334303        IssmDouble thickness;
    … …  
    360329}
    361330/*}}}*/
    362 /*FUNCTION PentaInput::PointwiseDivide{{{*/
    363 Input* PentaInput::PointwiseDivide(Input* inputB){
     331Input* PentaInput::PointwiseDivide(Input* inputB){/*{{{*/
    364332
    365333        /*Ouput*/
    … …  
    393361}
    394362/*}}}*/
    395 /*FUNCTION PentaInput::PointwiseMin{{{*/
    396 Input* PentaInput::PointwiseMin(Input* inputB){
     363Input* PentaInput::PointwiseMin(Input* inputB){/*{{{*/
    397364
    398365        /*Ouput*/
    … …  
    424391}
    425392/*}}}*/
    426 /*FUNCTION PentaInput::PointwiseMax{{{*/
    427 Input* PentaInput::PointwiseMax(Input* inputB){
     393Input* PentaInput::PointwiseMax(Input* inputB){/*{{{*/
    428394
    429395        /*Ouput*/
    … …  
    455421}
    456422/*}}}*/
    457 /*FUNCTION PentaInput::GetVectorFromInputs{{{*/
    458 void PentaInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){
     423void PentaInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){/*{{{*/
    459424        const int numvertices=6;
    460425        vector->SetValues(numvertices,doflist,this->values,INS_VAL);
    461426} /*}}}*/
    462 /*FUNCTION PentaInput::Configure{{{*/
    463 void PentaInput::Configure(Parameters* parameters){
     427void PentaInput::Configure(Parameters* parameters){/*{{{*/
    464428        /*do nothing: */
    465429}

  • issm/trunk-jpl/src/c/classes/Inputs/SegInput.cpp

    r17309 r18064  
    1313
    1414/*SegInput constructors and destructor*/
    15 /*FUNCTION SegInput::SegInput(){{{*/
    16 SegInput::SegInput(){
     15SegInput::SegInput(){/*{{{*/
    1716        values = NULL;
    1817}
    1918/*}}}*/
    20 /*FUNCTION SegInput::SegInput(int in_enum_type,IssmDouble* invalues,element_type_in){{{*/
    21 SegInput::SegInput(int in_enum_type,IssmDouble* in_values,int element_type_in)
     19SegInput::SegInput(int in_enum_type,IssmDouble* in_values,int element_type_in)/*{{{*/
    2220        :SegRef(1)
    2321{
    … …  
    3533}
    3634/*}}}*/
    37 /*FUNCTION SegInput::~SegInput(){{{*/
    38 SegInput::~SegInput(){
     35SegInput::~SegInput(){/*{{{*/
    3936        xDelete<IssmDouble>(this->values);
    4037}
    … …  
    4239
    4340/*Object virtual functions definitions:*/
    44 /*FUNCTION SegInput::Echo {{{*/
    45 void SegInput::Echo(void){
     41void SegInput::Echo(void){/*{{{*/
    4642        this->DeepEcho();
    4743}
    4844/*}}}*/
    49 /*FUNCTION SegInput::DeepEcho{{{*/
    50 void SegInput::DeepEcho(void){
     45void SegInput::DeepEcho(void){/*{{{*/
    5146
    5247        _printf_(setw(15)<<"   SegInput "<<setw(25)<<left<<EnumToStringx(this->enum_type)<<" [");
    … …  
    5550}
    5651/*}}}*/
    57 /*FUNCTION SegInput::Id{{{*/
    58 int    SegInput::Id(void){ return -1; }
     52int    SegInput::Id(void){ return -1; }/*{{{*/
    5953/*}}}*/
    60 /*FUNCTION SegInput::ObjectEnum{{{*/
    61 int SegInput::ObjectEnum(void){
     54int SegInput::ObjectEnum(void){/*{{{*/
    6255
    6356        return SegInputEnum;
    … …  
    6558}
    6659/*}}}*/
    67 /*FUNCTION SegInput::copy{{{*/
    68 Object* SegInput::copy() {
     60Object* SegInput::copy() {/*{{{*/
    6961
    7062        return new SegInput(this->enum_type,this->values,this->element_type);
    … …  
    7466
    7567/*SegInput management*/
    76 /*FUNCTION SegInput::InstanceEnum{{{*/
    77 int SegInput::InstanceEnum(void){
     68int SegInput::InstanceEnum(void){/*{{{*/
    7869
    7970        return this->enum_type;
    … …  
    8374
    8475/*Object functions*/
    85 /*FUNCTION SegInput::GetInputAverage{{{*/
    86 void SegInput::GetInputAverage(IssmDouble* pvalue){
     76void SegInput::GetInputAverage(IssmDouble* pvalue){/*{{{*/
    8777
    8878        int        numnodes  = this->NumberofNodes();
    … …  
    9686}
    9787/*}}}*/
    98 /*FUNCTION SegInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
    99 void SegInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
     88void SegInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){/*{{{*/
    10089
    10190        /*Call SegRef function*/
    … …  
    10594}
    10695/*}}}*/
    107 /*FUNCTION SegInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){{{*/
    108 void SegInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list,Gauss* gauss){
     96void SegInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list,Gauss* gauss){/*{{{*/
    10997
    11098        /*Call SegRef function*/
    … …  
    113101}
    114102/*}}}*/
    115 /*FUNCTION SegInput::Configure{{{*/
    116 void SegInput::Configure(Parameters* parameters){
     103void SegInput::Configure(Parameters* parameters){/*{{{*/
    117104        /*do nothing: */
    118105}
    119106/*}}}*/
    120 /*FUNCTION SegInput::Min{{{*/
    121 IssmDouble SegInput::Min(void){
     107IssmDouble SegInput::Min(void){/*{{{*/
    122108
    123109        const int  numnodes=this->NumberofNodes();

  • issm/trunk-jpl/src/c/classes/Inputs/TetraInput.cpp

    r18039 r18064  
    1313
    1414/*TetraInput constructors and destructor*/
    15 /*FUNCTION TetraInput::TetraInput(){{{*/
    16 TetraInput::TetraInput(){
     15TetraInput::TetraInput(){/*{{{*/
    1716        values = NULL;
    1817}
    1918/*}}}*/
    20 /*FUNCTION TetraInput::TetraInput(int in_enum_type,IssmDouble* invalues,element_type_in){{{*/
    21 TetraInput::TetraInput(int in_enum_type,IssmDouble* in_values,int element_type_in)
     19TetraInput::TetraInput(int in_enum_type,IssmDouble* in_values,int element_type_in)/*{{{*/
    2220        :TetraRef(1)
    2321{
    … …  
    3533}
    3634/*}}}*/
    37 /*FUNCTION TetraInput::~TetraInput(){{{*/
    38 TetraInput::~TetraInput(){
     35TetraInput::~TetraInput(){/*{{{*/
    3936        xDelete<IssmDouble>(this->values);
    4037}
    … …  
    4239
    4340/*Object virtual functions definitions:*/
    44 /*FUNCTION TetraInput::Echo {{{*/
    45 void TetraInput::Echo(void){
     41void TetraInput::Echo(void){/*{{{*/
    4642        this->DeepEcho();
    4743}
    4844/*}}}*/
    49 /*FUNCTION TetraInput::DeepEcho{{{*/
    50 void TetraInput::DeepEcho(void){
     45void TetraInput::DeepEcho(void){/*{{{*/
    5146
    5247        _printf_(setw(15)<<"   TetraInput "<<setw(25)<<left<<EnumToStringx(this->enum_type)<<" [");
    … …  
    5550}
    5651/*}}}*/
    57 /*FUNCTION TetraInput::Id{{{*/
    58 int    TetraInput::Id(void){ return -1; }
    59 /*}}}*/
    60 /*FUNCTION TetraInput::ObjectEnum{{{*/
    61 int TetraInput::ObjectEnum(void){
     52int    TetraInput::Id(void){ return -1; }/*{{{*/
     53/*}}}*/
     54int TetraInput::ObjectEnum(void){/*{{{*/
    6255
    6356        return TetraInputEnum;
    … …  
    6558}
    6659/*}}}*/
    67 /*FUNCTION TetraInput::copy{{{*/
    68 Object* TetraInput::copy() {
     60Object* TetraInput::copy() {/*{{{*/
    6961
    7062        return new TetraInput(this->enum_type,this->values,this->element_type);
    … …  
    7466
    7567/*TetraInput management*/
    76 /*FUNCTION TetraInput::InstanceEnum{{{*/
    77 int TetraInput::InstanceEnum(void){
     68int TetraInput::InstanceEnum(void){/*{{{*/
    7869
    7970        return this->enum_type;
    … …  
    8172}
    8273/*}}}*/
    83 /*FUNCTION TetraInput::GetResultInterpolation{{{*/
    84 int  TetraInput::GetResultInterpolation(void){
     74int  TetraInput::GetResultInterpolation(void){/*{{{*/
    8575
    8676        if(this->element_type==P0Enum){
    … …  
    9181}
    9282/*}}}*/
    93 /*FUNCTION TetraInput::GetResultNumberOfNodes{{{*/
    94 int  TetraInput::GetResultNumberOfNodes(void){
     83int  TetraInput::GetResultNumberOfNodes(void){/*{{{*/
    9584
    9685        return this->NumberofNodes();
    … …  
    9887}
    9988/*}}}*/
    100 /*FUNCTION TetraInput::ResultToPatch{{{*/
    101 void TetraInput::ResultToPatch(IssmDouble* values,int nodesperelement,int sid){
     89void TetraInput::ResultToPatch(IssmDouble* values,int nodesperelement,int sid){/*{{{*/
    10290
    10391        int numnodes = this->NumberofNodes();
    … …  
    113101
    114102/*Object functions*/
    115 /*FUNCTION TetraInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
    116 void TetraInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
     103void TetraInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){/*{{{*/
    117104
    118105        /*Call TetraRef function*/
    … …  
    122109}
    123110/*}}}*/
    124 /*FUNCTION TetraInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){{{*/
    125 void TetraInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){
     111void TetraInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){/*{{{*/
    126112
    127113        /*Call TetraRef function*/
    … …  
    130116}
    131117/*}}}*/
    132 /*FUNCTION TetraInput::ChangeEnum{{{*/
    133 void TetraInput::ChangeEnum(int newenumtype){
     118void TetraInput::ChangeEnum(int newenumtype){/*{{{*/
    134119        this->enum_type=newenumtype;
    135120}
    136121/*}}}*/
    137 /*FUNCTION TetraInput::GetInputAverage{{{*/
    138 void TetraInput::GetInputAverage(IssmDouble* pvalue){
     122void TetraInput::GetInputAverage(IssmDouble* pvalue){/*{{{*/
    139123
    140124        int        numnodes  = this->NumberofNodes();
    … …  
    148132}
    149133/*}}}*/
    150 /*FUNCTION TetraInput::GetInputAllTimeAverages{{{*/
    151 void TetraInput::GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){
     134void TetraInput::GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){/*{{{*/
    152135
    153136        IssmDouble* outvalues=NULL;
    … …  
    168151}
    169152/*}}}*/
    170 /*FUNCTION TetraInput::GetInputUpToCurrentTimeAverages{{{*/
    171 void TetraInput::GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){
     153void TetraInput::GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){/*{{{*/
    172154
    173155        IssmDouble* outvalues=NULL;
    … …  
    188170}
    189171/*}}}*/
    190 /*FUNCTION TetraInput::SpawnTriaInput{{{*/
    191 Input* TetraInput::SpawnTriaInput(int index1,int index2,int index3){
     172Input* TetraInput::SpawnTriaInput(int index1,int index2,int index3){/*{{{*/
    192173
    193174        /*output*/
    … …  
    221202
    222203/*Intermediary*/
    223 /*FUNCTION TetraInput::SquareMin{{{*/
    224 void TetraInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
     204void TetraInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){/*{{{*/
    225205
    226206        int        numnodes=this->NumberofNodes();
    … …  
    236216}
    237217/*}}}*/
    238 /*FUNCTION TetraInput::ContrainMin{{{*/
    239 void TetraInput::ConstrainMin(IssmDouble minimum){
     218void TetraInput::ConstrainMin(IssmDouble minimum){/*{{{*/
    240219
    241220        int numnodes = this->NumberofNodes();
    … …  
    243222}
    244223/*}}}*/
    245 /*FUNCTION TetraInput::InfinityNorm{{{*/
    246 IssmDouble TetraInput::InfinityNorm(void){
     224IssmDouble TetraInput::InfinityNorm(void){/*{{{*/
    247225
    248226        /*Output*/
    … …  
    254232}
    255233/*}}}*/
    256 /*FUNCTION TetraInput::Max{{{*/
    257 IssmDouble TetraInput::Max(void){
     234IssmDouble TetraInput::Max(void){/*{{{*/
    258235
    259236        int  numnodes=this->NumberofNodes();
    … …  
    266243}
    267244/*}}}*/
    268 /*FUNCTION TetraInput::MaxAbs{{{*/
    269 IssmDouble TetraInput::MaxAbs(void){
     245IssmDouble TetraInput::MaxAbs(void){/*{{{*/
    270246
    271247        int  numnodes=this->NumberofNodes();
    … …  
    278254}
    279255/*}}}*/
    280 /*FUNCTION TetraInput::Min{{{*/
    281 IssmDouble TetraInput::Min(void){
     256IssmDouble TetraInput::Min(void){/*{{{*/
    282257
    283258        const int  numnodes=this->NumberofNodes();
    … …  
    290265}
    291266/*}}}*/
    292 /*FUNCTION TetraInput::MinAbs{{{*/
    293 IssmDouble TetraInput::MinAbs(void){
     267IssmDouble TetraInput::MinAbs(void){/*{{{*/
    294268
    295269        const int  numnodes=this->NumberofNodes();
    … …  
    302276}
    303277/*}}}*/
    304 /*FUNCTION TetraInput::Scale{{{*/
    305 void TetraInput::Scale(IssmDouble scale_factor){
     278void TetraInput::Scale(IssmDouble scale_factor){/*{{{*/
    306279
    307280        const int numnodes=this->NumberofNodes();
    … …  
    309282}
    310283/*}}}*/
    311 /*FUNCTION TetraInput::Set{{{*/
    312 void TetraInput::Set(IssmDouble setvalue){
     284void TetraInput::Set(IssmDouble setvalue){/*{{{*/
    313285
    314286        const int numnodes=this->NumberofNodes();
    … …  
    316288}
    317289/*}}}*/
    318 /*FUNCTION TetraInput::AXPY{{{*/
    319 void TetraInput::AXPY(Input* xinput,IssmDouble scalar){
     290void TetraInput::AXPY(Input* xinput,IssmDouble scalar){/*{{{*/
    320291
    321292        const int numnodes=this->NumberofNodes();
    … …  
    332303}
    333304/*}}}*/
    334 /*FUNCTION TetraInput::Constrain{{{*/
    335 void TetraInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){
     305void TetraInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){/*{{{*/
    336306
    337307        int i;
    … …  
    343313}
    344314/*}}}*/
    345 /*FUNCTION TetraInput::GetVectorFromInputs{{{*/
    346 void TetraInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){
     315void TetraInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){/*{{{*/
    347316        const int numvertices=4;
    348317        vector->SetValues(numvertices,doflist,this->values,INS_VAL);
    349318} /*}}}*/
    350 /*FUNCTION TetraInput::PointwiseMin{{{*/
    351 Input* TetraInput::PointwiseMin(Input* inputB){
     319Input* TetraInput::PointwiseMin(Input* inputB){/*{{{*/
    352320
    353321        /*Ouput*/
    … …  
    380348}
    381349/*}}}*/
    382 /*FUNCTION TetraInput::PointwiseMax{{{*/
    383 Input* TetraInput::PointwiseMax(Input* inputB){
     350Input* TetraInput::PointwiseMax(Input* inputB){/*{{{*/
    384351
    385352        /*Ouput*/
    … …  
    412379}
    413380/*}}}*/
    414 /*FUNCTION TetraInput::PointwiseDivide{{{*/
    415 Input* TetraInput::PointwiseDivide(Input* inputB){
     381Input* TetraInput::PointwiseDivide(Input* inputB){/*{{{*/
    416382
    417383        /*Ouput*/
    … …  
    445411}
    446412/*}}}*/
    447 /*FUNCTION TetraInput::Configure{{{*/
    448 void TetraInput::Configure(Parameters* parameters){
     413void TetraInput::Configure(Parameters* parameters){/*{{{*/
    449414        /*do nothing: */
    450415}

  • issm/trunk-jpl/src/c/classes/Inputs/TransientInput.cpp

    r18001 r18064  
    1414
    1515/*TransientInput constructors and destructor*/
    16 /*FUNCTION TransientInput::TransientInput(){{{*/
    17 TransientInput::TransientInput(){
     16TransientInput::TransientInput(){/*{{{*/
    1817
    1918        enum_type=UNDEF;
    … …  
    2524}
    2625/*}}}*/
    27 /*FUNCTION TransientInput::TransientInput(int in_enum_type){{{*/
    28 TransientInput::TransientInput(int in_enum_type)
     26TransientInput::TransientInput(int in_enum_type)/*{{{*/
    2927{
    3028        /*Set Enum*/
    … …  
    3937}
    4038/*}}}*/
    41 /*FUNCTION TransientInput::TransientInput(int in_enum_type,IssmDouble* timesin,int N){{{*/
    42 TransientInput::TransientInput(int in_enum_type,IssmDouble* timesin,int N){
     39TransientInput::TransientInput(int in_enum_type,IssmDouble* timesin,int N){/*{{{*/
    4340
    4441        /*Set Enum*/
    … …  
    5451}
    5552/*}}}*/
    56 /*FUNCTION TransientInput::~TransientInput{{{*/
    57 TransientInput::~TransientInput(){
     53TransientInput::~TransientInput(){/*{{{*/
    5854        xDelete(this->timesteps);
    5955        this->timesteps=NULL;
    … …  
    6662
    6763/*Object virtual functions definitions:*/
    68 /*FUNCTION TransientInput::Echo {{{*/
    69 void TransientInput::Echo(void){
     64void TransientInput::Echo(void){/*{{{*/
    7065        this->DeepEcho();
    7166}
    7267/*}}}*/
    73 /*FUNCTION TransientInput::DeepEcho{{{*/
    74 void TransientInput::DeepEcho(void){
     68void TransientInput::DeepEcho(void){/*{{{*/
    7569
    7670        int i;
    … …  
    8680}
    8781/*}}}*/
    88 /*FUNCTION TransientInput::Id{{{*/
    89 int    TransientInput::Id(void){ return -1; }
    90 /*}}}*/
    91 /*FUNCTION TransientInput::ObjectEnum{{{*/
    92 int TransientInput::ObjectEnum(void){
     82int    TransientInput::Id(void){ return -1; }/*{{{*/
     83/*}}}*/
     84int TransientInput::ObjectEnum(void){/*{{{*/
    9385
    9486        return TransientInputEnum;
    … …  
    9688}
    9789/*}}}*/
    98 /*FUNCTION TransientInput::copy{{{*/
    99 Object* TransientInput::copy() {
     90Object* TransientInput::copy() {/*{{{*/
    10091
    10192        TransientInput* output=NULL;
    … …  
    115106
    116107/*TransientInput management*/
    117 /*FUNCTION TransientInput::InstanceEnum{{{*/
    118 int TransientInput::InstanceEnum(void){
     108int TransientInput::InstanceEnum(void){/*{{{*/
    119109
    120110        return this->enum_type;
    … …  
    122112}
    123113/*}}}*/
    124 /*FUNCTION TransientInput::SpawnTriaInput{{{*/
    125 Input* TransientInput::SpawnTriaInput(int index1,int index2,int index3){
     114Input* TransientInput::SpawnTriaInput(int index1,int index2,int index3){/*{{{*/
    126115
    127116        /*output*/
    … …  
    142131}
    143132/*}}}*/
    144 /*FUNCTION TransientInput::SpawnSegInput{{{*/
    145 Input* TransientInput::SpawnSegInput(int index1,int index2){
     133Input* TransientInput::SpawnSegInput(int index1,int index2){/*{{{*/
    146134
    147135        /*output*/
    … …  
    164152
    165153/*Object functions*/
    166 /*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
    167 void TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
     154void TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){/*{{{*/
    168155        IssmDouble time;
    169156
    … …  
    180167}
    181168/*}}}*/
    182 /*FUNCTION TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){{{*/
    183 void TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){
     169void TransientInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){/*{{{*/
    184170
    185171        /*Retrieve interpolated values for this time step: */
    … …  
    192178}
    193179/*}}}*/
    194 /*FUNCTION TransientInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){{{*/
    195 void TransientInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){
     180void TransientInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){/*{{{*/
    196181
    197182        IssmDouble time;
    … …  
    209194}
    210195/*}}}*/
    211 /*FUNCTION TransientInput::ChangeEnum{{{*/
    212 void TransientInput::ChangeEnum(int newenumtype){
     196void TransientInput::ChangeEnum(int newenumtype){/*{{{*/
    213197        this->enum_type=newenumtype;
    214198}
    215199/*}}}*/
    216 /*FUNCTION TransientInput::GetInputAverage{{{*/
    217 void TransientInput::GetInputAverage(IssmDouble* pvalue){
     200void TransientInput::GetInputAverage(IssmDouble* pvalue){/*{{{*/
    218201
    219202        IssmDouble time;
    … …  
    232215}
    233216/*}}}*/
    234 /*FUNCTION TransientInput::GetInputAllTimeAverages{{{*/
    235 void TransientInput::GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){
     217void TransientInput::GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){/*{{{*/
    236218
    237219        int i;
    … …  
    254236}
    255237/*}}}*/
    256 /*FUNCTION TransientInput::GetInputUpToCurrentTimeAverages{{{*/
    257 void TransientInput::GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){
     238void TransientInput::GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){/*{{{*/
    258239
    259240        int         i;
    … …  
    299280
    300281/*Intermediary*/
    301 /*FUNCTION TransientInput::AddTimeInput{{{*/
    302 void TransientInput::AddTimeInput(Input* input,IssmDouble time){
     282void TransientInput::AddTimeInput(Input* input,IssmDouble time){/*{{{*/
    303283
    304284        /*insert values at time step: */
    … …  
    328308}
    329309/*}}}*/
    330 /*FUNCTION TransientInput::AddTimeInput{{{*/
    331 void TransientInput::AddTimeInput(Input* input){
     310void TransientInput::AddTimeInput(Input* input){/*{{{*/
    332311
    333312        _assert_(this->inputs->Size()<this->numtimesteps);
    … …  
    336315}
    337316/*}}}*/
    338 /*FUNCTION TransientInput::GetResultInterpolation{{{*/
    339 int TransientInput::GetResultInterpolation(void){
     317int TransientInput::GetResultInterpolation(void){/*{{{*/
    340318
    341319        IssmDouble time;
    … …  
    352330}
    353331/*}}}*/
    354 /*FUNCTION TransientInput::GetResultNumberOfNodes{{{*/
    355 int TransientInput::GetResultNumberOfNodes(void){
     332int TransientInput::GetResultNumberOfNodes(void){/*{{{*/
    356333
    357334        IssmDouble time;
    … …  
    368345}
    369346/*}}}*/
    370 /*FUNCTION TransientInput::Extrude{{{*/
    371 void TransientInput::Extrude(void){
     347void TransientInput::Extrude(void){/*{{{*/
    372348
    373349        for(int i=0;i<this->numtimesteps;i++){
    … …  
    376352}
    377353/*}}}*/
    378 /*FUNCTION TransientInput::SquareMin{{{*/
    379 void TransientInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
     354void TransientInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){/*{{{*/
    380355
    381356        IssmDouble time;
    … …  
    394369}
    395370/*}}}*/
    396 /*FUNCTION TransientInput::InfinityNorm{{{*/
    397 IssmDouble TransientInput::InfinityNorm(void){
     371IssmDouble TransientInput::InfinityNorm(void){/*{{{*/
    398372
    399373        IssmDouble time;
    … …  
    414388}
    415389/*}}}*/
    416 /*FUNCTION TransientInput::Max{{{*/
    417 IssmDouble TransientInput::Max(void){
     390IssmDouble TransientInput::Max(void){/*{{{*/
    418391
    419392        IssmDouble time;
    … …  
    434407}
    435408/*}}}*/
    436 /*FUNCTION TransientInput::MaxAbs{{{*/
    437 IssmDouble TransientInput::MaxAbs(void){
     409IssmDouble TransientInput::MaxAbs(void){/*{{{*/
    438410
    439411        IssmDouble time;
    … …  
    455427}
    456428/*}}}*/
    457 /*FUNCTION TransientInput::Min{{{*/
    458 IssmDouble TransientInput::Min(void){
     429IssmDouble TransientInput::Min(void){/*{{{*/
    459430
    460431        IssmDouble time;
    … …  
    476447}
    477448/*}}}*/
    478 /*FUNCTION TransientInput::MinAbs{{{*/
    479 IssmDouble TransientInput::MinAbs(void){
     449IssmDouble TransientInput::MinAbs(void){/*{{{*/
    480450
    481451        IssmDouble time;
    … …  
    496466}
    497467/*}}}*/
    498 /*FUNCTION TransientInput::GetVectorFromInputs{{{*/
    499 void TransientInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){
     468void TransientInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){/*{{{*/
    500469
    501470        IssmDouble time;
    … …  
    513482
    514483} /*}}}*/
    515 /*FUNCTION TransientInput::GetTimeInput{{{*/
    516 Input* TransientInput::GetTimeInput(IssmDouble intime){
     484Input* TransientInput::GetTimeInput(IssmDouble intime){/*{{{*/
    517485
    518486        IssmDouble deltat;
    … …  
    563531}
    564532/*}}}*/
    565 /*FUNCTION TransientInput::Configure{{{*/
    566 void TransientInput::Configure(Parameters* parameters){
     533void TransientInput::Configure(Parameters* parameters){/*{{{*/
    567534        this->parameters=parameters;
    568535}

  • issm/trunk-jpl/src/c/classes/Inputs/TriaInput.cpp

    r18039 r18064  
    1313
    1414/*TriaInput constructors and destructor*/
    15 /*FUNCTION TriaInput::TriaInput(){{{*/
    16 TriaInput::TriaInput(){
     15TriaInput::TriaInput(){/*{{{*/
    1716        values = NULL;
    1817}
    1918/*}}}*/
    20 /*FUNCTION TriaInput::TriaInput(int in_enum_type,IssmDouble* invalues,element_type_in){{{*/
    21 TriaInput::TriaInput(int in_enum_type,IssmDouble* in_values,int element_type_in)
     19TriaInput::TriaInput(int in_enum_type,IssmDouble* in_values,int element_type_in)/*{{{*/
    2220        :TriaRef(1)
    2321{
    … …  
    3533}
    3634/*}}}*/
    37 /*FUNCTION TriaInput::~TriaInput(){{{*/
    38 TriaInput::~TriaInput(){
     35TriaInput::~TriaInput(){/*{{{*/
    3936        xDelete<IssmDouble>(this->values);
    4037}
    … …  
    4239
    4340/*Object virtual functions definitions:*/
    44 /*FUNCTION TriaInput::Echo {{{*/
    45 void TriaInput::Echo(void){
     41void TriaInput::Echo(void){/*{{{*/
    4642        this->DeepEcho();
    4743}
    4844/*}}}*/
    49 /*FUNCTION TriaInput::DeepEcho{{{*/
    50 void TriaInput::DeepEcho(void){
     45void TriaInput::DeepEcho(void){/*{{{*/
    5146
    5247        _printf_(setw(15)<<"   TriaInput "<<setw(25)<<left<<EnumToStringx(this->enum_type)<<" [");
    … …  
    5550}
    5651/*}}}*/
    57 /*FUNCTION TriaInput::Id{{{*/
    58 int    TriaInput::Id(void){ return -1; }
    59 /*}}}*/
    60 /*FUNCTION TriaInput::ObjectEnum{{{*/
    61 int TriaInput::ObjectEnum(void){
     52int    TriaInput::Id(void){ return -1; }/*{{{*/
     53/*}}}*/
     54int TriaInput::ObjectEnum(void){/*{{{*/
    6255
    6356        return TriaInputEnum;
    … …  
    6558}
    6659/*}}}*/
    67 /*FUNCTION TriaInput::copy{{{*/
    68 Object* TriaInput::copy() {
     60Object* TriaInput::copy() {/*{{{*/
    6961
    7062        return new TriaInput(this->enum_type,this->values,this->element_type);
    … …  
    7466
    7567/*TriaInput management*/
    76 /*FUNCTION TriaInput::InstanceEnum{{{*/
    77 int TriaInput::InstanceEnum(void){
     68int TriaInput::InstanceEnum(void){/*{{{*/
    7869
    7970        return this->enum_type;
    … …  
    8172}
    8273/*}}}*/
    83 /*FUNCTION TriaInput::SpawnTriaInput{{{*/
    84 Input* TriaInput::SpawnTriaInput(int index1,int index2,int index3){
     74Input* TriaInput::SpawnTriaInput(int index1,int index2,int index3){/*{{{*/
    8575
    8676        /*output*/
    … …  
    9585}
    9686/*}}}*/
    97 /*FUNCTION TriaInput::SpawnSegInput{{{*/
    98 Input* TriaInput::SpawnSegInput(int index1,int index2){
     87Input* TriaInput::SpawnSegInput(int index1,int index2){/*{{{*/
    9988
    10089        /*output*/
    … …  
    121110}
    122111/*}}}*/
    123 /*FUNCTION TriaInput::GetResultInterpolation{{{*/
    124 int  TriaInput::GetResultInterpolation(void){
     112int  TriaInput::GetResultInterpolation(void){/*{{{*/
    125113
    126114        if(this->element_type==P0Enum){
    … …  
    131119}
    132120/*}}}*/
    133 /*FUNCTION TriaInput::GetResultNumberOfNodes{{{*/
    134 int  TriaInput::GetResultNumberOfNodes(void){
     121int  TriaInput::GetResultNumberOfNodes(void){/*{{{*/
    135122
    136123        return this->NumberofNodes();
    … …  
    138125}
    139126/*}}}*/
    140 /*FUNCTION TriaInput::ResultToPatch{{{*/
    141 void TriaInput::ResultToPatch(IssmDouble* values,int nodesperelement,int sid){
     127void TriaInput::ResultToPatch(IssmDouble* values,int nodesperelement,int sid){/*{{{*/
    142128
    143129        int numnodes = this->NumberofNodes();
    … …  
    153139
    154140/*Object functions*/
    155 /*FUNCTION TriaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){{{*/
    156 void TriaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){
     141void TriaInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){/*{{{*/
    157142
    158143        /*Call TriaRef function*/
    … …  
    162147}
    163148/*}}}*/
    164 /*FUNCTION TriaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){{{*/
    165 void TriaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){
     149void TriaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){/*{{{*/
    166150
    167151        /*Call TriaRef function*/
    … …  
    170154}
    171155/*}}}*/
    172 /*FUNCTION TriaInput::ChangeEnum{{{*/
    173 void TriaInput::ChangeEnum(int newenumtype){
     156void TriaInput::ChangeEnum(int newenumtype){/*{{{*/
    174157        this->enum_type=newenumtype;
    175158}
    176159/*}}}*/
    177 /*FUNCTION TriaInput::GetInputAverage{{{*/
    178 void TriaInput::GetInputAverage(IssmDouble* pvalue){
     160void TriaInput::GetInputAverage(IssmDouble* pvalue){/*{{{*/
    179161
    180162        int        numnodes  = this->NumberofNodes();
    … …  
    188170}
    189171/*}}}*/
    190 /*FUNCTION TriaInput::GetInputAllTimeAverages{{{*/
    191 void TriaInput::GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){
     172void TriaInput::GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){/*{{{*/
    192173
    193174        IssmDouble* outvalues=NULL;
    … …  
    208189}
    209190/*}}}*/
    210 /*FUNCTION TriaInput::GetInputUpToCurrentTimeAverages{{{*/
    211 void TriaInput::GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){
     191void TriaInput::GetInputUpToCurrentTimeAverages(IssmDouble** pvalues, IssmDouble** ptimes, int* pnumtimes, IssmDouble currenttime){/*{{{*/
    212192
    213193        IssmDouble* outvalues=NULL;
    … …  
    230210
    231211/*Intermediary*/
    232 /*FUNCTION TriaInput::SquareMin{{{*/
    233 void TriaInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){
     212void TriaInput::SquareMin(IssmDouble* psquaremin,Parameters* parameters){/*{{{*/
    234213
    235214        int        numnodes=this->NumberofNodes();
    … …  
    245224}
    246225/*}}}*/
    247 /*FUNCTION TriaInput::ContrainMin{{{*/
    248 void TriaInput::ConstrainMin(IssmDouble minimum){
     226void TriaInput::ConstrainMin(IssmDouble minimum){/*{{{*/
    249227
    250228        int numnodes = this->NumberofNodes();
    … …  
    252230}
    253231/*}}}*/
    254 /*FUNCTION TriaInput::InfinityNorm{{{*/
    255 IssmDouble TriaInput::InfinityNorm(void){
     232IssmDouble TriaInput::InfinityNorm(void){/*{{{*/
    256233
    257234        /*Output*/
    … …  
    263240}
    264241/*}}}*/
    265 /*FUNCTION TriaInput::Max{{{*/
    266 IssmDouble TriaInput::Max(void){
     242IssmDouble TriaInput::Max(void){/*{{{*/
    267243
    268244        int  numnodes=this->NumberofNodes();
    … …  
    275251}
    276252/*}}}*/
    277 /*FUNCTION TriaInput::MaxAbs{{{*/
    278 IssmDouble TriaInput::MaxAbs(void){
     253IssmDouble TriaInput::MaxAbs(void){/*{{{*/
    279254
    280255        int  numnodes=this->NumberofNodes();
    … …  
    287262}
    288263/*}}}*/
    289 /*FUNCTION TriaInput::Min{{{*/
    290 IssmDouble TriaInput::Min(void){
     264IssmDouble TriaInput::Min(void){/*{{{*/
    291265
    292266        const int  numnodes=this->NumberofNodes();
    … …  
    299273}
    300274/*}}}*/
    301 /*FUNCTION TriaInput::MinAbs{{{*/
    302 IssmDouble TriaInput::MinAbs(void){
     275IssmDouble TriaInput::MinAbs(void){/*{{{*/
    303276
    304277        const int  numnodes=this->NumberofNodes();
    … …  
    311284}
    312285/*}}}*/
    313 /*FUNCTION TriaInput::Scale{{{*/
    314 void TriaInput::Scale(IssmDouble scale_factor){
     286void TriaInput::Scale(IssmDouble scale_factor){/*{{{*/
    315287
    316288        const int numnodes=this->NumberofNodes();
    … …  
    318290}
    319291/*}}}*/
    320 /*FUNCTION TriaInput::Set{{{*/
    321 void TriaInput::Set(IssmDouble setvalue){
     292void TriaInput::Set(IssmDouble setvalue){/*{{{*/
    322293
    323294        const int numnodes=this->NumberofNodes();
    … …  
    325296}
    326297/*}}}*/
    327 /*FUNCTION TriaInput::AXPY{{{*/
    328 void TriaInput::AXPY(Input* xinput,IssmDouble scalar){
     298void TriaInput::AXPY(Input* xinput,IssmDouble scalar){/*{{{*/
    329299
    330300        const int numnodes=this->NumberofNodes();
    … …  
    341311}
    342312/*}}}*/
    343 /*FUNCTION TriaInput::Constrain{{{*/
    344 void TriaInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){
     313void TriaInput::Constrain(IssmDouble cm_min, IssmDouble cm_max){/*{{{*/
    345314
    346315        int i;
    … …  
    352321}
    353322/*}}}*/
    354 /*FUNCTION TriaInput::GetVectorFromInputs{{{*/
    355 void TriaInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){
     323void TriaInput::GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){/*{{{*/
    356324        const int numvertices=3;
    357325        vector->SetValues(numvertices,doflist,this->values,INS_VAL);
    358326} /*}}}*/
    359 /*FUNCTION TriaInput::PointwiseMin{{{*/
    360 Input* TriaInput::PointwiseMin(Input* inputB){
     327Input* TriaInput::PointwiseMin(Input* inputB){/*{{{*/
    361328
    362329        /*Ouput*/
    … …  
    389356}
    390357/*}}}*/
    391 /*FUNCTION TriaInput::PointwiseMax{{{*/
    392 Input* TriaInput::PointwiseMax(Input* inputB){
     358Input* TriaInput::PointwiseMax(Input* inputB){/*{{{*/
    393359
    394360        /*Ouput*/
    … …  
    421387}
    422388/*}}}*/
    423 /*FUNCTION TriaInput::PointwiseDivide{{{*/
    424 Input* TriaInput::PointwiseDivide(Input* inputB){
     389Input* TriaInput::PointwiseDivide(Input* inputB){/*{{{*/
    425390
    426391        /*Ouput*/
    … …  
    454419}
    455420/*}}}*/
    456 /*FUNCTION TriaInput::Configure{{{*/
    457 void TriaInput::Configure(Parameters* parameters){
     421void TriaInput::Configure(Parameters* parameters){/*{{{*/
    458422        /*do nothing: */
    459423}

  • issm/trunk-jpl/src/c/classes/IoModel.cpp

    r17924 r18064  
    1919#include "../shared/shared.h"
    2020
    21 /*FUNCTION IoModel::IoModel(){{{*/
    22 IoModel::IoModel(){
     21IoModel::IoModel(){/*{{{*/
    2322        this->fid=NULL;
    2423        this->data=NULL;
    … …  
    5150}
    5251/*}}}*/
    53 /*FUNCTION IoModel::IoModel(FILE*  iomodel_handle){{{*/
    54 IoModel::IoModel(FILE* iomodel_handle){
     52IoModel::IoModel(FILE* iomodel_handle){/*{{{*/
    5553
    5654        /*First, keep track of the file handle: */
    … …  
    9795}
    9896/*}}}*/
    99 /*FUNCTION IoModel::~IoModel(){{{*/
    100 IoModel::~IoModel(){
     97IoModel::~IoModel(){/*{{{*/
    10198
    10299        /*Delete independents*/
    … …  
    140137/*}}}*/
    141138
    142 /*FUNCTION IoModel::CheckEnumSync{{{*/
    143 void  IoModel::CheckEnumSync(void){
     139void  IoModel::CheckEnumSync(void){/*{{{*/
    144140
    145141        int record_enum,record_length;
    … …  
    226222}
    227223/*}}}*/
    228 /*FUNCTION IoModel::Constant(bool* poutput,int constant_enum){{{*/
    229 void IoModel::Constant(bool* poutput,int constant_enum){
     224void IoModel::Constant(bool* poutput,int constant_enum){/*{{{*/
    230225
    231226        _assert_(constant_enum>=0);
    … …  
    235230}
    236231/*}}}*/
    237 /*FUNCTION IoModel::Constant(int* poutput,int constant_enum){{{*/
    238 void IoModel::Constant(int* poutput,int constant_enum){
     232void IoModel::Constant(int* poutput,int constant_enum){/*{{{*/
    239233
    240234        _assert_(constant_enum>=0);
    … …  
    244238}
    245239/*}}}*/
    246 /*FUNCTION IoModel::Constant(IssmDouble* poutput,int constant_enum){{{*/
    247 void IoModel::Constant(IssmDouble* poutput,int constant_enum){
     240void IoModel::Constant(IssmDouble* poutput,int constant_enum){/*{{{*/
    248241
    249242        _assert_(constant_enum>=0);
    … …  
    253246}
    254247/*}}}*/
    255 /*FUNCTION IoModel::Constant(char** poutput,int constant_enum){{{*/
    256 void IoModel::Constant(char** poutput,int constant_enum){
     248void IoModel::Constant(char** poutput,int constant_enum){/*{{{*/
    257249
    258250        _assert_(constant_enum>=0);
    … …  
    262254}
    263255/*}}}*/
    264 /*FUNCTION IoModel::CopyConstantObject{{{*/
    265 Param* IoModel::CopyConstantObject(int constant_enum){
     256Param* IoModel::CopyConstantObject(int constant_enum){/*{{{*/
    266257
    267258        _assert_(this->constants);
    … …  
    274265}
    275266/*}}}*/
    276 /*FUNCTION IoModel::Data{{{*/
    277 IssmDouble* IoModel::Data(int data_enum){
     267IssmDouble* IoModel::Data(int data_enum){/*{{{*/
    278268
    279269        _assert_(data_enum<MaximumNumberOfDefinitionsEnum);
    … …  
    283273}
    284274/*}}}*/
    285 /*FUNCTION IoModel::StartTrace{{{*/
    286 void IoModel::StartTrace(void){
     275void IoModel::StartTrace(void){/*{{{*/
    287276
    288277        bool autodiff = false;
    … …  
    322311}
    323312/*}}}*/
    324 /*FUNCTION IoModel::DeclareIndependents{{{*/
    325 void IoModel::DeclareIndependents(void){
     313void IoModel::DeclareIndependents(void){/*{{{*/
    326314
    327315        int  i;
    … …  
    374362}
    375363/*}}}*/
    376 /*FUNCTION IoModel::DeleteData(int num,...){{{*/
    377 void  IoModel::DeleteData(int num,...){
     364void  IoModel::DeleteData(int num,...){/*{{{*/
    378365
    379366        va_list ap;
    … …  
    391378        va_end(ap);
    392379} /*}}}*/
    393 /*FUNCTION IoModel::DeleteData(IssmDouble* {{{*/
    394 void  IoModel::DeleteData(IssmDouble* vector, int dataenum){
     380void  IoModel::DeleteData(IssmDouble* vector, int dataenum){/*{{{*/
    395381
    396382        /*do not erase independent variables for the AD mode computations!: */
    … …  
    398384
    399385} /*}}}*/
    400 /*FUNCTION IoModel::DeleteData(char*** pstringarray, int numstrings, int dataenum) {{{*/
    401 void  IoModel::DeleteData(char*** pstringarray, int numstrings, int dataenum){
     386void  IoModel::DeleteData(char*** pstringarray, int numstrings, int dataenum){/*{{{*/
    402387
    403388        int i;
    … …  
    413398        *pstringarray=NULL;
    414399} /*}}}*/
    415 /*FUNCTION IoModel::FetchConstants{{{*/
    416 void  IoModel::FetchConstants(void){
     400void  IoModel::FetchConstants(void){/*{{{*/
    417401
    418402        int my_rank;
    … …  
    637621}
    638622/*}}}*/
    639 /*FUNCTION IoModel::FetchData(bool*         pbool,int data_enum){{{*/
    640 void  IoModel::FetchData(bool* pboolean,int data_enum){
     623void  IoModel::FetchData(bool* pboolean,int data_enum){/*{{{*/
    641624
    642625        int my_rank;
    … …  
    666649}
    667650/*}}}*/
    668 /*FUNCTION IoModel::FetchData(int*          pinteger,int data_enum){{{*/
    669 void  IoModel::FetchData(int* pinteger,int data_enum){
     651void  IoModel::FetchData(int* pinteger,int data_enum){/*{{{*/
    670652
    671653        int my_rank;
    … …  
    694676}
    695677/*}}}*/
    696 /*FUNCTION IoModel::FetchData(IssmDouble*   pscalar,int data_enum){{{*/
    697 void  IoModel::FetchData(IssmDouble* pscalar,int data_enum){
     678void  IoModel::FetchData(IssmDouble* pscalar,int data_enum){/*{{{*/
    698679
    699680        int my_rank;
    … …  
    722703}
    723704/*}}}*/
    724 /*FUNCTION IoModel::FetchData(char**        pstring,int data_enum){{{*/
    725 void  IoModel::FetchData(char** pstring,int data_enum){
     705void  IoModel::FetchData(char** pstring,int data_enum){/*{{{*/
    726706
    727707        int my_rank;
    … …  
    769749}
    770750/*}}}*/
    771 /*FUNCTION IoModel::FetchData(int**         pintegerematrix,int* pM,int* pN,int data_enum){{{*/
    772 void  IoModel::FetchData(int** pmatrix,int* pM,int* pN,int data_enum){
     751void  IoModel::FetchData(int** pmatrix,int* pM,int* pN,int data_enum){/*{{{*/
    773752
    774753        int my_rank;
    … …  
    838817}
    839818/*}}}*/
    840 /*FUNCTION IoModel::FetchData(IssmDouble**  pIssmDoublematrix,int* pM,int* pN,int data_enum){{{*/
    841 void  IoModel::FetchData(IssmDouble** pmatrix,int* pM,int* pN,int data_enum){
     819void  IoModel::FetchData(IssmDouble** pmatrix,int* pM,int* pN,int data_enum){/*{{{*/
    842820
    843821        int my_rank;
    … …  
    898876}
    899877/*}}}*/
    900 /*FUNCTION IoModel::FetchData(char***       pstrings,int* pnumstrings,int data_enum){{{*/
    901 void  IoModel::FetchData(char*** pstrings,int* pnumstrings,int data_enum){
     878void  IoModel::FetchData(char*** pstrings,int* pnumstrings,int data_enum){/*{{{*/
    902879
    903880        int my_rank;
    … …  
    964941}
    965942/*}}}*/
    966 /*FUNCTION IoModel::FetchData(IssmDouble*** pmatrices,int** pmdims,int** pndims, int* pM,int data_enum){{{*/
    967 void  IoModel::FetchData(IssmDouble*** pmatrices,int** pmdims,int** pndims, int* pnumrecords,int data_enum){
     943void  IoModel::FetchData(IssmDouble*** pmatrices,int** pmdims,int** pndims, int* pnumrecords,int data_enum){/*{{{*/
    968944
    969945        int i;
    … …  
    10501026}
    10511027/*}}}*/
    1052 /*FUNCTION IoModel::FetchData(Option**  poption,int data_enum){{{*/
    1053 void  IoModel::FetchData(Option** poption,int index){
     1028void  IoModel::FetchData(Option** poption,int index){/*{{{*/
    10541029
    10551030        /*output: */
    … …  
    10961071}
    10971072/*}}}*/
    1098 /*FUNCTION IoModel::FetchData(int num,...){{{*/
    1099 void  IoModel::FetchData(int num,...){
     1073void  IoModel::FetchData(int num,...){/*{{{*/
    11001074
    11011075        va_list     ap;
    … …  
    11381112}
    11391113/*}}}*/
    1140 /*FUNCTION IoModel::FetchMultipleData(char***       pstrings,int* pnumstrings,int data_enum){{{*/
    1141 void  IoModel::FetchMultipleData(char*** pstrings,int* pnumstrings,int data_enum){
     1114void  IoModel::FetchMultipleData(char*** pstrings,int* pnumstrings,int data_enum){/*{{{*/
    11421115
    11431116        int  num_instances;
    … …  
    12031176}
    12041177/*}}}*/
    1205 /*FUNCTION IoModel::FetchMultipleData(int** pvector, int* pM,int data_enum){{{*/
    1206 void  IoModel::FetchMultipleData(int** pvector, int* pnum_instances,int data_enum){
     1178void  IoModel::FetchMultipleData(int** pvector, int* pnum_instances,int data_enum){/*{{{*/
    12071179
    12081180        int     num_instances;
    … …  
    12571229}
    12581230/*}}}*/
    1259 /*FUNCTION IoModel::FetchMultipleData(IssmDouble*** pmatrices,int** pmdims,int** pndims, int* pM,int data_enum){{{*/
    1260 void  IoModel::FetchMultipleData(IssmDouble*** pmatrices,int** pmdims,int** pndims, int* pnumrecords,int data_enum){
     1231void  IoModel::FetchMultipleData(IssmDouble*** pmatrices,int** pmdims,int** pndims, int* pnumrecords,int data_enum){/*{{{*/
    12611232
    12621233        int     num_instances;
    … …  
    13621333}
    13631334/*}}}*/
    1364 /*FUNCTION IoModel::FetchMultipleData(int*** pmatrices,int** pmdims,int** pndims, int* pM,int data_enum){{{*/
    1365 void  IoModel::FetchMultipleData(int*** pmatrices,int** pmdims,int** pndims, int* pnumrecords,int data_enum){
     1335void  IoModel::FetchMultipleData(int*** pmatrices,int** pmdims,int** pndims, int* pnumrecords,int data_enum){/*{{{*/
    13661336
    13671337        int     num_instances;
    … …  
    14691439}
    14701440/*}}}*/
    1471 /*FUNCTION IoModel::FetchDataToInput(Elements* elements,int vector_enum,IssmDouble default_value){{{*/
    1472 void IoModel::FetchDataToInput(Elements* elements,int vector_enum,IssmDouble default_value){
     1441void IoModel::FetchDataToInput(Elements* elements,int vector_enum,IssmDouble default_value){/*{{{*/
    14731442
    14741443        /*intermediary: */
    … …  
    14951464}
    14961465/*}}}*/
    1497 /*FUNCTION IoModel::FetchDataToInput(Elements* elements,int vector_enum){{{*/
    1498 void IoModel::FetchDataToInput(Elements* elements,int vector_enum){
     1466void IoModel::FetchDataToInput(Elements* elements,int vector_enum){/*{{{*/
    14991467
    15001468        /*intermediary: */
    … …  
    15681536}
    15691537/*}}}*/
    1570 /*FUNCTION IoModel::LastIndex{{{*/
    1571 void IoModel::LastIndex(int *pindex){
     1538void IoModel::LastIndex(int *pindex){/*{{{*/
    15721539
    15731540        int my_rank;
    … …  
    16691636}
    16701637/*}}}*/
    1671 /*FUNCTION IoModel::SetFilePointersToData{{{*/
    1672 fpos_t* IoModel::SetFilePointersToData(int** pcodes,int** pvector_types, int* pnum_instances, int data_enum){
     1638fpos_t* IoModel::SetFilePointersToData(int** pcodes,int** pvector_types, int* pnum_instances, int data_enum){/*{{{*/
    16731639
    16741640        int     found          = 0;

  • issm/trunk-jpl/src/c/classes/Loads/Friction.cpp

    r17952 r18064  
    1616
    1717/*Constructors/destructors*/
    18 /*FUNCTION Friction::Friction() {{{*/
    19 Friction::Friction(){
     18Friction::Friction(){/*{{{*/
    2019        this->element=NULL;
    2120        this->dim=0;
    … …  
    2423}
    2524/*}}}*/
    26 /*FUNCTION Friction::Friction(Element* element,int dim){{{*/
    27 Friction::Friction(Element* element_in,int dim_in){
     25Friction::Friction(Element* element_in,int dim_in){/*{{{*/
    2826
    2927        this->element=element_in;
    … …  
    3230}
    3331/*}}}*/
    34 /*FUNCTION Friction::~Friction() {{{*/
    35 Friction::~Friction(){
     32Friction::~Friction(){/*{{{*/
    3633}
    3734/*}}}*/
    3835
    3936/*methods: */
    40 /*FUNCTION Friction::Echo {{{*/
    41 void Friction::Echo(void){
     37void Friction::Echo(void){/*{{{*/
    4238        _printf_("Friction:\n");
    4339        _printf_("   dim: " << this->dim<< "\n");
    4440}
    4541/*}}}*/
    46 /*FUNCTION Friction::GetAlpha2{{{*/
    47 void Friction::GetAlpha2(IssmDouble* palpha2, Gauss* gauss){
     42void Friction::GetAlpha2(IssmDouble* palpha2, Gauss* gauss){/*{{{*/
    4843
    4944        switch(this->law){
    … …  
    5954
    6055}/*}}}*/
    61 /*FUNCTION Friction::GetAlpha2{{{*/
    62 void Friction::GetAlpha2Viscous(IssmDouble* palpha2, Gauss* gauss){
     56void Friction::GetAlpha2Viscous(IssmDouble* palpha2, Gauss* gauss){/*{{{*/
    6357
    6458        /*This routine calculates the basal friction coefficient
    … …  
    120114        *palpha2=alpha2;
    121115}/*}}}*/
    122 /*FUNCTION Friction::GetAlpha2Weertman{{{*/
    123 void Friction::GetAlpha2Weertman(IssmDouble* palpha2, Gauss* gauss){
     116void Friction::GetAlpha2Weertman(IssmDouble* palpha2, Gauss* gauss){/*{{{*/
    124117
    125118        /*This routine calculates the basal friction coefficient alpha2= C^-1/m |v|^(1/m-1) */
    … …  
    162155        *palpha2=alpha2;
    163156}/*}}}*/
    164 /*FUNCTION Friction::GetAlphaComplement(IssmDouble* palpha_complement, Gauss* gauss,int vxenum,int vyenum,int vzenum) {{{*/
    165 void Friction::GetAlphaComplement(IssmDouble* palpha_complement, Gauss* gauss){
     157void Friction::GetAlphaComplement(IssmDouble* palpha_complement, Gauss* gauss){/*{{{*/
    166158
    167159        /* FrictionGetAlpha2 computes alpha2= drag^2 * Neff ^r * vel ^s, with Neff=rho_ice*g*thickness+rho_ice*g*bed, r=q/p and s=1/p.

  • issm/trunk-jpl/src/c/classes/Loads/Loads.cpp

    r15838 r18064  
    2323
    2424/*Object constructors and destructor*/
    25 /*FUNCTION Loads::Loads(){{{*/
    26 Loads::Loads(){
     25Loads::Loads(){/*{{{*/
    2726        enum_type=LoadsEnum;
    2827        return;
    2928}
    3029/*}}}*/
    31 /*FUNCTION Loads::~Loads(){{{*/
    32 Loads::~Loads(){
     30Loads::~Loads(){/*{{{*/
    3331        return;
    3432}
    … …  
    3634
    3735/*Numerics:*/
    38 /*FUNCTION Loads::Configure{{{*/
    39 void Loads::Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters){
     36void Loads::Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters){/*{{{*/
    4037
    4138        vector<Object*>::iterator object;
    … …  
    5148}
    5249/*}}}*/
    53 /*FUNCTION Loads::IsPenalty{{{*/
    54 bool Loads::IsPenalty(int analysis_type){
     50bool Loads::IsPenalty(int analysis_type){/*{{{*/
    5551
    5652        int ispenalty=0;
    … …  
    7672}
    7773/*}}}*/
    78 /*FUNCTION Loads::MaxNumNodes{{{*/
    79 int Loads::MaxNumNodes(int analysis_type){
     74int Loads::MaxNumNodes(int analysis_type){/*{{{*/
    8075
    8176        int max=0;
    … …  
    10095}
    10196/*}}}*/
    102 /*FUNCTION Loads::NumberOfLoads(){{{*/
    103 int Loads::NumberOfLoads(void){
     97int Loads::NumberOfLoads(void){/*{{{*/
    10498
    10599        int localloads;
    … …  
    116110}
    117111/*}}}*/
    118 /*FUNCTION Loads::NumberOfLoads(int analysis){{{*/
    119 int Loads::NumberOfLoads(int analysis_type){
     112int Loads::NumberOfLoads(int analysis_type){/*{{{*/
    120113
    121114        int localloads = 0;
    … …  
    138131}
    139132/*}}}*/
    140 /*FUNCTION Loads::Size(){{{*/
    141 int Loads::Size(void){
     133int Loads::Size(void){/*{{{*/
    142134
    143135        return this->DataSet::Size();
    144136}
    145137/*}}}*/
    146 /*FUNCTION Loads::Size(int analysis){{{*/
    147 int Loads::Size(int analysis_type){
     138int Loads::Size(int analysis_type){/*{{{*/
    148139
    149140        int localloads = 0;
    … …  
    161152}
    162153/*}}}*/
    163 /*FUNCTION Loads::SetCurrentConfiguration{{{*/
    164 void Loads::SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters){
     154void Loads::SetCurrentConfiguration(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters){/*{{{*/
    165155
    166156        vector<Object*>::iterator object;

  • issm/trunk-jpl/src/c/classes/Loads/Numericalflux.cpp

    r17266 r18064  
    2121
    2222/*Numericalflux constructors and destructor*/
    23 /*FUNCTION Numericalflux::Numericalflux(){{{*/
    24 Numericalflux::Numericalflux(){
     23Numericalflux::Numericalflux(){/*{{{*/
    2524        this->parameters = NULL;
    2625        this->helement   = NULL;
    … …  
    3130}
    3231/*}}}*/
    33 /*FUNCTION Numericalflux::Numericalflux(int id, int i, IoModel* iomodel, int analysis_type) {{{*/
    34 Numericalflux::Numericalflux(int numericalflux_id,int i,int index,IoModel* iomodel, int in_analysis_type){
     32Numericalflux::Numericalflux(int numericalflux_id,int i,int index,IoModel* iomodel, int in_analysis_type){/*{{{*/
    3533
    3634        /* Intermediary */
    … …  
    124122}
    125123/*}}}*/
    126 /*FUNCTION Numericalflux::~Numericalflux(){{{*/
    127 Numericalflux::~Numericalflux(){
     124Numericalflux::~Numericalflux(){/*{{{*/
    128125        this->parameters=NULL;
    129126        delete helement;
    … …  
    134131
    135132/*Object virtual functions definitions:*/
    136 /*FUNCTION Numericalflux::Echo {{{*/
    137 void Numericalflux::Echo(void){
     133void Numericalflux::Echo(void){/*{{{*/
    138134        _printf_("Numericalflux:\n");
    139135        _printf_("   id: " << id << "\n");
    … …  
    146142}
    147143/*}}}*/
    148 /*FUNCTION Numericalflux::DeepEcho {{{*/
    149 void Numericalflux::DeepEcho(void){
     144void Numericalflux::DeepEcho(void){/*{{{*/
    150145
    151146        _printf_("Numericalflux:\n");
    … …  
    163158}               
    164159/*}}}*/
    165 /*FUNCTION Numericalflux::Id {{{*/
    166 int    Numericalflux::Id(void){
     160int    Numericalflux::Id(void){/*{{{*/
    167161        return id;
    168162}
    169163/*}}}*/
    170 /*FUNCTION Numericalflux::ObjectEnum{{{*/
    171 int Numericalflux::ObjectEnum(void){
     164int Numericalflux::ObjectEnum(void){/*{{{*/
    172165
    173166        return NumericalfluxEnum;
    … …  
    175168}
    176169/*}}}*/
    177 /*FUNCTION Numericalflux::copy {{{*/
    178 Object* Numericalflux::copy() {
     170Object* Numericalflux::copy() {/*{{{*/
    179171
    180172        Numericalflux* numericalflux=NULL;
    … …  
    205197
    206198/*Load virtual functions definitions:*/
    207 /*FUNCTION Numericalflux::Configure {{{*/
    208 void  Numericalflux::Configure(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){
     199void  Numericalflux::Configure(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
    209200
    210201        /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective
    … …  
    223214}
    224215/*}}}*/
    225 /*FUNCTION Numericalflux::SetCurrentConfiguration {{{*/
    226 void  Numericalflux::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){
    227 
    228 }
    229 /*}}}*/
    230 /*FUNCTION Numericalflux::CreateKMatrix {{{*/
    231 void  Numericalflux::CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){
     216void  Numericalflux::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
     217
     218}
     219/*}}}*/
     220void  Numericalflux::CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){/*{{{*/
    232221
    233222        /*recover some parameters*/
    … …  
    259248}
    260249/*}}}*/
    261 /*FUNCTION Numericalflux::CreatePVector {{{*/
    262 void  Numericalflux::CreatePVector(Vector<IssmDouble>* pf){
     250void  Numericalflux::CreatePVector(Vector<IssmDouble>* pf){/*{{{*/
    263251
    264252        /*recover some parameters*/
    … …  
    289277}
    290278/*}}}*/
    291 /*FUNCTION Numericalflux::GetNodesSidList{{{*/
    292 void Numericalflux::GetNodesSidList(int* sidlist){
     279void Numericalflux::GetNodesSidList(int* sidlist){/*{{{*/
    293280
    294281        _assert_(sidlist);
    … …  
    307294}
    308295/*}}}*/
    309 /*FUNCTION Numericalflux::GetNodesLidList{{{*/
    310 void Numericalflux::GetNodesLidList(int* lidlist){
     296void Numericalflux::GetNodesLidList(int* lidlist){/*{{{*/
    311297
    312298        _assert_(lidlist);
    … …  
    325311}
    326312/*}}}*/
    327 /*FUNCTION Numericalflux::GetNumberOfNodes{{{*/
    328 int Numericalflux::GetNumberOfNodes(void){
     313int Numericalflux::GetNumberOfNodes(void){/*{{{*/
    329314
    330315        switch(this->flux_type){
    … …  
    339324}
    340325/*}}}*/
    341 /*FUNCTION Numericalflux::IsPenalty{{{*/
    342 bool Numericalflux::IsPenalty(void){
     326bool Numericalflux::IsPenalty(void){/*{{{*/
    343327        return false;
    344328}
    345329/*}}}*/
    346 /*FUNCTION Numericalflux::PenaltyCreateKMatrix {{{*/
    347 void  Numericalflux::PenaltyCreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs,IssmDouble kmax){
     330void  Numericalflux::PenaltyCreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs,IssmDouble kmax){/*{{{*/
    348331
    349332        /*No stiffness loads applied, do nothing: */
    … …  
    352335}
    353336/*}}}*/
    354 /*FUNCTION Numericalflux::PenaltyCreatePVector{{{*/
    355 void  Numericalflux::PenaltyCreatePVector(Vector<IssmDouble>* pf,IssmDouble kmax){
     337void  Numericalflux::PenaltyCreatePVector(Vector<IssmDouble>* pf,IssmDouble kmax){/*{{{*/
    356338
    357339        /*No penalty loads applied, do nothing: */
    … …  
    360342}
    361343/*}}}*/
    362 /*FUNCTION Numericalflux::InAnalysis{{{*/
    363 bool Numericalflux::InAnalysis(int in_analysis_type){
     344bool Numericalflux::InAnalysis(int in_analysis_type){/*{{{*/
    364345        if (in_analysis_type==this->analysis_type) return true;
    365346        else return false;
    366347}
    367348/*}}}*/
    368 /*FUNCTION Numericalflux::SetwiseNodeConnectivity{{{*/
    369 void Numericalflux::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum){
     349void Numericalflux::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum){/*{{{*/
    370350
    371351        /*Output */
    … …  
    423403
    424404/*Numericalflux management*/
    425 /*FUNCTION Numericalflux::CreateKMatrixMasstransport{{{*/
    426 ElementMatrix* Numericalflux::CreateKMatrixMasstransport(void){
     405ElementMatrix* Numericalflux::CreateKMatrixMasstransport(void){/*{{{*/
    427406
    428407        switch(this->flux_type){
    … …  
    436415}
    437416/*}}}*/
    438 /*FUNCTION Numericalflux::CreateKMatrixMasstransportInternal {{{*/
    439 ElementMatrix* Numericalflux::CreateKMatrixMasstransportInternal(void){
     417ElementMatrix* Numericalflux::CreateKMatrixMasstransportInternal(void){/*{{{*/
    440418
    441419        /* constants*/
    … …  
    501479}
    502480/*}}}*/
    503 /*FUNCTION Numericalflux::CreateKMatrixMasstransportBoundary {{{*/
    504 ElementMatrix* Numericalflux::CreateKMatrixMasstransportBoundary(void){
     481ElementMatrix* Numericalflux::CreateKMatrixMasstransportBoundary(void){/*{{{*/
    505482
    506483        /* constants*/
    … …  
    573550}
    574551/*}}}*/
    575 /*FUNCTION Numericalflux::CreateKMatrixBalancethickness{{{*/
    576 ElementMatrix* Numericalflux::CreateKMatrixBalancethickness(void){
     552ElementMatrix* Numericalflux::CreateKMatrixBalancethickness(void){/*{{{*/
    577553
    578554        switch(this->flux_type){
    … …  
    586562}
    587563/*}}}*/
    588 /*FUNCTION Numericalflux::CreateKMatrixBalancethicknessInternal {{{*/
    589 ElementMatrix* Numericalflux::CreateKMatrixBalancethicknessInternal(void){
     564ElementMatrix* Numericalflux::CreateKMatrixBalancethicknessInternal(void){/*{{{*/
    590565
    591566        /* constants*/
    … …  
    650625}
    651626/*}}}*/
    652 /*FUNCTION Numericalflux::CreateKMatrixBalancethicknessBoundary {{{*/
    653 ElementMatrix* Numericalflux::CreateKMatrixBalancethicknessBoundary(void){
     627ElementMatrix* Numericalflux::CreateKMatrixBalancethicknessBoundary(void){/*{{{*/
    654628
    655629        /* constants*/
    … …  
    721695}
    722696/*}}}*/
    723 /*FUNCTION Numericalflux::CreateKMatrixAdjointBalancethickness{{{*/
    724 ElementMatrix* Numericalflux::CreateKMatrixAdjointBalancethickness(void){
     697ElementMatrix* Numericalflux::CreateKMatrixAdjointBalancethickness(void){/*{{{*/
    725698
    726699        switch(this->flux_type){
    … …  
    734707}
    735708/*}}}*/
    736 /*FUNCTION Numericalflux::CreateKMatrixAdjointBalancethicknessInternal {{{*/
    737 ElementMatrix* Numericalflux::CreateKMatrixAdjointBalancethicknessInternal(void){
     709ElementMatrix* Numericalflux::CreateKMatrixAdjointBalancethicknessInternal(void){/*{{{*/
    738710
    739711        ElementMatrix* Ke=CreateKMatrixBalancethicknessInternal();
    … …  
    742714}
    743715/*}}}*/
    744 /*FUNCTION Numericalflux::CreateKMatrixAdjointBalancethicknessBoundary {{{*/
    745 ElementMatrix* Numericalflux::CreateKMatrixAdjointBalancethicknessBoundary(void){
     716ElementMatrix* Numericalflux::CreateKMatrixAdjointBalancethicknessBoundary(void){/*{{{*/
    746717
    747718        ElementMatrix* Ke=CreateKMatrixBalancethicknessBoundary();
    … …  
    750721}
    751722/*}}}*/
    752 /*FUNCTION Numericalflux::CreatePVectorMasstransport{{{*/
    753 ElementVector* Numericalflux::CreatePVectorMasstransport(void){
     723ElementVector* Numericalflux::CreatePVectorMasstransport(void){/*{{{*/
    754724
    755725        switch(this->flux_type){
    … …  
    763733}
    764734/*}}}*/
    765 /*FUNCTION Numericalflux::CreatePVectorMasstransportInternal{{{*/
    766 ElementVector* Numericalflux::CreatePVectorMasstransportInternal(void){
     735ElementVector* Numericalflux::CreatePVectorMasstransportInternal(void){/*{{{*/
    767736
    768737        /*Nothing added to PVector*/
    … …  
    771740}
    772741/*}}}*/
    773 /*FUNCTION Numericalflux::CreatePVectorMasstransportBoundary{{{*/
    774 ElementVector* Numericalflux::CreatePVectorMasstransportBoundary(void){
     742ElementVector* Numericalflux::CreatePVectorMasstransportBoundary(void){/*{{{*/
    775743
    776744        /* constants*/
    … …  
    841809}
    842810/*}}}*/
    843 /*FUNCTION Numericalflux::CreatePVectorBalancethickness{{{*/
    844 ElementVector* Numericalflux::CreatePVectorBalancethickness(void){
     811ElementVector* Numericalflux::CreatePVectorBalancethickness(void){/*{{{*/
    845812
    846813        switch(this->flux_type){
    … …  
    854821}
    855822/*}}}*/
    856 /*FUNCTION Numericalflux::CreatePVectorBalancethicknessInternal{{{*/
    857 ElementVector* Numericalflux::CreatePVectorBalancethicknessInternal(void){
     823ElementVector* Numericalflux::CreatePVectorBalancethicknessInternal(void){/*{{{*/
    858824
    859825        /*Nothing added to PVector*/
    … …  
    862828}
    863829/*}}}*/
    864 /*FUNCTION Numericalflux::CreatePVectorBalancethicknessBoundary{{{*/
    865 ElementVector* Numericalflux::CreatePVectorBalancethicknessBoundary(void){
     830ElementVector* Numericalflux::CreatePVectorBalancethicknessBoundary(void){/*{{{*/
    866831
    867832        /* constants*/
    … …  
    929894}
    930895/*}}}*/
    931 /*FUNCTION Numericalflux::CreatePVectorAdjointBalancethickness{{{*/
    932 ElementVector* Numericalflux::CreatePVectorAdjointBalancethickness(void){
     896ElementVector* Numericalflux::CreatePVectorAdjointBalancethickness(void){/*{{{*/
    933897
    934898        /*No PVector for the Adjoint*/
    … …  
    936900}
    937901/*}}}*/
    938 /*FUNCTION Numericalflux::GetNormal {{{*/
    939 void Numericalflux:: GetNormal(IssmDouble* normal,IssmDouble xyz_list[4][3]){
     902void Numericalflux:: GetNormal(IssmDouble* normal,IssmDouble xyz_list[4][3]){/*{{{*/
    940903
    941904        /*Build unit outward pointing vector*/

  • issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp

    r17964 r18064  
    2020
    2121/*Pengrid constructors and destructor*/
    22 /*FUNCTION Pengrid::Pengrid(){{{*/
    23 Pengrid::Pengrid(){
     22Pengrid::Pengrid(){/*{{{*/
    2423        this->parameters=NULL;
    2524        this->hnode=NULL;
    … …  
    3635}
    3736/*}}}*/
    38 /*FUNCTION Pengrid::Pengrid(int index, int id, IoModel* iomodel,int analysis_type){{{*/
    39 Pengrid::Pengrid(int id, int index, IoModel* iomodel, int in_analysis_type){ //i is the element index
     37Pengrid::Pengrid(int id, int index, IoModel* iomodel, int in_analysis_type){ //i is the element index/*{{{*/
    4038
    4139        int pengrid_node_id;
    … …  
    7472}
    7573/*}}}*/
    76 /*FUNCTION Pengrid::~Pengrid(){{{*/
    77 Pengrid::~Pengrid(){
     74Pengrid::~Pengrid(){/*{{{*/
    7875        delete hnode;
    7976        delete helement;
    … …  
    8481
    8582/*Object virtual functions definitions:*/
    86 /*FUNCTION Pengrid::Echo {{{*/
    87 void Pengrid::Echo(void){
     83void Pengrid::Echo(void){/*{{{*/
    8884        this->DeepEcho();
    8985}
    9086/*}}}*/
    91 /*FUNCTION Pengrid::DeepEcho{{{*/
    92 void Pengrid::DeepEcho(void){
     87void Pengrid::DeepEcho(void){/*{{{*/
    9388
    9489        _printf_("Pengrid:\n");
    … …  
    10499}
    105100/*}}}*/
    106 /*FUNCTION Pengrid::Id {{{*/
    107 int    Pengrid::Id(void){ return id; }
    108 /*}}}*/
    109 /*FUNCTION Pengrid::ObjectEnum{{{*/
    110 int Pengrid::ObjectEnum(void){
     101int    Pengrid::Id(void){ return id; }/*{{{*/
     102/*}}}*/
     103int Pengrid::ObjectEnum(void){/*{{{*/
    111104
    112105        return PengridEnum;
    113106}
    114107/*}}}*/
    115 /*FUNCTION Icefront::copy {{{*/
    116 Object* Pengrid::copy() {
     108Object* Pengrid::copy() {/*{{{*/
    117109
    118110        Pengrid* pengrid=NULL;
    … …  
    147139
    148140/*Load virtual functions definitions:*/
    149 /*FUNCTION Pengrid::Configure {{{*/
    150 void  Pengrid::Configure(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){
     141void  Pengrid::Configure(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
    151142
    152143        /*Take care of hooking up all objects for this load, ie links the objects in the hooks to their respective
    … …  
    165156}
    166157/*}}}*/
    167 /*FUNCTION Pengrid::SetCurrentConfiguration {{{*/
    168 void  Pengrid::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){
    169 
    170 }
    171 /*}}}*/
    172 /*FUNCTION Pengrid::CreateKMatrix {{{*/
    173 void  Pengrid::CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){
     158void  Pengrid::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
     159
     160}
     161/*}}}*/
     162void  Pengrid::CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){/*{{{*/
    174163
    175164        /*No loads applied, do nothing: */
    … …  
    178167}
    179168/*}}}*/
    180 /*FUNCTION Pengrid::CreatePVector {{{*/
    181 void  Pengrid::CreatePVector(Vector<IssmDouble>* pf){
     169void  Pengrid::CreatePVector(Vector<IssmDouble>* pf){/*{{{*/
    182170
    183171        ElementVector* pe=NULL;
    … …  
    201189}
    202190/*}}}*/
    203 /*FUNCTION Pengrid::GetNodesSidList{{{*/
    204 void Pengrid::GetNodesSidList(int* sidlist){
     191void Pengrid::GetNodesSidList(int* sidlist){/*{{{*/
    205192
    206193        _assert_(sidlist);
    … …  
    210197}
    211198/*}}}*/
    212 /*FUNCTION Pengrid::GetNodesLidList{{{*/
    213 void Pengrid::GetNodesLidList(int* lidlist){
     199void Pengrid::GetNodesLidList(int* lidlist){/*{{{*/
    214200
    215201        _assert_(lidlist);
    … …  
    219205}
    220206/*}}}*/
    221 /*FUNCTION Pengrid::GetNumberOfNodes{{{*/
    222 int Pengrid::GetNumberOfNodes(void){
     207int Pengrid::GetNumberOfNodes(void){/*{{{*/
    223208
    224209        return NUMVERTICES;
    225210}
    226211/*}}}*/
    227 /*FUNCTION Pengrid::PenaltyCreateMatrix {{{*/
    228 void  Pengrid::PenaltyCreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs,IssmDouble kmax){
     212void  Pengrid::PenaltyCreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs,IssmDouble kmax){/*{{{*/
    229213
    230214        /*Retrieve parameters: */
    … …  
    254238}
    255239/*}}}*/
    256 /*FUNCTION Pengrid::PenaltyCreatePVector {{{*/
    257 void  Pengrid::PenaltyCreatePVector(Vector<IssmDouble>* pf,IssmDouble kmax){
     240void  Pengrid::PenaltyCreatePVector(Vector<IssmDouble>* pf,IssmDouble kmax){/*{{{*/
    258241
    259242        /*Retrieve parameters: */
    … …  
    285268}
    286269/*}}}*/
    287 /*FUNCTION Pengrid::InAnalysis{{{*/
    288 bool Pengrid::InAnalysis(int in_analysis_type){
     270bool Pengrid::InAnalysis(int in_analysis_type){/*{{{*/
    289271        if (in_analysis_type==this->analysis_type)return true;
    290272        else return false;
    291273}
    292274/*}}}*/
    293 /*FUNCTION Pengrid::IsPenalty{{{*/
    294 bool Pengrid::IsPenalty(void){
     275bool Pengrid::IsPenalty(void){/*{{{*/
    295276        return true;
    296277}
    297278/*}}}*/
    298 /*FUNCTION Pengrid::SetwiseNodeConnectivity{{{*/
    299 void Pengrid::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum){
     279void Pengrid::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum){/*{{{*/
    300280
    301281        /*Output */
    … …  
    349329
    350330/*Update virtual functions definitions:*/
    351 /*FUNCTION Pengrid::InputUpdateFromVector(IssmDouble* vector, int name, int type) {{{*/
    352 void  Pengrid::InputUpdateFromVector(IssmDouble* vector, int name, int type){
     331void  Pengrid::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
    353332        /*Nothing updated yet*/
    354333}
    355334/*}}}*/
    356 /*FUNCTION Pengrid::InputUpdateFromMatrixDakota(IssmDouble* vector, int nrows, int ncols, int name, int type) {{{*/
    357 void  Pengrid::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){
     335void  Pengrid::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){/*{{{*/
    358336        /*Nothing updated yet*/
    359337}
    360338/*}}}*/
    361 /*FUNCTION Pengrid::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type) {{{*/
    362 void  Pengrid::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){
     339void  Pengrid::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
    363340        /*Nothing updated yet*/
    364341}
    365342/*}}}*/
    366 /*FUNCTION Pengrid::InputUpdateFromConstant(IssmDouble constant, int name) {{{*/
    367 void  Pengrid::InputUpdateFromConstant(IssmDouble constant, int name){
     343void  Pengrid::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/
    368344        /*Nothing*/
    369345}
    370346/*}}}*/
    371 /*FUNCTION Pengrid::InputUpdateFromConstant(int constant, int name) {{{*/
    372 void  Pengrid::InputUpdateFromConstant(int constant, int name){
     347void  Pengrid::InputUpdateFromConstant(int constant, int name){/*{{{*/
    373348        /*Nothing updated yet*/
    374349}
    375350/*}}}*/
    376 /*FUNCTION Pengrid::InputUpdateFromConstant(bool constant, int name) {{{*/
    377 void  Pengrid::InputUpdateFromConstant(bool constant, int name){
     351void  Pengrid::InputUpdateFromConstant(bool constant, int name){/*{{{*/
    378352
    379353        switch(name){
    … …  
    388362
    389363/*Pengrid management:*/
    390 /*FUNCTION Pengrid::ConstraintActivate {{{*/
    391 void  Pengrid::ConstraintActivate(int* punstable){
     364void  Pengrid::ConstraintActivate(int* punstable){/*{{{*/
    392365
    393366        int analysis_type;
    … …  
    417390}
    418391/*}}}*/
    419 /*FUNCTION Pengrid::ConstraintActivateThermal {{{*/
    420 void  Pengrid::ConstraintActivateThermal(int* punstable){
     392void  Pengrid::ConstraintActivateThermal(int* punstable){/*{{{*/
    421393
    422394        //   The penalty is stable if it doesn't change during to successive iterations.   
    … …  
    481453}
    482454/*}}}*/
    483 /*FUNCTION Pengrid::PenaltyCreateKMatrixMelting {{{*/
    484 ElementMatrix* Pengrid::PenaltyCreateKMatrixMelting(IssmDouble kmax){
     455ElementMatrix* Pengrid::PenaltyCreateKMatrixMelting(IssmDouble kmax){/*{{{*/
    485456
    486457        IssmDouble pressure,temperature,t_pmp;
    … …  
    510481}
    511482/*}}}*/
    512 /*FUNCTION Pengrid::PenaltyCreateKMatrixThermal {{{*/
    513 ElementMatrix* Pengrid::PenaltyCreateKMatrixThermal(IssmDouble kmax){
     483ElementMatrix* Pengrid::PenaltyCreateKMatrixThermal(IssmDouble kmax){/*{{{*/
    514484
    515485        IssmDouble    penalty_factor;
    … …  
    528498}
    529499/*}}}*/
    530 /*FUNCTION Pengrid::PenaltyCreatePVectorMelting {{{*/
    531 ElementVector* Pengrid::PenaltyCreatePVectorMelting(IssmDouble kmax){
     500ElementVector* Pengrid::PenaltyCreatePVectorMelting(IssmDouble kmax){/*{{{*/
    532501
    533502        IssmDouble pressure;
    … …  
    570539}
    571540/*}}}*/
    572 /*FUNCTION Pengrid::PenaltyCreatePVectorThermal {{{*/
    573 ElementVector* Pengrid::PenaltyCreatePVectorThermal(IssmDouble kmax){
     541ElementVector* Pengrid::PenaltyCreatePVectorThermal(IssmDouble kmax){/*{{{*/
    574542
    575543        IssmDouble pressure;
    … …  
    596564}
    597565/*}}}*/
    598 /*FUNCTION Pengrid::ConstraintActivateHydrologyDCInefficient{{{*/
    599 void  Pengrid::ConstraintActivateHydrologyDCInefficient(int* punstable){
     566void  Pengrid::ConstraintActivateHydrologyDCInefficient(int* punstable){/*{{{*/
    600567
    601568        //   The penalty is stable if it doesn't change during two consecutive iterations.   
    … …  
    657624}
    658625/*}}}*/
    659 /*FUNCTION Pengrid::PenaltyCreateKMatrixHydrologyDCInefficient {{{*/
    660 ElementMatrix* Pengrid::PenaltyCreateKMatrixHydrologyDCInefficient(IssmDouble kmax){
     626ElementMatrix* Pengrid::PenaltyCreateKMatrixHydrologyDCInefficient(IssmDouble kmax){/*{{{*/
    661627        IssmDouble    penalty_factor;
    662628
    … …  
    674640}
    675641/*}}}*/
    676 /*FUNCTION Pengrid::PenaltyCreatePVectorHydrologyDCInefficient {{{*/
    677 ElementVector* Pengrid::PenaltyCreatePVectorHydrologyDCInefficient(IssmDouble kmax){
     642ElementVector* Pengrid::PenaltyCreatePVectorHydrologyDCInefficient(IssmDouble kmax){/*{{{*/
    678643
    679644        IssmDouble h_max;
    … …  
    699664}
    700665/*}}}*/
    701 /*FUNCTION Pengrid::CreatePVectorHydrologyDCInefficient {{{*/
    702 ElementVector* Pengrid::CreatePVectorHydrologyDCInefficient(void){
     666ElementVector* Pengrid::CreatePVectorHydrologyDCInefficient(void){/*{{{*/
    703667
    704668        IssmDouble moulin_load,dt;
    … …  
    716680 }
    717681/*}}}*/
    718 /*FUNCTION Pengrid::ResetConstraint {{{*/
    719 void  Pengrid::ResetConstraint(void){
     682void  Pengrid::ResetConstraint(void){/*{{{*/
    720683        active         = 0;
    721684        zigzag_counter = 0;

  • issm/trunk-jpl/src/c/classes/Loads/Penpair.cpp

    r16125 r18064  
    1919
    2020/*Penpair constructors and destructor*/
    21 /*FUNCTION Penpair::constructor {{{*/
    22 Penpair::Penpair(){
     21Penpair::Penpair(){/*{{{*/
    2322
    2423        this->hnodes=NULL;
    … …  
    2827}
    2928/*}}}*/
    30 /*FUNCTION Penpair::creation {{{*/
    31 Penpair::Penpair(int penpair_id, int* penpair_node_ids,int in_analysis_type){
     29Penpair::Penpair(int penpair_id, int* penpair_node_ids,int in_analysis_type){/*{{{*/
    3230
    3331        this->id=penpair_id;
    … …  
    4038}
    4139/*}}}*/
    42 /*FUNCTION Penpair::destructor {{{*/
    43 Penpair::~Penpair(){
     40Penpair::~Penpair(){/*{{{*/
    4441        delete hnodes;
    4542        return;
    … …  
    4845
    4946/*Object virtual functions definitions:*/
    50 /*FUNCTION Penpair::Echo {{{*/
    51 void Penpair::Echo(void){
     47void Penpair::Echo(void){/*{{{*/
    5248
    5349        _printf_("Penpair:\n");
    … …  
    5955}
    6056/*}}}*/
    61 /*FUNCTION Penpair::DeepEcho {{{*/
    62 void Penpair::DeepEcho(void){
     57void Penpair::DeepEcho(void){/*{{{*/
    6358
    6459        _printf_("Penpair:\n");
    … …  
    7065}               
    7166/*}}}*/
    72 /*FUNCTION Penpair::Id {{{*/
    73 int    Penpair::Id(void){ return id; }
    74 /*}}}*/
    75 /*FUNCTION Penpair::ObjectEnum{{{*/
    76 int Penpair::ObjectEnum(void){
     67int    Penpair::Id(void){ return id; }/*{{{*/
     68/*}}}*/
     69int Penpair::ObjectEnum(void){/*{{{*/
    7770
    7871        return PenpairEnum;
    7972}
    8073/*}}}*/
    81 /*FUNCTION Penpair::copy {{{*/
    82 Object* Penpair::copy() {
     74Object* Penpair::copy() {/*{{{*/
    8375
    8476        Penpair* penpair=NULL;
    … …  
    10395
    10496/*Load virtual functions definitions:*/
    105 /*FUNCTION Penpair::Configure {{{*/
    106 void  Penpair::Configure(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){
     97void  Penpair::Configure(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
    10798
    10899        /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective
    … …  
    118109}
    119110/*}}}*/
    120 /*FUNCTION Penpair::SetCurrentConfiguration {{{*/
    121 void  Penpair::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){
    122 
    123 }
    124 /*}}}*/
    125 /*FUNCTION Penpair::CreateKMatrix {{{*/
    126 void  Penpair::CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){
     111void  Penpair::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
     112
     113}
     114/*}}}*/
     115void  Penpair::CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){/*{{{*/
    127116        /*If you code this piece, don't forget that a penalty will be inactive if it is dealing with clone nodes*/
    128117        /*No loads applied, do nothing: */
    … …  
    131120}
    132121/*}}}*/
    133 /*FUNCTION Penpair::CreatePVector {{{*/
    134 void  Penpair::CreatePVector(Vector<IssmDouble>* pf){
     122void  Penpair::CreatePVector(Vector<IssmDouble>* pf){/*{{{*/
    135123
    136124        /*No loads applied, do nothing: */
    … …  
    139127}
    140128/*}}}*/
    141 /*FUNCTION Penpair::CreateJacobianMatrix{{{*/
    142 void  Penpair::CreateJacobianMatrix(Matrix<IssmDouble>* Jff){
     129void  Penpair::CreateJacobianMatrix(Matrix<IssmDouble>* Jff){/*{{{*/
    143130        this->CreateKMatrix(Jff,NULL);
    144131}
    145132/*}}}*/
    146 /*FUNCTION Penpair::GetNodesSidList{{{*/
    147 void Penpair::GetNodesSidList(int* sidlist){
     133void Penpair::GetNodesSidList(int* sidlist){/*{{{*/
    148134
    149135        _assert_(sidlist);
    … …  
    153139}
    154140/*}}}*/
    155 /*FUNCTION Penpair::GetNodesLidList{{{*/
    156 void Penpair::GetNodesLidList(int* lidlist){
     141void Penpair::GetNodesLidList(int* lidlist){/*{{{*/
    157142
    158143        _assert_(lidlist);
    … …  
    162147}
    163148/*}}}*/
    164 /*FUNCTION Penpair::GetNumberOfNodes{{{*/
    165 int Penpair::GetNumberOfNodes(void){
     149int Penpair::GetNumberOfNodes(void){/*{{{*/
    166150
    167151        return NUMVERTICES;
    168152}
    169153/*}}}*/
    170 /*FUNCTION Penpair::IsPenalty{{{*/
    171 bool Penpair::IsPenalty(void){
     154bool Penpair::IsPenalty(void){/*{{{*/
    172155        return true;
    173156}
    174157/*}}}*/
    175 /*FUNCTION Penpair::PenaltyCreateKMatrix {{{*/
    176 void  Penpair::PenaltyCreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs,IssmDouble kmax){
     158void  Penpair::PenaltyCreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs,IssmDouble kmax){/*{{{*/
    177159
    178160        /*Retrieve parameters: */
    … …  
    199181}
    200182/*}}}*/
    201 /*FUNCTION Penpair::PenaltyCreatePVector {{{*/
    202 void  Penpair::PenaltyCreatePVector(Vector<IssmDouble>* pf,IssmDouble kmax){
     183void  Penpair::PenaltyCreatePVector(Vector<IssmDouble>* pf,IssmDouble kmax){/*{{{*/
    203184        /*No loads applied, do nothing: */
    204185        return;
    205186}
    206187/*}}}*/
    207 /*FUNCTION Penpair::PenaltyCreateJacobianMatrix{{{*/
    208 void  Penpair::PenaltyCreateJacobianMatrix(Matrix<IssmDouble>* Jff,IssmDouble kmax){
     188void  Penpair::PenaltyCreateJacobianMatrix(Matrix<IssmDouble>* Jff,IssmDouble kmax){/*{{{*/
    209189        this->PenaltyCreateKMatrix(Jff,NULL,kmax);
    210190}
    211191/*}}}*/
    212 /*FUNCTION Penpair::InAnalysis{{{*/
    213 bool Penpair::InAnalysis(int in_analysis_type){
     192bool Penpair::InAnalysis(int in_analysis_type){/*{{{*/
    214193        if (in_analysis_type==this->analysis_type)return true;
    215194        else return false;
    216195}
    217196/*}}}*/
    218 /*FUNCTION Penpair::SetwiseNodeConnectivity{{{*/
    219 void Penpair::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum){
     197void Penpair::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum){/*{{{*/
    220198
    221199        /*Output */
    … …  
    273251
    274252/*Update virtual functions definitions:*/
    275 /*FUNCTION Penpair::InputUpdateFromConstant(IssmDouble constant, int name) {{{*/
    276 void  Penpair::InputUpdateFromConstant(IssmDouble constant, int name){
     253void  Penpair::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/
    277254        /*Nothing updated yet*/
    278255}
    279256/*}}}*/
    280 /*FUNCTION Penpair::InputUpdateFromConstant(int constant, int name) {{{*/
    281 void  Penpair::InputUpdateFromConstant(int constant, int name){
     257void  Penpair::InputUpdateFromConstant(int constant, int name){/*{{{*/
    282258        /*Nothing updated yet*/
    283259}
    284260/*}}}*/
    285 /*FUNCTION Penpair::InputUpdateFromConstant(bool constant, int name) {{{*/
    286 void  Penpair::InputUpdateFromConstant(bool constant, int name){
     261void  Penpair::InputUpdateFromConstant(bool constant, int name){/*{{{*/
    287262        /*Nothing updated yet*/
    288263}
    289264/*}}}*/
    290 /*FUNCTION Penpair::InputUpdateFromVector(IssmDouble* vector, int name, int type) {{{*/
    291 void  Penpair::InputUpdateFromVector(IssmDouble* vector, int name, int type){
     265void  Penpair::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
    292266        /*Nothing updated yet*/
    293267}
    … …  
    295269
    296270/*Penpair management:*/
    297 /*FUNCTION Penpair::PenaltyCreateKMatrixStressbalanceHoriz{{{*/
    298 ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax){
     271ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax){/*{{{*/
    299272
    300273        int    approximation0=nodes[0]->GetApproximation();
    … …  
    329302}
    330303/*}}}*/
    331 /*FUNCTION Penpair::PenaltyCreateKMatrixStressbalanceSSAHO {{{*/
    332 ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceSSAHO(IssmDouble kmax){
     304ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceSSAHO(IssmDouble kmax){/*{{{*/
    333305
    334306        const int numdof=NUMVERTICES*NDOF2;
    … …  
    356328}
    357329/*}}}*/
    358 /*FUNCTION Penpair::PenaltyCreateKMatrixStressbalanceFS {{{*/
    359 ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceFS(IssmDouble kmax){
     330ElementMatrix* Penpair::PenaltyCreateKMatrixStressbalanceFS(IssmDouble kmax){/*{{{*/
    360331
    361332        const int  numdof=NUMVERTICES*NDOF3;
    … …  
    388359}
    389360/*}}}*/
    390 /*FUNCTION Penpair::PenaltyCreateKMatrixMasstransport {{{*/
    391 ElementMatrix* Penpair::PenaltyCreateKMatrixMasstransport(IssmDouble kmax){
     361ElementMatrix* Penpair::PenaltyCreateKMatrixMasstransport(IssmDouble kmax){/*{{{*/
    392362
    393363        const int numdof=NUMVERTICES*NDOF1;

  • issm/trunk-jpl/src/c/classes/Loads/Riftfront.cpp

    r17924 r18064  
    2020
    2121/*Riftfront constructors and destructor*/
    22 /*FUNCTION Riftfront::Riftfront(){{{*/
    23 Riftfront::Riftfront(){
     22Riftfront::Riftfront(){/*{{{*/
    2423        this->parameters=NULL;
    2524        this->hnodes=NULL;
    … …  
    3130}
    3231/*}}}*/
    33 /*FUNCTION Riftfront::Riftfront(int id, int i, IoModel* iomodel,int analysis_type){{{*/
    34 Riftfront::Riftfront(int riftfront_id,int i, IoModel* iomodel,int riftfront_analysis_type){
     32Riftfront::Riftfront(int riftfront_id,int i, IoModel* iomodel,int riftfront_analysis_type){/*{{{*/
    3533
    3634        /*data: */
    … …  
    10199}
    102100/*}}}*/
    103 /*FUNCTION Riftfront::~Riftfront(){{{*/
    104 Riftfront::~Riftfront(){
     101Riftfront::~Riftfront(){/*{{{*/
    105102        this->parameters=NULL;
    106103        delete hnodes;
    … …  
    111108
    112109/*Object virtual functions definitions:*/
    113 /*FUNCTION Riftfront::Echo {{{*/
    114 void Riftfront::Echo(void){
     110void Riftfront::Echo(void){/*{{{*/
    115111
    116112        _printf_("Riftfront:\n");
    … …  
    138134}
    139135/*}}}*/
    140 /*FUNCTION Riftfront::DeepEcho{{{*/
    141 void Riftfront::DeepEcho(void){
     136void Riftfront::DeepEcho(void){/*{{{*/
    142137
    143138        _printf_("Riftfront:\n");
    … …  
    151146}
    152147/*}}}*/
    153 /*FUNCTION Riftfront::Id {{{*/
    154 int    Riftfront::Id(void){ return id; }
    155 /*}}}*/
    156 /*FUNCTION Riftfront::ObjectEnum{{{*/
    157 int Riftfront::ObjectEnum(void){
     148int    Riftfront::Id(void){ return id; }/*{{{*/
     149/*}}}*/
     150int Riftfront::ObjectEnum(void){/*{{{*/
    158151
    159152        return RiftfrontEnum;
    … …  
    161154}
    162155/*}}}*/
    163 /*FUNCTION Riftfront::copy {{{*/
    164 Object* Riftfront::copy() {
     156Object* Riftfront::copy() {/*{{{*/
    165157
    166158        Riftfront* riftfront=NULL;
    … …  
    209201
    210202/*Update virtual functions definitions:*/
    211 /*FUNCTION Riftfront::InputUpdateFromConstant(bool constant,int name) {{{*/
    212 void  Riftfront::InputUpdateFromConstant(bool constant,int name){
    213 }
    214 /*}}}*/
    215 /*FUNCTION Riftfront::InputUpdateFromConstant(IssmDouble constant,int name) {{{*/
    216 void  Riftfront::InputUpdateFromConstant(IssmDouble constant,int name){
    217 
    218 }
    219 /*}}}*/
    220 /*FUNCTION Riftfront::InputUpdateFromVector(IssmDouble* constant,int name) {{{*/
    221 void    Riftfront::InputUpdateFromVector(IssmDouble* vector, int name, int type){
     203void  Riftfront::InputUpdateFromConstant(bool constant,int name){/*{{{*/
     204}
     205/*}}}*/
     206void  Riftfront::InputUpdateFromConstant(IssmDouble constant,int name){/*{{{*/
     207
     208}
     209/*}}}*/
     210void    Riftfront::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
    222211
    223212        _error_("not implemented yet");
    … …  
    227216
    228217/*Load virtual functions definitions:*/
    229 /*FUNCTION Riftfront::Configure {{{*/
    230 void  Riftfront::Configure(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){
     218void  Riftfront::Configure(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
    231219
    232220        /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective
    … …  
    246234}
    247235/*}}}*/
    248 /*FUNCTION Riftfront::IsPenalty{{{*/
    249 bool Riftfront::IsPenalty(void){
     236bool Riftfront::IsPenalty(void){/*{{{*/
    250237        return true;
    251238}
    252239/*}}}*/
    253 /*FUNCTION Riftfront::SetCurrentConfiguration {{{*/
    254 void  Riftfront::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){
    255 
    256 }
    257 /*}}}*/
    258 /*FUNCTION Riftfront::PenaltyCreateKMatrix {{{*/
    259 void  Riftfront::PenaltyCreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs,IssmDouble kmax){
     240void  Riftfront::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
     241
     242}
     243/*}}}*/
     244void  Riftfront::PenaltyCreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs,IssmDouble kmax){/*{{{*/
    260245
    261246        /*Retrieve parameters: */
    … …  
    282267}
    283268/*}}}*/
    284 /*FUNCTION Riftfront::PenaltyCreatePVector {{{*/
    285 void  Riftfront::PenaltyCreatePVector(Vector<IssmDouble>* pf,IssmDouble kmax){
     269void  Riftfront::PenaltyCreatePVector(Vector<IssmDouble>* pf,IssmDouble kmax){/*{{{*/
    286270
    287271        /*Retrieve parameters: */
    … …  
    308292}
    309293/*}}}*/
    310 /*FUNCTION Riftfront::CreateKMatrix {{{*/
    311 void  Riftfront::CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){
     294void  Riftfront::CreateKMatrix(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){/*{{{*/
    312295        /*do nothing: */
    313296        return;
    314297}
    315298/*}}}*/
    316 /*FUNCTION Riftfront::CreatePVector {{{*/
    317 void  Riftfront::CreatePVector(Vector<IssmDouble>* pf){
     299void  Riftfront::CreatePVector(Vector<IssmDouble>* pf){/*{{{*/
    318300        /*do nothing: */
    319301        return;
    320302}
    321303/*}}}*/
    322 /*FUNCTION Riftfront::GetNodesSidList{{{*/
    323 void Riftfront::GetNodesSidList(int* sidlist){
     304void Riftfront::GetNodesSidList(int* sidlist){/*{{{*/
    324305
    325306        _assert_(sidlist);
    … …  
    329310}
    330311/*}}}*/
    331 /*FUNCTION Riftfront::GetNodesLidList{{{*/
    332 void Riftfront::GetNodesLidList(int* lidlist){
     312void Riftfront::GetNodesLidList(int* lidlist){/*{{{*/
    333313
    334314        _assert_(lidlist);
    … …  
    338318}
    339319/*}}}*/
    340 /*FUNCTION Riftfront::GetNumberOfNodes{{{*/
    341 int Riftfront::GetNumberOfNodes(void){
     320int Riftfront::GetNumberOfNodes(void){/*{{{*/
    342321
    343322        return NUMVERTICES;
    344323}
    345324/*}}}*/
    346 /*FUNCTION Riftfront::InAnalysis{{{*/
    347 bool Riftfront::InAnalysis(int in_analysis_type){
     325bool Riftfront::InAnalysis(int in_analysis_type){/*{{{*/
    348326        if (in_analysis_type==this->analysis_type) return true;
    349327        else return false;
    350328}
    351329/*}}}*/
    352 /*FUNCTION Riftfront::SetwiseNodeConnectivity{{{*/
    353 void Riftfront::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum){
     330void Riftfront::SetwiseNodeConnectivity(int* pd_nz,int* po_nz,Node* node,bool* flags,int* flagsindices,int set1_enum,int set2_enum){/*{{{*/
    354331
    355332        /*Output */
    … …  
    407384
    408385/*Riftfront numerics*/
    409 /*FUNCTION Riftfront::PenaltyCreateKMatrixStressbalanceHoriz {{{*/
    410 ElementMatrix* Riftfront::PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax){
     386ElementMatrix* Riftfront::PenaltyCreateKMatrixStressbalanceHoriz(IssmDouble kmax){/*{{{*/
    411387
    412388        const int   numdof = NDOF2*NUMVERTICES;
    … …  
    485461}
    486462/*}}}*/
    487 /*FUNCTION Riftfront::PenaltyCreatePVectorStressbalanceHoriz {{{*/
    488 ElementVector* Riftfront::PenaltyCreatePVectorStressbalanceHoriz(IssmDouble kmax){
     463ElementVector* Riftfront::PenaltyCreatePVectorStressbalanceHoriz(IssmDouble kmax){/*{{{*/
    489464
    490465        int        j;
    … …  
    580555}
    581556/*}}}*/
    582 /*FUNCTION Riftfront::Constrain {{{*/
    583557#define _ZIGZAGCOUNTER_
    584 
    585 int Riftfront::Constrain(int* punstable){
     558int Riftfront::Constrain(int* punstable){/*{{{*/
    586559
    587560        IssmDouble  penetration;
    … …  
    664637}
    665638/*}}}*/
    666 /*FUNCTION Riftfront::FreezeConstraints{{{*/
    667 void   Riftfront::FreezeConstraints(void){
     639void   Riftfront::FreezeConstraints(void){/*{{{*/
    668640
    669641        /*Just set frozen flag to 1: */
    … …  
    672644}
    673645/*}}}*/
    674 /*FUNCTION Riftfront::IsFrozen{{{*/
    675 bool   Riftfront::IsFrozen(void){
     646bool   Riftfront::IsFrozen(void){/*{{{*/
    676647
    677648        /*Just set frozen flag to 1: */

  • issm/trunk-jpl/src/c/classes/Massfluxatgate.h

    r17924 r18064  
    2929
    3030                /*Massfluxatgate constructors, destructors :*/
    31                 /*FUNCTION Massfluxatgate() {{{*/
    32                 Massfluxatgate(){
     31                Massfluxatgate(){/*{{{*/
    3332                        this->name        = 0;
    3433                        this->numsegments = 0;
    … …  
    3635                }
    3736                /*}}}*/
    38                 /*FUNCTION Massfluxatgate(char* name, int numsegments, doubletype* segments) {{{*/
    39                 Massfluxatgate(char* in_name, int in_numsegments, doubletype* in_segments) {
     37                Massfluxatgate(char* in_name, int in_numsegments, doubletype* in_segments) {/*{{{*/
    4038                       
    4139                        int i;
    … …  
    6361                }
    6462                /*}}}*/
    65                 /*FUNCTION Massfluxatgate(char* name, int numsegments, doubletype* x1, doubletype* y1, doubletype* x2, doubletype* y2,int* elements) {{{*/
    66                 Massfluxatgate(char* in_name, int in_numsegments, doubletype* in_x1, doubletype* in_y1, doubletype* in_x2, doubletype* in_y2,int* in_elements){
     63                Massfluxatgate(char* in_name, int in_numsegments, doubletype* in_x1, doubletype* in_y1, doubletype* in_x2, doubletype* in_y2,int* in_elements){/*{{{*/
    6764
    6865                        this->name   = xNew<char>(strlen(in_name)+1);
    … …  
    8178                }
    8279                /*}}}*/
    83                 /*FUNCTION ~Massfluxatgate() {{{*/
    84                 ~Massfluxatgate(){
     80                ~Massfluxatgate(){/*{{{*/
    8581                        xDelete<doubletype>(this->x1);
    8682                        xDelete<doubletype>(this->y1);
    … …  
    9389
    9490                /*Object virtual function resolutoin: */
    95                 /*FUNCTION Echo(){{{*/
    96                 void Echo(void){
     91                void Echo(void){/*{{{*/
    9792                        _printf_(" Massfluxatgate: " << name << "\n");
    9893                        _printf_("    numsegments: " << numsegments << "\n");
    … …  
    105100                }
    106101                /*}}}*/
    107                 /*FUNCTION DeepEcho(){{{*/
    108                 void DeepEcho(void){
     102                void DeepEcho(void){/*{{{*/
    109103                        this->Echo();
    110104                }
    111105                /*}}}*/
    112                 /*FUNCTION Id(){{{*/
    113                 int Id(void){
     106                int Id(void){/*{{{*/
    114107                        return -1;
    115108                }
    116109                /*}}}*/
    117                 /*FUNCTION ObjectEnum{{{*/
    118                 int ObjectEnum(void){
     110                int ObjectEnum(void){/*{{{*/
    119111                        return MassfluxatgateEnum;
    120112                }
    121113                /*}}}*/
    122                 /*FUNCTION copy {{{*/
    123                 Object* copy() {
     114                Object* copy() {/*{{{*/
    124115                        return new Massfluxatgate(this->name,this->numsegments,this->x1,this->y1,this->x2,this->y2,this->elements);
    125116                }
    126117                /*}}}*/
    127118                /*Definition virtual function resolutoin: */
    128                 /*FUNCTION char* Name() {{{*/
    129                 char* Name(){
     119                char* Name(){/*{{{*/
    130120
    131121                        char* name2=xNew<char>(strlen(this->name)+1);
    … …  
    135125                }
    136126                /*}}}*/
    137                 /*FUNCTION doubletype* Response(FemModel* femmodel) {{{*/
    138                  IssmDouble Response(FemModel* femmodel){
     127                 IssmDouble Response(FemModel* femmodel){/*{{{*/
    139128
    140129                        int          i,j;

  • issm/trunk-jpl/src/c/classes/Materials/Materials.cpp

    r17275 r18064  
    1919
    2020/*Object constructors and destructor*/
    21 /*FUNCTION Materials::Materials(){{{*/
    22 Materials::Materials(){
     21Materials::Materials(){/*{{{*/
    2322        enum_type=MaterialsEnum;
    2423        return;
    2524}
    2625/*}}}*/
    27 /*FUNCTION Materials::~Materials(){{{*/
    28 Materials::~Materials(){
     26Materials::~Materials(){/*{{{*/
    2927        return;
    3028}
    … …  
    3230
    3331/*Object management*/
    34 /*FUNCTION Materials::Configure{{{*/
    35 void Materials::Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters){
     32void Materials::Configure(Elements* elements,Loads* loads, Nodes* nodes, Vertices* vertices, Materials* materials,Parameters* parameters){/*{{{*/
    3633
    3734        vector<Object*>::iterator object;

  • issm/trunk-jpl/src/c/classes/Materials/Matice.cpp

    r18060 r18064  
    2727
    2828/*Matice constructors and destructor*/
    29 /*FUNCTION Matice::Matice(){{{*/
    30 Matice::Matice(){
     29Matice::Matice(){/*{{{*/
    3130        this->helement=NULL;
    3231        this->element=NULL;
    … …  
    3433}
    3534/*}}}*/
    36 /*FUNCTION Matice::Matice(int id, int index, IoModel* iomodel, int num_vertices){{{*/
    37 Matice::Matice(int matice_mid,int index, IoModel* iomodel){
     35Matice::Matice(int matice_mid,int index, IoModel* iomodel){/*{{{*/
    3836
    3937        /*Intermediaries:*/
    … …  
    5957}
    6058/*}}}*/
    61 /*FUNCTION Matice::~Matice(){{{*/
    62 Matice::~Matice(){
     59Matice::~Matice(){/*{{{*/
    6360        delete helement;
    6461        return;
    … …  
    6764
    6865/*Object virtual functions definitions:*/
    69 /*FUNCTION Matice::Echo {{{*/
    70 void Matice::Echo(void){
     66void Matice::Echo(void){/*{{{*/
    7167
    7268        _printf_("Matice:\n");
    … …  
    7672}
    7773/*}}}*/
    78 /*FUNCTION Matice::DeepEcho {{{*/
    79 void Matice::DeepEcho(void){
     74void Matice::DeepEcho(void){/*{{{*/
    8075
    8176        _printf_("Matice:\n");
    … …  
    8580}               
    8681/*}}}*/
    87 /*FUNCTION Matice::Id {{{*/
    88 int    Matice::Id(void){ return mid; }
    89 /*}}}*/
    90 /*FUNCTION Matice::ObjectEnum{{{*/
    91 int Matice::ObjectEnum(void){
     82int    Matice::Id(void){ return mid; }/*{{{*/
     83/*}}}*/
     84int Matice::ObjectEnum(void){/*{{{*/
    9285
    9386        return MaticeEnum;
    … …  
    9588}
    9689/*}}}*/
    97 /*FUNCTION Matice::copy() {{{*/
    98 Object* Matice::copy() {
     90Object* Matice::copy() {/*{{{*/
    9991
    10092        /*Output*/
    … …  
    113105}
    114106/*}}}*/
    115 /*FUNCTION Matice::copy2(Element* element) {{{*/
    116 Material* Matice::copy2(Element* element_in) {
     107Material* Matice::copy2(Element* element_in) {/*{{{*/
    117108
    118109        /*Output*/
    … …  
    133124
    134125/*Matice management*/
    135 /*FUNCTION Matice::Configure {{{*/
    136 void  Matice::Configure(Elements* elementsin){
     126void  Matice::Configure(Elements* elementsin){/*{{{*/
    137127
    138128        /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective
    … …  
    142132}
    143133/*}}}*/
    144 /*FUNCTION Matice::SetCurrentConfiguration {{{*/
    145 void  Matice::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){
    146 
    147 }
    148 /*}}}*/
    149 /*FUNCTION Matice::GetA {{{*/
    150 IssmDouble Matice::GetA(){
     134void  Matice::SetCurrentConfiguration(Elements* elementsin,Loads* loadsin,Nodes* nodesin,Vertices* verticesin,Materials* materialsin,Parameters* parametersin){/*{{{*/
     135
     136}
     137/*}}}*/
     138IssmDouble Matice::GetA(){/*{{{*/
    151139        /*
    152140         * A = 1/B^n
    … …  
    161149}
    162150/*}}}*/
    163 /*FUNCTION Matice::GetAbar {{{*/
    164 IssmDouble Matice::GetAbar(){
     151IssmDouble Matice::GetAbar(){/*{{{*/
    165152        /*
    166153         * A = 1/B^n
    … …  
    175162}
    176163/*}}}*/
    177 /*FUNCTION Matice::GetB {{{*/
    178 IssmDouble Matice::GetB(){
     164IssmDouble Matice::GetB(){/*{{{*/
    179165
    180166        /*Output*/
    … …  
    185171}
    186172/*}}}*/
    187 /*FUNCTION Matice::GetBbar {{{*/
    188 IssmDouble Matice::GetBbar(){
     173IssmDouble Matice::GetBbar(){/*{{{*/
    189174
    190175        /*Output*/
    … …  
    195180}
    196181/*}}}*/
    197 /*FUNCTION Matice::GetN {{{*/
    198 IssmDouble Matice::GetN(){
     182IssmDouble Matice::GetN(){/*{{{*/
    199183
    200184        /*Output*/
    … …  
    205189}
    206190/*}}}*/
    207 /*FUNCTION Matice::GetD {{{*/
    208 IssmDouble Matice::GetD(){
     191IssmDouble Matice::GetD(){/*{{{*/
    209192
    210193        _assert_(this->isdamaged);
    … …  
    215198}
    216199/*}}}*/
    217 /*FUNCTION Matice::GetDbar {{{*/
    218 IssmDouble Matice::GetDbar(){
     200IssmDouble Matice::GetDbar(){/*{{{*/
    219201
    220202        _assert_(this->isdamaged);
    … …  
    225207}
    226208/*}}}*/
    227 /*FUNCTION Matice::IsDamage() {{{*/
    228 bool Matice::IsDamage(){
     209bool Matice::IsDamage(){/*{{{*/
    229210
    230211        return this->isdamaged;
    231212}
    232213/*}}}*/
    233 /*FUNCTION Matice::GetViscosity {{{*/
    234 void  Matice::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){
     214void  Matice::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
    235215        /*From a string tensor and a material object, return viscosity, using Glen's flow law.
    236216                                                                (1-D) B
    … …  
    284264}
    285265/*}}}*/
    286 /*FUNCTION Matice::GetViscosity_B {{{*/
    287 void  Matice::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff){
     266void  Matice::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff){/*{{{*/
    288267
    289268        /*output: */
    … …  
    313292}
    314293/*}}}*/
    315 /*FUNCTION Matice::GetViscosity_D {{{*/
    316 void  Matice::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff){
     294void  Matice::GetViscosity_D(IssmDouble* pdmudD,IssmDouble eps_eff){/*{{{*/
    317295
    318296        /*output: */
    … …  
    340318}
    341319/*}}}*/
    342 /*FUNCTION Matice::GetViscosityBar {{{*/
    343 void  Matice::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){
     320void  Matice::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
    344321        /*From a string tensor and a material object, return viscosity, using Glen's flow law.
    345322                                                                (1-D) B
    … …  
    392369}
    393370/*}}}*/
    394 /*FUNCTION Matice::GetViscosityComplement {{{*/
    395 void  Matice::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){
     371void  Matice::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
    396372        /*Return viscosity accounting for steady state power law creep [Thomas and SSA, 1982]:
    397373         *
    … …  
    451427}
    452428/*}}}*/
    453 /*FUNCTION Matice::GetViscosityDComplement {{{*/
    454 void  Matice::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){
     429void  Matice::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
    455430        /*Return viscosity derivative for control method d(mu)/dD:
    456431         *
    … …  
    507482}
    508483/*}}}*/
    509 /*FUNCTION Matice::GetViscosityDerivativeEpsSquare{{{*/
    510 void  Matice::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){
     484void  Matice::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
    511485
    512486        /*output: */
    … …  
    541515}
    542516/*}}}*/
    543 /*FUNCTION Matice::GetViscosity2dDerivativeEpsSquare{{{*/
    544 void  Matice::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){
     517void  Matice::GetViscosity2dDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
    545518
    546519        /*output: */
    … …  
    570543}
    571544/*}}}*/
    572 /*FUNCTION Matice::InputUpdateFromVector(IssmDouble* vector, int name, int type) {{{*/
    573 void  Matice::InputUpdateFromVector(IssmDouble* vector, int name, int type){
    574 
    575 }
    576 /*}}}*/
    577 /*FUNCTION Matice::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type) {{{*/
    578 void  Matice::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){
    579 
    580 }
    581 /*}}}*/
    582 /*FUNCTION Matice::InputUpdateFromMatrixDakota(int* vector, int name, int type) {{{*/
    583 void  Matice::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){
     545void  Matice::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
     546
     547}
     548/*}}}*/
     549void  Matice::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
     550
     551}
     552/*}}}*/
     553void  Matice::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){/*{{{*/
    584554        /*Nothing updated yet*/
    585555}
    586556/*}}}*/
    587 /*FUNCTION Matice::InputUpdateFromConstant(IssmDouble constant, int name) {{{*/
    588 void  Matice::InputUpdateFromConstant(IssmDouble constant, int name){
     557void  Matice::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/
    589558        /*Nothing updated yet*/
    590559}
    591560/*}}}*/
    592 /*FUNCTION Matice::InputUpdateFromConstant(int constant, int name) {{{*/
    593 void  Matice::InputUpdateFromConstant(int constant, int name){
     561void  Matice::InputUpdateFromConstant(int constant, int name){/*{{{*/
    594562        /*Nothing updated yet*/
    595563}
    596564/*}}}*/
    597 /*FUNCTION Matice::InputUpdateFromConstant(bool constant, int name) {{{*/
    598 void  Matice::InputUpdateFromConstant(bool constant, int name){
     565void  Matice::InputUpdateFromConstant(bool constant, int name){/*{{{*/
    599566        /*Nothing updated yet*/
    600567}

  • issm/trunk-jpl/src/c/classes/Materials/Matpar.cpp

    r18001 r18064  
    1313
    1414/*Matpar constructors and destructor*/
    15 /*FUNCTION Matpar::Matpar() {{{*/
    16 Matpar::Matpar(){
     15Matpar::Matpar(){/*{{{*/
    1716        return;
    1817}
    1918/*}}}*/
    20 /*FUNCTION Matpar::Matpar(int matpar_mid,IoModel* iomodel){{{*/
    21 Matpar::Matpar(int matpar_mid, IoModel* iomodel){
     19Matpar::Matpar(int matpar_mid, IoModel* iomodel){/*{{{*/
    2220
    2321        bool isefficientlayer;
    … …  
    9492}
    9593/*}}}*/
    96 /*FUNCTION Matpar::~Matpar() {{{*/
    97 Matpar::~Matpar(){
     94Matpar::~Matpar(){/*{{{*/
    9895        return;
    9996}
    … …  
    10198
    10299/*Object virtual functions definitions:*/
    103 /*FUNCTION Matpar::Echo {{{*/
    104 void Matpar::Echo(void){
     100void Matpar::Echo(void){/*{{{*/
    105101
    106102        _printf_("Matpar:\n");
    … …  
    125121}
    126122/*}}}*/
    127 /*FUNCTION Matpar::DeepEcho {{{*/
    128 void Matpar::DeepEcho(void){
     123void Matpar::DeepEcho(void){/*{{{*/
    129124
    130125        this->Echo();
    131126}               
    132127/*}}}*/
    133 /*FUNCTION Matpar::Id {{{*/
    134 int    Matpar::Id(void){ return mid; }
    135 /*}}}*/
    136 /*FUNCTION Matpar::ObjectEnum{{{*/
    137 int Matpar::ObjectEnum(void){
     128int    Matpar::Id(void){ return mid; }/*{{{*/
     129/*}}}*/
     130int Matpar::ObjectEnum(void){/*{{{*/
    138131
    139132        return MatparEnum;
    … …  
    141134}
    142135/*}}}*/
    143 /*FUNCTION Matpar::copy {{{*/
    144 Object* Matpar::copy() {
     136Object* Matpar::copy() {/*{{{*/
    145137        return new Matpar(*this);
    146138}
    … …  
    148140
    149141/*Update virtual functions definitions:*/
    150 /*FUNCTION Matpar::InputUpdateFromVector(IssmDouble* vector, int name, int type) {{{*/
    151 void   Matpar::InputUpdateFromVector(IssmDouble* vector, int name, int type){
     142void   Matpar::InputUpdateFromVector(IssmDouble* vector, int name, int type){/*{{{*/
    152143        /*Nothing updated yet*/
    153144}
    154145/*}}}*/
    155 /*FUNCTION Matpar::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type) {{{*/
    156 void   Matpar::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){
     146void   Matpar::InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){/*{{{*/
    157147        /*Nothing updated yet*/
    158148}
    159149/*}}}*/
    160 /*FUNCTION Matpar::InputUpdateFromMatrixDakota(IssmDouble* vector, int name, int type) {{{*/
    161 void  Matpar::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){
     150void  Matpar::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols,int name, int type){/*{{{*/
    162151        /*Nothing updated yet*/
    163152}
    164153/*}}}*/
    165 /*FUNCTION Matpar::InputUpdateFromConstant(IssmDouble constant, int name) {{{*/
    166 void   Matpar::InputUpdateFromConstant(IssmDouble constant, int name){
     154void   Matpar::InputUpdateFromConstant(IssmDouble constant, int name){/*{{{*/
    167155
    168156        switch(name){
    … …  
    221209}
    222210/*}}}*/
    223 /*FUNCTION Matpar::InputUpdateFromConstant(int constant, int name) {{{*/
    224 void   Matpar::InputUpdateFromConstant(int constant, int name){
     211void   Matpar::InputUpdateFromConstant(int constant, int name){/*{{{*/
    225212        /*Nothing updated yet*/
    226213}
    227214/*}}}*/
    228 /*FUNCTION Matpar::InputUpdateFromConstant(bool constant, int name) {{{*/
    229 void   Matpar::InputUpdateFromConstant(bool constant, int name){
     215void   Matpar::InputUpdateFromConstant(bool constant, int name){/*{{{*/
    230216        /*Nothing updated yet*/
    231217}
    … …  
    233219
    234220/*Matpar management: */
    235 /*FUNCTION Matpar::Configure {{{*/
    236 void  Matpar::Configure(Elements* elementsin){
     221void  Matpar::Configure(Elements* elementsin){/*{{{*/
    237222
    238223        /*nothing done yet!*/
    … …  
    240225}
    241226/*}}}*/
    242 /*FUNCTION Matpar::Configure {{{*/
    243 IssmDouble Matpar::GetMaterialParameter(int enum_in){
     227IssmDouble Matpar::GetMaterialParameter(int enum_in){/*{{{*/
    244228
    245229        switch(enum_in){
    … …  
    272256}
    273257/*}}}*/
    274 /*FUNCTION Matpar::GetBeta {{{*/
    275 IssmDouble Matpar::GetBeta(){
     258IssmDouble Matpar::GetBeta(){/*{{{*/
    276259        return beta;
    277260}
    278261/*}}}*/
    279 /*FUNCTION Matpar::GetG {{{*/
    280 IssmDouble Matpar::GetG(){
     262IssmDouble Matpar::GetG(){/*{{{*/
    281263        return g;
    282264}
    283265/*}}}*/
    284 /*FUNCTION Matpar::GetMeltingPoint {{{*/
    285 IssmDouble Matpar::GetMeltingPoint(){
     266IssmDouble Matpar::GetMeltingPoint(){/*{{{*/
    286267        return meltingpoint;
    287268}
    288269/*}}}*/
    289 /*FUNCTION Matpar::GetRhoIce {{{*/
    290 IssmDouble Matpar::GetRhoIce(){
     270IssmDouble Matpar::GetRhoIce(){/*{{{*/
    291271
    292272        return rho_ice;
    293273}
    294274/*}}}*/
    295 /*FUNCTION Matpar::GetRhoWater {{{*/
    296 IssmDouble Matpar::GetRhoWater(){
     275IssmDouble Matpar::GetRhoWater(){/*{{{*/
    297276        return rho_water;
    298277}
    299278/*}}}*/
    300 /*FUNCTION Matpar::GetRhoFreshwater {{{*/
    301 IssmDouble Matpar::GetRhoFreshwater(){
     279IssmDouble Matpar::GetRhoFreshwater(){/*{{{*/
    302280        return rho_freshwater;
    303281}
    304282/*}}}*/
    305 /*FUNCTION Matpar::GetDesFac {{{*/
    306 IssmDouble Matpar::GetDesFac(){
     283IssmDouble Matpar::GetDesFac(){/*{{{*/
    307284        return desfac;
    308285}
    309286/*}}}*/
    310 /*FUNCTION Matpar::GetS0p {{{*/
    311 IssmDouble Matpar::GetS0p(){
     287IssmDouble Matpar::GetS0p(){/*{{{*/
    312288        return s0p;
    313289}
    314290/*}}}*/
    315 /*FUNCTION Matpar::TMeltingPoint {{{*/
    316 IssmDouble Matpar::TMeltingPoint(IssmDouble pressure){
     291IssmDouble Matpar::TMeltingPoint(IssmDouble pressure){/*{{{*/
    317292        return meltingpoint-beta*pressure;
    318293}
    319294/*}}}*/
    320 /*FUNCTION Matpar::PureIceEnthalpy{{{*/
    321 IssmDouble Matpar::PureIceEnthalpy(IssmDouble pressure){
     295IssmDouble Matpar::PureIceEnthalpy(IssmDouble pressure){/*{{{*/
    322296        return heatcapacity*(TMeltingPoint(pressure)-referencetemperature);
    323297}
    324298/*}}}*/
    325 /*FUNCTION Matpar::GetEnthalpyDiffusionParameter{{{*/
    326 IssmDouble Matpar::GetEnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure){
     299IssmDouble Matpar::GetEnthalpyDiffusionParameter(IssmDouble enthalpy,IssmDouble pressure){/*{{{*/
    327300        if (enthalpy<PureIceEnthalpy(pressure))
    328301                return thermalconductivity/heatcapacity;
    … …  
    331304}
    332305/*}}}*/
    333 /*FUNCTION Matpar::GetEnthalpyDiffusionParameterVolume{{{*/
    334 IssmDouble Matpar::GetEnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure){
     306IssmDouble Matpar::GetEnthalpyDiffusionParameterVolume(int numvertices,IssmDouble* enthalpy,IssmDouble* pressure){/*{{{*/
    335307
    336308        int         iv;
    … …  
    378350}
    379351/*}}}*/
    380 /*FUNCTION Matpar::EnthalpyToThermal {{{*/
    381 void Matpar::EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure){
     352void Matpar::EnthalpyToThermal(IssmDouble* ptemperature,IssmDouble* pwaterfraction,IssmDouble enthalpy,IssmDouble pressure){/*{{{*/
    382353
    383354        /*Ouput*/
    … …  
    398369}
    399370/*}}}*/
    400 /*FUNCTION Matpar::ThermalToEnthalpy {{{*/
    401 void Matpar::ThermalToEnthalpy(IssmDouble * penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure){
     371void Matpar::ThermalToEnthalpy(IssmDouble * penthalpy,IssmDouble temperature,IssmDouble waterfraction,IssmDouble pressure){/*{{{*/
    402372
    403373        /*Ouput*/
    … …  
    415385}
    416386/*}}}*/
    417 /*FUNCTION Matpar::GetLithosphereShearModulus {{{*/                     
    418 IssmDouble Matpar::GetLithosphereShearModulus(){                 
     387IssmDouble Matpar::GetLithosphereShearModulus(){                 /*{{{*/
    419388        return lithosphere_shear_modulus;                       
    420389}               
    421390/*}}}*/
    422 /*FUNCTION Matpar::GetLithosphereDensity {{{*/                   
    423 IssmDouble Matpar::GetLithosphereDensity(){             
     391IssmDouble Matpar::GetLithosphereDensity(){              /*{{{*/
    424392        return lithosphere_density;                     
    425393}               
    426394/*}}}*/
    427 /*FUNCTION Matpar::GetMantleDensity {{{*/                       
    428 IssmDouble Matpar::GetMantleDensity(){           
     395IssmDouble Matpar::GetMantleDensity(){           /*{{{*/
    429396        return mantle_density;                   
    430397}               
    431398/*}}}*/
    432 /*FUNCTION Matpar::GetMantleShearModulus {{{*/                   
    433 IssmDouble Matpar::GetMantleShearModulus(){             
     399IssmDouble Matpar::GetMantleShearModulus(){              /*{{{*/
    434400        return mantle_shear_modulus;                     
    435401}               

  • issm/trunk-jpl/src/c/classes/Misfit.h

    r17294 r18064  
    3131               
    3232                /*Misfit constructors, destructors :*/
    33                 /*FUNCTION Misfit() {{{*/
    34                 Misfit(){
     33                Misfit(){/*{{{*/
    3534
    3635                        this->name = NULL;
    … …  
    4443                }
    4544                /*}}}*/
    46                 /*FUNCTION Misfit(char* in_name, int in_model_enum, int in_observation_enum char* in_timeinterpolation, int in_weights_enum) {{{*/
    47                 Misfit(char* in_name, int in_model_enum, int in_observation_enum, char* in_timeinterpolation, int in_weights_enum){
     45                Misfit(char* in_name, int in_model_enum, int in_observation_enum, char* in_timeinterpolation, int in_weights_enum){/*{{{*/
    4846
    4947                        this->name   = xNew<char>(strlen(in_name)+1);
    … …  
    6159                }
    6260                /*}}}*/
    63                 /*FUNCTION ~Misfit() {{{*/
    64                 ~Misfit(){
     61                ~Misfit(){/*{{{*/
    6562                        if(this->name)xDelete(this->name);
    6663                        if(this->timeinterpolation)xDelete(this->timeinterpolation);
    … …  
    7067                /*}}}*/
    7168                /*Object virtual function resolutoin: */
    72                 /*FUNCTION Echo(){{{*/
    73                 void Echo(void){
     69                void Echo(void){/*{{{*/
    7470                        _printf_(" Misfit: " << name << "\n");
    7571                        _printf_("    model_enum: " << model_enum << " " << EnumToStringx(model_enum) << "\n");
    … …  
    7975                }
    8076                /*}}}*/
    81                 /*FUNCTION DeepEcho(){{{*/
    82                 void DeepEcho(void){
     77                void DeepEcho(void){/*{{{*/
    8378                        this->Echo();
    8479                }
    8580                /*}}}*/
    86                 /*FUNCTION Id(){{{*/
    87                 int Id(void){
     81                int Id(void){/*{{{*/
    8882                        return -1;
    8983                }
    9084                /*}}}*/
    91                 /*FUNCTION ObjectEnum{{{*/
    92                 int ObjectEnum(void){
     85                int ObjectEnum(void){/*{{{*/
    9386                        return MisfitEnum;
    9487                }
    9588                /*}}}*/
    96                 /*FUNCTION copy {{{*/
    97                 Object* copy() {
     89                Object* copy() {/*{{{*/
    9890                        return new Misfit(this->name,this->model_enum,this->observation_enum,this->timeinterpolation,this->weights_enum);
    9991                }
    10092                /*}}}*/
    10193                /*Definition virtual function resolutoin: */
    102                 /*FUNCTION char* Name() {{{*/
    103                 char* Name(){
     94                char* Name(){/*{{{*/
    10495
    10596                        char* name2=xNew<char>(strlen(this->name)+1);
    … …  
    109100                }
    110101                /*}}}*/
    111                 /*FUNCTION IssmDouble Response(FemModel* femmodel) {{{*/
    112                  IssmDouble Response(FemModel* femmodel){
     102                 IssmDouble Response(FemModel* femmodel){/*{{{*/
    113103
    114104                         int i;

  • issm/trunk-jpl/src/c/classes/Node.cpp

    r17700 r18064  
    1717
    1818/*Node constructors and destructors:*/
    19 /*FUNCTION Node::Node() default constructor {{{*/
    20 Node::Node(){
     19Node::Node(){/*{{{*/
    2120        this->approximation=0;
    2221}
    2322/*}}}*/
    24 /*FUNCTION Node::Node(int node_id,int node_sid,int node_lid,int io_index, IoModel* iomodel,int analysis_enum,int approximation) {{{*/
    25 Node::Node(int node_id,int node_sid,int node_lid,int io_index, IoModel* iomodel,int analysis_enum,int in_approximation){
     23Node::Node(int node_id,int node_sid,int node_lid,int io_index, IoModel* iomodel,int analysis_enum,int in_approximation){/*{{{*/
    2624
    2725        /*Intermediary*/
    … …  
    123121}
    124122/*}}}*/
    125 /*FUNCTION Node::~Node(){{{*/
    126 Node::~Node(){
     123Node::~Node(){/*{{{*/
    127124        return;
    128125}
    … …  
    130127
    131128/*Object virtual functions definitions:*/
    132 /*FUNCTION Node::Echo{{{*/
    133 void Node::Echo(void){
     129void Node::Echo(void){/*{{{*/
    134130
    135131        _printf_("Node:\n");
    … …  
    143139}
    144140/*}}}*/
    145 /*FUNCTION Node::DeepEcho{{{*/
    146 void Node::DeepEcho(void){
     141void Node::DeepEcho(void){/*{{{*/
    147142
    148143        _printf_("Node:\n");
    … …  
    156151}
    157152/*}}}*/
    158 /*FUNCTION Node::Id{{{*/
    159 int    Node::Id(void){ return id; }
    160 /*}}}*/
    161 /*FUNCTION Node::ObjectEnum{{{*/
    162 int Node::ObjectEnum(void){
     153int  Node::Id(void){ return id; }/*{{{*/
     154/*}}}*/
     155int  Node::ObjectEnum(void){/*{{{*/
    163156
    164157        return NodeEnum;
    … …  
    168161
    169162/*Node management:*/
    170 /*FUNCTION Node::GetDof {{{*/
    171 int   Node::GetDof(int dofindex,int setenum){
     163int  Node::GetDof(int dofindex,int setenum){/*{{{*/
    172164
    173165        _assert_(!this->indexingupdate);
    … …  
    187179
    188180} /*}}}*/
    189 /*FUNCTION Node::GetDofList{{{*/
    190 void  Node::GetDofList(int* outdoflist,int approximation_enum,int setenum){
     181void Node::GetDofList(int* outdoflist,int approximation_enum,int setenum){/*{{{*/
    191182        int i;
    192183        int count=0;
    … …  
    251242}
    252243/*}}}*/
    253 /*FUNCTION Node::GetLocalDofList{{{*/
    254 void  Node::GetLocalDofList(int* outdoflist,int approximation_enum,int setenum){
     244void Node::GetLocalDofList(int* outdoflist,int approximation_enum,int setenum){/*{{{*/
    255245        int i;
    256246        int count=0;
    … …  
    352342}
    353343/*}}}*/
    354 /*FUNCTION Node::Sid{{{*/
    355 int Node::Sid(void){
     344int  Node::Sid(void){/*{{{*/
    356345        return sid;
    357346}
    358347/*}}}*/
    359 /*FUNCTION Node::Lid{{{*/
    360 int  Node::Lid(void){
     348int  Node::Lid(void){/*{{{*/
    361349        return lid;
    362350}
    363351/*}}}*/
    364 /*FUNCTION Node::GetCoordinateSystem{{{*/
    365 void Node::GetCoordinateSystem(IssmDouble* coord_system_out){
     352void Node::GetCoordinateSystem(IssmDouble* coord_system_out){/*{{{*/
    366353
    367354        /*Copy coord_system*/
    … …  
    370357}
    371358/*}}}*/
    372 /*FUNCTION Node::InAnalysis{{{*/
    373 bool Node::InAnalysis(int in_analysis_enum){
     359bool Node::InAnalysis(int in_analysis_enum){/*{{{*/
    374360        if (in_analysis_enum==this->analysis_enum) return true;
    375361        else return false;
    … …  
    378364
    379365/*Node numerics:*/
    380 /*FUNCTION Node::ApplyConstraints{{{*/
    381 void  Node::ApplyConstraint(int dof,IssmDouble value){
     366void Node::ApplyConstraint(int dof,IssmDouble value){/*{{{*/
    382367
    383368        /*Dof should be added in the s set, describing which
    … …  
    387372}
    388373/*}}}*/
    389 /*FUNCTION Node::RequiresDofReindexing{{{*/
    390 bool Node::RequiresDofReindexing(void){
     374bool Node::RequiresDofReindexing(void){/*{{{*/
    391375
    392376        return this->indexingupdate;
    … …  
    394378}
    395379/*}}}*/
    396 /*FUNCTION Node::ReindexingDone{{{*/
    397 void Node::ReindexingDone(void){
     380void Node::ReindexingDone(void){/*{{{*/
    398381
    399382        this->indexingupdate = false;
    … …  
    401384}
    402385/*}}}*/
    403 /*FUNCTION Node::RelaxConstraint{{{*/
    404 void  Node::RelaxConstraint(int dof){
     386void Node::RelaxConstraint(int dof){/*{{{*/
    405387
    406388        /*Dof should be added to the f-set, and taken out of the s-set:*/
    … …  
    409391}
    410392/*}}}*/
    411 /*FUNCTION Node::CreateNodalConstraints{{{*/
    412 void  Node::CreateNodalConstraints(Vector<IssmDouble>* ys){
     393void Node::CreateNodalConstraints(Vector<IssmDouble>* ys){/*{{{*/
    413394
    414395        int i;
    … …  
    437418}
    438419/*}}}*/
    439 /*FUNCTION Node::DofInSSet {{{*/
    440 void  Node::DofInSSet(int dof){
     420void Node::DofInSSet(int dof){/*{{{*/
    441421
    442422        /*Put dof for this node into the s set (ie, this dof will be constrained
    … …  
    451431}
    452432/*}}}*/
    453 /*FUNCTION Node::DofInFSet {{{*/
    454 void  Node::DofInFSet(int dof){
     433void Node::DofInFSet(int dof){/*{{{*/
    455434
    456435        /*Put dof for this node into the f set (ie, this dof will NOT be constrained
    … …  
    465444}
    466445/*}}}*/
    467 /*FUNCTION Node::FreezeDof{{{*/
    468 void  Node::FreezeDof(int dof){
     446void Node::FreezeDof(int dof){/*{{{*/
    469447
    470448        DofInSSet(dof); //with 0 displacement for this dof.
    … …  
    472450}
    473451/*}}}*/
    474 /*FUNCTION Node::Deactivate{{{*/
    475 void  Node::Deactivate(void){
     452void Node::Deactivate(void){/*{{{*/
    476453
    477454        if(IsActive()){
    … …  
    482459}
    483460/*}}}*/
    484 /*FUNCTION Node::Activate{{{*/
    485 void  Node::Activate(void){
     461void Node::Activate(void){/*{{{*/
    486462
    487463        if(!IsActive()){
    … …  
    492468}
    493469/*}}}*/
    494 /*FUNCTION Node::IsActive{{{*/
    495 bool Node::IsActive(void){
     470bool Node::IsActive(void){/*{{{*/
    496471
    497472        return indexing.active;
    … …  
    499474}
    500475/*}}}*/
    501 /*FUNCTION Node::GetApproximation {{{*/
    502 int   Node::GetApproximation(){
     476int  Node::GetApproximation(){/*{{{*/
    503477
    504478        return approximation;
    505479}
    506480/*}}}*/
    507 /*FUNCTION Node::GetNumberOfDofs{{{*/
    508 int   Node::GetNumberOfDofs(int approximation_enum,int setenum){
     481int  Node::GetNumberOfDofs(int approximation_enum,int setenum){/*{{{*/
    509482
    510483        /*Get number of degrees of freedom in a node, for a certain set (g,f or s-set)
    … …  
    553526}
    554527/*}}}*/
    555 /*FUNCTION Node::IsClone {{{*/
    556 int   Node::IsClone(){
     528int  Node::IsClone(){/*{{{*/
    557529
    558530        return indexing.clone;
    … …  
    560532}
    561533/*}}}*/
    562 /*FUNCTION Node::VecMerge {{{*/
    563 void Node::VecMerge(Vector<IssmDouble>* ug, IssmDouble* vector_serial,int setenum){
     534void Node::VecMerge(Vector<IssmDouble>* ug, IssmDouble* vector_serial,int setenum){/*{{{*/
    564535
    565536        IssmDouble *values  = NULL;
    … …  
    611582}
    612583/*}}}*/
    613 /*FUNCTION Node::VecReduce {{{*/
    614 void   Node::VecReduce(Vector<IssmDouble>* vector, IssmDouble* ug_serial,int setenum){
     584void Node::VecReduce(Vector<IssmDouble>* vector, IssmDouble* ug_serial,int setenum){/*{{{*/
    615585
    616586        IssmDouble* values=NULL;
    … …  
    658628
    659629/* indexing routines:*/
    660 /*FUNCTION Node::DistributeDofs{{{*/
    661 void  Node::DistributeDofs(int* pdofcount,int setenum){
     630void Node::DistributeDofs(int* pdofcount,int setenum){/*{{{*/
    662631
    663632        int i;
    … …  
    700669}
    701670/*}}}*/
    702 /*FUNCTION Node::OffsetDofs{{{*/
    703 void  Node::OffsetDofs(int dofcount,int setenum){
     671void Node::OffsetDofs(int dofcount,int setenum){/*{{{*/
    704672
    705673        int i;
    … …  
    723691}
    724692/*}}}*/
    725 /*FUNCTION Node::ShowTrueDofs{{{*/
    726 void  Node::ShowTrueDofs(int* truedofs, int ncols,int setenum){
     693void Node::ShowTrueDofs(int* truedofs, int ncols,int setenum){/*{{{*/
    727694
    728695        int j;
    … …  
    748715}
    749716/*}}}*/
    750 /*FUNCTION Node::UpdateCloneDofs{{{*/
    751 void  Node::UpdateCloneDofs(int* alltruedofs,int ncols,int setenum){
     717void Node::UpdateCloneDofs(int* alltruedofs,int ncols,int setenum){/*{{{*/
    752718
    753719        int j;
    … …  
    773739}
    774740/*}}}*/
    775 /*FUNCTION Node::SetClone {{{*/
    776 void  Node::SetClone(int* minranks){
     741void Node::SetClone(int* minranks){/*{{{*/
    777742
    778743        int my_rank;

  • issm/trunk-jpl/src/c/classes/Options/OptionUtilities.cpp

    r15012 r18064  
    1515/*}}}*/
    1616
    17 /*FUNCTION ColumnWiseDimsFromIndex{{{*/
    18 int ColumnWiseDimsFromIndex(int* dims,int index,int* size,int ndims){
     17int ColumnWiseDimsFromIndex(int* dims,int index,int* size,int ndims){/*{{{*/
    1918
    2019        int   i;
    … …  
    3433        return(0);
    3534}/*}}}*/
    36 /*FUNCTION IndexFromColumnWiseDims{{{*/
    37 int IndexFromColumnWiseDims(int* dims, int* size, int ndims) {
     35int IndexFromColumnWiseDims(int* dims, int* size, int ndims) {/*{{{*/
    3836
    3937        int   i;
    … …  
    5351        return(index);
    5452}/*}}}*/
    55 /*FUNCTION RowWiseDimsFromIndex{{{*/
    56 int RowWiseDimsFromIndex(int* dims, int index, int* size, int ndims) {
     53int RowWiseDimsFromIndex(int* dims, int index, int* size, int ndims) {/*{{{*/
    5754
    5855        int   i;
    … …  
    7269        return(0);
    7370}/*}}}*/
    74 /*FUNCTION IndexFromRowWiseDims{{{*/
    75 int IndexFromRowWiseDims(int* dims, int* size, int ndims) {
     71int IndexFromRowWiseDims(int* dims, int* size, int ndims) {/*{{{*/
    7672
    7773        int   i;
    … …  
    9187        return(index);
    9288}/*}}}*/
    93 /*FUNCTION StringFromDims{{{*/
    94 int StringFromDims(char* cstr, int* dims, int ndims) {
     89int StringFromDims(char* cstr, int* dims, int ndims) {/*{{{*/
    9590
    9691        sprintf(&cstr[0],"[");
    … …  
    10095        return(0);
    10196}/*}}}*/
    102 /*FUNCTION StringFromSize{{{*/
    103 int StringFromSize(char* cstr, int* size, int ndims) {
     97int StringFromSize(char* cstr, int* size, int ndims) {/*{{{*/
    10498
    10599        sprintf(&cstr[0],"[");

  • issm/trunk-jpl/src/c/classes/Options/Options.cpp

    r15067 r18064  
    2121
    2222/*Object constructors and destructor*/
    23 /*FUNCTION Options::Options(){{{*/
    24 Options::Options(){
     23Options::Options(){/*{{{*/
    2524        return;
    2625}
    2726/*}}}*/
    28 /*FUNCTION Options::~Options(){{{*/
    29 Options::~Options(){
     27Options::~Options(){/*{{{*/
    3028        return;
    3129}
    … …  
    3331
    3432/*Object management*/
    35 /*FUNCTION Options::AddOption{{{*/
    36 int  Options::AddOption(Option* in_option){
     33int  Options::AddOption(Option* in_option){/*{{{*/
    3734
    3835        char* name=NULL;
    … …  
    6865}
    6966/*}}}*/
    70 /*FUNCTION Options::GetOption{{{*/
    71 Option* Options::GetOption(const char* name){
     67Option* Options::GetOption(const char* name){/*{{{*/
    7268
    7369        vector<Object*>::iterator object;

  • issm/trunk-jpl/src/c/classes/Params/BoolParam.cpp

    r16655 r18064  
    1616
    1717/*BoolParam constructors and destructor*/
    18 /*FUNCTION BoolParam::BoolParam(){{{*/
    19 BoolParam::BoolParam(){
     18BoolParam::BoolParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION BoolParam::BoolParam(int enum_type,bool value){{{*/
    24 BoolParam::BoolParam(int in_enum_type,bool in_value){
     22BoolParam::BoolParam(int in_enum_type,bool in_value){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    2826}
    2927/*}}}*/
    30 /*FUNCTION BoolParam::~BoolParam(){{{*/
    31 BoolParam::~BoolParam(){
     28BoolParam::~BoolParam(){/*{{{*/
    3229        return;
    3330}
    … …  
    3532
    3633/*Object virtual functions definitions:*/
    37 /*FUNCTION BoolParam::Echo {{{*/
    38 void BoolParam::Echo(void){
     34void BoolParam::Echo(void){/*{{{*/
    3935        this->DeepEcho();
    4036}
    4137/*}}}*/
    42 /*FUNCTION BoolParam::DeepEcho{{{*/
    43 void BoolParam::DeepEcho(void){
     38void BoolParam::DeepEcho(void){/*{{{*/
    4439        _printf_(setw(22)<<"   BoolParam "<<setw(35)<<left<<EnumToStringx(this->enum_type)<<" "<<(value?"true":"false")<<"\n");
    4540}
    4641/*}}}*/
    47 /*FUNCTION BoolParam::Id{{{*/
    48 int    BoolParam::Id(void){ return -1; }
     42int    BoolParam::Id(void){ return -1; }/*{{{*/
    4943/*}}}*/
    50 /*FUNCTION BoolParam::ObjectEnum{{{*/
    51 int BoolParam::ObjectEnum(void){
     44int BoolParam::ObjectEnum(void){/*{{{*/
    5245
    5346        return BoolParamEnum;
    … …  
    5548}
    5649/*}}}*/
    57 /*FUNCTION BoolParam::copy{{{*/
    58 Object* BoolParam::copy() {
     50Object* BoolParam::copy() {/*{{{*/
    5951
    6052        return new BoolParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/DataSetParam.cpp

    r16655 r18064  
    1616
    1717/*DataSetParam constructors and destructor*/
    18 /*FUNCTION DataSetParam::DataSetParam(){{{*/
    19 DataSetParam::DataSetParam(){
     18DataSetParam::DataSetParam(){/*{{{*/
    2019        value=NULL;
    2120        return;
    2221}
    2322/*}}}*/
    24 /*FUNCTION DataSetParam::DataSetParam(int enum_type,DataSet *value){{{*/
    25 DataSetParam::DataSetParam(int in_enum_type,DataSet* in_value){
     23DataSetParam::DataSetParam(int in_enum_type,DataSet* in_value){/*{{{*/
    2624
    2725        enum_type=in_enum_type;
    … …  
    2927}
    3028/*}}}*/
    31 /*FUNCTION DataSetParam::~DataSetParam(){{{*/
    32 DataSetParam::~DataSetParam(){
     29DataSetParam::~DataSetParam(){/*{{{*/
    3330        delete value;
    3431}
    … …  
    3633
    3734/*Object virtual functions definitions:*/
    38 /*FUNCTION DataSetParam::Echo {{{*/
    39 void DataSetParam::Echo(void){
     35void DataSetParam::Echo(void){/*{{{*/
    4036        this->DeepEcho();
    4137}
    4238/*}}}*/
    43 /*FUNCTION DataSetParam::DeepEcho{{{*/
    44 void DataSetParam::DeepEcho(void){
     39void DataSetParam::DeepEcho(void){/*{{{*/
    4540
    4641        _printf_(setw(22)<<"   DataSetParam "<<setw(35)<<left<<EnumToStringx(this->enum_type)<<" ----- begin\n");
    … …  
    4944}
    5045/*}}}*/
    51 /*FUNCTION DataSetParam::Id{{{*/
    52 int    DataSetParam::Id(void){ return -1; }
     46int    DataSetParam::Id(void){ return -1; }/*{{{*/
    5347/*}}}*/
    54 /*FUNCTION DataSetParam::ObjectEnum{{{*/
    55 int DataSetParam::ObjectEnum(void){
     48int DataSetParam::ObjectEnum(void){/*{{{*/
    5649
    5750        return DataSetParamEnum;
    … …  
    5952}
    6053/*}}}*/
    61 /*FUNCTION DataSetParam::copy{{{*/
    62 Object* DataSetParam::copy() {
     54Object* DataSetParam::copy() {/*{{{*/
    6355
    6456        return new DataSetParam(this->enum_type,this->value);
    … …  
    6860
    6961/*DataSetParam virtual functions definitions: */
    70 /*FUNCTION DataSetParam::GetParameterValue{{{*/
    71 void DataSetParam::GetParameterValue(DataSet** pdataset){
     62void DataSetParam::GetParameterValue(DataSet** pdataset){/*{{{*/
    7263        *pdataset=value->Copy();
    7364}

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatArrayParam.cpp

    r16233 r18064  
    1616
    1717/*DoubleMatArrayParam constructors and destructor*/
    18 /*FUNCTION DoubleMatArrayParam::DoubleMatArrayParam(){{{*/
    19 DoubleMatArrayParam::DoubleMatArrayParam(){
     18DoubleMatArrayParam::DoubleMatArrayParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION DoubleMatArrayParam::DoubleMatArrayParam(int enum_type,IssmDouble** array, int M, int* mdim_array, int* ndim_array){{{*/
    24 DoubleMatArrayParam::DoubleMatArrayParam(int in_enum_type,IssmDouble** in_array, int in_M, int* in_mdim_array, int* in_ndim_array){
     22DoubleMatArrayParam::DoubleMatArrayParam(int in_enum_type,IssmDouble** in_array, int in_M, int* in_mdim_array, int* in_ndim_array){/*{{{*/
    2523
    2624        int i;
    … …  
    5957}
    6058/*}}}*/
    61 /*FUNCTION DoubleMatArrayParam::~DoubleMatArrayParam(){{{*/
    62 DoubleMatArrayParam::~DoubleMatArrayParam(){
     59DoubleMatArrayParam::~DoubleMatArrayParam(){/*{{{*/
    6360
    6461        int i;
    … …  
    7976
    8077/*Object virtual functions definitions:*/
    81 /*FUNCTION DoubleMatArrayParam::Echo {{{*/
    82 void DoubleMatArrayParam::Echo(void){
     78void DoubleMatArrayParam::Echo(void){/*{{{*/
    8379
    8480        _printf_("DoubleMatArrayParam:\n");
    … …  
    8985}
    9086/*}}}*/
    91 /*FUNCTION DoubleMatArrayParam::DeepEcho{{{*/
    92 void DoubleMatArrayParam::DeepEcho(void){
     87void DoubleMatArrayParam::DeepEcho(void){/*{{{*/
    9388
    9489        int i,j,k;
    … …  
    113108}
    114109/*}}}*/
    115 /*FUNCTION DoubleMatArrayParam::Id{{{*/
    116 int    DoubleMatArrayParam::Id(void){ return -1; }
    117 /*}}}*/
    118 /*FUNCTION DoubleMatArrayParam::ObjectEnum{{{*/
    119 int DoubleMatArrayParam::ObjectEnum(void){
     110int    DoubleMatArrayParam::Id(void){ return -1; }/*{{{*/
     111/*}}}*/
     112int DoubleMatArrayParam::ObjectEnum(void){/*{{{*/
    120113
    121114        return DoubleMatArrayParamEnum;
    … …  
    123116}
    124117/*}}}*/
    125 /*FUNCTION DoubleMatArrayParam::copy{{{*/
    126 Object* DoubleMatArrayParam::copy() {
     118Object* DoubleMatArrayParam::copy() {/*{{{*/
    127119
    128120        return new DoubleMatArrayParam(this->enum_type,this->array, this->M, this->mdim_array,this->ndim_array);
    … …  
    132124
    133125/*DoubleMatArrayParam virtual functions definitions: */
    134 /*FUNCTION DoubleMatArrayParam::GetParameterValue(IssmDouble*** parray, int* pM,int** pmdims, int** pndims){{{*/
    135 void  DoubleMatArrayParam::GetParameterValue(IssmDouble*** pout_array, int* pout_M,int** pout_mdim_array, int** pout_ndim_array){
     126void  DoubleMatArrayParam::GetParameterValue(IssmDouble*** pout_array, int* pout_M,int** pout_mdim_array, int** pout_ndim_array){/*{{{*/
    136127
    137128        int i,m,n;
    … …  
    183174}
    184175/*}}}*/
    185 /*FUNCTION DoubleMatArrayParam::SetValue(IssmDouble** array, int M, int* mdim_array, int* ndim_array){{{*/
    186 void  DoubleMatArrayParam::SetValue(IssmDouble** in_array, int in_M, int* in_mdim_array, int* in_ndim_array){
     176void  DoubleMatArrayParam::SetValue(IssmDouble** in_array, int in_M, int* in_mdim_array, int* in_ndim_array){/*{{{*/
    187177
    188178        int i,m,n;

  • issm/trunk-jpl/src/c/classes/Params/DoubleMatParam.cpp

    r16233 r18064  
    1616
    1717/*DoubleMatParam constructors and destructor*/
    18 /*FUNCTION DoubleMatParam::DoubleMatParam(){{{*/
    19 DoubleMatParam::DoubleMatParam(){
     18DoubleMatParam::DoubleMatParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION DoubleMatParam::DoubleMatParam(int enum_type,IssmDoubleMat value){{{*/
    24 DoubleMatParam::DoubleMatParam(int in_enum_type,IssmDouble* in_value, int in_M,int in_N){
     22DoubleMatParam::DoubleMatParam(int in_enum_type,IssmDouble* in_value, int in_M,int in_N){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    3230}
    3331/*}}}*/
    34 /*FUNCTION DoubleMatParam::~DoubleMatParam(){{{*/
    35 DoubleMatParam::~DoubleMatParam(){
     32DoubleMatParam::~DoubleMatParam(){/*{{{*/
    3633        xDelete<IssmDouble>(value);
    3734        return;
    … …  
    4037
    4138/*Object virtual functions definitions:*/
    42 /*FUNCTION DoubleMatParam::Echo {{{*/
    43 void DoubleMatParam::Echo(void){
     39void DoubleMatParam::Echo(void){/*{{{*/
    4440
    4541        _printf_("DoubleMatParam:\n");
    … …  
    4945}
    5046/*}}}*/
    51 /*FUNCTION DoubleMatParam::DeepEcho{{{*/
    52 void DoubleMatParam::DeepEcho(void){
     47void DoubleMatParam::DeepEcho(void){/*{{{*/
    5348
    5449        int i,j;
    … …  
    6459}
    6560/*}}}*/
    66 /*FUNCTION DoubleMatParam::Id{{{*/
    67 int    DoubleMatParam::Id(void){ return -1; }
     61int    DoubleMatParam::Id(void){ return -1; }/*{{{*/
    6862/*}}}*/
    69 /*FUNCTION DoubleMatParam::ObjectEnum{{{*/
    70 int DoubleMatParam::ObjectEnum(void){
     63int DoubleMatParam::ObjectEnum(void){/*{{{*/
    7164
    7265        return DoubleMatParamEnum;
    … …  
    7467}
    7568/*}}}*/
    76 /*FUNCTION DoubleMatParam::copy{{{*/
    77 Object* DoubleMatParam::copy() {
     69Object* DoubleMatParam::copy() {/*{{{*/
    7870
    7971        return new DoubleMatParam(this->enum_type,this->value,this->M,this->N);
    … …  
    8375
    8476/*DoubleMatParam virtual functions definitions: */
    85 /*FUNCTION DoubleMatParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){{{*/
    86 void  DoubleMatParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){
     77void  DoubleMatParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){/*{{{*/
    8778        IssmDouble* output=NULL;
    8879
    … …  
    9687}
    9788/*}}}*/
    98 /*FUNCTION DoubleMatParam::GetParameterValue(int** pintarray,int* pM,int* pN){{{*/
    99 void  DoubleMatParam::GetParameterValue(int** pintarray,int* pM,int* pN){
     89void  DoubleMatParam::GetParameterValue(int** pintarray,int* pM,int* pN){/*{{{*/
    10090        _error_("DoubleMat of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of int");
    10191}
    10292/*}}}*/
    103 /*FUNCTION DoubleMatParam::SetValue{{{*/
    104 void  DoubleMatParam::SetValue(IssmDouble* IssmDoublearray,int in_M,int in_N){
     93void  DoubleMatParam::SetValue(IssmDouble* IssmDoublearray,int in_M,int in_N){/*{{{*/
    10594
    10695        /*avoid leak: */

  • issm/trunk-jpl/src/c/classes/Params/DoubleParam.cpp

    r16655 r18064  
    1313
    1414/*DoubleParam constructors and destructor*/
    15 /*FUNCTION DoubleParam::DoubleParam(){{{*/
    16 DoubleParam::DoubleParam(){
     15DoubleParam::DoubleParam(){/*{{{*/
    1716        return;
    1817}
    1918/*}}}*/
    20 /*FUNCTION DoubleParam::DoubleParam(int enum_type,IssmDouble value){{{*/
    21 DoubleParam::DoubleParam(int in_enum_type,IssmDouble in_value){
     19DoubleParam::DoubleParam(int in_enum_type,IssmDouble in_value){/*{{{*/
    2220
    2321        enum_type=in_enum_type;
    … …  
    2523}
    2624/*}}}*/
    27 /*FUNCTION DoubleParam::~DoubleParam(){{{*/
    28 DoubleParam::~DoubleParam(){
     25DoubleParam::~DoubleParam(){/*{{{*/
    2926        return;
    3027}
    … …  
    3229
    3330/*Object virtual functions definitions:*/
    34 /*FUNCTION DoubleParam::Echo {{{*/
    35 void DoubleParam::Echo(void){
     31void DoubleParam::Echo(void){/*{{{*/
    3632        this->DeepEcho();
    3733}
    3834/*}}}*/
    39 /*FUNCTION DoubleParam::DeepEcho{{{*/
    40 void DoubleParam::DeepEcho(void){
     35void DoubleParam::DeepEcho(void){/*{{{*/
    4136
    4237        _printf_(setw(22)<<"   DoubleParam "<<setw(35)<<left<<EnumToStringx(this->enum_type)<<" "<<this->value<<"\n");
    4338}
    4439/*}}}*/
    45 /*FUNCTION DoubleParam::Id{{{*/
    46 int    DoubleParam::Id(void){ return -1; }
     40int    DoubleParam::Id(void){ return -1; }/*{{{*/
    4741/*}}}*/
    48 /*FUNCTION DoubleParam::ObjectEnum{{{*/
    49 int DoubleParam::ObjectEnum(void){
     42int DoubleParam::ObjectEnum(void){/*{{{*/
    5043
    5144        return DoubleParamEnum;
    … …  
    5346}
    5447/*}}}*/
    55 /*FUNCTION DoubleParam::copy{{{*/
    56 Object* DoubleParam::copy() {
     48Object* DoubleParam::copy() {/*{{{*/
    5749
    5850        return new DoubleParam(this->enum_type,this->value);
    … …  
    6254
    6355/*DoubleParam virtual functions definitions: */
    64 /*FUNCTION DoubleParam::GetParameterValue(int* pinteger){{{*/
    65 void DoubleParam::GetParameterValue(int* pinteger){
     56void DoubleParam::GetParameterValue(int* pinteger){/*{{{*/
    6657        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an integer");
    6758}
    6859/*}}}*/
    69 /*FUNCTION DoubleParam::GetParameterValue(bool* pbool){{{*/
    70 void DoubleParam::GetParameterValue(bool* pbool){
     60void DoubleParam::GetParameterValue(bool* pbool){/*{{{*/
    7161        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an bool");
    7262}
    7363/*}}}*/
    74 /*FUNCTION DoubleParam::GetParameterValue(int** pintarray,int* pM){{{*/
    75 void DoubleParam::GetParameterValue(int** pintarray,int* pM){
     64void DoubleParam::GetParameterValue(int** pintarray,int* pM){/*{{{*/
    7665        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of integers");
    7766}
    7867/*}}}*/
    79 /*FUNCTION DoubleParam::GetParameterValue(int** pintarray,int* pM,int* pN){{{*/
    80 void DoubleParam::GetParameterValue(int** pintarray,int* pM,int* pN){
     68void DoubleParam::GetParameterValue(int** pintarray,int* pM,int* pN){/*{{{*/
    8169        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of integers");
    8270}
    8371/*}}}*/
    84 /*FUNCTION DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){{{*/
    85 void DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){
     72void DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){/*{{{*/
    8673        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of IssmDouble");
    8774}
    8875/*}}}*/
    89 /*FUNCTION DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){{{*/
    90 void DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){
     76void DoubleParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){/*{{{*/
    9177        _error_("Double param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of IssmDouble");
    9278}

  • issm/trunk-jpl/src/c/classes/Params/DoubleTransientMatParam.cpp

    r15128 r18064  
    1515/*}}}*/
    1616
    17 /*FUNCTION DoubleTransientMatParam::DoubleTransientMatParam(int enum_type,IssmDoubleMat value){{{*/
    18 DoubleTransientMatParam::DoubleTransientMatParam(int in_enum_type,IssmDouble* in_value, int in_M,int in_N):DoubleMatParam(in_enum_type,in_value,in_M,in_N){
     17DoubleTransientMatParam::DoubleTransientMatParam(int in_enum_type,IssmDouble* in_value, int in_M,int in_N):DoubleMatParam(in_enum_type,in_value,in_M,in_N){/*{{{*/
    1918}
    2019/*}}}*/

  • issm/trunk-jpl/src/c/classes/Params/DoubleVecParam.cpp

    r16655 r18064  
    1616
    1717/*DoubleVecParam constructors and destructor*/
    18 /*FUNCTION DoubleVecParam::DoubleVecParam(){{{*/
    19 DoubleVecParam::DoubleVecParam(){
     18DoubleVecParam::DoubleVecParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION DoubleVecParam::DoubleVecParam(int enum_type,IssmDoubleVec values,int M){{{*/
    24 DoubleVecParam::DoubleVecParam(int in_enum_type,IssmDouble* in_values, int in_M){
     22DoubleVecParam::DoubleVecParam(int in_enum_type,IssmDouble* in_values, int in_M){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    3129}
    3230/*}}}*/
    33 /*FUNCTION DoubleVecParam::~DoubleVecParam(){{{*/
    34 DoubleVecParam::~DoubleVecParam(){
     31DoubleVecParam::~DoubleVecParam(){/*{{{*/
    3532        xDelete<IssmDouble>(values);
    3633        return;
    … …  
    3936
    4037/*Object virtual functions definitions:*/
    41 /*FUNCTION DoubleVecParam::Echo {{{*/
    42 void DoubleVecParam::Echo(void){
     38void DoubleVecParam::Echo(void){/*{{{*/
    4339
    4440        _printf_(setw(22)<<"   DoubleVecParam "<<setw(35)<<left<<EnumToStringx(this->enum_type)<<" size: "<<this->M<<"\n");
    … …  
    4642}
    4743/*}}}*/
    48 /*FUNCTION DoubleVecParam::DeepEcho{{{*/
    49 void DoubleVecParam::DeepEcho(void){
     44void DoubleVecParam::DeepEcho(void){/*{{{*/
    5045        _printf_(setw(22)<<"   DoubleVecParam "<<setw(35)<<left<<EnumToStringx(this->enum_type)<<" "<<"[");
    5146        for(int i=0;i<this->M;i++) _printf_(" "<< this->values[i]);
    … …  
    5348}
    5449/*}}}*/
    55 /*FUNCTION DoubleVecParam::Id{{{*/
    56 int    DoubleVecParam::Id(void){ return -1; }
     50int    DoubleVecParam::Id(void){ return -1; }/*{{{*/
    5751/*}}}*/
    58 /*FUNCTION DoubleVecParam::ObjectEnum{{{*/
    59 int DoubleVecParam::ObjectEnum(void){
     52int DoubleVecParam::ObjectEnum(void){/*{{{*/
    6053
    6154        return DoubleVecParamEnum;
    … …  
    6356}
    6457/*}}}*/
    65 /*FUNCTION DoubleVecParam::copy{{{*/
    66 Object* DoubleVecParam::copy() {
     58Object* DoubleVecParam::copy() {/*{{{*/
    6759
    6860        return new DoubleVecParam(this->enum_type,this->values,this->M);
    … …  
    7264
    7365/*DoubleVecParam virtual functions definitions: */
    74 /*FUNCTION DoubleVecParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){{{*/
    75 void  DoubleVecParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){
     66void  DoubleVecParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){/*{{{*/
    7667        IssmDouble* output=NULL;
    7768        int M;
    … …  
    8677}
    8778/*}}}*/
    88 /*FUNCTION DoubleVecParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM){{{*/
    89 void  DoubleVecParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){
     79void  DoubleVecParam::GetParameterValue(IssmDouble** pIssmDoublearray,int* pM,int* pN){/*{{{*/
    9080        IssmDouble* output=NULL;
    9181        int M;
    … …  
    10393}
    10494/*}}}*/
    105 /*FUNCTION DoubleVecParam::GetParameterValue(int** pintarray,int* pM){{{*/
    106 void  DoubleVecParam::GetParameterValue(int** pintarray,int* pM){
     95void  DoubleVecParam::GetParameterValue(int** pintarray,int* pM){/*{{{*/
    10796        _error_("DoubleVec param of enum " << enum_type << " (" << EnumToStringx(enum_type) << ") cannot return an array of int");
    10897}
    10998/*}}}*/
    110 /*FUNCTION DoubleVecParam::SetValue{{{*/
    111 void  DoubleVecParam::SetValue(IssmDouble* IssmDoublearray,int in_M){
     99void  DoubleVecParam::SetValue(IssmDouble* IssmDoublearray,int in_M){/*{{{*/
    112100
    113101        /*avoid leak: */

  • issm/trunk-jpl/src/c/classes/Params/FileParam.cpp

    r16655 r18064  
    1616
    1717/*FileParam constructors and destructor*/
    18 /*FUNCTION FileParam::FileParam(){{{*/
    19 FileParam::FileParam(){
     18FileParam::FileParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION FileParam::FileParam(int enum_type,FILE *value){{{*/
    24 FileParam::FileParam(int in_enum_type,FILE* in_value){
     22FileParam::FileParam(int in_enum_type,FILE* in_value){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    2826}
    2927/*}}}*/
    30 /*FUNCTION FileParam::~FileParam(){{{*/
    31 FileParam::~FileParam(){
     28FileParam::~FileParam(){/*{{{*/
    3229        return;
    3330}
    … …  
    3532
    3633/*Object virtual functions definitions:*/
    37 /*FUNCTION FileParam::Echo {{{*/
    38 void FileParam::Echo(void){
     34void FileParam::Echo(void){/*{{{*/
    3935        this->DeepEcho();
    4036}
    4137/*}}}*/
    42 /*FUNCTION FileParam::DeepEcho{{{*/
    43 void FileParam::DeepEcho(void){
     38void FileParam::DeepEcho(void){/*{{{*/
    4439
    4540        _printf_(setw(22)<<"   FileParam "<<setw(35)<<left<<EnumToStringx(this->enum_type)<<" "<<this->value<<"\n");
    4641}
    4742/*}}}*/
    48 /*FUNCTION FileParam::Id{{{*/
    49 int    FileParam::Id(void){ return -1; }
     43int    FileParam::Id(void){ return -1; }/*{{{*/
    5044/*}}}*/
    51 /*FUNCTION FileParam::ObjectEnum{{{*/
    52 int FileParam::ObjectEnum(void){
     45int FileParam::ObjectEnum(void){/*{{{*/
    5346
    5447        return FileParamEnum;
    … …  
    5649}
    5750/*}}}*/
    58 /*FUNCTION FileParam::copy{{{*/
    59 Object* FileParam::copy() {
     51Object* FileParam::copy() {/*{{{*/
    6052
    6153        return new FileParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/IntMatParam.cpp

    r16233 r18064  
    1616
    1717/*IntMatParam constructors and destructor*/
    18 /*FUNCTION IntMatParam::IntMatParam(){{{*/
    19 IntMatParam::IntMatParam(){
     18IntMatParam::IntMatParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION IntMatParam::IntMatParam(int enum_type,IssmIntMat value){{{*/
    24 IntMatParam::IntMatParam(int in_enum_type,int* in_value, int in_M,int in_N){
     22IntMatParam::IntMatParam(int in_enum_type,int* in_value, int in_M,int in_N){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    3230}
    3331/*}}}*/
    34 /*FUNCTION IntMatParam::~IntMatParam(){{{*/
    35 IntMatParam::~IntMatParam(){
     32IntMatParam::~IntMatParam(){/*{{{*/
    3633        xDelete<int>(value);
    3734        return;
    … …  
    4037
    4138/*Object virtual functions definitions:*/
    42 /*FUNCTION IntMatParam::Echo {{{*/
    43 void IntMatParam::Echo(void){
     39void IntMatParam::Echo(void){/*{{{*/
    4440
    4541        _printf_("IntMatParam:\n");
    … …  
    4945}
    5046/*}}}*/
    51 /*FUNCTION IntMatParam::DeepEcho{{{*/
    52 void IntMatParam::DeepEcho(void){
     47void IntMatParam::DeepEcho(void){/*{{{*/
    5348
    5449        int i,j;
    … …  
    6459}
    6560/*}}}*/
    66 /*FUNCTION IntMatParam::Id{{{*/
    67 int    IntMatParam::Id(void){ return -1; }
     61int    IntMatParam::Id(void){ return -1; }/*{{{*/
    6862/*}}}*/
    69 /*FUNCTION IntMatParam::ObjectEnum{{{*/
    70 int IntMatParam::ObjectEnum(void){
     63int IntMatParam::ObjectEnum(void){/*{{{*/
    7164
    7265        return IntMatParamEnum;
    … …  
    7467}
    7568/*}}}*/
    76 /*FUNCTION IntMatParam::copy{{{*/
    77 Object* IntMatParam::copy() {
     69Object* IntMatParam::copy() {/*{{{*/
    7870
    7971        return new IntMatParam(this->enum_type,this->value,this->M,this->N);
    … …  
    8375
    8476/*IntMatParam virtual functions definitions: */
    85 /*FUNCTION IntMatParam::GetParameterValue{{{*/
    86 void  IntMatParam::GetParameterValue(int** pintarray,int* pM,int* pN){
     77void  IntMatParam::GetParameterValue(int** pintarray,int* pM,int* pN){/*{{{*/
    8778        int* output=NULL;
    8879
    … …  
    9687}
    9788/*}}}*/
    98 /*FUNCTION IntMatParam::SetValue{{{*/
    99 void  IntMatParam::SetValue(int* intarray,int in_M,int in_N){
     89void  IntMatParam::SetValue(int* intarray,int in_M,int in_N){/*{{{*/
    10090
    10191        /*avoid leak: */

  • issm/trunk-jpl/src/c/classes/Params/IntParam.cpp

    r16655 r18064  
    1616
    1717/*IntParam constructors and destructor*/
    18 /*FUNCTION IntParam::IntParam(){{{*/
    19 IntParam::IntParam(){
     18IntParam::IntParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION IntParam::IntParam(int enum_type,IssmInt value){{{*/
    24 IntParam::IntParam(int in_enum_type,IssmInt in_value){
     22IntParam::IntParam(int in_enum_type,IssmInt in_value){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    2826}
    2927/*}}}*/
    30 /*FUNCTION IntParam::~IntParam(){{{*/
    31 IntParam::~IntParam(){
     28IntParam::~IntParam(){/*{{{*/
    3229        return;
    3330}
    … …  
    3532
    3633/*Object virtual functions definitions:*/
    37 /*FUNCTION IntParam::Echo {{{*/
    38 void IntParam::Echo(void){
     34void IntParam::Echo(void){/*{{{*/
    3935        this->DeepEcho();
    4036}
    4137/*}}}*/
    42 /*FUNCTION IntParam::DeepEcho{{{*/
    43 void IntParam::DeepEcho(void){
     38void IntParam::DeepEcho(void){/*{{{*/
    4439
    4540        _printf_(setw(22)<<"   IntParam "<<setw(35)<<left<<EnumToStringx(this->enum_type)<<" "<<this->value<<"\n");
    4641}
    4742/*}}}*/
    48 /*FUNCTION IntParam::Id{{{*/
    49 int    IntParam::Id(void){ return -1; }
     43int    IntParam::Id(void){ return -1; }/*{{{*/
    5044/*}}}*/
    51 /*FUNCTION IntParam::ObjectEnum{{{*/
    52 int IntParam::ObjectEnum(void){
     45int IntParam::ObjectEnum(void){/*{{{*/
    5346
    5447        return IntParamEnum;
    … …  
    5649}
    5750/*}}}*/
    58 /*FUNCTION IntParam::copy{{{*/
    59 Object* IntParam::copy() {
     51Object* IntParam::copy() {/*{{{*/
    6052
    6153        return new IntParam(this->enum_type,this->value);

  • issm/trunk-jpl/src/c/classes/Params/IntVecParam.cpp

    r16233 r18064  
    1616
    1717/*IntVecParam constructors and destructor*/
    18 /*FUNCTION IntVecParam::IntVecParam(){{{*/
    19 IntVecParam::IntVecParam(){
     18IntVecParam::IntVecParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION IntVecParam::IntVecParam(int enum_type,int* values,int M){{{*/
    24 IntVecParam::IntVecParam(int in_enum_type,int* in_values, int in_M){
     22IntVecParam::IntVecParam(int in_enum_type,int* in_values, int in_M){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    3432}
    3533/*}}}*/
    36 /*FUNCTION IntVecParam::IntVecParam(int enum_type,IssmDouble* values,int M){{{*/
    37 IntVecParam::IntVecParam(int in_enum_type,IssmDouble* in_values, int in_M){
     34IntVecParam::IntVecParam(int in_enum_type,IssmDouble* in_values, int in_M){/*{{{*/
    3835
    3936        enum_type=in_enum_type;
    … …  
    4744}
    4845/*}}}*/
    49 /*FUNCTION IntVecParam::~IntVecParam(){{{*/
    50 IntVecParam::~IntVecParam(){
     46IntVecParam::~IntVecParam(){/*{{{*/
    5147        xDelete<int>(values);
    5248        return;
    … …  
    5551
    5652/*Object virtual functions definitions:*/
    57 /*FUNCTION IntVecParam::Echo {{{*/
    58 void IntVecParam::Echo(void){
     53void IntVecParam::Echo(void){/*{{{*/
    5954
    6055        _printf_("IntVecParam:\n");
    … …  
    6459}
    6560/*}}}*/
    66 /*FUNCTION IntVecParam::DeepEcho{{{*/
    67 void IntVecParam::DeepEcho(void){
     61void IntVecParam::DeepEcho(void){/*{{{*/
    6862
    6963        int i;
    … …  
    7771}
    7872/*}}}*/
    79 /*FUNCTION IntVecParam::Id{{{*/
    80 int    IntVecParam::Id(void){ return -1; }
     73int    IntVecParam::Id(void){ return -1; }/*{{{*/
    8174/*}}}*/
    82 /*FUNCTION IntVecParam::ObjectEnum{{{*/
    83 int IntVecParam::ObjectEnum(void){
     75int IntVecParam::ObjectEnum(void){/*{{{*/
    8476
    8577        return IntVecParamEnum;
    … …  
    8779}
    8880/*}}}*/
    89 /*FUNCTION IntVecParam::copy{{{*/
    90 Object* IntVecParam::copy() {
     81Object* IntVecParam::copy() {/*{{{*/
    9182
    9283        return new IntVecParam(this->enum_type,this->values,this->M);
    … …  
    9687
    9788/*IntVecParam virtual functions definitions: */
    98 /*FUNCTION IntVecParam::GetParameterValue{{{*/
    99 void  IntVecParam::GetParameterValue(int** pintarray,int* pM){
     89void  IntVecParam::GetParameterValue(int** pintarray,int* pM){/*{{{*/
    10090        int* output=NULL;
    10191
    … …  
    110100}
    111101/*}}}*/
    112 /*FUNCTION IntVecParam::SetValue{{{*/
    113 void  IntVecParam::SetValue(int* intarray,int in_M){
     102void  IntVecParam::SetValue(int* intarray,int in_M){/*{{{*/
    114103
    115104        /*avoid leak: */

  • issm/trunk-jpl/src/c/classes/Params/MatrixParam.cpp

    r16233 r18064  
    1616
    1717/*MatrixParam constructors and destructor*/
    18 /*FUNCTION MatrixParam::MatrixParam(){{{*/
    19 MatrixParam::MatrixParam(){
     18MatrixParam::MatrixParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION MatrixParam::MatrixParam(int enum_type,Matrix<IssmDouble>* value){{{*/
    24 MatrixParam::MatrixParam(int in_enum_type,Matrix<IssmDouble>* in_value){
     22MatrixParam::MatrixParam(int in_enum_type,Matrix<IssmDouble>* in_value){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    3230}
    3331/*}}}*/
    34 /*FUNCTION MatrixParam::~MatrixParam(){{{*/
    35 MatrixParam::~MatrixParam(){
     32MatrixParam::~MatrixParam(){/*{{{*/
    3633        delete value;
    3734}
    … …  
    3936
    4037/*Object virtual functions definitions:*/
    41 /*FUNCTION MatrixParam::Echo {{{*/
    42 void MatrixParam::Echo(void){
     38void MatrixParam::Echo(void){/*{{{*/
    4339
    4440        _printf_("MatrixParam:\n");
    … …  
    4743}
    4844/*}}}*/
    49 /*FUNCTION MatrixParam::DeepEcho{{{*/
    50 void MatrixParam::DeepEcho(void){
     45void MatrixParam::DeepEcho(void){/*{{{*/
    5146
    5247        _printf_("MatrixParam:\n");
    … …  
    5550}
    5651/*}}}*/
    57 /*FUNCTION MatrixParam::Id{{{*/
    58 int    MatrixParam::Id(void){ return -1; }
     52int    MatrixParam::Id(void){ return -1; }/*{{{*/
    5953/*}}}*/
    60 /*FUNCTION MatrixParam::ObjectEnum{{{*/
    61 int MatrixParam::ObjectEnum(void){
     54int MatrixParam::ObjectEnum(void){/*{{{*/
    6255
    6356        return MatrixParamEnum;
    … …  
    6558}
    6659/*}}}*/
    67 /*FUNCTION MatrixParam::copy{{{*/
    68 Object* MatrixParam::copy() {
     60Object* MatrixParam::copy() {/*{{{*/
    6961
    7062        return new MatrixParam(this->enum_type,this->value);
    … …  
    7466
    7567/*MatrixParam virtual functions definitions: */
    76 /*FUNCTION MatrixParam::GetParameterValue{{{*/
    77 void  MatrixParam::GetParameterValue(Matrix<IssmDouble>** poutput){
     68void  MatrixParam::GetParameterValue(Matrix<IssmDouble>** poutput){/*{{{*/
    7869        Matrix<IssmDouble>* output=NULL;
    7970
    … …  
    8475}
    8576/*}}}*/
    86 /*FUNCTION MatrixParam::SetValue{{{*/
    87 void  MatrixParam::SetValue(Matrix<IssmDouble>* matrix){
     77void  MatrixParam::SetValue(Matrix<IssmDouble>* matrix){/*{{{*/
    8878
    8979        /*avoid leak: */

  • issm/trunk-jpl/src/c/classes/Params/Parameters.cpp

    r16792 r18064  
    4040
    4141/*Object constructors and destructor*/
    42 /*FUNCTION Parameters::Parameters(){{{*/
    43 Parameters::Parameters(){
     42Parameters::Parameters(){/*{{{*/
    4443        enum_type=ParametersEnum;
    4544        return;
    4645}
    4746/*}}}*/
    48 /*FUNCTION Parameters::~Parameters(){{{*/
    49 Parameters::~Parameters(){
     47Parameters::~Parameters(){/*{{{*/
    5048        return;
    5149}
    … …  
    5351
    5452/*Object management*/
    55 /*FUNCTION Parameters::Exist{{{*/
    56 bool Parameters::Exist(int enum_type){
     53bool Parameters::Exist(int enum_type){/*{{{*/
    5754
    5855        vector<Object*>::iterator object;
    … …  
    6663}
    6764/*}}}*/
    68 /*FUNCTION Parameters::FindParam(bool* pbool,int enum_type){{{*/
    69 void Parameters::FindParam(bool* pbool,int enum_type){ _assert_(this);
     65void Parameters::FindParam(bool* pbool,int enum_type){ _assert_(this);/*{{{*/
    7066
    7167        vector<Object*>::iterator object;
    … …  
    8379}
    8480/*}}}*/
    85 /*FUNCTION Parameters::FindParam(int* pinteger,int enum_type){{{*/
    86 void Parameters::FindParam(int* pinteger,int enum_type){ _assert_(this);
     81void Parameters::FindParam(int* pinteger,int enum_type){ _assert_(this);/*{{{*/
    8782
    8883        vector<Object*>::iterator object;
    … …  
    10095}
    10196/*}}}*/
    102 /*FUNCTION Parameters::FindParam(IssmDouble* pscalar, int enum_type){{{*/
    103 void Parameters::FindParam(IssmDouble* pscalar, int enum_type){ _assert_(this);
     97void Parameters::FindParam(IssmDouble* pscalar, int enum_type){ _assert_(this);/*{{{*/
    10498
    10599        vector<Object*>::iterator object;
    … …  
    117111}
    118112/*}}}*/
    119 /*FUNCTION Parameters::FindParam(IssmDouble* pscalar, int enum_type,IssmDouble time){{{*/
    120 void Parameters::FindParam(IssmDouble* pscalar, int enum_type,IssmDouble time){ _assert_(this);
     113void Parameters::FindParam(IssmDouble* pscalar, int enum_type,IssmDouble time){ _assert_(this);/*{{{*/
    121114
    122115        vector<Object*>::iterator object;
    … …  
    134127}
    135128/*}}}*/
    136 /*FUNCTION Parameters::FindParam(char** pstring,int enum_type){{{*/
    137 void Parameters::FindParam(char** pstring,int enum_type){ _assert_(this);
     129void Parameters::FindParam(char** pstring,int enum_type){ _assert_(this);/*{{{*/
    138130
    139131        vector<Object*>::iterator object;
    … …  
    152144}
    153145/*}}}*/
    154 /*FUNCTION Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){{{*/
    155 void Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){ _assert_(this);
     146void Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){ _assert_(this);/*{{{*/
    156147
    157148        vector<Object*>::iterator object;
    … …  
    170161}
    171162/*}}}*/
    172 /*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int enum_type){{{*/
    173 void Parameters::FindParam(int** pintarray,int* pM, int enum_type){ _assert_(this);
     163void Parameters::FindParam(int** pintarray,int* pM, int enum_type){ _assert_(this);/*{{{*/
    174164
    175165        vector<Object*>::iterator object;
    … …  
    188178}
    189179/*}}}*/
    190 /*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int* pN,int enum_type){{{*/
    191 void Parameters::FindParam(int** pintarray,int* pM,int *pN,int enum_type){ _assert_(this);
     180void Parameters::FindParam(int** pintarray,int* pM,int *pN,int enum_type){ _assert_(this);/*{{{*/
    192181
    193182        vector<Object*>::iterator object;
    … …  
    206195}
    207196/*}}}*/
    208 /*FUNCTION Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM,int enum_type){{{*/
    209 void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int enum_type){ _assert_(this);
     197void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int enum_type){ _assert_(this);/*{{{*/
    210198
    211199        vector<Object*>::iterator object;
    … …  
    224212}
    225213/*}}}*/
    226 /*FUNCTION Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int* pN,int enum_type){{{*/
    227 void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int* pN,int enum_type){ _assert_(this);
     214void Parameters::FindParam(IssmDouble** pIssmDoublearray,int* pM, int* pN,int enum_type){ _assert_(this);/*{{{*/
    228215
    229216        vector<Object*>::iterator object;
    … …  
    242229}
    243230/*}}}*/
    244 /*FUNCTION Parameters::FindParam(IssmDouble*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){{{*/
    245 void Parameters::FindParam(IssmDouble*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){ _assert_(this);
     231void Parameters::FindParam(IssmDouble*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){ _assert_(this);/*{{{*/
    246232
    247233        vector<Object*>::iterator object;
    … …  
    259245}
    260246/*}}}*/
    261 /*FUNCTION Parameters::FindParam(Vector<IssmDouble>** pvec,int enum_type){{{*/
    262 void Parameters::FindParam(Vector<IssmDouble>** pvec,int enum_type){ _assert_(this);
     247void Parameters::FindParam(Vector<IssmDouble>** pvec,int enum_type){ _assert_(this);/*{{{*/
    263248
    264249        vector<Object*>::iterator object;
    … …  
    277262}
    278263/*}}}*/
    279 /*FUNCTION Parameters::FindParam(Matrix<IssmDouble>** pmat,int enum_type){{{*/
    280 void Parameters::FindParam(Matrix<IssmDouble>** pmat,int enum_type){ _assert_(this);
     264void Parameters::FindParam(Matrix<IssmDouble>** pmat,int enum_type){ _assert_(this);/*{{{*/
    281265
    282266        vector<Object*>::iterator object;
    … …  
    295279}
    296280/*}}}*/
    297 /*FUNCTION Parameters::FindParam(FILE** pfid,int enum_type){{{*/
    298 void Parameters::FindParam(FILE** pfid,int enum_type){ _assert_(this);
     281void Parameters::FindParam(FILE** pfid,int enum_type){ _assert_(this);/*{{{*/
    299282
    300283        vector<Object*>::iterator object;
    … …  
    312295}
    313296/*}}}*/
    314 /*FUNCTION Parameters::FindParam(DataSet** pdataset,int enum_type){{{*/
    315 void Parameters::FindParam(DataSet** pdataset,int enum_type){
     297void Parameters::FindParam(DataSet** pdataset,int enum_type){ /*{{{*/
    316298        _assert_(this);
    317299
    … …  
    331313/*}}}*/
    332314
    333 /*FUNCTION Parameters::SetParam(bool boolean,int enum_type);{{{*/
    334 void   Parameters::SetParam(bool boolean,int enum_type){
     315void   Parameters::SetParam(bool boolean,int enum_type){/*{{{*/
    335316
    336317        Param* param=NULL;
    … …  
    343324}
    344325/*}}}*/
    345 /*FUNCTION Parameters::SetParam(int integer,int enum_type);{{{*/
    346 void   Parameters::SetParam(int integer,int enum_type){
     326void   Parameters::SetParam(int integer,int enum_type){/*{{{*/
    347327
    348328        Param* param=NULL;
    … …  
    355335}
    356336/*}}}*/
    357 /*FUNCTION Parameters::SetParam(IssmDouble scalar,int enum_type);{{{*/
    358 void   Parameters::SetParam(IssmDouble scalar,int enum_type){
     337void   Parameters::SetParam(IssmDouble scalar,int enum_type){/*{{{*/
    359338
    360339        Param* param=NULL;
    … …  
    367346}
    368347/*}}}*/
    369 /*FUNCTION Parameters::SetParam(char* string,int enum_type);{{{*/
    370 void   Parameters::SetParam(char* string,int enum_type){
     348void   Parameters::SetParam(char* string,int enum_type){/*{{{*/
    371349
    372350        Param* param=NULL;
    … …  
    379357}
    380358/*}}}*/
    381 /*FUNCTION Parameters::SetParam(char** stringarray,int M, int enum_type);{{{*/
    382 void   Parameters::SetParam(char** stringarray,int M, int enum_type){
     359void   Parameters::SetParam(char** stringarray,int M, int enum_type){/*{{{*/
    383360
    384361        Param* param=NULL;
    … …  
    391368}
    392369/*}}}*/
    393 /*FUNCTION Parameters::SetParam(IssmDouble* IssmDoublearray,int M,int enum_type);{{{*/
    394 void   Parameters::SetParam(IssmDouble* IssmDoublearray,int M, int enum_type){
     370void   Parameters::SetParam(IssmDouble* IssmDoublearray,int M, int enum_type){/*{{{*/
    395371
    396372        Param* param=NULL;
    … …  
    403379}
    404380/*}}}*/
    405 /*FUNCTION Parameters::SetParam(IssmDouble* IssmDoublearray,int M,int N, int enum_type);{{{*/
    406 void   Parameters::SetParam(IssmDouble* IssmDoublearray,int M, int N, int enum_type){
     381void   Parameters::SetParam(IssmDouble* IssmDoublearray,int M, int N, int enum_type){/*{{{*/
    407382
    408383        Param* param=NULL;
    … …  
    415390}
    416391/*}}}*/
    417 /*FUNCTION Parameters::SetParam(int* intarray,int M,int enum_type);{{{*/
    418 void   Parameters::SetParam(int* intarray,int M, int enum_type){
     392void   Parameters::SetParam(int* intarray,int M, int enum_type){/*{{{*/
    419393
    420394        Param* param=NULL;
    … …  
    427401}
    428402/*}}}*/
    429 /*FUNCTION Parameters::SetParam(int* intarray,int M,int N, int enum_type);{{{*/
    430 void   Parameters::SetParam(int* intarray,int M, int N, int enum_type){
     403void   Parameters::SetParam(int* intarray,int M, int N, int enum_type){/*{{{*/
    431404
    432405        Param* param=NULL;
    … …  
    439412}
    440413/*}}}*/
    441 /*FUNCTION Parameters::SetParam(Vector<IssmDouble>* vector,int enum_type);{{{*/
    442 void   Parameters::SetParam(Vector<IssmDouble>* vector,int enum_type){
     414void   Parameters::SetParam(Vector<IssmDouble>* vector,int enum_type){/*{{{*/
    443415
    444416        Param* param=NULL;
    … …  
    451423}
    452424/*}}}*/
    453 /*FUNCTION Parameters::SetParam(Matrix<IssmDouble>* matrix,int enum_type);{{{*/
    454 void   Parameters::SetParam(Matrix<IssmDouble>* matrix,int enum_type){
     425void   Parameters::SetParam(Matrix<IssmDouble>* matrix,int enum_type){/*{{{*/
    455426
    456427        Param* param=NULL;
    … …  
    463434}
    464435/*}}}*/
    465 /*FUNCTION Parameters::SetParam(FILE* fid,int enum_type);{{{*/
    466 void   Parameters::SetParam(FILE* fid,int enum_type){
     436void   Parameters::SetParam(FILE* fid,int enum_type){/*{{{*/
    467437
    468438        Param* param=NULL;
    … …  
    475445}
    476446/*}}}*/
    477 /*FUNCTION Parameters::SetParam(DataSet* dataset, int enum_type);{{{*/
    478 void   Parameters::SetParam(DataSet* dataset,int enum_type){
     447void   Parameters::SetParam(DataSet* dataset,int enum_type){/*{{{*/
    479448
    480449        Param* param=NULL;
    … …  
    488457/*}}}*/
    489458
    490 /*FUNCTION Parameters::FindParamObject{{{*/
    491 Object* Parameters::FindParamObject(int enum_type){
     459Object* Parameters::FindParamObject(int enum_type){/*{{{*/
    492460
    493461        vector<Object*>::iterator object;

  • issm/trunk-jpl/src/c/classes/Params/StringArrayParam.cpp

    r16655 r18064  
    1616
    1717/*StringArrayParam constructors and destructor*/
    18 /*FUNCTION StringArrayParam::StringArrayParam(){{{*/
    19 StringArrayParam::StringArrayParam(){
     18StringArrayParam::StringArrayParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION StringArrayParam::StringArrayParam(int enum_type,char** in_values,int in_numstrings){{{*/
    24 StringArrayParam::StringArrayParam(int in_enum_type,char** in_values, int in_numstrings){
     22StringArrayParam::StringArrayParam(int in_enum_type,char** in_values, int in_numstrings){/*{{{*/
    2523
    2624        int i;
    … …  
    4442}
    4543/*}}}*/
    46 /*FUNCTION StringArrayParam::~StringArrayParam(){{{*/
    47 StringArrayParam::~StringArrayParam(){
     44StringArrayParam::~StringArrayParam(){/*{{{*/
    4845
    4946        int i;
    … …  
    5956
    6057/*Object virtual functions definitions:*/
    61 /*FUNCTION StringArrayParam::Echo {{{*/
    62 void StringArrayParam::Echo(void){
     58void StringArrayParam::Echo(void){/*{{{*/
    6359        this->DeepEcho();
    6460}
    6561/*}}}*/
    66 /*FUNCTION StringArrayParam::DeepEcho{{{*/
    67 void StringArrayParam::DeepEcho(void){
     62void StringArrayParam::DeepEcho(void){/*{{{*/
    6863
    6964        _printf_(setw(22)<<"   StringArrayParam "<<setw(35)<<left<<EnumToStringx(this->enum_type)<<" {");
    … …  
    7267}
    7368/*}}}*/
    74 /*FUNCTION StringArrayParam::Id{{{*/
    75 int    StringArrayParam::Id(void){ return -1; }
     69int    StringArrayParam::Id(void){ return -1; }/*{{{*/
    7670/*}}}*/
    77 /*FUNCTION StringArrayParam::ObjectEnum{{{*/
    78 int StringArrayParam::ObjectEnum(void){
     71int StringArrayParam::ObjectEnum(void){/*{{{*/
    7972
    8073        return StringArrayParamEnum;
    … …  
    8275}
    8376/*}}}*/
    84 /*FUNCTION StringArrayParam::copy{{{*/
    85 Object* StringArrayParam::copy() {
     77Object* StringArrayParam::copy() {/*{{{*/
    8678
    8779        return new StringArrayParam(this->enum_type,this->value,this->numstrings);
    … …  
    9183
    9284/*StringArrayParam virtual functions definitions: */
    93 /*FUNCTION StringArrayParam::GetParameterValue{{{*/
    94 void  StringArrayParam::GetParameterValue(char*** pstringarray,int* pM){
     85void  StringArrayParam::GetParameterValue(char*** pstringarray,int* pM){/*{{{*/
    9586
    9687        int   i;
    … …  
    122113}
    123114/*}}}*/
    124 /*FUNCTION StringArrayParam::SetValue{{{*/
    125 void  StringArrayParam::SetValue(char** stringarray,int M){
     115void  StringArrayParam::SetValue(char** stringarray,int M){/*{{{*/
    126116
    127117        int   i;

  • issm/trunk-jpl/src/c/classes/Params/StringParam.cpp

    r16655 r18064  
    1616
    1717/*StringParam constructors and destructor*/
    18 /*FUNCTION StringParam::StringParam(){{{*/
    19 StringParam::StringParam(){
     18StringParam::StringParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION StringParam::StringParam(int enum_type,IssmString value){{{*/
    24 StringParam::StringParam(int in_enum_type,char* in_value){
     22StringParam::StringParam(int in_enum_type,char* in_value){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    3028}
    3129/*}}}*/
    32 /*FUNCTION StringParam::~StringParam(){{{*/
    33 StringParam::~StringParam(){
     30StringParam::~StringParam(){/*{{{*/
    3431        xDelete<char>(value);
    3532}
    … …  
    3734
    3835/*Object virtual functions definitions:*/
    39 /*FUNCTION StringParam::Echo {{{*/
    40 void StringParam::Echo(void){
     36void StringParam::Echo(void){/*{{{*/
    4137        this->DeepEcho();
    4238}
    4339/*}}}*/
    44 /*FUNCTION StringParam::DeepEcho{{{*/
    45 void StringParam::DeepEcho(void){
     40void StringParam::DeepEcho(void){/*{{{*/
    4641        _printf_(setw(22)<<"   StringParam "<<setw(35)<<left<<EnumToStringx(this->enum_type)<<" "<<this->value<<"\n");
    4742}
    4843/*}}}*/
    49 /*FUNCTION StringParam::Id{{{*/
    50 int    StringParam::Id(void){ return -1; }
     44int    StringParam::Id(void){ return -1; }/*{{{*/
    5145/*}}}*/
    52 /*FUNCTION StringParam::ObjectEnum{{{*/
    53 int StringParam::ObjectEnum(void){
     46int StringParam::ObjectEnum(void){/*{{{*/
    5447
    5548        return StringParamEnum;
    … …  
    5750}
    5851/*}}}*/
    59 /*FUNCTION StringParam::copy{{{*/
    60 Object* StringParam::copy() {
     52Object* StringParam::copy() {/*{{{*/
    6153
    6254        return new StringParam(this->enum_type,this->value);
    … …  
    6658
    6759/*StringParam virtual functions definitions: */
    68 /*FUNCTION StringParam::GetParameterValue{{{*/
    69 void  StringParam::GetParameterValue(char** pstring){
     60void  StringParam::GetParameterValue(char** pstring){/*{{{*/
    7061
    7162        char* outstring=NULL;
    … …  
    8172}
    8273/*}}}*/
    83 /*FUNCTION StringParam::SetValue{{{*/
    84 void  StringParam::SetValue(char* string){
     74void  StringParam::SetValue(char* string){/*{{{*/
    8575
    8676        int   stringsize;

  • issm/trunk-jpl/src/c/classes/Params/TransientParam.cpp

    r16233 r18064  
    1616
    1717/*TransientParam constructors and destructor*/
    18 /*FUNCTION TransientParam::TransientParam(){{{*/
    19 TransientParam::TransientParam(){
     18TransientParam::TransientParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION TransientParam::TransientParam(int enum_type,IssmDoubleMat value){{{*/
    24 TransientParam::TransientParam(int in_enum_type,IssmDouble* in_values,IssmDouble* in_time,int in_N){
     22TransientParam::TransientParam(int in_enum_type,IssmDouble* in_values,IssmDouble* in_time,int in_N){/*{{{*/
    2523
    2624        _assert_(in_values && in_time);
    … …  
    3634}
    3735/*}}}*/
    38 /*FUNCTION TransientParam::~TransientParam(){{{*/
    39 TransientParam::~TransientParam(){
     36TransientParam::~TransientParam(){/*{{{*/
    4037        xDelete<IssmDouble>(values);
    4138        xDelete<IssmDouble>(timesteps);
    … …  
    4441
    4542/*Object virtual functions definitions:*/
    46 /*FUNCTION TransientParam::Echo {{{*/
    47 void TransientParam::Echo(void){
     43void TransientParam::Echo(void){/*{{{*/
    4844
    4945        _printf_("TransientParam:\n");
    … …  
    5349}
    5450/*}}}*/
    55 /*FUNCTION TransientParam::DeepEcho{{{*/
    56 void TransientParam::DeepEcho(void){
     51void TransientParam::DeepEcho(void){/*{{{*/
    5752
    5853        _printf_("TransientParam:\n");
    … …  
    6459}
    6560/*}}}*/
    66 /*FUNCTION TransientParam::Id{{{*/
    67 int    TransientParam::Id(void){ return -1; }
     61int    TransientParam::Id(void){ return -1; }/*{{{*/
    6862/*}}}*/
    69 /*FUNCTION TransientParam::ObjectEnum{{{*/
    70 int TransientParam::ObjectEnum(void){
     63int TransientParam::ObjectEnum(void){/*{{{*/
    7164
    7265        return TransientParamEnum;
    … …  
    7467}
    7568/*}}}*/
    76 /*FUNCTION TransientParam::copy{{{*/
    77 Object* TransientParam::copy() {
     69Object* TransientParam::copy() {/*{{{*/
    7870
    7971        return new TransientParam(this->enum_type,this->values,this->timesteps,this->N);
    … …  
    8375
    8476/*TransientParam virtual functions definitions: */
    85 /*FUNCTION TransientParam::GetParameterValue(IssmDouble* pdouble,IssmDouble time){{{*/
    86 void  TransientParam::GetParameterValue(IssmDouble* pdouble,IssmDouble time){
     77void  TransientParam::GetParameterValue(IssmDouble* pdouble,IssmDouble time){/*{{{*/
    8778
    8879        IssmDouble output;

  • issm/trunk-jpl/src/c/classes/Params/VectorParam.cpp

    r16233 r18064  
    1616
    1717/*VectorParam constructors and destructor*/
    18 /*FUNCTION VectorParam::VectorParam(){{{*/
    19 VectorParam::VectorParam(){
     18VectorParam::VectorParam(){/*{{{*/
    2019        return;
    2120}
    2221/*}}}*/
    23 /*FUNCTION VectorParam::VectorParam(int enum_type,IssmVector value){{{*/
    24 VectorParam::VectorParam(int in_enum_type,Vector<IssmDouble>* in_value){
     22VectorParam::VectorParam(int in_enum_type,Vector<IssmDouble>* in_value){/*{{{*/
    2523
    2624        enum_type=in_enum_type;
    … …  
    3432}
    3533/*}}}*/
    36 /*FUNCTION VectorParam::~VectorParam(){{{*/
    37 VectorParam::~VectorParam(){
     34VectorParam::~VectorParam(){/*{{{*/
    3835        delete value;
    3936}
    … …  
    4138
    4239/*Object virtual functions definitions:*/
    43 /*FUNCTION VectorParam::Echo {{{*/
    44 void VectorParam::Echo(void){
     40void VectorParam::Echo(void){/*{{{*/
    4541
    4642        _printf_("VectorParam:\n");
    … …  
    4945}
    5046/*}}}*/
    51 /*FUNCTION VectorParam::DeepEcho{{{*/
    52 void VectorParam::DeepEcho(void){
     47void VectorParam::DeepEcho(void){/*{{{*/
    5348
    5449        _printf_("VectorParam:\n");
    … …  
    5752}
    5853/*}}}*/
    59 /*FUNCTION VectorParam::Id{{{*/
    60 int    VectorParam::Id(void){ return -1; }
     54int    VectorParam::Id(void){ return -1; }/*{{{*/
    6155/*}}}*/
    62 /*FUNCTION VectorParam::ObjectEnum{{{*/
    63 int VectorParam::ObjectEnum(void){
     56int VectorParam::ObjectEnum(void){/*{{{*/
    6457
    6558        return VectorParamEnum;
    … …  
    6760}
    6861/*}}}*/
    69 /*FUNCTION VectorParam::copy{{{*/
    70 Object* VectorParam::copy() {
     62Object* VectorParam::copy() {/*{{{*/
    7163
    7264        return new VectorParam(this->enum_type,this->value);
    … …  
    7668
    7769/*VectorParam virtual functions definitions: */
    78 /*FUNCTION VectorParam::GetParameterValue{{{*/
    79 void  VectorParam::GetParameterValue(Vector<IssmDouble>** poutput){
     70void  VectorParam::GetParameterValue(Vector<IssmDouble>** poutput){/*{{{*/
    8071        Vector<IssmDouble>*  output=NULL;
    8172
    … …  
    8778}
    8879/*}}}*/
    89 /*FUNCTION VectorParam::SetValue{{{*/
    90 void  VectorParam::SetValue(Vector<IssmDouble>* vector){
     80void  VectorParam::SetValue(Vector<IssmDouble>* vector){/*{{{*/
    9181
    9282        /*avoid leak: */

  • issm/trunk-jpl/src/c/classes/gauss/GaussPenta.cpp

    r17504 r18064  
    1313
    1414/*GaussPenta constructors and destructors:*/
    15 /*FUNCTION GaussPenta::GaussPenta() {{{*/
    16 GaussPenta::GaussPenta(){
     15GaussPenta::GaussPenta(){/*{{{*/
    1716
    1817        numgauss=-1;
    … …  
    3130}
    3231/*}}}*/
    33 /*FUNCTION GaussPenta::GaussPenta(int order_horiz,int order_vert) {{{*/
    34 GaussPenta::GaussPenta(int order_horiz,int order_vert){
     32GaussPenta::GaussPenta(int order_horiz,int order_vert){/*{{{*/
    3533
    3634        /*Intermediaries*/
    … …  
    8583}
    8684/*}}}*/
    87 /*FUNCTION GaussPenta::GaussPenta(int index1, int index2, int order){{{*/
    88 GaussPenta::GaussPenta(int index1, int index2,int order){
     85GaussPenta::GaussPenta(int index1, int index2,int order){/*{{{*/
    8986
    9087        /*Intermediaties*/
    … …  
    142139}
    143140/*}}}*/
    144 /*FUNCTION GaussPenta::GaussPenta(int index1, int index2, int index3, int order){{{*/
    145 GaussPenta::GaussPenta(int index1, int index2, int index3, int order){
     141GaussPenta::GaussPenta(int index1, int index2, int index3, int order){/*{{{*/
    146142
    147143        /*Basal Tria*/
    … …  
    171167}
    172168/*}}}*/
    173 /*FUNCTION GaussPenta::GaussPenta(int index1, int index2, int index3, int index4,int order_horiz,int order_vert){{{*/
    174 GaussPenta::GaussPenta(int index1, int index2, int index3, int index4,int order_horiz,int order_vert){
     169GaussPenta::GaussPenta(int index1, int index2, int index3, int index4,int order_horiz,int order_vert){/*{{{*/
    175170
    176171        /*Intermediaties*/
    … …  
    238233}
    239234/*}}}*/
    240 /*FUNCTION GaussPenta::GaussPenta(int index,double r1,double r2,int order) {{{*/
    241 GaussPenta::GaussPenta(int index,IssmDouble r1,IssmDouble r2,bool mainlyfloating,int order){
     235GaussPenta::GaussPenta(int index,IssmDouble r1,IssmDouble r2,bool mainlyfloating,int order){/*{{{*/
    242236
    243237        /*
    … …  
    400394}
    401395/*}}}*/
    402 /*FUNCTION GaussPenta::GaussPenta(IssmDouble area_coordinates[4][3],int order_horiz,int order_vert){{{*/
    403 GaussPenta::GaussPenta(IssmDouble area_coordinates[4][3],int order_horiz,int order_vert){
     396GaussPenta::GaussPenta(IssmDouble area_coordinates[4][3],int order_horiz,int order_vert){/*{{{*/
    404397
    405398        /*Intermediaties*/
    … …  
    439432}
    440433/*}}}*/
    441 /*FUNCTION GaussPenta::~GaussPenta(){{{*/
    442 GaussPenta::~GaussPenta(){
     434GaussPenta::~GaussPenta(){/*{{{*/
    443435        xDelete<IssmDouble>(weights);
    444436        xDelete<IssmDouble>(coords1);
    … …  
    450442
    451443/*Methods*/
    452 /*FUNCTION GaussPenta::Echo{{{*/
    453 void GaussPenta::Echo(void){
     444void GaussPenta::Echo(void){/*{{{*/
    454445
    455446        _printf_("GaussPenta:\n");
    … …  
    495486}
    496487/*}}}*/
    497 /*FUNCTION GaussPenta::Enum{{{*/
    498 int GaussPenta::Enum(void){
     488int GaussPenta::Enum(void){/*{{{*/
    499489        return GaussPentaEnum;
    500490}
    501491/*}}}*/
    502 /*FUNCTION GaussPenta::GaussPoint{{{*/
    503 void GaussPenta::GaussPoint(int ig){
     492void GaussPenta::GaussPoint(int ig){/*{{{*/
    504493
    505494        /*Check input in debugging mode*/
    … …  
    515504}
    516505/*}}}*/
    517 /*FUNCTION GaussPenta::GaussVertex{{{*/
    518 void GaussPenta::GaussVertex(int iv){
     506void GaussPenta::GaussVertex(int iv){/*{{{*/
    519507
    520508        /*in debugging mode: check that the default constructor has been called*/
    … …  
    535523}
    536524/*}}}*/
    537 /*FUNCTION GaussPenta::GaussFaceTria{{{*/
    538 void GaussPenta::GaussFaceTria(int index1, int index2, int index3, int order){
     525void GaussPenta::GaussFaceTria(int index1, int index2, int index3, int order){/*{{{*/
    539526
    540527        /*in debugging mode: check that the default constructor has been called*/
    … …  
    553540}
    554541/*}}}*/
    555 /*FUNCTION GaussPenta::GaussNode{{{*/
    556 void GaussPenta::GaussNode(int finiteelement,int iv){
     542void GaussPenta::GaussNode(int finiteelement,int iv){/*{{{*/
    557543
    558544        /*in debugging mode: check that the default constructor has been called*/
    … …  
    705691}
    706692/*}}}*/
    707 /*FUNCTION GaussPenta::begin{{{*/
    708 int GaussPenta::begin(void){
     693int GaussPenta::begin(void){/*{{{*/
    709694
    710695        /*Check that this has been initialized*/
    … …  
    720705}
    721706/*}}}*/
    722 /*FUNCTION GaussPenta::end{{{*/
    723 int GaussPenta::end(void){
     707int GaussPenta::end(void){/*{{{*/
    724708
    725709        /*Check that this has been initialized*/
    … …  
    735719}
    736720/*}}}*/
    737 /*FUNCTION GaussPenta::SynchronizeGaussBase{{{*/
    738 void GaussPenta::SynchronizeGaussBase(Gauss* gauss){
     721void GaussPenta::SynchronizeGaussBase(Gauss* gauss){/*{{{*/
    739722
    740723        _assert_(gauss->Enum()==GaussTriaEnum);

  • issm/trunk-jpl/src/c/classes/gauss/GaussSeg.cpp

    r17315 r18064  
    1212
    1313/*GaussSeg constructors and destructors:*/
    14 /*FUNCTION GaussSeg::GaussSeg() {{{*/
    15 GaussSeg::GaussSeg(){
     14GaussSeg::GaussSeg(){/*{{{*/
    1615
    1716        numgauss=-1;
    … …  
    2423}
    2524/*}}}*/
    26 /*FUNCTION GaussSeg::GaussSeg(int order) {{{*/
    27 GaussSeg::GaussSeg(int order){
     25GaussSeg::GaussSeg(int order){/*{{{*/
    2826
    2927        IssmPDouble* pcoords1=NULL;
    … …  
    5250}
    5351/*}}}*/
    54 /*FUNCTION GaussSeg::GaussSeg(IssmDouble position) {{{*/
    55 GaussSeg::GaussSeg(IssmDouble position){
     52GaussSeg::GaussSeg(IssmDouble position){/*{{{*/
    5653
    5754        /*Get gauss points*/
    … …  
    7067}
    7168/*}}}*/
    72 /*FUNCTION GaussSeg::~GaussSeg(){{{*/
    73 GaussSeg::~GaussSeg(){
     69GaussSeg::~GaussSeg(){/*{{{*/
    7470        xDelete<IssmDouble>(weights);
    7571        xDelete<IssmDouble>(coords1);
    … …  
    7874
    7975/*Methods*/
    80 /*FUNCTION GaussSeg::Echo{{{*/
    81 void GaussSeg::Echo(void){
     76void GaussSeg::Echo(void){/*{{{*/
    8277
    8378        _printf_("GaussSeg:\n");
    … …  
    10095}
    10196/*}}}*/
    102 /*FUNCTION GaussSeg::Enum{{{*/
    103 int GaussSeg::Enum(void){
     97int GaussSeg::Enum(void){/*{{{*/
    10498        return GaussSegEnum;
    10599}
    106100/*}}}*/
    107 /*FUNCTION GaussSeg::GaussPoint{{{*/
    108 void GaussSeg::GaussPoint(int ig){
     101void GaussSeg::GaussPoint(int ig){/*{{{*/
    109102
    110103        /*Check input in debugging mode*/
    … …  
    116109}
    117110/*}}}*/
    118 /*FUNCTION GaussSeg::GaussVertex{{{*/
    119 void GaussSeg::GaussVertex(int iv){
     111void GaussSeg::GaussVertex(int iv){/*{{{*/
    120112
    121113        /*in debugging mode: check that the default constructor has been called*/
    … …  
    130122}
    131123/*}}}*/
    132 /*FUNCTION GaussSeg::GaussNode{{{*/
    133 void GaussSeg::GaussNode(int finiteelement,int iv){
     124void GaussSeg::GaussNode(int finiteelement,int iv){/*{{{*/
    134125
    135126        /*in debugging mode: check that the default constructor has been called*/
    … …  
    150141}
    151142/*}}}*/
    152 /*FUNCTION GaussSeg::begin{{{*/
    153 int GaussSeg::begin(void){
     143int GaussSeg::begin(void){/*{{{*/
    154144
    155145        /*Check that this has been initialized*/
    … …  
    162152}
    163153/*}}}*/
    164 /*FUNCTION GaussSeg::end{{{*/
    165 int GaussSeg::end(void){
     154int GaussSeg::end(void){/*{{{*/
    166155
    167156        /*Check that this has been initialized*/
    … …  
    174163}
    175164/*}}}*/
    176 /*FUNCTION GaussSeg::SynchronizeGaussBase{{{*/
    177 void GaussSeg::SynchronizeGaussBase(Gauss* gauss){
     165void GaussSeg::SynchronizeGaussBase(Gauss* gauss){/*{{{*/
    178166
    179167        _error_("not supported");

  • issm/trunk-jpl/src/c/classes/gauss/GaussTetra.cpp

    r17866 r18064  
    1313
    1414/*GaussTetra constructors and destructors:*/
    15 /*FUNCTION GaussTetra::GaussTetra() {{{*/
    16 GaussTetra::GaussTetra(){
     15GaussTetra::GaussTetra(){/*{{{*/
    1716
    1817        numgauss=-1;
    … …  
    3130}
    3231/*}}}*/
    33 /*FUNCTION GaussTetra::GaussTetra(int order) {{{*/
    34 GaussTetra::GaussTetra(int order){
     32GaussTetra::GaussTetra(int order){/*{{{*/
    3533
    3634        /*Get gauss points*/
    … …  
    5856}
    5957/*}}}*/
    60 /*FUNCTION GaussTetra::GaussTetra(int index1,int index2,int index3,int order) {{{*/
    61 GaussTetra::GaussTetra(int index1,int index2,int index3,int order){
     58GaussTetra::GaussTetra(int index1,int index2,int index3,int order){/*{{{*/
    6259
    6360        /*Basal Tria*/
    … …  
    8784}
    8885/*}}}*/
    89 /*FUNCTION GaussTetra::~GaussTetra(){{{*/
    90 GaussTetra::~GaussTetra(){
     86GaussTetra::~GaussTetra(){/*{{{*/
    9187        xDelete<IssmDouble>(weights);
    9288        xDelete<IssmDouble>(coords1);
    … …  
    9894
    9995/*Methods*/
    100 /*FUNCTION GaussTetra::Echo{{{*/
    101 void GaussTetra::Echo(void){
     96void GaussTetra::Echo(void){/*{{{*/
    10297
    10398        _printf_("GaussTetra:\n");
    … …  
    143138}
    144139/*}}}*/
    145 /*FUNCTION GaussTetra::Enum{{{*/
    146 int GaussTetra::Enum(void){
     140int GaussTetra::Enum(void){/*{{{*/
    147141        return GaussTetraEnum;
    148142}
    149143/*}}}*/
    150 /*FUNCTION GaussTetra::GaussPoint{{{*/
    151 void GaussTetra::GaussPoint(int ig){
     144void GaussTetra::GaussPoint(int ig){/*{{{*/
    152145
    153146        /*Check input in debugging mode*/
    … …  
    163156}
    164157/*}}}*/
    165 /*FUNCTION GaussTetra::GaussVertex{{{*/
    166 void GaussTetra::GaussVertex(int iv){
     158void GaussTetra::GaussVertex(int iv){/*{{{*/
    167159
    168160        /*in debugging mode: check that the default constructor has been called*/
    … …  
    181173}
    182174/*}}}*/
    183 /*FUNCTION GaussTetra::GaussNode{{{*/
    184 void GaussTetra::GaussNode(int finiteelement,int iv){
     175void GaussTetra::GaussNode(int finiteelement,int iv){/*{{{*/
    185176
    186177        /*in debugging mode: check that the default constructor has been called*/
    … …  
    229220}
    230221/*}}}*/
    231 /*FUNCTION GaussTetra::begin{{{*/
    232 int GaussTetra::begin(void){
     222int GaussTetra::begin(void){/*{{{*/
    233223
    234224        /*Check that this has been initialized*/
    … …  
    244234}
    245235/*}}}*/
    246 /*FUNCTION GaussTetra::end{{{*/
    247 int GaussTetra::end(void){
     236int GaussTetra::end(void){/*{{{*/
    248237
    249238        /*Check that this has been initialized*/
    … …  
    259248}
    260249/*}}}*/
    261 /*FUNCTION GaussTetra::SynchronizeGaussBase{{{*/
    262 void GaussTetra::SynchronizeGaussBase(Gauss* gauss){
     250void GaussTetra::SynchronizeGaussBase(Gauss* gauss){/*{{{*/
    263251
    264252        _error_("not supported");

  • issm/trunk-jpl/src/c/classes/gauss/GaussTria.cpp

    r18039 r18064  
    77
    88/*GaussTria constructors and destructors:*/
    9 /*FUNCTION GaussTria::GaussTria() {{{*/
    10 GaussTria::GaussTria(){
     9GaussTria::GaussTria(){/*{{{*/
    1110
    1211        numgauss=-1;
    … …  
    2322}
    2423/*}}}*/
    25 /*FUNCTION GaussTria::GaussTria(int order) {{{*/
    26 GaussTria::GaussTria(int order){
     24GaussTria::GaussTria(int order){/*{{{*/
    2725
    2826        /*Get gauss points*/
    … …  
    3735}
    3836/*}}}*/
    39 /*FUNCTION GaussTria::GaussTria(int index1,int index2,int order) {{{*/
    40 GaussTria::GaussTria(int index1,int index2,int order){
     37GaussTria::GaussTria(int index1,int index2,int order){/*{{{*/
    4138
    4239        /*Intermediaties*/
    … …  
    10097}
    10198/*}}}*/
    102 /*FUNCTION GaussTria::GaussTria(IssmDouble area_coordinates,int order) {{{*/
    103 GaussTria::GaussTria(IssmDouble area_coordinates[2][3],int order){
     99GaussTria::GaussTria(IssmDouble area_coordinates[2][3],int order){/*{{{*/
    104100
    105101        /*Intermediaties*/
    … …  
    136132}
    137133/*}}}*/
    138 /*FUNCTION GaussTria::GaussTria(int index,double r1,double r2,int order) {{{*/
    139 GaussTria::GaussTria(int index,IssmDouble r1,IssmDouble r2,bool mainlyfloating,int order){
     134GaussTria::GaussTria(int index,IssmDouble r1,IssmDouble r2,bool mainlyfloating,int order){/*{{{*/
    140135
    141136        /*
    … …  
    292287}
    293288/*}}}*/
    294 /*FUNCTION GaussTria::~GaussTria(){{{*/
    295 GaussTria::~GaussTria(){
     289GaussTria::~GaussTria(){/*{{{*/
    296290        xDelete<IssmDouble>(weights);
    297291        xDelete<IssmDouble>(coords3);
    … …  
    303297
    304298/*Methods*/
    305 /*FUNCTION GaussTria::Echo{{{*/
    306 void GaussTria::Echo(void){
     299void GaussTria::Echo(void){/*{{{*/
    307300
    308301        _printf_("GaussTria:\n");
    … …  
    341334}
    342335/*}}}*/
    343 /*FUNCTION GaussTria::Enum{{{*/
    344 int GaussTria::Enum(void){
     336int GaussTria::Enum(void){/*{{{*/
    345337        return GaussTriaEnum;
    346338}
    347339/*}}}*/
    348 /*FUNCTION GaussTria::GaussEdgeCenter{{{*/
    349 void GaussTria::GaussEdgeCenter(int index1,int index2){
     340void GaussTria::GaussEdgeCenter(int index1,int index2){/*{{{*/
    350341
    351342        int     index3;
    … …  
    377368}
    378369/*}}}*/
    379 /*FUNCTION GaussTria::GaussPoint{{{*/
    380 void GaussTria::GaussPoint(int ig){
     370void GaussTria::GaussPoint(int ig){/*{{{*/
    381371
    382372        /*Check input in debugging mode*/
    … …  
    391381}
    392382/*}}}*/
    393 /*FUNCTION GaussTria::GaussFromCoords{{{*/
    394 void GaussTria::GaussFromCoords(IssmDouble x,IssmDouble y,IssmDouble* xyz_list){
     383void GaussTria::GaussFromCoords(IssmDouble x,IssmDouble y,IssmDouble* xyz_list){/*{{{*/
    395384
    396385        /*Intermediaries*/
    … …  
    418407}
    419408/*}}}*/
    420 /*FUNCTION GaussTria::GaussVertex{{{*/
    421 void GaussTria::GaussVertex(int iv){
     409void GaussTria::GaussVertex(int iv){/*{{{*/
    422410
    423411        /*in debugging mode: check that the default constructor has been called*/
    … …  
    434422}
    435423/*}}}*/
    436 /*FUNCTION GaussTria::GaussNode{{{*/
    437 void GaussTria::GaussNode(int finiteelement,int iv){
     424void GaussTria::GaussNode(int finiteelement,int iv){/*{{{*/
    438425
    439426        /*in debugging mode: check that the default constructor has been called*/
    … …  
    481468}
    482469/*}}}*/
    483 /*FUNCTION GaussTria::begin{{{*/
    484 int GaussTria::begin(void){
     470int GaussTria::begin(void){/*{{{*/
    485471
    486472        /*Check that this has been initialized*/
    … …  
    495481}
    496482/*}}}*/
    497 /*FUNCTION GaussTria::end{{{*/
    498 int GaussTria::end(void){
     483int GaussTria::end(void){/*{{{*/
    499484
    500485        /*Check that this has been initialized*/
    … …  
    509494}
    510495/*}}}*/
    511 /*FUNCTION GaussTria::SynchronizeGaussBase{{{*/
    512 void GaussTria::SynchronizeGaussBase(Gauss* gauss){
     496void GaussTria::SynchronizeGaussBase(Gauss* gauss){/*{{{*/
    513497
    514498        _error_("not supported");

  • issm/trunk-jpl/src/c/classes/kriging/ExponentialVariogram.cpp

    r15741 r18064  
    1313
    1414/*ExponentialVariogram constructors and destructor*/
    15 /*FUNCTION ExponentialVariogram::ExponentialVariogram(){{{*/
    16 ExponentialVariogram::ExponentialVariogram(){
     15ExponentialVariogram::ExponentialVariogram(){/*{{{*/
    1716        this->nugget = 0.2;
    1817        this->sill   = 1;
    … …  
    2120}
    2221/*}}}*/
    23 /*FUNCTION ExponentialVariogram::ExponentialVariogram(Options* options){{{*/
    24 ExponentialVariogram::ExponentialVariogram(Options* options){
     22ExponentialVariogram::ExponentialVariogram(Options* options){/*{{{*/
    2523
    2624        /*Defaults*/
    … …  
    3836}
    3937/*}}}*/
    40 /*FUNCTION ExponentialVariogram::~ExponentialVariogram(){{{*/
    41 ExponentialVariogram::~ExponentialVariogram(){
     38ExponentialVariogram::~ExponentialVariogram(){/*{{{*/
    4239        return;
    4340}
    … …  
    4542
    4643/*Object virtual functions definitions:*/
    47 /*FUNCTION ExponentialVariogram::Echo {{{*/
    48 void ExponentialVariogram::Echo(void){
     44void ExponentialVariogram::Echo(void){/*{{{*/
    4945        _printf_("ExponentialVariogram\n");
    5046        _printf_("   nugget: " << this->nugget << "\n");
    … …  
    5551
    5652/*Variogram function*/
    57 /*FUNCTION ExponentialVariogram::Covariance{{{*/
    58 double ExponentialVariogram::Covariance(double deltax,double deltay){
     53double ExponentialVariogram::Covariance(double deltax,double deltay){/*{{{*/
    5954        /*The covariance can be deduced from the variogram from the following
    6055         * relationship:
    … …  
    7671}
    7772/*}}}*/
    78 /*FUNCTION ExponentialVariogram::SemiVariogram{{{*/
    79 double ExponentialVariogram::SemiVariogram(double deltax,double deltay){
     73double ExponentialVariogram::SemiVariogram(double deltax,double deltay){/*{{{*/
    8074        /*http://en.wikipedia.org/wiki/Variogram*/
    8175        double h,a,gamma;

  • issm/trunk-jpl/src/c/classes/kriging/GaussianVariogram.cpp

    r15741 r18064  
    1313
    1414/*GaussianVariogram constructors and destructor*/
    15 /*FUNCTION GaussianVariogram::GaussianVariogram(){{{*/
    16 GaussianVariogram::GaussianVariogram(){
     15GaussianVariogram::GaussianVariogram(){/*{{{*/
    1716        this->nugget = 0.2;
    1817        this->sill   = 1;
    … …  
    2120}
    2221/*}}}*/
    23 /*FUNCTION GaussianVariogram::GaussianVariogram(Options* options){{{*/
    24 GaussianVariogram::GaussianVariogram(Options* options){
     22GaussianVariogram::GaussianVariogram(Options* options){/*{{{*/
    2523
    2624        /*Defaults*/
    … …  
    3836}
    3937/*}}}*/
    40 /*FUNCTION GaussianVariogram::~GaussianVariogram(){{{*/
    41 GaussianVariogram::~GaussianVariogram(){
     38GaussianVariogram::~GaussianVariogram(){/*{{{*/
    4239        return;
    4340}
    … …  
    4542
    4643/*Object virtual functions definitions:*/
    47 /*FUNCTION GaussianVariogram::Echo {{{*/
    48 void GaussianVariogram::Echo(void){
     44void GaussianVariogram::Echo(void){/*{{{*/
    4945        _printf_("GaussianVariogram\n");
    5046        _printf_("   nugget: " << this->nugget << "\n");
    … …  
    5551
    5652/*Variogram function*/
    57 /*FUNCTION GaussianVariogram::Covariance{{{*/
    58 double GaussianVariogram::Covariance(double deltax,double deltay){
     53double GaussianVariogram::Covariance(double deltax,double deltay){/*{{{*/
    5954        /*The covariance can be deduced from the variogram from the following
    6055         * relationship:
    … …  
    7772}
    7873/*}}}*/
    79 /*FUNCTION GaussianVariogram::SemiVariogram{{{*/
    80 double GaussianVariogram::SemiVariogram(double deltax,double deltay){
     74double GaussianVariogram::SemiVariogram(double deltax,double deltay){/*{{{*/
    8175        /*http://en.wikipedia.org/wiki/Variogram*/
    8276        double h2,a,gamma;

  • issm/trunk-jpl/src/c/classes/kriging/Observation.cpp

    r15104 r18064  
    77
    88/*Observation constructors and destructor*/
    9 /*FUNCTION Observation::Observation(){{{*/
    10 Observation::Observation(){
     9Observation::Observation(){/*{{{*/
    1110        return;
    1211}
    1312/*}}}*/
    14 /*FUNCTION Observation::Observation(double x,double y,int xi,int yi,int index,double value){{{*/
    15 Observation::Observation(double x_in,double y_in,int xi_in,int yi_in,int index_in,double value_in){
     13Observation::Observation(double x_in,double y_in,int xi_in,int yi_in,int index_in,double value_in){/*{{{*/
    1614
    1715        this->x      = x_in;
    … …  
    2523}
    2624/*}}}*/
    27 /*FUNCTION Observation::~Observation(){{{*/
    28 Observation::~Observation(){
     25Observation::~Observation(){/*{{{*/
    2926        return;
    3027}
    … …  
    3229
    3330/*Object virtual functions definitions:*/
    34 /*FUNCTION Observation::Echo {{{*/
    35 void Observation::Echo(void){
     31void Observation::Echo(void){/*{{{*/
    3632
    3733        _printf_("Observation\n");
    … …  
    4743
    4844/*Observations functions*/
    49 /*FUNCTION Observation::WriteXYObs(double* px,double* py,double* pobs){{{*/
    50 void Observation::WriteXYObs(double* px,double* py,double* pobs){
     45void Observation::WriteXYObs(double* px,double* py,double* pobs){/*{{{*/
    5146        *px   = this->x;
    5247        *py   = this->y;

  • issm/trunk-jpl/src/c/classes/kriging/Observations.cpp

    r17924 r18064  
    3030
    3131/*Object constructors and destructor*/
    32 /*FUNCTION Observations::Observations(){{{*/
    33 Observations::Observations(){
     32Observations::Observations(){/*{{{*/
    3433        this->quadtree = NULL;
    3534        return;
    3635}
    3736/*}}}*/
    38 /*FUNCTION Observations::Observations(IssmPDouble* observations_list,IssmPDouble* x,IssmPDouble* y,int n,Options* options){{{*/
    39 Observations::Observations(IssmPDouble* observations_list,IssmPDouble* x,IssmPDouble* y,int n,Options* options){
     37Observations::Observations(IssmPDouble* observations_list,IssmPDouble* x,IssmPDouble* y,int n,Options* options){/*{{{*/
    4038
    4139        /*Intermediaries*/
    … …  
    112110}
    113111/*}}}*/
    114 /*FUNCTION Observations::~Observations(){{{*/
    115 Observations::~Observations(){
     112Observations::~Observations(){/*{{{*/
    116113        delete quadtree;
    117114        return;
    … …  
    120117
    121118/*Methods*/
    122 /*FUNCTION Observations::ClosestObservation{{{*/
    123 void Observations::ClosestObservation(IssmPDouble *px,IssmPDouble *py,IssmPDouble *pobs,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius){
     119void Observations::ClosestObservation(IssmPDouble *px,IssmPDouble *py,IssmPDouble *pobs,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius){/*{{{*/
    124120
    125121        /*Output and Intermediaries*/
    … …  
    172168
    173169}/*}}}*/
    174 /*FUNCTION Observations::Distances{{{*/
    175 void Observations::Distances(IssmPDouble* distances,IssmPDouble *x,IssmPDouble *y,int n,IssmPDouble radius){
     170void Observations::Distances(IssmPDouble* distances,IssmPDouble *x,IssmPDouble *y,int n,IssmPDouble radius){/*{{{*/
    176171
    177172        IssmPDouble xi,yi,obs;
    … …  
    187182        }
    188183}/*}}}*/
    189 /*FUNCTION Observations::ObservationList(IssmPDouble **px,IssmPDouble **py,IssmPDouble **pobs,int* pnobs,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius,int maxdata){{{*/
    190 void Observations::ObservationList(IssmPDouble **px,IssmPDouble **py,IssmPDouble **pobs,int* pnobs,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius,int maxdata){
     184void Observations::ObservationList(IssmPDouble **px,IssmPDouble **py,IssmPDouble **pobs,int* pnobs,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius,int maxdata){/*{{{*/
    191185
    192186        /*Output and Intermediaries*/
    … …  
    270264        *pnobs=nobs;
    271265}/*}}}*/
    272 /*FUNCTION Observations::ObservationList(IssmPDouble **px,IssmPDouble **py,IssmPDouble **pobs,int* pnobs){{{*/
    273 void Observations::ObservationList(IssmPDouble **px,IssmPDouble **py,IssmPDouble **pobs,int* pnobs){
     266void Observations::ObservationList(IssmPDouble **px,IssmPDouble **py,IssmPDouble **pobs,int* pnobs){/*{{{*/
    274267
    275268        /*Output and Intermediaries*/
    … …  
    298291        *pnobs=nobs;
    299292}/*}}}*/
    300 /*FUNCTION Observations::InterpolationIDW{{{*/
    301 void Observations::InterpolationIDW(IssmPDouble *pprediction,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius,int mindata,int maxdata,IssmPDouble power){
     293void Observations::InterpolationIDW(IssmPDouble *pprediction,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius,int mindata,int maxdata,IssmPDouble power){/*{{{*/
    302294
    303295        /*Intermediaries*/
    … …  
    347339        xDelete<IssmPDouble>(obs);
    348340}/*}}}*/
    349 /*FUNCTION Observations::InterpolationKriging{{{*/
    350 void Observations::InterpolationKriging(IssmPDouble *pprediction,IssmPDouble *perror,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius,int mindata,int maxdata,Variogram* variogram){
     341void Observations::InterpolationKriging(IssmPDouble *pprediction,IssmPDouble *perror,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius,int mindata,int maxdata,Variogram* variogram){/*{{{*/
    351342
    352343        /*Intermediaries*/
    … …  
    424415
    425416}/*}}}*/
    426 /*FUNCTION Observations::InterpolationNearestNeighbor{{{*/
    427 void Observations::InterpolationNearestNeighbor(IssmPDouble *pprediction,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius){
     417void Observations::InterpolationNearestNeighbor(IssmPDouble *pprediction,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius){/*{{{*/
    428418
    429419        /*Intermediaries*/
    … …  
    436426        *pprediction = obs;
    437427}/*}}}*/
    438 /*FUNCTION Observations::InterpolationV4{{{*/
    439 void Observations::InterpolationV4(IssmPDouble *pprediction,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius,int mindata,int maxdata){
     428void Observations::InterpolationV4(IssmPDouble *pprediction,IssmPDouble x_interp,IssmPDouble y_interp,IssmPDouble radius,int mindata,int maxdata){/*{{{*/
    440429        /* Reference:  David T. Sandwell, Biharmonic spline interpolation of GEOS-3
    441430         * and SEASAT altimeter data, Geophysical Research Letters, 2, 139-142,
    … …  
    519508        xDelete<IssmPDouble>(weights);
    520509}/*}}}*/
    521 /*FUNCTION Observations::QuadtreeColoring{{{*/
    522 void Observations::QuadtreeColoring(IssmPDouble* A,IssmPDouble *x,IssmPDouble *y,int n){
     510void Observations::QuadtreeColoring(IssmPDouble* A,IssmPDouble *x,IssmPDouble *y,int n){/*{{{*/
    523511
    524512        int xi,yi,level;
    … …  
    531519
    532520}/*}}}*/
    533 /*FUNCTION Observations::Variomap{{{*/
    534 void Observations::Variomap(IssmPDouble* gamma,IssmPDouble *x,int n){
     521void Observations::Variomap(IssmPDouble* gamma,IssmPDouble *x,int n){/*{{{*/
    535522
    536523        /*Output and Intermediaries*/

  • issm/trunk-jpl/src/c/classes/kriging/PowerVariogram.cpp

    r15741 r18064  
    1313
    1414/*PowerVariogram constructors and destructor*/
    15 /*FUNCTION PowerVariogram::PowerVariogram(){{{*/
    16 PowerVariogram::PowerVariogram(){
     15PowerVariogram::PowerVariogram(){/*{{{*/
    1716        this->nugget = 0.2;
    1817        this->slope  = 1.;
    … …  
    2120}
    2221/*}}}*/
    23 /*FUNCTION PowerVariogram::PowerVariogram(Options* options){{{*/
    24 PowerVariogram::PowerVariogram(Options* options){
     22PowerVariogram::PowerVariogram(Options* options){/*{{{*/
    2523
    2624        /*Defaults*/
    … …  
    3937}
    4038/*}}}*/
    41 /*FUNCTION PowerVariogram::~PowerVariogram(){{{*/
    42 PowerVariogram::~PowerVariogram(){
     39PowerVariogram::~PowerVariogram(){/*{{{*/
    4340        return;
    4441}
    … …  
    4643
    4744/*Object virtual functions definitions:*/
    48 /*FUNCTION PowerVariogram::Echo {{{*/
    49 void PowerVariogram::Echo(void){
     45void PowerVariogram::Echo(void){/*{{{*/
    5046        _printf_("PowerVariogram\n");
    5147        _printf_("   nugget: " << this->nugget << "\n");
    … …  
    5652
    5753/*Variogram function*/
    58 /*FUNCTION PowerVariogram::Covariance{{{*/
    59 double PowerVariogram::Covariance(double deltax,double deltay){
     54double PowerVariogram::Covariance(double deltax,double deltay){/*{{{*/
    6055        /*The covariance can be deduced from the variogram from the following
    6156         * relationship:
    … …  
    7469}
    7570/*}}}*/
    76 /*FUNCTION PowerVariogram::SemiVariogram{{{*/
    77 double PowerVariogram::SemiVariogram(double deltax,double deltay){
     71double PowerVariogram::SemiVariogram(double deltax,double deltay){/*{{{*/
    7872        /*http://en.wikipedia.org/wiki/Variogram*/
    7973        double h,gamma;

  • issm/trunk-jpl/src/c/classes/kriging/Quadtree.cpp

    r16989 r18064  
    8181
    8282        /*Constructors/Destructors*/
    83 /*FUNCTION Quadtree::Quadtree(){{{*/
    84 Quadtree::Quadtree(){
     83Quadtree::Quadtree(){/*{{{*/
    8584        _error_("Constructor not supported");
    8685
    8786}
    8887/*}}}*/
    89 /*FUNCTION Quadtree::Quadtree(double xmin,double xmax,double ymin,double ymax,int maxdepth){{{*/
    90 Quadtree::Quadtree(double xmin,double xmax,double ymin,double ymax,int maxdepth){
     88Quadtree::Quadtree(double xmin,double xmax,double ymin,double ymax,int maxdepth){/*{{{*/
    9189
    9290        /*Intermediaries*/
    … …  
    106104}
    107105/*}}}*/
    108         /*FUNCTION Quadtree::~Quadtree(){{{*/
    109         Quadtree::~Quadtree(){
     106        Quadtree::~Quadtree(){/*{{{*/
    110107
    111108                delete boxcontainer;
    … …  
    116113
    117114        /*Methods*/
    118 /*FUNCTION Quadtree::Add{{{*/
    119 void  Quadtree::Add(Observation* observation){
     115void  Quadtree::Add(Observation* observation){/*{{{*/
    120116
    121117        /*Intermediaries*/
    … …  
    199195
    200196}/*}}}*/
    201 /*FUNCTION Quadtree::AddAndAverage{{{*/
    202 void Quadtree::AddAndAverage(double x,double y,double value){
     197void Quadtree::AddAndAverage(double x,double y,double value){/*{{{*/
    203198
    204199        QuadtreeBox **pbox = NULL;
    … …  
    248243        }
    249244}/*}}}*/
    250 /*FUNCTION Quadtree::ClosestObs{{{*/
    251 void Quadtree::ClosestObs(int *pindex,double x,double y){
     245void Quadtree::ClosestObs(int *pindex,double x,double y){/*{{{*/
    252246
    253247        QuadtreeBox **pbox = NULL;
    … …  
    288282        *pindex=index;
    289283}/*}}}*/
    290 /*FUNCTION Quadtree::Echo{{{*/
    291 void  Quadtree::Echo(void){
     284void  Quadtree::Echo(void){/*{{{*/
    292285
    293286        _printf_("Quadtree:\n");
    … …  
    298291
    299292}/*}}}*/
    300 /*FUNCTION Quadtree::DeepEcho{{{*/
    301 void  Quadtree::DeepEcho(void){
     293void  Quadtree::DeepEcho(void){/*{{{*/
    302294
    303295        _printf_("Quadtree:\n");
    … …  
    309301
    310302}/*}}}*/
    311 /*FUNCTION Quadtree::IntergerCoordinates{{{*/
    312 void  Quadtree::IntergerCoordinates(int *xi,int *yi,double x,double y){
     303void  Quadtree::IntergerCoordinates(int *xi,int *yi,double x,double y){/*{{{*/
    313304
    314305        /*Intermediaries*/
    … …  
    333324        *yi=int(coefficient*(y - ymin));
    334325}/*}}}*/
    335 /*FUNCTION Quadtree::NewQuadtreeBox(double xcenter,double ycenter,double length){{{*/
    336 Quadtree::QuadtreeBox* Quadtree::NewQuadtreeBox(double xcenter,double ycenter,double length){
     326Quadtree::QuadtreeBox* Quadtree::NewQuadtreeBox(double xcenter,double ycenter,double length){/*{{{*/
    337327
    338328        /*Output*/
    … …  
    357347        return newbox;
    358348}/*}}}*/
    359 /*FUNCTION Quadtree::NewQuadtreeBox(QuadtreeBox* master,int index) {{{*/
    360 Quadtree::QuadtreeBox* Quadtree::NewQuadtreeBox(QuadtreeBox* master,int index){
     349Quadtree::QuadtreeBox* Quadtree::NewQuadtreeBox(QuadtreeBox* master,int index){/*{{{*/
    361350
    362351        /*Output*/
    … …  
    402391        return newbox;
    403392}/*}}}*/
    404 /*FUNCTION Quadtree::QuadtreeDepth{{{*/
    405 void Quadtree::QuadtreeDepth(int* A,int xi,int yi){
     393void Quadtree::QuadtreeDepth(int* A,int xi,int yi){/*{{{*/
    406394
    407395        QuadtreeBox **pbox = NULL;
    … …  
    430418        *A=level;
    431419}/*}}}*/
    432 /*FUNCTION Quadtree::QuadtreeDepth2{{{*/
    433 void Quadtree::QuadtreeDepth2(int* A,int xi,int yi){
     420void Quadtree::QuadtreeDepth2(int* A,int xi,int yi){/*{{{*/
    434421
    435422        QuadtreeBox **pbox = NULL;
    … …  
    483470        *A=level;
    484471}/*}}}*/
    485 /*FUNCTION Quadtree::RangeSearch{{{*/
    486 void Quadtree::RangeSearch(int **pindices,int *pnobs,double x,double y,double range){
     472void Quadtree::RangeSearch(int **pindices,int *pnobs,double x,double y,double range){/*{{{*/
    487473
    488474        /*Intermediaries*/
    … …  
    503489
    504490/*QuadtreeBox methos*/
    505 /*FUNCTION QuadtreeBox::Echo{{{*/
    506 void  Quadtree::QuadtreeBox::Echo(void){
     491void  Quadtree::QuadtreeBox::Echo(void){/*{{{*/
    507492
    508493        _printf_("QuadtreeBox:\n");
    … …  
    513498
    514499}/*}}}*/
    515 /*FUNCTION QuadtreeBox::IsWithinRange{{{*/
    516 int Quadtree::QuadtreeBox::IsWithinRange(double x,double y,double range){
     500int Quadtree::QuadtreeBox::IsWithinRange(double x,double y,double range){/*{{{*/
    517501
    518502        /*Return 0 if the 2 boxes do not overlap*/
    … …  
    532516
    533517}/*}}}*/
    534 /*FUNCTION QuadtreeBox::RangeSearch{{{*/
    535 void Quadtree::QuadtreeBox::RangeSearch(int* indices,int *pnobs,double x,double y,double range){
     518void Quadtree::QuadtreeBox::RangeSearch(int* indices,int *pnobs,double x,double y,double range){/*{{{*/
    536519
    537520        /*Intermediaries*/
    … …  
    574557        *pnobs=nobs;
    575558}/*}}}*/
    576 /*FUNCTION QuadtreeBox::WriteObservations{{{*/
    577 void Quadtree::QuadtreeBox::WriteObservations(int* indices,int *pnobs){
     559void Quadtree::QuadtreeBox::WriteObservations(int* indices,int *pnobs){/*{{{*/
    578560
    579561        /*Intermediaries*/

  • issm/trunk-jpl/src/c/classes/kriging/SphericalVariogram.cpp

    r15741 r18064  
    1313
    1414/*SphericalVariogram constructors and destructor*/
    15 /*FUNCTION SphericalVariogram::SphericalVariogram(){{{*/
    16 SphericalVariogram::SphericalVariogram(){
     15SphericalVariogram::SphericalVariogram(){/*{{{*/
    1716        this->nugget = 0.2;
    1817        this->sill   = 1;
    … …  
    2120}
    2221/*}}}*/
    23 /*FUNCTION SphericalVariogram::SphericalVariogram(Options* options){{{*/
    24 SphericalVariogram::SphericalVariogram(Options* options){
     22SphericalVariogram::SphericalVariogram(Options* options){/*{{{*/
    2523
    2624        /*Defaults*/
    … …  
    3836}
    3937/*}}}*/
    40 /*FUNCTION SphericalVariogram::~SphericalVariogram(){{{*/
    41 SphericalVariogram::~SphericalVariogram(){
     38SphericalVariogram::~SphericalVariogram(){/*{{{*/
    4239        return;
    4340}
    … …  
    4542
    4643/*Object virtual functions definitions:*/
    47 /*FUNCTION SphericalVariogram::Echo {{{*/
    48 void SphericalVariogram::Echo(void){
     44void SphericalVariogram::Echo(void){/*{{{*/
    4945        _printf_("SphericalVariogram\n");
    5046        _printf_("   nugget: " << this->nugget << "\n");
    … …  
    5551
    5652/*Variogram function*/
    57 /*FUNCTION SphericalVariogram::Covariance{{{*/
    58 double SphericalVariogram::Covariance(double deltax,double deltay){
     53double SphericalVariogram::Covariance(double deltax,double deltay){/*{{{*/
    5954        /*The covariance can be deduced from the variogram from the following
    6055         * relationship:
    … …  
    7671}
    7772/*}}}*/
    78 /*FUNCTION SphericalVariogram::SemiVariogram{{{*/
    79 double SphericalVariogram::SemiVariogram(double deltax,double deltay){
     73double SphericalVariogram::SemiVariogram(double deltax,double deltay){/*{{{*/
    8074        /*http://en.wikipedia.org/wiki/Variogram*/
    8175        double h,gamma;

  • issm/trunk-jpl/src/c/classes/matrix/ElementMatrix.cpp

    r16658 r18064  
    1818
    1919/*ElementMatrix constructors and destructor*/
    20 /*FUNCTION ElementMatrix::ElementMatrix(){{{*/
    21 ElementMatrix::ElementMatrix(){
     20ElementMatrix::ElementMatrix(){/*{{{*/
    2221
    2322        this->nrows=0;
    … …  
    4241}
    4342/*}}}*/
    44 /*FUNCTION ElementMatrix::ElementMatrix(ElementMatrix* Ke){{{*/
    45 ElementMatrix::ElementMatrix(ElementMatrix* Ke){
     43ElementMatrix::ElementMatrix(ElementMatrix* Ke){/*{{{*/
    4644
    4745        if(!Ke) _error_("Input Element Matrix is a NULL pointer");
    … …  
    5048}
    5149/*}}}*/
    52 /*FUNCTION ElementMatrix::ElementMatrix(ElementMatrix* Ke1, ElementMatrix* Ke2){{{*/
    53 ElementMatrix::ElementMatrix(ElementMatrix* Ke1, ElementMatrix* Ke2){
     50ElementMatrix::ElementMatrix(ElementMatrix* Ke1, ElementMatrix* Ke2){/*{{{*/
    5451
    5552        /*intermediaries*/
    … …  
    179176}
    180177/*}}}*/
    181 /*FUNCTION ElementMatrix::ElementMatrix(ElementMatrix* Ke1, ElementMatrix* Ke2,ElementMatrix* Ke3){{{*/
    182 ElementMatrix::ElementMatrix(ElementMatrix* Ke1, ElementMatrix* Ke2,ElementMatrix* Ke3){
     178ElementMatrix::ElementMatrix(ElementMatrix* Ke1, ElementMatrix* Ke2,ElementMatrix* Ke3){/*{{{*/
    183179
    184180        /*Concatenate all matrices*/
    … …  
    194190}
    195191/*}}}*/
    196 /*FUNCTION ElementMatrix::ElementMatrix(Node** nodes,int numnodes,Parameters* parameters,int approximation){{{*/
    197 ElementMatrix::ElementMatrix(Node** nodes,int numnodes,Parameters* parameters,int approximation){
     192ElementMatrix::ElementMatrix(Node** nodes,int numnodes,Parameters* parameters,int approximation){/*{{{*/
    198193
    199194        /*get Matrix size and properties*/
    … …  
    225220}
    226221/*}}}*/
    227 /*FUNCTION ElementMatrix::~ElementMatrix(){{{*/
    228 ElementMatrix::~ElementMatrix(){
     222ElementMatrix::~ElementMatrix(){/*{{{*/
    229223
    230224        xDelete<IssmDouble>(this->values);
    … …  
    242236
    243237/*ElementMatrix specific routines: */
    244 /*FUNCTION ElementMatrix::AddToGlobal(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){{{*/
    245 void ElementMatrix::AddToGlobal(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){
     238void ElementMatrix::AddToGlobal(Matrix<IssmDouble>* Kff, Matrix<IssmDouble>* Kfs){/*{{{*/
    246239
    247240        int i,j;
    … …  
    300293}
    301294/*}}}*/
    302 /*FUNCTION ElementMatrix::AddToGlobal(Matrix<IssmDouble>* Jff){{{*/
    303 void ElementMatrix::AddToGlobal(Matrix<IssmDouble>* Jff){
     295void ElementMatrix::AddToGlobal(Matrix<IssmDouble>* Jff){/*{{{*/
    304296
    305297        int i,j;
    … …  
    337329}
    338330/*}}}*/
    339 /*FUNCTION ElementMatrix::CheckConsistency{{{*/
    340 void ElementMatrix::CheckConsistency(void){
     331void ElementMatrix::CheckConsistency(void){/*{{{*/
    341332        /*Check element matrix values, only in debugging mode*/
    342333        #ifdef _ISSM_DEBUG_
    … …  
    350341}
    351342/*}}}*/
    352 /*FUNCTION ElementMatrix::Transpose{{{*/
    353 void ElementMatrix::Transpose(void){
     343void ElementMatrix::Transpose(void){/*{{{*/
    354344
    355345        /*Intermediaries*/
    … …  
    373363}
    374364/*}}}*/
    375 /*FUNCTION ElementMatrix::StaticCondensation{{{*/
    376 void ElementMatrix::StaticCondensation(int bsize,int* bindices){
     365void ElementMatrix::StaticCondensation(int bsize,int* bindices){/*{{{*/
    377366        /*
    378367         * | Kii  Kib | | Ui |    |Fi|
    … …  
    477466}
    478467/*}}}*/
    479 /*FUNCTION ElementMatrix::Echo{{{*/
    480 void ElementMatrix::Echo(void){
     468void ElementMatrix::Echo(void){/*{{{*/
    481469
    482470        int i,j;
    … …  
    523511}
    524512/*}}}*/
    525 /*FUNCTION ElementMatrix::Init{{{*/
    526 void ElementMatrix::Init(ElementMatrix* Ke){
     513void ElementMatrix::Init(ElementMatrix* Ke){/*{{{*/
    527514
    528515        _assert_(Ke);
Note: See TracChangeset for help on using the changeset viewer.