Changeset 13236


Ignore:
Timestamp:
09/04/12 12:27:17 (13 years ago)
Author:
Mathieu Morlighem
Message:

CHG: preparing files for python inclusion

Location:
issm/trunk-jpl/src/modules
Files:
70 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/modules/AverageFilter/AverageFilter.cpp

    r12517 r13236  
    1010*/
    1111
    12 
    1312#include "./AverageFilter.h"
    1413
    15 void mexFunction( int nlhs, mxArray* plhs[],
    16                                   int nrhs, const mxArray* prhs[])
    17 {
     14void AverageFilterUsage(void){/*{{{*/
     15        _printLine_("   AverageFilter usage:");
     16        _printLine_("   [image_out]=AverageFilter(image_in,pixels);\n");
     17        _printLine_("   where:");
     18        _printLine_("      image_in in double format");
     19        _printLine_("      pixels: characteristic size of smoothing");
     20        _printLine_("      image_out in double format");
     21        _printLine_("");
     22}/*}}}*/
     23WRAPPER(AverageFilter){
    1824
    1925        int i,j;
    … …  
    4955        MODULEEND();
    5056}
    51 
    52 
    53 void AverageFilterUsage(void)
    54 {
    55         _printLine_("   AverageFilter usage:");
    56         _printLine_("   [image_out]=AverageFilter(image_in,pixels);\n");
    57         _printLine_("   where:");
    58         _printLine_("      image_in in double format");
    59         _printLine_("      pixels: characteristic size of smoothing");
    60         _printLine_("      image_out in double format");
    61         _printLine_("");
    62 }

  • issm/trunk-jpl/src/modules/AverageFilter/AverageFilter.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void AverageFilterUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/BamgConvertMesh/BamgConvertMesh.cpp

    r13036 r13236  
    44#include "./BamgConvertMesh.h"
    55
    6 void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void BamgConvertMeshUsage(void){/*{{{*/
     7        _pprintString_("BAMGCONVERTMESH - convert [x y index] to a bamg geom and mesh geom");
     8        _pprintLine_("");
     9        _pprintLine_("   Usage:");
     10        _pprintLine_("      [bamggeom bamgmesh]=BamgConvertMesh(index,x,y);");
     11        _pprintLine_("      index: index of the mesh");
     12        _pprintLine_("      x,y: coordinates of the nodes");
     13        _pprintLine_("");
     14}/*}}}*/
     15WRAPPER(BamgConvertMesh){
    716
    817        /*input: */
    … …  
    5362        MODULEEND();
    5463}
    55 
    56 void BamgConvertMeshUsage(void){
    57         _pprintString_("BAMGCONVERTMESH - convert [x y index] to a bamg geom and mesh geom");
    58         _pprintLine_("");
    59         _pprintLine_("   Usage:");
    60         _pprintLine_("      [bamggeom bamgmesh]=BamgConvertMesh(index,x,y);");
    61         _pprintLine_("      index: index of the mesh");
    62         _pprintLine_("      x,y: coordinates of the nodes");
    63         _pprintLine_("");
    64 }

  • issm/trunk-jpl/src/modules/BamgConvertMesh/BamgConvertMesh.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void BamgConvertMeshUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/BamgMesher/BamgMesher.cpp

    r12518 r13236  
    44#include "./BamgMesher.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void BamgMesherUsage(void){/*{{{*/
     7        _pprintLine_("");
     8        _pprintLine_("   usage: [bamgmesh,bamggeom]=" << __FUNCT__ << "(bamgmesh,bamggeom,bamgoptions);");
     9        _pprintLine_("");
     10}/*}}}*/
     11WRAPPER(BamgMesher){
    712
    813        /*Outputs*/
    … …  
    4954        MODULEEND();
    5055}
    51 
    52 void BamgMesherUsage(void){
    53         _pprintLine_("");
    54         _pprintLine_("   usage: [bamgmesh,bamggeom]=" << __FUNCT__ << "(bamgmesh,bamggeom,bamgoptions);");
    55         _pprintLine_("");
    56 }

  • issm/trunk-jpl/src/modules/BamgMesher/BamgMesher.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void BamgMesherUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/BamgTriangulate/BamgTriangulate.cpp

    r13036 r13236  
    44#include "./BamgTriangulate.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void BamgTriangulateUsage(void){/*{{{*/
     7        _pprintString_("BAMGTRIANGULATE - Delaunay Triangulation of a list of points");
     8        _pprintLine_("");
     9        _pprintLine_("   Usage:");
     10        _pprintLine_("      index=BamgTriangulate(x,y);");
     11        _pprintLine_("      index: index of the triangulation");
     12        _pprintLine_("      x,y: coordinates of the nodes");
     13        _pprintLine_("");
     14}/*}}}*/
     15WRAPPER(BamgTriangulate){
    716
    817        /*input: */
    … …  
    4655        MODULEEND();
    4756}
    48 
    49 void BamgTriangulateUsage(void)
    50 {
    51         _pprintString_("BAMGTRIANGULATE - Delaunay Triangulation of a list of points");
    52         _pprintLine_("");
    53         _pprintLine_("   Usage:");
    54         _pprintLine_("      index=BamgTriangulate(x,y);");
    55         _pprintLine_("      index: index of the triangulation");
    56         _pprintLine_("      x,y: coordinates of the nodes");
    57         _pprintLine_("");
    58 }

  • issm/trunk-jpl/src/modules/BamgTriangulate/BamgTriangulate.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void BamgTriangulateUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/Chaco/Chaco.cpp

    r13038 r13236  
    99#endif
    1010
    11 
    1211#include "./Chaco.h"
    1312
    14 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     13void ChacoUsage(void){/*{{{*/
     14        _pprintLine_("");
     15        _pprintLine_("Usage: [assgn] = Chaco(A,vwgts,ewgts,x,y,z,options,nparts,goal);");
     16        _pprintLine_("");
     17}/*}}}*/
     18WRAPPER(Chaco){
    1519   
    1620        int i;
    … …  
    130134        MODULEEND();
    131135}
    132 
    133 void ChacoUsage(void){
    134         _pprintLine_("");
    135         _pprintLine_("Usage: [assgn] = Chaco(A,vwgts,ewgts,x,y,z,options,nparts,goal);");
    136         _pprintLine_("");
    137 }

  • issm/trunk-jpl/src/modules/Chaco/Chaco.h

    r13235 r13236  
    2626#include "../../c/shared/shared.h"
    2727#include "../../c/issm-binding.h"
    28 
    29 /* local prototypes: */
    30 void ChacoUsage(void);
    3128
    3229#undef __FUNCT__

  • issm/trunk-jpl/src/modules/ContourToMesh/ContourToMesh.cpp

    r13229 r13236  
    22    \brief: takes an  contour file, and figures out which nodes or elements from the mesh 
    33    are inside this contour.
    4         usage:
    5         [in_nod,in_elem]=ContourToMesh(index,x,y,contours,interptype,edgevalue);
    6        
    7         input:
    8 
    9                 index,x,y: delaunay triangulation.
    10                 contours: structure holding sets of vertices making open contours.
    11                 interptype: string definining type of interpolation ('element', or 'node', or 'element and node');
    12                 edgevalue: integer (0, 1 or 2) defining the value associated to the nodes on the edges of the polygons
    13 
    14         output:
    15                 in_nod: vector of flags (0 or 1), of size nods if interptype is set to 'node' or 'element and node',
    16                                 or of size 0 otherwise.
    17                 in_elem: vector of flags (0 or 1), of size nel if interptype is set to 'element' or 'element and node',
    18                                 or of size 0 otherwise.
    194*/
    205       
    216#include "./ContourToMesh.h"
    227
     8void ContourToMeshUsage(void){/*{{{*/
     9        _printLine_("CONTOURTOMESH - Flag the elements or nodes inside a contour");
     10        _printLine_("");
     11        _printLine_("      Usage: ");
     12        _printLine_("         [in_nod,in_elem]=ContourToMesh(index,x,y,contourname,interptype,edgevalue)\n");
     13        _printLine_("");
     14        _printLine_("         index,x,y: mesh triangulation.");
     15        _printLine_("         contourname: name of .exp file containing the contours.");
     16        _printLine_("         interptype: string definining type of interpolation ('element', or 'node').");
     17        _printLine_("         edgevalue: integer (0, 1 or 2) defining the value associated to the nodes on the edges of the polygons.");
     18        _printLine_("         in_nod: vector of flags (0 or 1), of size nods if interptype is set to 'node' or 'element and node', ");
     19        _printLine_("            or of size 0 otherwise.");
     20        _printLine_("         in_elem: vector of flags (0 or 1), of size nel if interptype is set to 'element' or 'element and node', ");
     21        _printLine_("            or of size 0 otherwise.");
     22        _printLine_("");
     23        _printLine_("      Example: ");
     24        _printLine_("         in_nod=ContourToMesh(md.elements,md.x,md.y,'Contour.exp','node',1)");
     25        _printLine_("         in_elements=ContourToMesh(md.elements,md.x,md.y,'Contour.exp','element',0)");
     26        _printLine_("         [in_nodes,in_elements]=ContourToMesh(md.elements,md.x,md.y,'Contour.exp','element and node',0)");
     27        _printLine_("");
     28}/*}}}*/
    2329WRAPPER(ContourToMesh){
    2430
    … …  
    5662        }
    5763
    58 
    5964        /*Fetch inputs: */
    6065        FetchData(&index,&nel,NULL,INDEX);
    … …  
    8893       
    8994}
    90 
    91 void ContourToMeshUsage(void)//{{{1
    92 {
    93         _printLine_("CONTOURTOMESH - Flag the elements or nodes inside a contour");
    94         _printLine_("");
    95         _printLine_("      Usage: ");
    96         _printLine_("         [in_nod,in_elem]=ContourToMesh(index,x,y,contourname,interptype,edgevalue)\n");
    97         _printLine_("");
    98         _printLine_("         index,x,y: mesh triangulation.");
    99         _printLine_("         contourname: name of .exp file containing the contours.");
    100         _printLine_("         interptype: string definining type of interpolation ('element', or 'node').");
    101         _printLine_("         edgevalue: integer (0, 1 or 2) defining the value associated to the nodes on the edges of the polygons.");
    102         _printLine_("         in_nod: vector of flags (0 or 1), of size nods if interptype is set to 'node' or 'element and node', ");
    103         _printLine_("            or of size 0 otherwise.");
    104         _printLine_("         in_elem: vector of flags (0 or 1), of size nel if interptype is set to 'element' or 'element and node', ");
    105         _printLine_("            or of size 0 otherwise.");
    106         _printLine_("");
    107         _printLine_("      Example: ");
    108         _printLine_("         in_nod=ContourToMesh(md.elements,md.x,md.y,'Contour.exp','node',1)");
    109         _printLine_("         in_elements=ContourToMesh(md.elements,md.x,md.y,'Contour.exp','element',0)");
    110         _printLine_("         [in_nodes,in_elements]=ContourToMesh(md.elements,md.x,md.y,'Contour.exp','element and node',0)");
    111         _printLine_("");
    112 }
    113 //}}}

  • issm/trunk-jpl/src/modules/ContourToMesh/ContourToMesh.h

    r13235 r13236  
    6363#define NRHS 6
    6464
    65 /* local prototypes: */
    66 void ContourToMeshUsage(void);
    67 
    6865#endif  /* _CONTOURTOMESH_H */
    6966

  • issm/trunk-jpl/src/modules/ContourToNodes/ContourToNodes.cpp

    r13229 r13236  
    11/*! \file  ContourtoNodes
    22    \brief: takes a  contour file, and figures out which nodes  (x,y list)
    3     are inside this contour.
    4 
    5         usage:
    6         [flags]=ContourToNodes(x,y,contours,interptype,edgevalue);
    7        
    8         where:
    9 
    10         input:
    11 
    12                 x,y: node cooredinates
    13                
    14                 contours: structure holding sets of vertices making open contours.
    15                
    16                 interptype: string definining type of interpolation ('element', or 'node', or 'element and node');
    17 
    18                 edgevalue: integer (0, 1 or 2) defining the value associated to the nodes on the edges of the polygons
    19 
    20         output:
    21                 flags: vector of flags (0 or 1), of size nods
    223*/
    234       
    245#include "./ContourToNodes.h"
    256
    26 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
     7void ContourToNodesUsage(void){/*{{{*/
     8        _printLine_("   usage:");
     9        _printLine_("   [flags]=ContourToNodes(x,y,contourname,edgevalue);\n");
     10        _printLine_("   where:");
     11        _printLine_("      x,y: list of nodes.");
     12        _printLine_("      contourname: name of .exp file containing the contours, or resulting structure from call to expread.");
     13        _printLine_("      interptype: string definining type of interpolation ('element', or 'node').");
     14        _printLine_("      edgevalue: integer (0, 1 or 2) defining the value associated to the nodes on the edges of the polygons.");
     15        _printLine_("      flags: vector of flags (0 or 1), of size nods.");
     16        _printLine_("");
     17}/*}}}*/
     18WRAPPER(ContourToNodes){
    2719
    2820        int i,j;
    … …  
    8779        MODULEEND();
    8880}
    89 
    90 void ContourToNodesUsage(void){
    91         _printLine_("   usage:");
    92         _printLine_("   [flags]=ContourToNodes(x,y,contourname,edgevalue);\n");
    93         _printLine_("   where:");
    94         _printLine_("      x,y: list of nodes.");
    95         _printLine_("      contourname: name of .exp file containing the contours, or resulting structure from call to expread.");
    96         _printLine_("      interptype: string definining type of interpolation ('element', or 'node').");
    97         _printLine_("      edgevalue: integer (0, 1 or 2) defining the value associated to the nodes on the edges of the polygons.");
    98         _printLine_("      flags: vector of flags (0 or 1), of size nods.");
    99         _printLine_("");
    100 }

  • issm/trunk-jpl/src/modules/ContourToNodes/ContourToNodes.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void ContourToNodesUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/ElementConnectivity/ElementConnectivity.cpp

    r12518 r13236  
    55#include "./ElementConnectivity.h"
    66
     7void ElementConnectivityUsage(void) {/*{{{*/
     8        _pprintLine_("");
     9        _pprintLine_("   usage: elementconnectivity = " << __FUNCT__ << "(elements, nodeconnectivity);");
     10        _pprintLine_("");
     11}/*}}}*/
    712WRAPPER(ElementConnectivity){
    813
    … …  
    3540        MODULEEND();
    3641}
    37 
    38 void ElementConnectivityUsage(void) {
    39         _pprintLine_("");
    40         _pprintLine_("   usage: elementconnectivity = " << __FUNCT__ << "(elements, nodeconnectivity);");
    41         _pprintLine_("");
    42 }

  • issm/trunk-jpl/src/modules/ElementConnectivity/ElementConnectivity.h

    r13235 r13236  
    5353#define NRHS  2
    5454
    55 /* local prototypes: */
    56 void ElementConnectivityUsage(void);
    57 
    5855#endif  /* _ELEMENTCONNECTIVITY_H */

  • issm/trunk-jpl/src/modules/EnumToString/EnumToString.cpp

    r13214 r13236  
    55#include "./EnumToString.h"
    66
     7void EnumToStringUsage(void){/*{{{*/
     8        _pprintLine_("");
     9        _pprintLine_("   usage: " << __FUNCT__ << "string = EnumToString(enum);");
     10        _pprintLine_("");
     11}/*}}}*/
    712WRAPPER(EnumToString){
    813
    … …  
    2833        MODULEEND();
    2934}
    30 
    31 void EnumToStringUsage(void){
    32         _pprintLine_("");
    33         _pprintLine_("   usage: " << __FUNCT__ << "string = EnumToString(enum);");
    34         _pprintLine_("");
    35 }

  • issm/trunk-jpl/src/modules/EnumToString/EnumToString.h

    r13214 r13236  
    4747#define NRHS  1
    4848
    49 /* local prototypes: */
    50 void EnumToStringUsage(void);
    51 
    5249#endif  /* _TEST_H */

  • issm/trunk-jpl/src/modules/Exp2Kml/Exp2Kml.cpp

    r13216 r13236  
    44#include "./Exp2Kml.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void Exp2KmlUsage(void){/*{{{*/
     7        _pprintLine_("Exp2Kml - exp to kml file conversion module:");
     8        _pprintLine_("");
     9        _pprintLine_("   This module converts a file from exp to kml format.");
     10        _pprintLine_("");
     11        _pprintLine_("   Usage:");
     12        _pprintLine_("      [ret]=Exp2Kml(filexp,filkml,sgn,'param name',param,...);");
     13        _pprintLine_("");
     14        _pprintLine_("      filexp      file name of exp file to be read (char)");
     15        _pprintLine_("      filkml      file name of kml file to be written (char)");
     16        _pprintLine_("      sgn         sign for hemisphere (double, +1 (north) or -1 (south))");
     17        _pprintLine_("");
     18        _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
     19        _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
     20        _pprintLine_("      holes       flag for treatment of multiple profiles (char, optional, 'yes' for holes))");
     21        _pprintLine_("");
     22        _pprintLine_("      ret         return code (non-zero for warning)");
     23        _pprintLine_("");
     24        _pprintLine_("   Examples:");
     25        _pprintLine_("      [ret]=Exp2Kml('file.exp','file.kml', 1);");
     26        _pprintLine_("      [ret]=Exp2Kml('file.exp','file.kml', 1,'central_meridian',45,'standard_parallel',70,'holes','yes');");
     27        _pprintLine_("      [ret]=Exp2Kml('file.exp','file.kml',-1,'central_meridian', 0,'standard_parallel',71,'holes','yes');");
     28        _pprintLine_("");
     29}/*}}}*/
     30WRAPPER(Exp2Kml){
    731
    832        int i,verbose=1;
    … …  
    7195        MODULEEND();
    7296}
    73 
    74 void Exp2KmlUsage(void){
    75         _pprintLine_("Exp2Kml - exp to kml file conversion module:");
    76         _pprintLine_("");
    77         _pprintLine_("   This module converts a file from exp to kml format.");
    78         _pprintLine_("");
    79         _pprintLine_("   Usage:");
    80         _pprintLine_("      [ret]=Exp2Kml(filexp,filkml,sgn,'param name',param,...);");
    81         _pprintLine_("");
    82         _pprintLine_("      filexp      file name of exp file to be read (char)");
    83         _pprintLine_("      filkml      file name of kml file to be written (char)");
    84         _pprintLine_("      sgn         sign for hemisphere (double, +1 (north) or -1 (south))");
    85         _pprintLine_("");
    86         _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
    87         _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
    88         _pprintLine_("      holes       flag for treatment of multiple profiles (char, optional, 'yes' for holes))");
    89         _pprintLine_("");
    90         _pprintLine_("      ret         return code (non-zero for warning)");
    91         _pprintLine_("");
    92         _pprintLine_("   Examples:");
    93         _pprintLine_("      [ret]=Exp2Kml('file.exp','file.kml', 1);");
    94         _pprintLine_("      [ret]=Exp2Kml('file.exp','file.kml', 1,'central_meridian',45,'standard_parallel',70,'holes','yes');");
    95         _pprintLine_("      [ret]=Exp2Kml('file.exp','file.kml',-1,'central_meridian', 0,'standard_parallel',71,'holes','yes');");
    96         _pprintLine_("");
    97 }
    98 

  • issm/trunk-jpl/src/modules/Exp2Kml/Exp2Kml.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void Exp2KmlUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/HoleFiller/HoleFiller.cpp

    r12517 r13236  
    1010*/
    1111
    12 
    1312#include "./HoleFiller.h"
    1413
    15 void mexFunction( int nlhs, mxArray* plhs[],
    16                                   int nrhs, const mxArray* prhs[])
    17 {
     14void HoleFillerUsage(void){/*{{{*/
     15        _printLine_("   HoleFiller usage:");
     16        _printLine_("   [image_out]=HoleFiller(image_in,smooth);\n");
     17        _printLine_("   where:");
     18        _printLine_("      image_in in double format");
     19        _printLine_("      smooth: 1 to smooth with a box filer, 0 to leave data raw");
     20        _printLine_("      image_out in double format");
     21        _printLine_("");
     22}/*}}}*/
     23WRAPPER(HoleFiller){
    1824
    1925        int i,j;
    … …  
    5662        MODULEEND();
    5763}
    58 
    59 
    60 void HoleFillerUsage(void)
    61 {
    62         _printLine_("   HoleFiller usage:");
    63         _printLine_("   [image_out]=HoleFiller(image_in,smooth);\n");
    64         _printLine_("   where:");
    65         _printLine_("      image_in in double format");
    66         _printLine_("      smooth: 1 to smooth with a box filer, 0 to leave data raw");
    67         _printLine_("      image_out in double format");
    68         _printLine_("");
    69 }

  • issm/trunk-jpl/src/modules/HoleFiller/HoleFiller.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void HoleFillerUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/InternalFront/InternalFront.cpp

    r13038 r13236  
    55#include "./InternalFront.h"
    66
    7 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     7void InternalFrontUsage(void) {/*{{{*/
     8        _pprintLine_("");
     9        _pprintLine_("   usage: icefront = " << __FUNCT__ << "(md);");
     10        _pprintLine_("");
     11}/*}}}*/
     12WRAPPER(InternalFront){
    813
    914        bool*   elementonwater=NULL;
    … …  
    9297        MODULEEND();
    9398}
    94 
    95 void InternalFrontUsage(void) {
    96         _pprintLine_("");
    97         _pprintLine_("   usage: icefront = " << __FUNCT__ << "(md);");
    98         _pprintLine_("");
    99 }

  • issm/trunk-jpl/src/modules/InternalFront/InternalFront.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void InternalFrontUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/InterpFromGridToMesh/InterpFromGridToMesh.cpp

    r13229 r13236  
    11/*!\file InterpFromGridToMesh.c
    22 * \brief: data interpolation from a list of (x,y,values) into mesh vertices
    3  
    4         InterpFromGridToMesh.c
    5 
    6         usage:
    7         data_mesh=InterpFromGridToMesh(x,y,data,x_mesh,y_mesh);
    8        
    9         where:
    10 
    11                 input:
    12                 x,y: coordinates of matrix data
    13                 data - matrix holding the data to be interpolated onto the mesh.
    14                 x_mesh,y_mesh: coordinates of the mesh vertices onto which we interpolate.
    15                
    16                 output:
    17                 data_mesh:  vector of mesh interpolated data.
    183*/
    194       
    205#include "./InterpFromGridToMesh.h"
    216
    22 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
     7void InterpFromGridToMeshUsage(void){/*{{{*/
     8        _pprintLine_("INTERPFROMGRIDTOMESH - interpolation from a grid onto a list of points");
     9        _pprintLine_("");
     10        _pprintLine_("   This function is a multi-threaded mex file that interpolates a field");
     11        _pprintLine_("   defined on a grid onto a list of points");
     12        _pprintLine_("");
     13        _pprintLine_("   Usage:");
     14        _pprintLine_("      data_mesh=InterpFromGridToMesh(x,y,data,x_mesh,y_mesh,default_value);");
     15        _pprintLine_("");
     16        _pprintLine_("      data: matrix holding the data to be interpolated onto the mesh.");
     17        _pprintLine_("      x,y: coordinates of matrix data. (x and y must be in increasing order)");
     18        _pprintLine_("      x_mesh,y_mesh: coordinates of the points onto which we interpolate.");
     19        _pprintLine_("      default_value: default value if no data is found (holes).");
     20        _pprintLine_("      data_mesh: vector of mesh interpolated data.");
     21        _pprintLine_("");
     22        _pprintLine_("   Example:");
     23        _pprintLine_("      load('velocities.mat');");
     24        _pprintLine_("      md.inversion.vx_obs=InterpFromGridToMesh(x_n,y_m,vx,md.mesh.x,md.mesh.y,0);");
     25        _pprintLine_("");
     26}/*}}}*/
     27WRAPPER(InterpFromGridToMesh){
    2328
    2429        int i,j;
    … …  
    7176        MODULEEND();
    7277}
    73 
    74 void InterpFromGridToMeshUsage(void)
    75 {
    76         _pprintLine_("INTERPFROMGRIDTOMESH - interpolation from a grid onto a list of points");
    77         _pprintLine_("");
    78         _pprintLine_("   This function is a multi-threaded mex file that interpolates a field");
    79         _pprintLine_("   defined on a grid onto a list of points");
    80         _pprintLine_("");
    81         _pprintLine_("   Usage:");
    82         _pprintLine_("      data_mesh=InterpFromGridToMesh(x,y,data,x_mesh,y_mesh,default_value);");
    83         _pprintLine_("");
    84         _pprintLine_("      data: matrix holding the data to be interpolated onto the mesh.");
    85         _pprintLine_("      x,y: coordinates of matrix data. (x and y must be in increasing order)");
    86         _pprintLine_("      x_mesh,y_mesh: coordinates of the points onto which we interpolate.");
    87         _pprintLine_("      default_value: default value if no data is found (holes).");
    88         _pprintLine_("      data_mesh: vector of mesh interpolated data.");
    89         _pprintLine_("");
    90         _pprintLine_("   Example:");
    91         _pprintLine_("      load('velocities.mat');");
    92         _pprintLine_("      md.inversion.vx_obs=InterpFromGridToMesh(x_n,y_m,vx,md.mesh.x,md.mesh.y,0);");
    93         _pprintLine_("");
    94 }

  • issm/trunk-jpl/src/modules/InterpFromGridToMesh/InterpFromGridToMesh.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void InterpFromGridToMeshUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/InterpFromMesh2d/InterpFromMesh2d.cpp

    r13229 r13236  
    55#include "./InterpFromMesh2d.h"
    66
    7 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
     7void InterpFromMesh2dUsage(void){/*{{{*/
     8        _pprintLine_("   usage:");
     9        _pprintLine_("         data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime);\n");
     10        _pprintLine_("      or data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime,default_value);\n");
     11        _pprintLine_("      or data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime,default_value,contourname);\n");
     12        _pprintLine_("   where:");
     13        _pprintLine_("      x,y: coordinates of the nodes where data is defined");
     14        _pprintLine_("      index: index of the mesh where data is defined");
     15        _pprintLine_("      data - vector holding the data to be interpolated onto the points.");
     16        _pprintLine_("      x_prime,y_prime: coordinates of the mesh vertices onto which we interpolate.");
     17        _pprintLine_("      default_value: a scalar or vector of size length(x_prime).");
     18        _pprintLine_("      contourname: linear interpolation will happen on all x_interp,y_interp inside the contour, default value will be adopted on the rest of the mesh.");
     19        _pprintLine_("      data_prime:  vector of prime interpolated data.");
     20        _pprintLine_("");
     21}/*}}}*/
     22WRAPPER(InterpFromMesh2d){
    823
    924        /*input: */
    … …  
    135150        MODULEEND();
    136151}
    137 
    138 void InterpFromMesh2dUsage(void)
    139 {
    140         _pprintLine_("   usage:");
    141         _pprintLine_("         data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime);\n");
    142         _pprintLine_("      or data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime,default_value);\n");
    143         _pprintLine_("      or data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime,default_value,contourname);\n");
    144         _pprintLine_("   where:");
    145         _pprintLine_("      x,y: coordinates of the nodes where data is defined");
    146         _pprintLine_("      index: index of the mesh where data is defined");
    147         _pprintLine_("      data - vector holding the data to be interpolated onto the points.");
    148         _pprintLine_("      x_prime,y_prime: coordinates of the mesh vertices onto which we interpolate.");
    149         _pprintLine_("      default_value: a scalar or vector of size length(x_prime).");
    150         _pprintLine_("      contourname: linear interpolation will happen on all x_interp,y_interp inside the contour, default value will be adopted on the rest of the mesh.");
    151         _pprintLine_("      data_prime:  vector of prime interpolated data.");
    152         _pprintLine_("");
    153 }

  • issm/trunk-jpl/src/modules/InterpFromMesh2d/InterpFromMesh2d.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void InterpFromMesh2dUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/InterpFromMeshToGrid/InterpFromMeshToGrid.cpp

    r12518 r13236  
    55#include "./InterpFromMeshToGrid.h"
    66
    7 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     7void InterpFromMeshToGridUsage(void){/*{{{*/
     8        _pprintLine_("INTERPFROMMESHTOGRID - interpolation of a data defined on a mesh onto a grid");
     9        _pprintLine_("");
     10        _pprintLine_("   This function is a multi-threaded mex file that interpolates a field");
     11        _pprintLine_("   defined on a triangular mesh onto a regular grid");
     12        _pprintLine_("");
     13        _pprintLine_("   Usage:");
     14        _pprintLine_("      [x_m,y_m,griddata]=InterpFromMeshToGrid(index,x,y,data,xmin,ymax,xposting,yposting,nlines,ncols,default_value)");
     15        _pprintLine_("");
     16        _pprintLine_("      index,x,y: delaunay triangulation defining the mesh.");
     17        _pprintLine_("      meshdata: vertex values of data to be interpolated.");
     18        _pprintLine_("      xmin,ymax,posting,nlines,ncols: parameters that define the grid");
     19        _pprintLine_("      default_value: value of points located out of the mesh.");
     20        _pprintLine_("");
     21}/*}}}*/
     22WRAPPER(InterpFromMeshToGrid){
    823
    924        /*input datasets: */
    … …  
    6176        MODULEEND();
    6277}
    63 
    64 void InterpFromMeshToGridUsage(void)
    65 {
    66         _pprintLine_("INTERPFROMMESHTOGRID - interpolation of a data defined on a mesh onto a grid");
    67         _pprintLine_("");
    68         _pprintLine_("   This function is a multi-threaded mex file that interpolates a field");
    69         _pprintLine_("   defined on a triangular mesh onto a regular grid");
    70         _pprintLine_("");
    71         _pprintLine_("   Usage:");
    72         _pprintLine_("      [x_m,y_m,griddata]=InterpFromMeshToGrid(index,x,y,data,xmin,ymax,xposting,yposting,nlines,ncols,default_value)");
    73         _pprintLine_("");
    74         _pprintLine_("      index,x,y: delaunay triangulation defining the mesh.");
    75         _pprintLine_("      meshdata: vertex values of data to be interpolated.");
    76         _pprintLine_("      xmin,ymax,posting,nlines,ncols: parameters that define the grid");
    77         _pprintLine_("      default_value: value of points located out of the mesh.");
    78         _pprintLine_("");
    79 }

  • issm/trunk-jpl/src/modules/InterpFromMeshToGrid/InterpFromMeshToGrid.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void InterpFromMeshToGridUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp

    r13036 r13236  
    44#include "./InterpFromMeshToMesh2d.h"
    55
    6 
     6void InterpFromMeshToMesh2dUsage(void){/*{{{*/
     7        _pprintLine_("INTERFROMMESHTOMESH2D - interpolation from a 2d triangular mesh onto a list of point");
     8        _pprintLine_("");
     9        _pprintLine_("   This function is a multi-threaded mex file that interpolates a field");
     10        _pprintLine_("   defined on a Delaunay triangulation onto a list of point");
     11        _pprintLine_("");
     12        _pprintLine_("   Usage:");
     13        _pprintLine_("         data_interp=InterpFromMeshToMesh2d(index,x,y,data,x_interp,y_interp);");
     14        _pprintLine_("      or data_interp=InterpFromMeshToMesh2d(index,x,y,data,x_interp,y_interp,OPTIONS);");
     15        _pprintLine_("");
     16        _pprintLine_("      index             : index of the mesh where data is defined");
     17        _pprintLine_("      x,y               : coordinates of the nodes where data is defined");
     18        _pprintLine_("      data              : matrix holding the data to be interpolated onto the mesh. (one column per field)");
     19        _pprintLine_("      x_interp,y_interp : coordinates of the points onto which we interpolate.");
     20        _pprintLine_("      data_interp       : vector of mesh interpolated data.");
     21        _pprintLine_("      Available options :");
     22        _pprintLine_("         - 'default' : default value if point is outsite of triangulation (instead of linear interolation)");
     23        _pprintLine_("");
     24        _pprintLine_("   Example:");
     25        _pprintLine_("      load('temperature.mat');");
     26        _pprintLine_("      md.initialization.temperature=InterpFromMeshToMesh2d(index,x,y,temperature,md.mesh.x,md.mesh.y);");
     27        _pprintLine_("      md.initialization.temperature=InterpFromMeshToMesh2d(index,x,y,temperature,md.mesh.x,md.mesh.y,'default',253);");
     28        _pprintLine_("");
     29}/*}}}*/
    730WRAPPER(InterpFromMeshToMesh2d){
    831
    … …  
    5578        MODULEEND();
    5679}
    57 
    58 void InterpFromMeshToMesh2dUsage(void){ /*{{{*/
    59         _pprintLine_("INTERFROMMESHTOMESH2D - interpolation from a 2d triangular mesh onto a list of point");
    60         _pprintLine_("");
    61         _pprintLine_("   This function is a multi-threaded mex file that interpolates a field");
    62         _pprintLine_("   defined on a Delaunay triangulation onto a list of point");
    63         _pprintLine_("");
    64         _pprintLine_("   Usage:");
    65         _pprintLine_("         data_interp=InterpFromMeshToMesh2d(index,x,y,data,x_interp,y_interp);");
    66         _pprintLine_("      or data_interp=InterpFromMeshToMesh2d(index,x,y,data,x_interp,y_interp,OPTIONS);");
    67         _pprintLine_("");
    68         _pprintLine_("      index             : index of the mesh where data is defined");
    69         _pprintLine_("      x,y               : coordinates of the nodes where data is defined");
    70         _pprintLine_("      data              : matrix holding the data to be interpolated onto the mesh. (one column per field)");
    71         _pprintLine_("      x_interp,y_interp : coordinates of the points onto which we interpolate.");
    72         _pprintLine_("      data_interp       : vector of mesh interpolated data.");
    73         _pprintLine_("      Available options :");
    74         _pprintLine_("         - 'default' : default value if point is outsite of triangulation (instead of linear interolation)");
    75         _pprintLine_("");
    76         _pprintLine_("   Example:");
    77         _pprintLine_("      load('temperature.mat');");
    78         _pprintLine_("      md.initialization.temperature=InterpFromMeshToMesh2d(index,x,y,temperature,md.mesh.x,md.mesh.y);");
    79         _pprintLine_("      md.initialization.temperature=InterpFromMeshToMesh2d(index,x,y,temperature,md.mesh.x,md.mesh.y,'default',253);");
    80         _pprintLine_("");
    81 }
    82 /*}}}*/

  • issm/trunk-jpl/src/modules/InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void InterpFromMeshToMesh2dUsage(void);
    2118
    2219/*Header files: */

  • issm/trunk-jpl/src/modules/InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.cpp

    r13229 r13236  
    11/*!\file InterpFromMeshToMesh3d.c
    22 * \brief: data interpolation from a list of (x,y,values) into mesh vertices
    3  
    4         InterpFromMeshToMesh3d.c
    5 
    6         usage:
    7         data_mesh=InterpFromMeshToMesh3d(index,x,y,z,data,x_mesh,y_mesh,z_mesh);
    8        
    9         where:
    10 
    11                 input:
    12                 x,y,z: coordinates of matrix data
    13                 data - matrix holding the data to be interpolated onto the mesh.
    14                 x_mesh,y_mesh,z_mesh: coordinates of the mesh vertices onto which we interpolate.
    15                
    16                 output:
    17                 data_mesh:  vector of mesh interpolated data.
    18 
    193*/
    204       
    215#include "./InterpFromMeshToMesh3d.h"
    226
    23 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
     7void InterpFromMeshToMesh3dUsage(void){/*{{{*/
     8        _pprintLine_("INTERPFROMMESHTOMESH3D - interpolation from a 3d hexahedron mesh onto a list of point");
     9        _pprintLine_("");
     10        _pprintLine_("   This function is a multi-threaded mex file that interpolates a field");
     11        _pprintLine_("   defined on a triangular mesh onto a list of point");
     12        _pprintLine_("");
     13        _pprintLine_("   Usage:");
     14        _pprintLine_("      data_prime=InterpFromMeshToMesh3d(index,x,y,z,data,x_prime,y_prime,z_prime,default_value);");
     15        _pprintLine_("");
     16        _pprintLine_("      index: index of the mesh where data is defined");
     17        _pprintLine_("      x,y,z: coordinates of the nodes where data is defined");
     18        _pprintLine_("      data: matrix holding the data to be interpolated onto the mesh.");
     19        _pprintLine_("      x_prime,y_prime,z_prime: coordinates of the points onto which we interpolate.");
     20        _pprintLine_("      default_value: default value if no data is found (holes).");
     21        _pprintLine_("      data_prime: vector of mesh interpolated data.");
     22        _pprintLine_("");
     23        _pprintLine_("   Example:");
     24        _pprintLine_("      load('temperature.mat');");
     25        _pprintLine_("      md.initialization.temperature=InterpFromMeshToMesh3d(index,x,y,z,temperature,md.mesh.x,md.mesh.y,md.mesh.z,253);");
     26        _pprintLine_("");
     27}/*}}}*/
     28WRAPPER(InterpFromMeshToMesh3d){
    2429
    2530        /*input: */
    … …  
    95100        MODULEEND();
    96101}
    97 
    98 void InterpFromMeshToMesh3dUsage(void){
    99         _pprintLine_("INTERPFROMMESHTOMESH3D - interpolation from a 3d hexahedron mesh onto a list of point");
    100         _pprintLine_("");
    101         _pprintLine_("   This function is a multi-threaded mex file that interpolates a field");
    102         _pprintLine_("   defined on a triangular mesh onto a list of point");
    103         _pprintLine_("");
    104         _pprintLine_("   Usage:");
    105         _pprintLine_("      data_prime=InterpFromMeshToMesh3d(index,x,y,z,data,x_prime,y_prime,z_prime,default_value);");
    106         _pprintLine_("");
    107         _pprintLine_("      index: index of the mesh where data is defined");
    108         _pprintLine_("      x,y,z: coordinates of the nodes where data is defined");
    109         _pprintLine_("      data: matrix holding the data to be interpolated onto the mesh.");
    110         _pprintLine_("      x_prime,y_prime,z_prime: coordinates of the points onto which we interpolate.");
    111         _pprintLine_("      default_value: default value if no data is found (holes).");
    112         _pprintLine_("      data_prime: vector of mesh interpolated data.");
    113         _pprintLine_("");
    114         _pprintLine_("   Example:");
    115         _pprintLine_("      load('temperature.mat');");
    116         _pprintLine_("      md.initialization.temperature=InterpFromMeshToMesh3d(index,x,y,z,temperature,md.mesh.x,md.mesh.y,md.mesh.z,253);");
    117         _pprintLine_("");
    118 }

  • issm/trunk-jpl/src/modules/InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void InterpFromMeshToMesh3dUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/KMLFileRead/KMLFileRead.cpp

    r13216 r13236  
    44#include "./KMLFileRead.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void KMLFileReadUsage(void){/*{{{*/
     7        _pprintLine_("KMLFileRead - KML file reader module:");
     8        _pprintLine_("");
     9        _pprintLine_("   This module reads a KML file.");
     10        _pprintLine_("");
     11        _pprintLine_("   Usage:");
     12        _pprintLine_("      [ierror]=KMLFileRead(kmlfile,'param name',param,...);");
     13        _pprintLine_("");
     14        _pprintLine_("      kmlfile      file name of kml file to be read (char)");
     15        _pprintLine_("");
     16        _pprintLine_("      echo         echo command (char, optional, 'off'/'on')");
     17        _pprintLine_("      deepecho     deep echo command (char, optional, 'off'/'on')");
     18        _pprintLine_("      write        write command (char, optional, 'off'/'stdout'/kmlfile)");
     19        _pprintLine_("");
     20        _pprintLine_("      ierror       return code (non-zero for error)");
     21        _pprintLine_("");
     22        _pprintLine_("   Examples:");
     23        _pprintLine_("      [ierror]=KMLFileRead('file.kml','deepecho','on');");
     24        _pprintLine_("      [ierror]=KMLFileRead('filin.kml','echo','on','write','filout.kml');");
     25        _pprintLine_("");
     26}/*}}}*/
     27WRAPPER(KMLFileRead){
    728
    829        int i,j,nnodes=0,verbose=1;
    … …  
    105126        MODULEEND();
    106127}
    107 
    108 void KMLFileReadUsage(void){
    109         _pprintLine_("KMLFileRead - KML file reader module:");
    110         _pprintLine_("");
    111         _pprintLine_("   This module reads a KML file.");
    112         _pprintLine_("");
    113         _pprintLine_("   Usage:");
    114         _pprintLine_("      [ierror]=KMLFileRead(kmlfile,'param name',param,...);");
    115         _pprintLine_("");
    116         _pprintLine_("      kmlfile      file name of kml file to be read (char)");
    117         _pprintLine_("");
    118         _pprintLine_("      echo         echo command (char, optional, 'off'/'on')");
    119         _pprintLine_("      deepecho     deep echo command (char, optional, 'off'/'on')");
    120         _pprintLine_("      write        write command (char, optional, 'off'/'stdout'/kmlfile)");
    121         _pprintLine_("");
    122         _pprintLine_("      ierror       return code (non-zero for error)");
    123         _pprintLine_("");
    124         _pprintLine_("   Examples:");
    125         _pprintLine_("      [ierror]=KMLFileRead('file.kml','deepecho','on');");
    126         _pprintLine_("      [ierror]=KMLFileRead('filin.kml','echo','on','write','filout.kml');");
    127         _pprintLine_("");
    128 }
    129 

  • issm/trunk-jpl/src/modules/KMLFileRead/KMLFileRead.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void KMLFileReadUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/KMLMeshWrite/KMLMeshWrite.cpp

    r13173 r13236  
    44#include "./KMLMeshWrite.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void KMLMeshWriteUsage(void){/*{{{*/
     7        _pprintLine_("KMLMeshWrite - KML mesh writer module:");
     8        _pprintLine_("");
     9        _pprintLine_("   This module writes the mesh of a model as KML polygons into the specified KML file.");
     10        _pprintLine_("");
     11        _pprintLine_("   Usage:");
     12        _pprintLine_("      ierror=KMLMeshWrite(name,notes,elem,nodecon,lat,long,part,data,cmap,kmlfile);");
     13        _pprintLine_("");
     14        _pprintLine_("      name       model name (string, may be empty)");
     15        _pprintLine_("      notes      model notes (string or cell array of strings, may be empty)");
     16        _pprintLine_("      elem       elements (double array)");
     17        _pprintLine_("      nodecon    nodal connectivity array (double array, may be empty)");
     18        _pprintLine_("      lat        nodal latititudes (double vector)");
     19        _pprintLine_("      long       nodal longitudes (double vector)");
     20        _pprintLine_("      part       nodal partitions (double vector, may be empty)");
     21        _pprintLine_("      data       nodal or element data (double vector, may be empty)");
     22        _pprintLine_("      cmap       color map (double nx3 array, may be empty)");
     23        _pprintLine_("      kmlfile    KML file name (string)");
     24        _pprintLine_("");
     25        _pprintLine_("      ierror     error flag (double, non-zero for error)");
     26        _pprintLine_("");
     27        _pprintLine_("   Example:");
     28        _pprintLine_("      KMLMeshWrite(md.name,md.notes,md.elements,md.nodeconnectivity,md.lat,md.long,md.part,md.fm_criterion,options.cmap,filekml);");
     29        _pprintLine_("");
     30}/*}}}*/
     31WRAPPER(KMLMeshWrite){
    732
    833        int i,j,nnodes=0,verbose=1;
    … …  
    122147        MODULEEND();
    123148}
    124 
    125 void KMLMeshWriteUsage(void){
    126         _pprintLine_("KMLMeshWrite - KML mesh writer module:");
    127         _pprintLine_("");
    128         _pprintLine_("   This module writes the mesh of a model as KML polygons into the specified KML file.");
    129         _pprintLine_("");
    130         _pprintLine_("   Usage:");
    131         _pprintLine_("      ierror=KMLMeshWrite(name,notes,elem,nodecon,lat,long,part,data,cmap,kmlfile);");
    132         _pprintLine_("");
    133         _pprintLine_("      name       model name (string, may be empty)");
    134         _pprintLine_("      notes      model notes (string or cell array of strings, may be empty)");
    135         _pprintLine_("      elem       elements (double array)");
    136         _pprintLine_("      nodecon    nodal connectivity array (double array, may be empty)");
    137         _pprintLine_("      lat        nodal latititudes (double vector)");
    138         _pprintLine_("      long       nodal longitudes (double vector)");
    139         _pprintLine_("      part       nodal partitions (double vector, may be empty)");
    140         _pprintLine_("      data       nodal or element data (double vector, may be empty)");
    141         _pprintLine_("      cmap       color map (double nx3 array, may be empty)");
    142         _pprintLine_("      kmlfile    KML file name (string)");
    143         _pprintLine_("");
    144         _pprintLine_("      ierror     error flag (double, non-zero for error)");
    145         _pprintLine_("");
    146         _pprintLine_("   Example:");
    147         _pprintLine_("      KMLMeshWrite(md.name,md.notes,md.elements,md.nodeconnectivity,md.lat,md.long,md.part,md.fm_criterion,options.cmap,filekml);");
    148         _pprintLine_("");
    149 }

  • issm/trunk-jpl/src/modules/KMLMeshWrite/KMLMeshWrite.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void KMLMeshWriteUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/KMLOverlay/KMLOverlay.cpp

    r13216 r13236  
    44#include "./KMLOverlay.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void KMLOverlayUsage(void){/*{{{*/
     7        _pprintLine_("KMLOverlay - KML file overlay module:");
     8        _pprintLine_("");
     9        _pprintLine_("   This module reads a list of image files and writes a KML or KMZ overlay file.");
     10        _pprintLine_("");
     11        _pprintLine_("   Usage:");
     12        _pprintLine_("      ierror=KMLOverlay(kmlfile,'param name',param,...);");
     13        _pprintLine_("");
     14        _pprintLine_("      kmlfile     KML or KMZ file name (string)");
     15        _pprintLine_("");
     16        _pprintLine_("      lataxis     latitude axis (double vector [south north], required)");
     17        _pprintLine_("      longaxis    longitude axis (double vector [west east], required)");
     18        _pprintLine_("      images      relative or http image file names (string or array of strings or cell array of strings, required)");
     19        _pprintLine_("      zip         flag to zip the doc.kml and image files into kmzfile (double, non-zero for kmz)");
     20        _pprintLine_("");
     21        _pprintLine_("      ierror     error flag (double, non-zero for error)");
     22        _pprintLine_("");
     23        _pprintLine_("   Example:");
     24        _pprintLine_("      KMLOverlay(kmlfile,'lataxis',[south north],'longaxis',[west east],'images',{'file1.png','http://issm/file2.png'},'zip',1);");
     25        _pprintLine_("");
     26}/*}}}*/
     27WRAPPER(KMLOverlay){
    728
    829        int i,verbose=1;
    … …  
    111132        MODULEEND();
    112133}
    113 
    114 void KMLOverlayUsage(void){
    115         _pprintLine_("KMLOverlay - KML file overlay module:");
    116         _pprintLine_("");
    117         _pprintLine_("   This module reads a list of image files and writes a KML or KMZ overlay file.");
    118         _pprintLine_("");
    119         _pprintLine_("   Usage:");
    120         _pprintLine_("      ierror=KMLOverlay(kmlfile,'param name',param,...);");
    121         _pprintLine_("");
    122         _pprintLine_("      kmlfile     KML or KMZ file name (string)");
    123         _pprintLine_("");
    124         _pprintLine_("      lataxis     latitude axis (double vector [south north], required)");
    125         _pprintLine_("      longaxis    longitude axis (double vector [west east], required)");
    126         _pprintLine_("      images      relative or http image file names (string or array of strings or cell array of strings, required)");
    127         _pprintLine_("      zip         flag to zip the doc.kml and image files into kmzfile (double, non-zero for kmz)");
    128         _pprintLine_("");
    129         _pprintLine_("      ierror     error flag (double, non-zero for error)");
    130         _pprintLine_("");
    131         _pprintLine_("   Example:");
    132         _pprintLine_("      KMLOverlay(kmlfile,'lataxis',[south north],'longaxis',[west east],'images',{'file1.png','http://issm/file2.png'},'zip',1);");
    133         _pprintLine_("");
    134 }

  • issm/trunk-jpl/src/modules/KMLOverlay/KMLOverlay.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void KMLOverlayUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/Kml2Exp/Kml2Exp.cpp

    r13036 r13236  
    44#include "./Kml2Exp.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void Kml2ExpUsage(void){/*{{{*/
     7        _pprintLine_("Kml2Exp - kml to exp file conversion module:");
     8        _pprintLine_("");
     9        _pprintLine_("   This module converts a file from kml to exp format.");
     10        _pprintLine_("");
     11        _pprintLine_("   Usage:");
     12        _pprintLine_("      [ret]=Kml2Exp(filexp,filkml,sgn,'param name',param,...);");
     13        _pprintLine_("");
     14        _pprintLine_("      filkml      file name of kml file to be read (char)");
     15        _pprintLine_("      filexp      file name of exp file to be written (char)");
     16        _pprintLine_("      sgn         sign for hemisphere (double, +1 (north) or -1 (south))");
     17        _pprintLine_("");
     18        _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
     19        _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
     20        _pprintLine_("");
     21        _pprintLine_("      ret         return code (non-zero for warning)");
     22        _pprintLine_("");
     23        _pprintLine_("   Examples:");
     24        _pprintLine_("      [ret]=Kml2Exp('file.kml','file.exp', 1);");
     25        _pprintLine_("      [ret]=Kml2Exp('file.kml','file.exp', 1,'central_meridian',45,'standard_parallel',70);");
     26        _pprintLine_("      [ret]=Kml2Exp('file.kml','file.exp',-1,'central_meridian', 0,'standard_parallel',71);");
     27        _pprintLine_("");
     28}/*}}}*/
     29WRAPPER(Kml2Exp){
    730
    831        int i,verbose=1;
    … …  
    6487        MODULEEND();
    6588}
    66 
    67 void Kml2ExpUsage(void){
    68         _pprintLine_("Kml2Exp - kml to exp file conversion module:");
    69         _pprintLine_("");
    70         _pprintLine_("   This module converts a file from kml to exp format.");
    71         _pprintLine_("");
    72         _pprintLine_("   Usage:");
    73         _pprintLine_("      [ret]=Kml2Exp(filexp,filkml,sgn,'param name',param,...);");
    74         _pprintLine_("");
    75         _pprintLine_("      filkml      file name of kml file to be read (char)");
    76         _pprintLine_("      filexp      file name of exp file to be written (char)");
    77         _pprintLine_("      sgn         sign for hemisphere (double, +1 (north) or -1 (south))");
    78         _pprintLine_("");
    79         _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
    80         _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
    81         _pprintLine_("");
    82         _pprintLine_("      ret         return code (non-zero for warning)");
    83         _pprintLine_("");
    84         _pprintLine_("   Examples:");
    85         _pprintLine_("      [ret]=Kml2Exp('file.kml','file.exp', 1);");
    86         _pprintLine_("      [ret]=Kml2Exp('file.kml','file.exp', 1,'central_meridian',45,'standard_parallel',70);");
    87         _pprintLine_("      [ret]=Kml2Exp('file.kml','file.exp',-1,'central_meridian', 0,'standard_parallel',71);");
    88         _pprintLine_("");
    89 }
    90 

  • issm/trunk-jpl/src/modules/Kml2Exp/Kml2Exp.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void Kml2ExpUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/Kriging/Kriging.cpp

    r13036 r13236  
    44#include "./Kriging.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void KrigingUsage(void){/*{{{*/
     7        _pprintLine_("");
     8        _pprintLine_("   usage: predictions=" << __FUNCT__ << "(x,y,observations,x_interp,y_interp,'options');");
     9        _pprintLine_("   available options:");
     10        _pprintLine_("      -'model': Available variogram models 'gaussian' (default),'spherical','power','exponential'");
     11        _pprintLine_("         -'nugget': nugget effect (default 0.2)");
     12        _pprintLine_("         -'range':  for gaussian, spherical and exponential models (default sqrt(3))");
     13        _pprintLine_("         -'sill':   for gaussian, spherical and exponential models (default 1)");
     14        _pprintLine_("         -'slope':  for power model (default 1)");
     15        _pprintLine_("         -'power':  for power model (default 1)");
     16        _pprintLine_("      -'searchradius': search radius for each prediction (default is observations span)");
     17        _pprintLine_("      -'boxlength':    minimum length of quadtree boxes (useful to decrease the number of observations)");
     18        _pprintLine_("      -'maxdata':      minimum number of observations for a prediction (default is 50)");
     19        _pprintLine_("      -'mindata':      maximum number of observations for a prediction (default is 1)");
     20        _pprintLine_("      -'maxtrimming':  maximum trimming value (default is -1.e+21)");
     21        _pprintLine_("      -'mintrimming':  minimum trimming value (default is +1.e+21)");
     22        _pprintLine_("      -'minspacing':   minimum distance between observation (default is 0.01)");
     23        _pprintLine_("");
     24}/*}}}*/
     25WRAPPER(Kriging){
    726
    827        /*Outputs*/
    … …  
    5271        MODULEEND();
    5372}
    54 
    55 void KrigingUsage(void){
    56         _pprintLine_("");
    57         _pprintLine_("   usage: predictions=" << __FUNCT__ << "(x,y,observations,x_interp,y_interp,'options');");
    58         _pprintLine_("   available options:");
    59         _pprintLine_("      -'model': Available variogram models 'gaussian' (default),'spherical','power','exponential'");
    60         _pprintLine_("         -'nugget': nugget effect (default 0.2)");
    61         _pprintLine_("         -'range':  for gaussian, spherical and exponential models (default sqrt(3))");
    62         _pprintLine_("         -'sill':   for gaussian, spherical and exponential models (default 1)");
    63         _pprintLine_("         -'slope':  for power model (default 1)");
    64         _pprintLine_("         -'power':  for power model (default 1)");
    65         _pprintLine_("      -'searchradius': search radius for each prediction (default is observations span)");
    66         _pprintLine_("      -'boxlength':    minimum length of quadtree boxes (useful to decrease the number of observations)");
    67         _pprintLine_("      -'maxdata':      minimum number of observations for a prediction (default is 50)");
    68         _pprintLine_("      -'mindata':      maximum number of observations for a prediction (default is 1)");
    69         _pprintLine_("      -'maxtrimming':  maximum trimming value (default is -1.e+21)");
    70         _pprintLine_("      -'mintrimming':  minimum trimming value (default is +1.e+21)");
    71         _pprintLine_("      -'minspacing':   minimum distance between observation (default is 0.01)");
    72         _pprintLine_("");
    73 }

  • issm/trunk-jpl/src/modules/Kriging/Kriging.h

    r13235 r13236  
    11/*
    2         KrigingUsage.h
     2        Kriging.h
    33*/
    44
    … …  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void KrigingUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/Ll2xy/Ll2xy.cpp

    r13036 r13236  
    44#include "./Ll2xy.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void Ll2xyUsage(void){/*{{{*/
     7        _pprintLine_("Ll2xy - lat/long to x/y coordinate transformation module:");
     8        _pprintLine_("");
     9        _pprintLine_("   This module transforms lat/long to x/y coordinates.");
     10        _pprintLine_("");
     11        _pprintLine_("   Usage:");
     12        _pprintLine_("      [x,y]=Ll2xy(lat,lon,sgn,'param name',param,...);");
     13        _pprintLine_("");
     14        _pprintLine_("      lat         latitude coordinates (double vector)");
     15        _pprintLine_("      lon         longitude coordinates (double vector)");
     16        _pprintLine_("      sgn         sign for hemisphere (double, +1 (north) or -1 (south))");
     17        _pprintLine_("");
     18        _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
     19        _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
     20        _pprintLine_("");
     21        _pprintLine_("      x           x coordinates (double vector)");
     22        _pprintLine_("      y           y coordinates (double vector)");
     23        _pprintLine_("");
     24        _pprintLine_("   Examples:");
     25        _pprintLine_("      [x,y]=Ll2xy(lat,lon, 1);");
     26        _pprintLine_("      [x,y]=Ll2xy(lat,lon, 1,'central_meridian',45,'standard_parallel',70);");
     27        _pprintLine_("      [x,y]=Ll2xy(lat,lon,-1,'central_meridian', 0,'standard_parallel',71);");
     28        _pprintLine_("");
     29}/*}}}*/
     30WRAPPER(Ll2xy){
    731
    832        int i,verbose=1;
    … …  
    7296        MODULEEND();
    7397}
    74 
    75 void Ll2xyUsage(void){
    76         _pprintLine_("Ll2xy - lat/long to x/y coordinate transformation module:");
    77         _pprintLine_("");
    78         _pprintLine_("   This module transforms lat/long to x/y coordinates.");
    79         _pprintLine_("");
    80         _pprintLine_("   Usage:");
    81         _pprintLine_("      [x,y]=Ll2xy(lat,lon,sgn,'param name',param,...);");
    82         _pprintLine_("");
    83         _pprintLine_("      lat         latitude coordinates (double vector)");
    84         _pprintLine_("      lon         longitude coordinates (double vector)");
    85         _pprintLine_("      sgn         sign for hemisphere (double, +1 (north) or -1 (south))");
    86         _pprintLine_("");
    87         _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
    88         _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
    89         _pprintLine_("");
    90         _pprintLine_("      x           x coordinates (double vector)");
    91         _pprintLine_("      y           y coordinates (double vector)");
    92         _pprintLine_("");
    93         _pprintLine_("   Examples:");
    94         _pprintLine_("      [x,y]=Ll2xy(lat,lon, 1);");
    95         _pprintLine_("      [x,y]=Ll2xy(lat,lon, 1,'central_meridian',45,'standard_parallel',70);");
    96         _pprintLine_("      [x,y]=Ll2xy(lat,lon,-1,'central_meridian', 0,'standard_parallel',71);");
    97         _pprintLine_("");
    98 }

  • issm/trunk-jpl/src/modules/Ll2xy/Ll2xy.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void Ll2xyUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/MeshPartition/MeshPartition.cpp

    r13038 r13236  
    11/*!\file:  MeshPartition.cpp
    22 * \brief: partition mesh according to number of areas, using Metis library.
    3 
    4         usage:
    5         [element_partitioning,node_partitioning]=MeshPartition(model,numareas)
    6        
    7         %Info needed from model are the following:
    8         %mesh info:
    9         numberofelements,numberofvertices,elements,elements_width
    10         %Non-extruded 2d mesh info
    11         nel2d,nods2d,elements2d,
    12         %Extruded 2d mesh info
    13         nel2d_ext,nods2d_ext,elements2d_ext,
    14         %Diverse
    15         numberoflayers,dim)
    16 
    17         output:
    18         vector of partitioning area numbers, for every element.
    19         vector of partitioning area numbers, for every node.
    203*/
    214       
    225#include "./MeshPartition.h"
    236
    24 
    25 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
    26 
     7void MeshPartitionUsage(void){/*{{{*/
     8        _printLine_("   usage:");
     9        _printString_("   [element_partitioning,node_partitioning]=MeshPartition(md.mesh,numpartitions)");
     10        _printLine_("   where:");
     11        _printLine_("      element_partitioning is a vector of partitioning area numbers, for every element.");
     12        _printLine_("      node_partitioning is a vector of partitioning area numbers, for every node.");
     13        _printLine_("");
     14}/*}}}*/
     15WRAPPER(MeshPartition){
    2716
    2817        /*Indexing: */
    … …  
    9483        MODULEEND();
    9584}
    96 
    97 void MeshPartitionUsage(void){
    98         _printLine_("   usage:");
    99         _printString_("   [element_partitioning,node_partitioning]=MeshPartition(md.mesh,numpartitions)");
    100         _printLine_("   where:");
    101         _printLine_("      element_partitioning is a vector of partitioning area numbers, for every element.");
    102         _printLine_("      node_partitioning is a vector of partitioning area numbers, for every node.");
    103         _printLine_("");
    104 }

  • issm/trunk-jpl/src/modules/MeshPartition/MeshPartition.h

    r13235 r13236  
    1717#endif
    1818
    19 /* local prototypes: */
    20 void MeshPartitionUsage(void);
    21 
    2219#include "../../c/include/globals.h"
    2320#include "../../c/modules/modules.h"
    … …  
    2522#include "../../c/shared/shared.h"
    2623#include "../../c/issm-binding.h"
    27 
    28 #undef CLEANUP
    29 #define CLEANUP MeshPartitionLocalCleanup();
    3024
    3125#undef __FUNCT__

  • issm/trunk-jpl/src/modules/MeshProfileIntersection/MeshProfileIntersection.cpp

    r13220 r13236  
    1818#include "./MeshProfileIntersection.h"
    1919
    20 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
     20void MeshProfileIntersectionUsage(void){/*{{{*/
     21        _printLine_("   usage:");
     22        _printLine_("   [segments]=MeshProfileIntersection(index,x,y,filename);");
     23        _printLine_("   where:");
     24        _printLine_("   input:");
     25        _printLine_("        index,x,y is a triangulation");
     26        _printLine_("        filename: name of Argus style .exp file containing the segments (can be groups of disconnected segments)");
     27        _printLine_("   output:");
     28        _printLine_("        segments: array made of x1,y1,x2,y2,element_id lines (x1,y1) and (x2,y2) are segment extremitis for a segment ");
     29        _printLine_("        belonging to the elemnt_id element. there are as many lines in segments as there are segments intersecting the ");
     30        _printLine_("        mesh.");
     31}/*}}}*/
     32WRAPPER(MeshProfileIntersection){
    2133
    2234        int i,j;
    … …  
    100112
    101113}
    102 
    103 void MeshProfileIntersectionUsage(void){
    104         _printLine_("   usage:");
    105         _printLine_("   [segments]=MeshProfileIntersection(index,x,y,filename);");
    106         _printLine_("   where:");
    107         _printLine_("   input:");
    108         _printLine_("        index,x,y is a triangulation");
    109         _printLine_("        filename: name of Argus style .exp file containing the segments (can be groups of disconnected segments)");
    110         _printLine_("   output:");
    111         _printLine_("        segments: array made of x1,y1,x2,y2,element_id lines (x1,y1) and (x2,y2) are segment extremitis for a segment ");
    112         _printLine_("        belonging to the elemnt_id element. there are as many lines in segments as there are segments intersecting the ");
    113         _printLine_("        mesh.");
    114 }

  • issm/trunk-jpl/src/modules/MeshProfileIntersection/MeshProfileIntersection.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void MeshProfileIntersectionUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/NodeConnectivity/NodeConnectivity.cpp

    r12518 r13236  
    55#include "./NodeConnectivity.h"
    66
     7void NodeConnectivityUsage(void){/*{{{*/
     8        _pprintLine_("");
     9        _pprintLine_("   usage: connectivity = " << __FUNCT__ << "(elements, numnodes);");
     10        _pprintLine_("");
     11}/*}}}*/
    712WRAPPER(NodeConnectivity){
    813
    … …  
    3540        MODULEEND();
    3641}
    37 
    38 void NodeConnectivityUsage(void) {
    39         _pprintLine_("");
    40         _pprintLine_("   usage: connectivity = " << __FUNCT__ << "(elements, numnodes);");
    41         _pprintLine_("");
    42 }

  • issm/trunk-jpl/src/modules/NodeConnectivity/NodeConnectivity.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
     18
     19#undef __FUNCT__
     20#define __FUNCT__  "NodeConnectivity"
    1821
    1922/*Header files: */
    … …  
    4447#endif
    4548
    46 #undef __FUNCT__
    47 #define __FUNCT__  "NodeConnectivity"
    48 
    4949/* serial arg counts: */
    5050#undef NLHS
    … …  
    5353#define NRHS  2
    5454
    55 /* local prototypes: */
    56 void NodeConnectivityUsage(void);
    57 
    5855#endif  /* _NODECONNECTIVITY_H */

  • issm/trunk-jpl/src/modules/PointCloudFindNeighbors/PointCloudFindNeighbors.cpp

    r13229 r13236  
    55#include "./PointCloudFindNeighbors.h"
    66
    7 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
     7void PointCloudFindNeighborsUsage(void){/*{{{*/
     8        _printLine_("   usage:");
     9        _printLine_("   [flags]=PointCloudFindNeighbors(x,y,mindistance,multithread);\n");
     10        _printLine_("   where:");
     11        _printLine_("      x,y: list of points.");
     12        _printLine_("      mindistance: minimum distance that should exist between points in the cloud.");
     13        _printLine_("      multithread: run multithreaded or not. with multithreads, flags can get 1 and 2 values in duplicates.");
     14        _printLine_("      flags: array of flags (flag==1 means point is within mindistance of another point)");
     15        _printLine_("");
     16}/*}}}*/
     17WRAPPER(PointCloudFindNeighbors){
    818
    919        int i,j;
    … …  
    4050        MODULEEND();
    4151}
    42 
    43 void PointCloudFindNeighborsUsage(void){
    44         _printLine_("   usage:");
    45         _printLine_("   [flags]=PointCloudFindNeighbors(x,y,mindistance,multithread);\n");
    46         _printLine_("   where:");
    47         _printLine_("      x,y: list of points.");
    48         _printLine_("      mindistance: minimum distance that should exist between points in the cloud.");
    49         _printLine_("      multithread: run multithreaded or not. with multithreads, flags can get 1 and 2 values in duplicates.");
    50         _printLine_("      flags: array of flags (flag==1 means point is within mindistance of another point)");
    51         _printLine_("");
    52 }

  • issm/trunk-jpl/src/modules/PointCloudFindNeighbors/PointCloudFindNeighbors.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void PointCloudFindNeighborsUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/PropagateFlagsFromConnectivity/PropagateFlagsFromConnectivity.cpp

    r12517 r13236  
    55#include "./PropagateFlagsFromConnectivity.h"
    66
    7 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     7void PropagateFlagsFromConnectivityUsage(void) {/*{{{*/
     8        _printLine_("");
     9        _printLine_("   usage: [pool] = " << __FUNCT__ << "(connectivity,pool,index,flags);");;
     10        _printLine_("");
     11}/*}}}*/
     12WRAPPER(PropagateFlagsFromConnectivity){
    813
    914        /*input/output datasets: */
    … …  
    4045        MODULEEND();
    4146}
    42 
    43 void PropagateFlagsFromConnectivityUsage(void) {
    44         _printLine_("");
    45         _printLine_("   usage: [pool] = " << __FUNCT__ << "(connectivity,pool,index,flags);");;
    46         _printLine_("");
    47 }

  • issm/trunk-jpl/src/modules/PropagateFlagsFromConnectivity/PropagateFlagsFromConnectivity.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void PropagateFlagsFromConnectivityUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/Scotch/Scotch.cpp

    r13036 r13236  
    88#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
    99#endif
    10 
    11 
    1210#include "./Scotch.h"
    1311
    14 /******************************/
    15 /*                            */
    16 /* This is the main function. */
    17 /*                            */
    18 /******************************/
    19 
    20 void mexFunction( int nlhs,
    21                                   mxArray *plhs[],
    22                                   int nrhs,
    23                                   const mxArray *prhs[] )
    24 {
    25 
    26 #ifndef _HAVE_SCOTCH_ //only works if scotch library has been compiled in.
     12void GmapUsage(void){/*{{{*/
     13        mexPrintf("\n");
     14        mexPrintf("Usage: [maptab]=Scotch(adjmat,vertlb,vertwt,edgewt,archtyp,archpar,\n");
     15        mexPrintf("                         Scotch-specific parameters);\n");
     16        mexPrintf("\n");
     17}/*}}}*/
     18void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){
     19
     20        #ifndef _HAVE_SCOTCH_ //only works if scotch library has been compiled in.
    2721        _error_("Scotch not available! Cannot carry out Scotch partitioning!");
    2822        #else
    … …  
    4236        /* Check for proper number of arguments */
    4337   
    44         if      (nrhs == 0 && nlhs == 0) {
     38        if (nrhs == 0 && nlhs == 0) {
    4539                GmapUsage();
    4640                return;
    … …  
    254248#endif //#ifndef _HAVE_SCOTCH_
    255249}
    256 
    257 void GmapUsage( void )
    258 {
    259 
    260     mexPrintf("\n");
    261     mexPrintf("Usage: [maptab]=Scotch(adjmat,vertlb,vertwt,edgewt,archtyp,archpar,\n");
    262     mexPrintf("                         Scotch-specific parameters);\n");
    263     mexPrintf("\n");
    264 
    265     return;
    266 }
    267 

  • issm/trunk-jpl/src/modules/Scotch/Scotch.h

    r13214 r13236  
    66#define _SCOTCH_H
    77
    8 /* local prototypes: */
    9 void GmapUsage(void);
    10 
    118#include <stdio.h>
    129#include <string.h>    /*  strcasecmp  */
    1310#include <time.h>      /*  clock,time,difftime  */
    14 
    1511#include "../../c/include/globals.h"
    1612#include "../../c/modules/modules.h"

  • issm/trunk-jpl/src/modules/Shp2Kml/Shp2Kml.cpp

    r13036 r13236  
    1111#include "./Shp2Kml.h"
    1212
    13 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     13void Shp2KmlUsage(void){/*{{{*/
     14        _pprintLine_("Shp2Kml - shp to kml file conversion module:");
     15        _pprintLine_("");
     16        _pprintLine_("   This module converts a file from shp to kml format.");
     17        _pprintLine_("");
     18        _pprintLine_("   Usage:");
     19        _pprintLine_("      [ret]=Shp2Kml(filshp,filkml,sgn,'param name',param,...);");
     20        _pprintLine_("");
     21        _pprintLine_("      filshp      file name of shp file to be read (char, extension optional)");
     22        _pprintLine_("      filkml      file name of kml file to be written (char)");
     23        _pprintLine_("      sgn         sign for hemisphere (double, +1 (north); -1 (south); or 0 (no translation))");
     24        _pprintLine_("");
     25        _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
     26        _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
     27        _pprintLine_("");
     28        _pprintLine_("      ret         return code (non-zero for warning)");
     29        _pprintLine_("");
     30        _pprintLine_("   Examples:");
     31        _pprintLine_("      [ret]=Shp2Kml('file.shp','file.kml', 0);");
     32        _pprintLine_("      [ret]=Shp2Kml('file.shp','file.kml', 1,'central_meridian',45,'standard_parallel',70);");
     33        _pprintLine_("      [ret]=Shp2Kml('file.shp','file.kml',-1,'central_meridian', 0,'standard_parallel',71);");
     34        _pprintLine_("");
     35}/*}}}*/
     36WRAPPER(Shp2Kml){
    1437
    1538        int i,verbose=1;
    … …  
    7598        MODULEEND();
    7699}
    77 
    78 void Shp2KmlUsage(void){
    79         _pprintLine_("Shp2Kml - shp to kml file conversion module:");
    80         _pprintLine_("");
    81         _pprintLine_("   This module converts a file from shp to kml format.");
    82         _pprintLine_("");
    83         _pprintLine_("   Usage:");
    84         _pprintLine_("      [ret]=Shp2Kml(filshp,filkml,sgn,'param name',param,...);");
    85         _pprintLine_("");
    86         _pprintLine_("      filshp      file name of shp file to be read (char, extension optional)");
    87         _pprintLine_("      filkml      file name of kml file to be written (char)");
    88         _pprintLine_("      sgn         sign for hemisphere (double, +1 (north); -1 (south); or 0 (no translation))");
    89         _pprintLine_("");
    90         _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
    91         _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
    92         _pprintLine_("");
    93         _pprintLine_("      ret         return code (non-zero for warning)");
    94         _pprintLine_("");
    95         _pprintLine_("   Examples:");
    96         _pprintLine_("      [ret]=Shp2Kml('file.shp','file.kml', 0);");
    97         _pprintLine_("      [ret]=Shp2Kml('file.shp','file.kml', 1,'central_meridian',45,'standard_parallel',70);");
    98         _pprintLine_("      [ret]=Shp2Kml('file.shp','file.kml',-1,'central_meridian', 0,'standard_parallel',71);");
    99         _pprintLine_("");
    100 }

  • issm/trunk-jpl/src/modules/Shp2Kml/Shp2Kml.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void Shp2KmlUsage(void);
    2118
    2219#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/StringToEnum/StringToEnum.cpp

    r13034 r13236  
    55#include "./StringToEnum.h"
    66
     7void StringToEnumUsage(void){/*{{{*/
     8        _pprintLine_("");
     9        _pprintLine_("   usage: " << __FUNCT__ << "enum = StringToEnum(string);");
     10        _pprintLine_("");
     11}/*}}}*/
    712WRAPPER(StringToEnum){
    813
    … …  
    2833        MODULEEND();
    2934}
    30 
    31 void StringToEnumUsage(void)
    32 {
    33         _pprintLine_("");
    34         _pprintLine_("   usage: " << __FUNCT__ << "enum = StringToEnum(string);");
    35         _pprintLine_("");
    36 }

  • issm/trunk-jpl/src/modules/StringToEnum/StringToEnum.h

    r13214 r13236  
    4747#define NRHS  1
    4848
    49 /* local prototypes: */
    50 void StringToEnumUsage(void);
    51 
    5249#endif  /* _TEST_H */

  • issm/trunk-jpl/src/modules/TriMesh/TriMesh.cpp

    r13228 r13236  
    55#include "./TriMesh.h"
    66
     7void TriMeshUsage(void){/*{{{*/
     8        _printLine_("");
     9        _printLine_("   usage: [index,x,y,segments,segmentmarkers]=TriMesh(domainoutlinefilename,rifts,area) ");
     10        _printLine_("      where: index,x,y defines a triangulation, segments is an array made ");
     11        _printLine_("      of exterior segments to the mesh domain outline, segmentmarkers is an array flagging each segment, ");
     12        _printLine_("      outlinefilename an Argus domain outline file, ");
     13        _printLine_("      area is the maximum area desired for any element of the resulting mesh, ");
     14        _printLine_("");
     15}/*}}}*/
    716WRAPPER(TriMesh){
    817       
    … …  
    6069        MODULEEND();
    6170}
    62 
    63 void TriMeshUsage(void) //{{{1
    64 {
    65         _printLine_("");
    66         _printLine_("   usage: [index,x,y,segments,segmentmarkers]=TriMesh(domainoutlinefilename,rifts,area) ");
    67         _printLine_("      where: index,x,y defines a triangulation, segments is an array made ");
    68         _printLine_("      of exterior segments to the mesh domain outline, segmentmarkers is an array flagging each segment, ");
    69         _printLine_("      outlinefilename an Argus domain outline file, ");
    70         _printLine_("      area is the maximum area desired for any element of the resulting mesh, ");
    71         _printLine_("");
    72 }
    73 //}}}

  • issm/trunk-jpl/src/modules/TriMesh/TriMesh.h

    r13235 r13236  
    6363#define NRHS  3
    6464
    65 /* local prototypes: */
    66 void TriMeshUsage(void);
    67 
    6865#endif  /* _TRIMESH_H */

  • issm/trunk-jpl/src/modules/TriMeshProcessRifts/TriMeshProcessRifts.cpp

    r13225 r13236  
    55#include "./TriMeshProcessRifts.h"
    66
    7 void mexFunction(       int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] ){
     7void TriMeshProcessRiftsUsage(void){/*{{{*/
     8        _printLine_("");
     9        _printLine_("   usage: [index2,x2,y2,segments2,segmentmarkers2,rifts2]=TriMeshProcessrifts(index1,x1,y1,segments1,segmentmarkers1) ");
     10        _printLine_("      where: (index1,x1,y1,segments1,segmentmarkers1) is an initial triangulation.");
     11        _printLine_("      index2,x2,y2,segments2,segmentmarkers2,rifts2 is the resulting triangulation where rifts have been processed.");
     12}/*}}}*/
     13WRAPPER(TriMeshProcessRifts){
    814
    915        /*Matlab arrays: */
    … …  
    245251        return;
    246252}
    247 
    248 void TriMeshProcessRiftsUsage(void){
    249         _printLine_("");
    250         _printLine_("   usage: [index2,x2,y2,segments2,segmentmarkers2,rifts2]=TriMeshProcessrifts(index1,x1,y1,segments1,segmentmarkers1) ");
    251         _printLine_("      where: (index1,x1,y1,segments1,segmentmarkers1) is an initial triangulation.");
    252         _printLine_("      index2,x2,y2,segments2,segmentmarkers2,rifts2 is the resulting triangulation where rifts have been processed.");
    253 }

  • issm/trunk-jpl/src/modules/TriMeshProcessRifts/TriMeshProcessRifts.h

    r13214 r13236  
    99#include "triangle.h"
    1010#include "string.h"
    11 
    1211#include "../../c/include/globals.h"
    1312#include "../../c/modules/modules.h"
    … …  
    1716#include "../../c/EnumDefinitions/EnumDefinitions.h"
    1817
    19 void TriMeshProcessRiftsUsage(void);
    2018#undef __FUNCT__
    2119#define __FUNCT__ "TriMeshProcessRifts"

  • issm/trunk-jpl/src/modules/TriaSearch/TriaSearch.cpp

    r12601 r13236  
    44#include "./TriaSearch.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void TriaSearchUsage(void){/*{{{*/
     7        _pprintLine_("TriaSearch- find triangle holding a point (x0,y0) in a mesh");
     8        _pprintLine_("");
     9        _pprintLine_("   Usage:");
     10        _pprintLine_("         tria=TriaSearch(index,x,y,x0,y0);");
     11        _pprintLine_("      index,x,y: mesh triangulatrion");
     12        _pprintLine_("      x0,y0: coordinates of the point for which we are trying to find a triangle");
     13        _pprintLine_("      x0,y0 can be an array of points");
     14        _pprintLine_("");
     15}/*}}}*/
     16WRAPPER(TriaSearch){
    717
    818        int i;
    … …  
    4959        MODULEEND();
    5060}
    51 
    52 void TriaSearchUsage(void){
    53         _pprintLine_("TriaSearch- find triangle holding a point (x0,y0) in a mesh");
    54         _pprintLine_("");
    55         _pprintLine_("   Usage:");
    56         _pprintLine_("         tria=TriaSearch(index,x,y,x0,y0);");
    57         _pprintLine_("      index,x,y: mesh triangulatrion");
    58         _pprintLine_("      x0,y0: coordinates of the point for which we are trying to find a triangle");
    59         _pprintLine_("      x0,y0 can be an array of points");
    60         _pprintLine_("");
    61 }

  • issm/trunk-jpl/src/modules/TriaSearch/TriaSearch.h

    r13235 r13236  
    1515#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1616#endif
    17 
    18 /* local prototypes: */
    19 void TriaSearchUsage(void);
    2017
    2118#include "../../c/include/globals.h"

  • issm/trunk-jpl/src/modules/Xy2ll/Xy2ll.cpp

    r13036 r13236  
    44#include "./Xy2ll.h"
    55
    6 void mexFunction( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){
     6void Xy2llUsage(void){/*{{{*/
     7        _pprintLine_("Xy2ll - x/y to lat/long coordinate transformation module:");
     8        _pprintLine_("");
     9        _pprintLine_("   This module transforms x/y to lat/long coordinates.");
     10        _pprintLine_("");
     11        _pprintLine_("   Usage:");
     12        _pprintLine_("      [lat,lon]=Xy2ll(x,y,sgn,'param name',param,...);");
     13        _pprintLine_("");
     14        _pprintLine_("      x           x coordinates (double vector)");
     15        _pprintLine_("      y           y coordinates (double vector)");
     16        _pprintLine_("      sgn         sign for hemisphere (double, +1 (north) or -1 (south))");
     17        _pprintLine_("");
     18        _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
     19        _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
     20        _pprintLine_("");
     21        _pprintLine_("      lat         latitude coordinates (double vector)");
     22        _pprintLine_("      lon         longitude coordinates (double vector)");
     23        _pprintLine_("");
     24        _pprintLine_("   Examples:");
     25        _pprintLine_("      [lat,lon]=Xy2ll(x,y, 1);");
     26        _pprintLine_("      [lat,lon]=Xy2ll(x,y, 1,'central_meridian',45,'standard_parallel',70);");
     27        _pprintLine_("      [lat,lon]=Xy2ll(x,y,-1,'central_meridian', 0,'standard_parallel',71);");
     28        _pprintLine_("");
     29}/*}}}*/
     30WRAPPER(Xy2ll){
    731
    832        int i,verbose=1;
    … …  
    7195        MODULEEND();
    7296}
    73 
    74 void Xy2llUsage(void){
    75         _pprintLine_("Xy2ll - x/y to lat/long coordinate transformation module:");
    76         _pprintLine_("");
    77         _pprintLine_("   This module transforms x/y to lat/long coordinates.");
    78         _pprintLine_("");
    79         _pprintLine_("   Usage:");
    80         _pprintLine_("      [lat,lon]=Xy2ll(x,y,sgn,'param name',param,...);");
    81         _pprintLine_("");
    82         _pprintLine_("      x           x coordinates (double vector)");
    83         _pprintLine_("      y           y coordinates (double vector)");
    84         _pprintLine_("      sgn         sign for hemisphere (double, +1 (north) or -1 (south))");
    85         _pprintLine_("");
    86         _pprintLine_("      central_meridian     central meridian (double, optional, but must specify with sp)");
    87         _pprintLine_("      standard_parallel    standard parallel (double, optional, but must specify with cm)");
    88         _pprintLine_("");
    89         _pprintLine_("      lat         latitude coordinates (double vector)");
    90         _pprintLine_("      lon         longitude coordinates (double vector)");
    91         _pprintLine_("");
    92         _pprintLine_("   Examples:");
    93         _pprintLine_("      [lat,lon]=Xy2ll(x,y, 1);");
    94         _pprintLine_("      [lat,lon]=Xy2ll(x,y, 1,'central_meridian',45,'standard_parallel',70);");
    95         _pprintLine_("      [lat,lon]=Xy2ll(x,y,-1,'central_meridian', 0,'standard_parallel',71);");
    96         _pprintLine_("");
    97 }
    98 

  • issm/trunk-jpl/src/modules/Xy2ll/Xy2ll.h

    r13235 r13236  
    1616#define PY_ARRAY_UNIQUE_SYMBOL PythonIOSymbol
    1717#endif
    18 
    19 /* local prototypes: */
    20 void Xy2llUsage(void);
    2118
    2219#include "../../c/include/globals.h"
Note: See TracChangeset for help on using the changeset viewer.