Changeset 21700


Ignore:
Timestamp:
05/03/17 17:30:39 (8 years ago)
Author:
felicity
Message:

NEW: ESTAR material functions for inversion capabilities

Location:
issm/trunk-jpl/src/c/classes/Materials
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/classes/Materials/Material.h

    r21393 r21700  
    5353                virtual void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input)=0;
    5454                virtual void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon)=0;
     55                virtual void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input)=0;
     56                virtual void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input)=0;
     57                virtual void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input)=0;
    5558
    5659};

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

    r21407 r21700  
    160160/*}}}*/
    161161IssmDouble Matestar::GetB(){/*{{{*/
     162
    162163        /*Output*/
    163164        IssmDouble B;
    … …  
    168169/*}}}*/
    169170IssmDouble Matestar::GetBbar(){/*{{{*/
     171
    170172        /*Output*/
    171173        IssmDouble Bbar;
    … …  
    193195}
    194196/*}}}*/
     197IssmDouble Matestar::GetEcbar(){/*{{{*/
     198
     199        /*Output*/
     200        IssmDouble Ecbar;
     201
     202        element->inputs->GetInputAverage(&Ecbar,MaterialsRheologyEcbarEnum);
     203        return Ecbar;
     204}
     205/*}}}*/
    195206IssmDouble Matestar::GetEs(){/*{{{*/
    196207
    … …  
    202213}
    203214/*}}}*/
     215IssmDouble Matestar::GetEsbar(){/*{{{*/
     216
     217        /*Output*/
     218        IssmDouble Esbar;
     219
     220        element->inputs->GetInputAverage(&Esbar,MaterialsRheologyEsbarEnum);
     221        return Esbar;
     222}
     223/*}}}*/
    204224IssmDouble Matestar::GetN(){/*{{{*/
    205225
    … …  
    211231void  Matestar::GetViscosity(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
    212232        _error_("not implemented yet");
    213         /*From a string tensor and a material object, return viscosity, using Glen's flow law.
    214                                                                 (1-D) B
    215           viscosity= -------------------------
    216                                                   2 eps_eff ^[(n-1)/n]
    217 
    218           where viscosity is the viscotiy, B the flow law parameter , eps_eff is the effective strain rate
    219           and n the flow law exponent.
    220 
    221           If eps_eff = 0 , it means this is the first time SystemMatrices is being run, and we
    222           return 10^14, initial viscosity.
    223           */
     233}
     234/*}}}*/
     235void  Matestar::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
     236        _error_("not implemented yet");
     237}
     238/*}}}*/
     239void  Matestar::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
     240        _error_("not implemented yet");
     241}
     242/*}}}*/
     243void  Matestar::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
     244        _error_("not implemented yet");
     245}
     246/*}}}*/
     247void  Matestar::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
     248        _error_("not implemented yet");
     249}
     250/*}}}*/
     251IssmDouble Matestar::GetViscosityGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,bool isdepthaveraged){/*{{{*/
    224252
    225253        /*output: */
    226254        IssmDouble viscosity;
    227255
    228         /*Intermediary: */
    229         IssmDouble B,D=0.,n;
    230 
    231         /*Get B and n*/
    232         B=GetB(); _assert_(B>0.);
    233         n=GetN(); _assert_(n>0.);
    234 
    235         if (n==1.){
    236                 /*Linear Viscous behavior (Newtonian fluid) viscosity=B/2: */
    237                 viscosity=(1.-D)*B/2.;
    238         }
    239         else{
    240 
    241                 /*if no strain rate, return maximum viscosity*/
    242                 if(eps_eff==0.){
    243                         viscosity = 1.e+14/2.;
    244                         //viscosity = B;
    245                         //viscosity=2.5*pow(10.,17);
    246                 }
    247 
    248                 else{
    249                         viscosity=(1.-D)*B/(2.*pow(eps_eff,(n-1.)/n));
    250                 }
    251         }
    252 
    253         /*Checks in debugging mode*/
    254         if(viscosity<=0) _error_("Negative viscosity");
    255 
    256         /*Return: */
    257         *pviscosity=viscosity;
    258 }
    259 /*}}}*/
    260 void  Matestar::GetViscosityBar(IssmDouble* pviscosity,IssmDouble eps_eff){/*{{{*/
    261         _error_("not implemented yet");
    262 }
    263 /*}}}*/
    264 void  Matestar::GetViscosityComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
    265         _error_("not implemented yet");
    266 }
    267 /*}}}*/
    268 void  Matestar::GetViscosityDComplement(IssmDouble* pviscosity_complement, IssmDouble* epsilon){/*{{{*/
    269         _error_("not implemented yet");
    270 }
    271 /*}}}*/
    272 void  Matestar::GetViscosityDerivativeEpsSquare(IssmDouble* pmu_prime, IssmDouble* epsilon){/*{{{*/
    273         _error_("not implemented yet");
    274 }
    275 /*}}}*/
    276 IssmDouble Matestar::GetViscosityGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz){/*{{{*/
    277 
    278         /*Intermediaries*/
    279         IssmDouble viscosity;
     256        /*Intermediaries*/
    280257        IssmDouble epseff,epsprime_norm;
    281258        IssmDouble lambdas;
    282259        IssmDouble vmag,dvmag[3];
    283         IssmDouble B,Ec,Es,E;
     260        IssmDouble B,Ec,Es,E,n;
    284261
    285262        /*Calculate velocity magnitude and its derivative*/
    … …  
    300277
    301278        /*Get B and enhancement*/
    302         B=GetB(); _assert_(B>0.);
    303         Ec=GetEc(); _assert_(Ec>=0.);
    304         Es=GetEs(); _assert_(Es>=0.);
     279        n=GetN(); _assert_(n>0.);
     280        if (isdepthaveraged==0.){
     281                B=GetB(); _assert_(B>0.);
     282                Ec=GetEc(); _assert_(Ec>=0.);
     283                Es=GetEs(); _assert_(Es>=0.);
     284        }
     285        else{
     286                B=GetBbar(); _assert_(B>0.);
     287                Ec=GetEcbar(); _assert_(Ec>=0.);
     288                Es=GetEsbar(); _assert_(Es>=0.);
     289        }
    305290
    306291        /*Get total enhancement factor E(lambdas)*/
    … …  
    315300        }
    316301        else{
    317                 viscosity = B/(2.*pow(E*epseff*epseff,1./3.));
     302                viscosity = B/(2.*pow(E,1./n)*pow(epseff,2./n));
    318303        }
    319304
    … …  
    322307}
    323308/*}}}*/
     309IssmDouble Matestar::GetViscosity_BGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,bool isdepthaveraged){/*{{{*/
     310
     311        /*Intermediaries*/
     312        IssmDouble dmudB;
     313        IssmDouble epseff,epsprime_norm;
     314        IssmDouble lambdas;
     315        IssmDouble vmag,dvmag[3];
     316        IssmDouble Ec,Es,E;
     317
     318        /*Calculate velocity magnitude and its derivative*/
     319        vmag = sqrt(vx*vx+vy*vy+vz*vz);
     320        if(vmag<1e-12){
     321                dvmag[0]=0;
     322                dvmag[1]=0;
     323                dvmag[2]=0;
     324        }
     325        else{
     326                dvmag[0]=1./(2*sqrt(vmag))*(2*vx*dvx[0]+2*vy*dvy[0]+2*vz*dvz[0]);
     327                dvmag[1]=1./(2*sqrt(vmag))*(2*vx*dvx[1]+2*vy*dvy[1]+2*vz*dvz[1]);
     328                dvmag[2]=1./(2*sqrt(vmag))*(2*vx*dvx[2]+2*vy*dvy[2]+2*vz*dvz[2]);
     329        }
     330
     331        EstarStrainrateQuantities(&epseff,&epsprime_norm,vx,vy,vz,vmag,dvx,dvy,dvz,&dvmag[0]);
     332        lambdas=EstarLambdaS(epseff,epsprime_norm);
     333
     334        /*Get enhancement*/
     335        if (isdepthaveraged==0.){
     336                Ec=GetEc(); _assert_(Ec>=0.);
     337                Es=GetEs(); _assert_(Es>=0.);
     338        }
     339        else{
     340                Ec=GetEcbar(); _assert_(Ec>=0.);
     341                Es=GetEsbar(); _assert_(Es>=0.);
     342        }
     343
     344        /*Get total enhancement factor E(lambdas)*/
     345        E = Ec + (Es-Ec)*lambdas*lambdas; _assert_(E>0.);
     346
     347        /*Compute dmudB*/
     348        if(epseff==0.) dmudB = 0.;
     349        else           dmudB = 1./(2.*pow(E,1./3.)*pow(epseff,2./3.));
     350
     351        /*Assign output*/
     352        return dmudB;
     353
     354}
     355/*}}}*/
    324356void  Matestar::GetViscosity_B(IssmDouble* pdmudB,IssmDouble eps_eff){/*{{{*/
    325         /*output: */
    326         IssmDouble dmudB;
    327 
    328         /*Intermediary: */
    329         IssmDouble E=1.,n;
    330 
    331         n=GetN(); _assert_(n>0.);
    332         if(n==1.){
    333                 /*Linear Viscous behavior (Newtonian fluid) dmudB=B/2E: */
    334                 dmudB=1./(2.*E);
    335         }
    336         else{
    337                 if(eps_eff==0.) dmudB = 0.;
    338                 else            dmudB = 1./(2.*pow(E*eps_eff*eps_eff,1./3.));
    339         }
    340 
    341         /*Return: */
    342         *pdmudB=dmudB;
     357         _error_("not implemented yet");
    343358}
    344359/*}}}*/
    … …  
    393408}
    394409/*}}}*/
    395 void  Matestar::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
     410void  Matestar::ViscosityBFS(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
    396411
    397412        /*Intermediaries*/
    398413        IssmDouble vx,vy,vz;
    399414        IssmDouble dvx[3],dvy[3],dvz[3];
    400         IssmDouble B,Ec,Es;
     415        bool isdepthaveraged=0.;
    401416
    402417        /*Get velocity derivatives in all directions*/
    … …  
    418433        }
    419434
    420         /*Compute viscosity*/
    421         *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]);
    422 }
    423 /*}}}*/
    424 void  Matestar::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
    425         this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon);
    426 }/*}}}*/
    427 void  Matestar::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     435        /*Compute dmudB*/
     436        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],isdepthaveraged);
     437}
     438/*}}}*/
     439void  Matestar::ViscosityBHO(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
    428440
    429441        /*Intermediaries*/
    430442        IssmDouble vx,vy,vz;
    431443        IssmDouble dvx[3],dvy[3],dvz[3];
     444        bool isdepthaveraged=0.;
    432445
    433446        /*Get velocity derivatives in all directions*/
    … …  
    450463
    451464        /*Compute viscosity*/
    452         *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]);
    453 }/*}}}*/
    454 void  Matestar::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
    455         _error_("not implemented yet");
    456 }/*}}}*/
    457 void  Matestar::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surface_input){/*{{{*/
    458         _error_("not implemented yet");
    459 }/*}}}*/
    460 void  Matestar::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     465        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],isdepthaveraged);
     466}/*}}}*/
     467void  Matestar::ViscosityBSSA(IssmDouble* pdmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
    461468        /*Intermediaries*/
    462469        IssmDouble vx,vy,vz;
    463470        IssmDouble dvx[3],dvy[3],dvz[3];
    464         IssmDouble B,Ec,Es;
     471        bool isdepthaveraged=1.;
    465472
    466473        /*Get velocity derivatives in all directions*/
    … …  
    486493
    487494        /*Compute viscosity*/
    488         *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0]);
     495        *pdmudB=GetViscosity_BGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],isdepthaveraged);
     496}/*}}}*/
     497void  Matestar::ViscosityFS(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){/*{{{*/
     498
     499        /*Intermediaries*/
     500        IssmDouble vx,vy,vz;
     501        IssmDouble dvx[3],dvy[3],dvz[3];
     502        bool isdepthaveraged=0.;
     503
     504        /*Get velocity derivatives in all directions*/
     505        _assert_(dim>1);
     506        _assert_(vx_input);
     507        vx_input->GetInputValue(&vx,gauss);
     508        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     509        _assert_(vy_input);
     510        vy_input->GetInputValue(&vy,gauss);
     511        vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     512        if(dim==3){
     513                _assert_(vz_input);
     514                vz_input->GetInputValue(&vz,gauss);
     515                vz_input->GetInputDerivativeValue(&dvz[0],xyz_list,gauss);
     516        }
     517        else{
     518                vz = 0.;
     519                dvz[0] = 0.; dvz[1] = 0.; dvz[2] = 0.;
     520        }
     521
     522        /*Compute viscosity*/
     523        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],isdepthaveraged);
     524}
     525/*}}}*/
     526void  Matestar::ViscosityFSDerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
     527        this->GetViscosityDerivativeEpsSquare(pmu_prime,epsilon);
     528}/*}}}*/
     529void  Matestar::ViscosityHO(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     530
     531        /*Intermediaries*/
     532        IssmDouble vx,vy,vz;
     533        IssmDouble dvx[3],dvy[3],dvz[3];
     534        bool isdepthaveraged=0.;
     535
     536        /*Get velocity derivatives in all directions*/
     537        _assert_(dim==2 || dim==3);
     538        _assert_(vx_input);
     539        vx_input->GetInputValue(&vx,gauss);
     540        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     541        if(dim==3){
     542                _assert_(vy_input);
     543                vy_input->GetInputValue(&vy,gauss);
     544                vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     545        }
     546        else{
     547                dvx[2] = 0.;
     548                vy = 0.;
     549                dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
     550        }
     551        vz = 0.;
     552        dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
     553
     554        /*Compute viscosity*/
     555        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],isdepthaveraged);
     556}/*}}}*/
     557void  Matestar::ViscosityHODerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/
     558        _error_("not implemented yet");
     559}/*}}}*/
     560void  Matestar::ViscosityL1L2(IssmDouble* pviscosity,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* surface_input){/*{{{*/
     561        _error_("not implemented yet");
     562}/*}}}*/
     563void  Matestar::ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){/*{{{*/
     564
     565        /*Intermediaries*/
     566        IssmDouble vx,vy,vz;
     567        IssmDouble dvx[3],dvy[3],dvz[3];
     568        bool isdepthaveraged=1.;
     569
     570        /*Get velocity derivatives in all directions*/
     571        _assert_(dim==1 || dim==2);
     572        _assert_(vx_input);
     573        vx_input->GetInputValue(&vx,gauss);
     574        vx_input->GetInputDerivativeValue(&dvx[0],xyz_list,gauss);
     575        if(dim==2){
     576                _assert_(vy_input);
     577                vy_input->GetInputValue(&vy,gauss);
     578                vy_input->GetInputDerivativeValue(&dvy[0],xyz_list,gauss);
     579        }
     580        else{
     581                dvx[1] = 0.;
     582                dvx[2] = 0.;
     583                vy = 0.;
     584                dvy[0] = 0.; dvy[1] = 0.; dvy[2] = 0.;
     585        }
     586        dvx[2] = 0.;
     587        dvy[2] = 0.;
     588        vz = 0.;
     589        dvz[0] = 0.; dvz[1] = 0.; dvz[2] = -dvx[0]-dvy[1];
     590
     591        /*Compute viscosity*/
     592        *pviscosity=GetViscosityGeneral(vx,vy,vz,&dvx[0],&dvy[0],&dvz[0],isdepthaveraged);
    489593}/*}}}*/
    490594void  Matestar::ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){/*{{{*/

  • issm/trunk-jpl/src/c/classes/Materials/Matestar.h

    r21393 r21700  
    7070                IssmDouble GetDbar();
    7171                IssmDouble GetEc();
     72                IssmDouble GetEcbar();
    7273                IssmDouble GetEs();
     74                IssmDouble GetEsbar();
    7375                IssmDouble GetN();
    7476                bool       IsDamage();
    … …  
    8486                void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    8587                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
     88                void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input);
     89                void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
     90                void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    8691                /*}}}*/
    87                 IssmDouble GetViscosityGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz);
     92                IssmDouble GetViscosityGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,bool isdepthaveraged);
     93                IssmDouble GetViscosity_BGeneral(IssmDouble vx,IssmDouble vy,IssmDouble vz,IssmDouble* dvx,IssmDouble* dvy,IssmDouble* dvz,bool isdepthaveraged);
    8894};
    8995

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

    r21484 r21700  
    8888                void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input);
    8989                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon);
     90                void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not supported");};
     91                void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
     92                void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
    9093                /*}}}*/
    9194};

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

    r21677 r21700  
    125125                void       ViscositySSA(IssmDouble* pviscosity,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
    126126                void       ViscositySSADerivativeEpsSquare(IssmDouble* pmu_prime,IssmDouble* epsilon){_error_("not supported");};
     127                void       ViscosityBFS(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not supported");};
     128                void       ViscosityBHO(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
     129                void       ViscosityBSSA(IssmDouble* pmudB,int dim,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input){_error_("not supported");};
    127130                /*}}}*/
    128131                /*Numerics: {{{*/
Note: See TracChangeset for help on using the changeset viewer.