Changeset 17230


Ignore:
Timestamp:
02/07/14 09:43:44 (11 years ago)
Author:
jbondzio
Message:

revert to r17226

Location:
issm/trunk-jpl
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/externalpackages/vim/addons/vimrc

    r17227 r17230  
    100100
    101101" save & "make" the current file in all modes
    102 map <F6> :w <Enter> :make <Enter><Enter>
    103 map! <F6>  <ESC> :w <Enter> :make <Enter><Enter>
     102map <F8> :w <Enter> :make <Enter><Enter>
     103map! <F8>  <ESC> :w <Enter> :make <Enter><Enter>
    104104" make update: nice for longer documents
    105 map <F5> :w <Enter> :make update <Enter><Enter>
    106 map! <F5> <ESC> :w <Enter> :make update <Enter><Enter>
    107 
    108 " switch between tabs
    109 nmap <F7> :tabp <CR>
    110 nmap <F8> :tabn <CR>
     105map <F7> :w <Enter> :make update <Enter><Enter>
     106map! <F7> <ESC> :w <Enter> :make update <Enter><Enter>
    111107
    112108
    … …  
    145141  autocmd BufWritePost   *.sh         !chmod +x %
    146142
    147         " Commenting blocks of code.
    148         autocmd FileType c,cpp,java,scala let b:comment_leader = '// '
    149         autocmd FileType sh,ruby,python   let b:comment_leader = '# '
    150         autocmd FileType conf,fstab       let b:comment_leader = '# '
    151         autocmd FileType tex              let b:comment_leader = '% '
    152         autocmd FileType mail             let b:comment_leader = '> '
    153         autocmd FileType vim              let b:comment_leader = '" '
    154         noremap <silent> ,cc :<C-B>silent <C-E>s/^/<C-R>=escape(b:comment_leader,'\/')<CR>/<CR>:nohlsearch<CR>
    155         noremap <silent> ,cu :<C-B>silent <C-E>s/^\V<C-R>=escape(b:comment_leader,'\/')<CR>//e<CR>:nohlsearch<CR>
    156143endif " has("autocmd")
    157144" ----------------------------------------------------------------------}}}

  • issm/trunk-jpl/src/c/Makefile.am

    r17227 r17230  
    285285                                        ./modules/CreateNodalConstraintsx/CreateNodalConstraintsx.h\
    286286                                        ./modules/CreateNodalConstraintsx/CreateNodalConstraintsx.cpp\
    287                                         ./modules/SetActiveNodesLSMx/SetActiveNodesLSMx.h\
    288                                         ./modules/SetActiveNodesLSMx/SetActiveNodesLSMx.cpp\
    289287                                        ./modules/UpdateDynamicConstraintsx/UpdateDynamicConstraintsx.h\
    290288                                        ./modules/UpdateDynamicConstraintsx/UpdateDynamicConstraintsx.cpp\

  • issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp

    r17227 r17230  
    3333        iomodel->FetchDataToInput(elements,VxEnum);
    3434        iomodel->FetchDataToInput(elements,VyEnum);
    35         iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
     35       
    3636}
    3737/*}}}*/
    … …  
    6767        bool save_results;
    6868
     69        /* extrapolate */
     70        Analysis* analysis = new ExtrapolationAnalysis();
     71        femmodel->parameters->SetParam(VxEnum,ExtrapolationVariableEnum);
     72        analysis->Core(femmodel);
     73        delete analysis;
     74
    6975        /*activate formulation: */
    7076        femmodel->SetCurrentConfiguration(LevelsetAnalysisEnum);
    7177
     78        /*recover parameters: */
     79        femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
     80
    7281        if(VerboseSolution()) _printf0_("call computational core:\n");
    7382        solutionsequence_linear(femmodel);
    7483
    75         /*recover parameters: */
    76         femmodel->parameters->FindParam(&save_results,SaveResultsEnum);
    7784        if(save_results){
    7885                if(VerboseSolution()) _printf0_("   saving results\n");
    … …  
    321328}/*}}}*/
    322329
    323 /* Update of constraints */
    324 // void LevelsetAnalysis::UpdateNoIceConstraints(FemModel* femmodel){/*{{{*/
    325 //
    326 //      IssmDouble* mask_ice = GetMaskOfIce(femmodel->elements, femmodel->nodes);
    327 //
    328 //      for (int i=0;i<femmodel->nodes->Size();i++){
    329 //              Node* node=dynamic_cast<Node*>(femmodel->nodes->GetObjectByOffset(i));
    330 //              if(node->InAnalysis(LevelsetAnalysisEnum)){
    331 //                      if(mask_ice[node->Sid()]==1.){//FIXME: what should be done with actual spcs to ice model?
    332 // //                           node->DofInFSet(0); /*remove spc*/
    333 //                      }
    334 //                      else{
    335 //                              IssmDouble defval=0.;
    336 //                              node->ApplyConstraint(1,defval); /*apply spc*/
    337 //                      }
    338 //              }
    339 //      }
    340 // }/*}}}*/
    341 // IssmDouble* LevelsetAnalysis::GetMaskOfIce(Elements* elements, Nodes* nodes){/*{{{*/
    342 //
    343 //      int                 i;
    344 //      IssmDouble*         mask_ice      = NULL;
    345 //      Vector<IssmDouble>* vec_mask_ice  = NULL;
    346 //      Element*            element       = NULL;
    347 //
    348 //      /*Initialize vector with number of vertices*/
    349 //      IssmDouble numnodes=nodes->NumberOfNodes(LevelsetAnalysisEnum);
    350 //      vec_mask_ice=new Vector<IssmDouble>(numnodes); //nodes at ice front that have ice at next time step
    351 //      for(i=0;i<numnodes;i++)
    352 //              vec_mask_ice[i]=0.;
    353 //      /*Fill vector vertices that have no contact to ice: */
    354 //      for(i=0;i<elements->Size();i++){
    355 //              element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    356 //              SetMaskOfIceElement(vec_mask_ice, element);
    357 //      }
    358 //
    359 //      /*Assemble vector and serialize */
    360 //      vec_mask_ice->Assemble();
    361 //      mask_ice=vec_mask_ice->ToMPISerial();
    362 //      delete vec_mask_ice;
    363 //      return mask_ice;
    364 //
    365 // }/*}}}*/
    366 // void LevelsetAnalysis::SetMaskOfIceElement(Vector<IssmDouble>* vec_mask_ice, Element* element){/*{{{*/
    367 //
    368 //      /* Intermediaries */
    369 //      int numnodes = element->GetNumberOfNodes();
    370 //     
    371 //      if(element->IsIceInElement()){
    372 //              for(int i = 0;i<numnodes;i++){
    373 //                      vec_mask_ice->SetValue(element->nodes[i]->Sid(),1.,INS_VAL);
    374 //              }
    375 //      }
    376 // }/*}}}*/

  • issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.h

    r17227 r17230  
    3232        void GetBprime(IssmDouble* Bprime,Element* element,IssmDouble* xyz_list,Gauss* gauss);
    3333
    34         /* Updating constraints */
    35 //      void UpdateNoIceConstraints(FemModel* femmodel);
    36 //      IssmDouble* GetMaskOfIce(Elements* elements, Nodes* nodes);
    37 //      void SetMaskOfIceElement(Vector<IssmDouble>* vec_mask_ice, Element* element);
    3834};
    3935#endif

  • issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp

    r17227 r17230  
    189189        iomodel->FetchDataToInput(elements,LoadingforceYEnum);
    190190        iomodel->FetchDataToInput(elements,DamageDEnum);
    191         iomodel->FetchDataToInput(elements,IceMaskNodeActivationEnum);
    192 
    193191
    194192        if(iomodel->meshtype==Mesh3DEnum){
    … …  
    10261024}/*}}}*/
    10271025void StressbalanceAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/
    1028         SetActiveNodesLSMx(femmodel->elements);
     1026        /*Default, do nothing*/
    10291027        return;
    10301028}/*}}}*/
    … …  
    11451143        delete Ke1;
    11461144        delete Ke2;
    1147        
    1148         // FIXME: TESTING
    1149 //      _printf0_("\n element ID: " << element->Id() << ";\n");
    1150 //      Ke->Echo();
    11511145        return Ke;
    11521146}/*}}}*/
    … …  
    12711265                newviscosity=viscosity+viscosity_overshoot*(viscosity-oldviscosity);
    12721266                D_scalar=2.*newviscosity*thickness*gauss->weight*Jdet;
    1273                
    1274 //              _printf0_("element, node, weight, Jdet: " << element->Id() << "; " << ig << "; " << gauss->weight << "; " << Jdet << "\n");
    1275 
    12761267                for(int i=0;i<3;i++) D[i*3+i]=D_scalar;
    12771268
    … …  
    13241315        delete pe1;
    13251316        delete pe2;
    1326 
    1327 //      _printf0_("\n element ID: " << element->Id() << ";\n");
    1328 //      pe->Echo();
    1329 
    13301317        return pe;
    13311318}/*}}}*/
    … …  
    13851372
    13861373        /*If no front, return NULL*/
    1387         if(!element->IsIcefront()) return NULL;
     1374        if(!element->IsZeroLevelset(MaskIceLevelsetEnum)) return NULL;
    13881375
    13891376        /*Intermediaries*/
    … …  
    14081395        IssmDouble gravity     = element->GetMaterialParameter(ConstantsGEnum);
    14091396        element->GetVerticesCoordinates(&xyz_list);
    1410 
    1411 //      element->ZeroLevelsetCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
    1412         element->GetIcefrontCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
    1413 
     1397        element->ZeroLevelsetCoordinates(&xyz_list_front,xyz_list,MaskIceLevelsetEnum);
    14141398        element->NormalSection(&normal[0],xyz_list_front);
    1415 //      element->GetNormalFromLSF(&normal[0]);
    14161399
    14171400        /*Start looping on Gaussian points*/
    … …  
    18021785
    18031786        /*If no front, return NULL*/
    1804         if(!element->IsIcefront()) return NULL;
     1787        if(!element->IsZeroLevelset(MaskIceLevelsetEnum)) return NULL;
    18051788
    18061789        /*Intermediaries*/
    … …  
    22252208
    22262209        /*If no front, return NULL*/
    2227         if(!element->IsIcefront()) return NULL;
     2210        if(!element->IsZeroLevelset(MaskIceLevelsetEnum)) return NULL;
    22282211
    22292212        /*Intermediaries*/
    … …  
    29912974
    29922975        /*If no front, return NULL*/
    2993         if(!element->IsIcefront()) return NULL;
     2976        if(!element->IsZeroLevelset(MaskIceLevelsetEnum)) return NULL;
    29942977
    29952978        /*Intermediaries*/

  • issm/trunk-jpl/src/c/classes/Elements/Element.h

    r17227 r17230  
    220220                virtual int    PressureInterpolation()=0;
    221221                virtual bool   IsZeroLevelset(int levelset_enum)=0;
    222                 virtual bool   IsIcefront(void)=0;
    223222                virtual void   ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum)=0;
    224223                virtual void   GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum)=0;

  • issm/trunk-jpl/src/c/classes/Elements/Penta.h

    r17227 r17230  
    114114                int    PressureInterpolation();
    115115                bool   IsZeroLevelset(int levelset_enum);
    116                 bool   IsIcefront(void){_error_("not implemented yet");};
    117116                void   ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum);
    118117                void   GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Elements/Seg.h

    r17227 r17230  
    159159                void        ViscousHeating(IssmDouble* pphi,IssmDouble* xyz_list,Gauss* gauss,Input* vx_input,Input* vy_input,Input* vz_input){_error_("not implemented yet");};
    160160                bool        IsZeroLevelset(int levelset_enum){_error_("not implemented");};
    161                 bool            IsIcefront(void){_error_("not implemented yet");};
    162161                void        ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum){_error_("not implemented");};
    163162                void            GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

    r17227 r17230  
    909909                }
    910910        }
    911         _assert_(nrfrontnodes==2);
    912        
    913         /* arrange order of frontnodes such that they are oriented counterclockwise */
    914         if((NUMVERTICES+indicesfront[0]-indicesfront[1])%NUMVERTICES!=2){
    915                 int index=indicesfront[0];
    916                 indicesfront[0]=indicesfront[1];
    917                 indicesfront[1]=index;
    918         }
     911
    919912        IssmDouble* xyz_front = xNew<IssmDouble>(3*nrfrontnodes);
    920913        /* Return nodes */
    921914        for(i=0;i<nrfrontnodes;i++){
    922915                for(dir=0;dir<3;dir++){
    923                         xyz_front[3*i+dir]=xyz_list[3*indicesfront[i]+dir];
    924                 }
    925         }
    926 
    927 //      for(i=0;i<nrfrontnodes;i++){
    928 //              _printf0_("coords frontnode " << i << " :[");
    929 //              for(dir=0;dir<3;dir++){
    930 //                      xyz_front[3*i+dir]=xyz_list[indicesfront[i]+dir];
    931 //                      _printf0_(xyz_front[3*i+dir] << "; ");
    932 //              }
    933 //              _printf0_("]\n");
    934 //      }
     916                        xyz_front[3*i+dir]=xyz_list[indicesfront[i]+dir];
     917                }
     918        }
    935919
    936920        *pxyz_front=xyz_front;
    … …  
    938922        xDelete<int>(indicesfront);
    939923}/*}}}*/
    940 void  Tria::GetNormalFromLSF(IssmDouble *normal){/*{{{*/
     924void  Tria::GetNormalFromLSF(IssmDouble *pnormal){/*{{{*/
    941925
    942926        /* Intermediaries */
    … …  
    945929        IssmDouble* xyz_list = NULL;
    946930        IssmDouble  dlevelset[dim], norm_dlevelset;
     931        IssmDouble  normal[dim]={0.};
    947932
    948933        /*Retrieve all inputs and parameters*/
    … …  
    951936       
    952937        counter=0;
    953         for(i=0;i<dim;i++) normal[i]=0.;
    954 
    955938        Gauss* gauss = this->NewGauss(2);
    956939        for(int ig=gauss->begin();ig<gauss->end();ig++){
    … …  
    964947        }
    965948        _assert_(counter>0);
    966         for(i=0;i<dim;i++) normal[i]/=IssmDouble(counter);
     949        for(i=0;i<dim;i++) normal[i]/counter;
     950       
     951        pnormal=&normal[0];
    967952
    968953        delete gauss;
    … …  
    16251610                                name==MaskGroundediceLevelsetEnum ||
    16261611                                name==MaskIceLevelsetEnum ||
    1627                                 name==IceMaskNodeActivationEnum ||
    16281612                                name==SurfaceSlopeXEnum ||
    16291613                                name==SurfaceSlopeYEnum ||
    … …  
    26022586        GetInputListOnVertices(&ls[0],levelset_enum);
    26032587
    2604         /* If levelset function changes sign, or is zero on at least two vertices, there is a zero level set here */
     2588        /*If the level set is awlays <0, there is no ice front here*/
    26052589        iszerols= false;
    26062590        if(IsIceInElement()){
    … …  
    26132597}
    26142598/*}}}*/
    2615 /*FUNCTION Tria::IsIcefront{{{*/
    2616 bool Tria::IsIcefront(void){
    2617 
    2618         bool isicefront;
    2619         int i,nrice;
    2620         IssmDouble ls[NUMVERTICES];
    2621 
    2622         /*Retrieve all inputs and parameters*/
    2623         GetInputListOnVertices(&ls[0],MaskIceLevelsetEnum);
    2624 
    2625         /* If only one vertex has ice, there is an ice front here */
    2626         isicefront= false;
    2627         if(IsIceInElement()){
    2628                 nrice=0;       
    2629                 for(i=0;i<NUMVERTICES;i++)
    2630                         if(ls[i]<0.) nrice++;
    2631                 if(nrice==1) isicefront= true;
    2632         }
    2633         return isicefront;
    2634 }
    2635 /*}}}*/
    2636 
    26372599
    26382600#ifdef _HAVE_RESPONSES_

  • issm/trunk-jpl/src/c/classes/Elements/Tria.h

    r17227 r17230  
    132132                void        ZeroLevelsetCoordinates(IssmDouble** pxyz_zero,IssmDouble* xyz_list,int levelsetenum);
    133133                void        GetIcefrontCoordinates(IssmDouble** pxyz_front,IssmDouble* xyz_list,int levelsetenum);
    134                 void        GetNormalFromLSF(IssmDouble *normal);
     134            void        GetNormalFromLSF(IssmDouble *pnormal);
    135135                bool        IsZeroLevelset(int levelset_enum);
    136                 bool        IsIcefront(void);
    137136
    138137                #ifdef _HAVE_RESPONSES_

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

    r17227 r17230  
    406406        /*start module: */
    407407        if(VerboseModule()) _printf0_("   Updating constraints for time: " << time << "\n");
    408         if(VerboseModule()) _printf0_("   and analysis: " << EnumToStringx(analysis_type) << "\n");
    409         Analysis* analysis = EnumToAnalysis(analysis_type);
    410         _assert_(analysis);
    411 //      analysis->UpdateConstraints(this);
    412         delete analysis;
    413 
     408
     409        // analysis->UpdateConstraints();
     410       
    414411        /*Second, constraints might be time dependent: */
    415412        SpcNodesx(nodes,constraints,parameters,analysis_type);

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

    r17229 r17230  
    8686        /*output*/
    8787        TriaInput* outinput=NULL;
    88 
    89         if(this->element_type==P0Enum){
    90                 outinput=new TriaInput(this->enum_type,&this->values[0],P0Enum);
    91         }
    92         else{
    93                 /*Assume P1 interpolation only for now*/
    94                 IssmDouble newvalues[3];
    95 
    96                 /*Create array of indices depending on location (0=base 1=surface)*/
    97                 int indices[3];
    98                 switch(location){
    99                         case 0:
    100                                 indices[0] = 0;
    101                                 indices[1] = 1;
    102                                 indices[2] = 2;
    103                                 break;
    104                         case 1:
    105                                 indices[0] = 3;
    106                                 indices[1] = 4;
    107                                 indices[2] = 5;
    108                                 break;
    109                         default:
    110                                 _error_("case "<<location<<" not supported");
    111                 }
    112 
    113                 /*Create new input*/
    114                 for(int i=0;i<3;i++){
    115                         _assert_(indices[i]>=0 && indices[i]<6);
    116                         newvalues[i]=this->values[indices[i]];
    117                 }
    118                 outinput=new TriaInput(this->enum_type,&newvalues[0],P1Enum);
    119         }
     88        IssmDouble newvalues[3]; //Assume P1 interpolation only for now
     89
     90        /*Create arrow of indices depending on location (0=base 1=surface)*/
     91        int indices[3];
     92        switch(location){
     93                case 0:
     94                        indices[0] = 0;
     95                        indices[1] = 1;
     96                        indices[2] = 2;
     97                        break;
     98                case 1:
     99                        indices[0] = 3;
     100                        indices[1] = 4;
     101                        indices[2] = 5;
     102                        break;
     103                default:
     104                        _error_("case "<<location<<" not supported");
     105        }
     106
     107        /*Loop over the new indices*/
     108        for(int i=0;i<3;i++){
     109
     110                /*Check index value*/
     111                _assert_(indices[i]>=0 && indices[i]<6);
     112
     113                /*Assign value to new input*/
     114                newvalues[i]=this->values[indices[i]];
     115        }
     116
     117        /*Create new Tria input*/
     118        outinput=new TriaInput(this->enum_type,&newvalues[0],P1Enum);
    120119
    121120        /*Assign output*/

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

    r17229 r17230  
    100100        /*output*/
    101101        SegInput* outinput=NULL;
    102 
    103         if(this->element_type==P0Enum){
    104                 outinput=new SegInput(this->enum_type,&this->values[0],P0Enum);
    105         }
    106         else{
    107                 /*Assume P1 interpolation only for now*/
    108                 IssmDouble newvalues[2];
    109 
    110                 /*Create array of indices depending on location (0=base 1=surface)*/
    111                 newvalues[0]=this->values[index1];
    112                 newvalues[1]=this->values[index2];
    113 
    114                 /*Create new Seg input*/
    115                 outinput=new SegInput(this->enum_type,&newvalues[0],P1Enum);
    116         }
     102        IssmDouble newvalues[2]; //Assume P1 interpolation only for now
     103
     104        /*Create arrow of indices depending on location (0=base 1=surface)*/
     105
     106        newvalues[0]=this->values[index1];
     107        newvalues[1]=this->values[index2];
     108
     109        /*Create new Seg input*/
     110        outinput=new SegInput(this->enum_type,&newvalues[0],P1Enum);
    117111
    118112        /*Assign output*/

  • issm/trunk-jpl/src/c/cores/transient_core.cpp

    r17227 r17230  
    162162                if(islevelset){
    163163                        if(VerboseSolution()) _printf0_("   computing movement of ice boundaries\n");
    164 
    165                         /* extrapolate */
    166                         Analysis* extanalysis = new ExtrapolationAnalysis();
    167                         int vars[2] = {VxEnum, VyEnum};
    168                         for(int iv=0; iv<2;iv++){
    169                                 femmodel->parameters->SetParam(vars[iv],ExtrapolationVariableEnum);
    170                                 extanalysis->Core(femmodel);
    171                         }
    172                         delete extanalysis;
    173 
    174                         LevelsetAnalysis* lsanalysis = new LevelsetAnalysis();
    175                         /* solve level-set equation */
    176                         lsanalysis->Core(femmodel);
    177                         delete lsanalysis;
    178 
    179                         /* update vertices included for next calculation */
    180                         GetMaskOfIceVerticesLSMx(femmodel);
     164                        analysis = new LevelsetAnalysis();
     165                        analysis->Core(femmodel);
     166                        delete analysis;
    181167                }
    182168

  • issm/trunk-jpl/src/c/modules/SystemMatricesx/SystemMatricesx.cpp

    r17227 r17230  
    119119        //Kfs->AllocationInfo();
    120120
    121         // TESTING
    122         IssmDouble* Kffd=Kff->ToSerial();
    123         Kff->GetSize(&M,&N);
    124         _printf0_(" (Kff stiffness matrix size: "<<M<<" x "<<N<<")\n");
    125 //      printarray(Kffd,M,N);
    126    for(int row=0;row<M;row++){
    127                 IssmDouble value = Kffd[row*N + row];
    128                 if(fabs(value)<1.)
    129                  _printf0_("Kff(" << row << "," << row << ")=" << value << "\n");
    130          }
    131         delete Kffd;
    132        
    133 
    134121        /*cleanu up and assign output pointers: */
    135122        delete analysis;

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

    r17227 r17230  
    3131#include "./GetVectorFromControlInputsx/GetVectorFromControlInputsx.h"
    3232#include "./GiaDeflectionCorex/GiaDeflectionCorex.h"
    33 #include "./SetActiveNodesLSMx/SetActiveNodesLSMx.h"
    3433#include "./SetControlInputsFromVectorx/SetControlInputsFromVectorx.h"
    3534#include "./Gradjx/Gradjx.h"

  • issm/trunk-jpl/src/m/dev/devpath.py

    r17227 r17230  
    2525from plotmodel import plotmodel
    2626
    27 c = get_ipython().config
    28 c.InteractiveShellApp.exec_lines = []
    29 c.InteractiveShellApp.exec_lines.append('%load_ext autoreload')
    30 c.InteractiveShellApp.exec_lines.append('%autoreload 2')
    31 c.InteractiveShellApp.exec_lines.append('print "Warning: disable autoreload in startup.py to improve performance." ')
     27#c = get_ipython().config
     28#c.InteractiveShellApp.exec_lines = []
     29#c.InteractiveShellApp.exec_lines.append('%load_ext autoreload')
     30#c.InteractiveShellApp.exec_lines.append('%autoreload 2')
     31#c.InteractiveShellApp.exec_lines.append('print "Warning: disable autoreload in startup.py to improve performance." ')
    3232
    3333print("\n  ISSM development path correctly loaded\n\n")

  • issm/trunk-jpl/src/m/plot/processmesh.py

    r17227 r17230  
    1414        if md.mesh.numberofvertices==0:
    1515                raise ValueError('processmesh error: mesh is empty')
    16 #       if md.mesh.numberofvertices==md.mesh.numberofelements:
    17 #               raise ValueError('processmesh error: the number of elements is the same as the number of nodes')
     16        if md.mesh.numberofvertices==md.mesh.numberofelements:
     17                raise ValueError('processmesh error: the number of elements is the same as the number of nodes')
    1818
    1919        if len(data)==0 or not isinstance(data,dict):

  • issm/trunk-jpl/test/NightlyRun/test336.py

    r17227 r17230  
    88from MatlabFuncs import *
    99
    10 md=triangle(model(),'../Exp/Square.exp',10000.)
     10md=triangle(model(),'../Exp/Square.exp',150000.)
    1111md=setmask(md,'','')
    1212md=parameterize(md,'../Par/SquareSheetConstrained.py')
    … …  
    2020md.transient.isgroundingline=False
    2121md.transient.isgia=False
    22 md.transient.islevelset=False
     22md.transient.islevelset=True
    2323
    2424# init levelset function
    … …  
    2727xmin=min(md.mesh.x)
    2828xmax=max(md.mesh.x)
    29 xmed=(xmax+xmin)/2.
    30 ymed=(ymax+ymin)/2.
    31 md.mask.ice_levelset=numpy.sqrt(numpy.power(md.mesh.x-xmed,2.)+numpy.power(md.mesh.y-ymed,2.)) - (xmax-xmin)/3.
    32 
    33 # set spcs
    34 mask=1.*numpy.ones((md.mesh.numberofvertices,1))
    35 nrverts=md.mesh.elements.shape[1]
    36 for i in range(0,md.mesh.numberofelements):
    37         elt=numpy.copy(md.mesh.elements[i])
    38         elt-=1
    39         isiceinelement=False
    40         for iv in range(0,nrverts):
    41                 if(md.mask.ice_levelset[elt[iv]]<=0.):
    42                         isiceinelement=True
    43         if(isiceinelement):
    44                 for iv in range(0,nrverts):
    45                         mask[elt[iv]]=2.
    46 
    47 v=0.
    48 for i in range(0,md.mesh.numberofvertices):
    49         if(mask[i]==1.):
    50                 md.stressbalance.spcvx[i]=v
    51                 md.stressbalance.spcvy[i]=v
    52                 md.stressbalance.spcvz[i]=v
     29xmed=(xmax+xmin)/2
     30ymed=(ymax+ymin)/2
     31distx=numpy.absolute(md.mesh.x.reshape(-1,1)-xmed)
     32disty=numpy.absolute(md.mesh.y.reshape(-1,1)-ymed)
     33md.mask.ice_levelset=numpy.maximum(distx,disty)-1.e5
    5334
    5435md=solve(md,TransientSolutionEnum())
    … …  
    5637#Fields and tolerances to track changes
    5738field_names     =['Vx','Vy','Vel','Pressure','MaskIceLevelset']
    58 field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13]#,1e-13,1e-13]
     39field_tolerances=[1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13,1e-13]
    5940field_values=[\
    6041        md.results.TransientSolution[0].Vx,\
    … …  
    6243        md.results.TransientSolution[0].Vel,\
    6344        md.results.TransientSolution[0].Pressure,\
    64 #       md.results.TransientSolution[0].MaskIceLevelset,\
     45        md.results.TransientSolution[0].MaskIceLevelset,\
    6546        md.results.TransientSolution[1].Vx,\
    6647        md.results.TransientSolution[1].Vy,\
    6748        md.results.TransientSolution[1].Vel,\
    6849        md.results.TransientSolution[1].Pressure,\
    69 #       md.results.TransientSolution[1].MaskIceLevelset,\
     50        md.results.TransientSolution[1].MaskIceLevelset,\
    7051        ]
Note: See TracChangeset for help on using the changeset viewer.