Changeset 20993

Timestamp:

07/24/16 00:20:27 (9 years ago)

Author:

agscott1

Message:

CHG: Changed flowequation classes to use IoCodeToEnumElementEquation and IoCodeToEnumVertexEquation for StressbalanceAnalysis and Penta/Tetra/Tria Elements.

Location:

issm/trunk-jpl/src

Files:

• c/analyses/StressbalanceAnalysis.cpp (modified) (14 diffs)
• c/analyses/StressbalanceSIAAnalysis.cpp (modified) (2 diffs)
• c/classes/Elements/Penta.cpp (modified) (3 diffs)
• c/classes/Elements/PentaRef.cpp (modified) (1 diff)
• c/classes/Elements/Tetra.cpp (modified) (1 diff)
• c/classes/Elements/Tria.cpp (modified) (1 diff)
• c/shared/io/Marshalling/IoCodeConversions.cpp (modified) (1 diff)
• c/shared/io/Marshalling/IoCodeConversions.h (modified) (1 diff)
• m/classes/flowequation.js (modified) (1 diff)
• m/classes/flowequation.m (modified) (1 diff)
• m/classes/flowequation.py (modified) (1 diff)

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

@@ -130 +130 @@
                                         for(i=0;i<iomodel->numberofvertices;i++){
                                                 if(iomodel->my_vertices[i]){
-                                                        if(reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
+                                                        if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum){
                                                                 constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+i+1,0,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum));
                                                                 count++;
@@ -140 +140 @@
                                         for(i=0;i<iomodel->numberofvertices;i++){
                                                 if(iomodel->my_vertices[i]){
-                                                        if(reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
+                                                        if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum){
                                                                 constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+i+1,0,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum));
                                                                 count++;
@@ -150 +150 @@
                                         for(i=0;i<iomodel->numberofvertices;i++){
                                                 if(iomodel->my_vertices[i]){
-                                                        if(reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
+                                                        if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum){
                                                                 constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+i+1,0,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum));
                                                                 count++;
@@ -160 +160 @@
                                         for(i=0;i<iomodel->numberofvertices;i++){
                                                 if(iomodel->my_vertices[i]){
-                                                        if(reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
+                                                        if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum){
                                                                 constraints->AddObject(new SpcStatic(count+1,iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofedges+iomodel->numberofelements+iomodel->numberoffaces+i+1,0,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum));
                                                                 count++;
@@ -224 +224 @@
 
                         /*Start with adding spcs of coupling: zero at the border SSA/HO for the appropriate dofs*/
-                        if(reCast<int,IssmDouble>(vertices_type[i]==SSAHOApproximationEnum)){
+                        if(IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==SSAHOApproximationEnum){
                                 /*If grionSSA, spc HO dofs: 3 & 4*/
                                         if (reCast<int,IssmDouble>(nodeonHO[i])){
@@ -259 +259 @@
                         }
                         /*Also add spcs of coupling: zero at the border HO/FS for the appropriate dofs*/
-                        else if (reCast<int,IssmDouble>(vertices_type[i])==HOFSApproximationEnum){
+                        else if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==HOFSApproximationEnum){
                                 /*If grion,HO spc FS dofs: 3 4 & 5*/
                                         if (reCast<int,IssmDouble>(nodeonHO[i])){
@@ -299 +299 @@
                         }
                         /*Also add spcs of coupling: zero at the border HO/FS for the appropriate dofs*/
-                        else if (reCast<int,IssmDouble>(vertices_type[i])==SSAFSApproximationEnum){
+                        else if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==SSAFSApproximationEnum){
                                 /*If grion,HO spc FS dofs: 3 4 & 5*/
                                         if (reCast<int,IssmDouble>(nodeonSSA[i])){
@@ -360 +360 @@
                                         xDelete<IssmDouble>(values);
                                 }
-                                else if (vertices_type[i]==SIAApproximationEnum){
+                                else if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==SIAApproximationEnum){
                                         constraints->AddObject(new SpcDynamic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,0,StressbalanceAnalysisEnum));
                                         count++;
@@ -383 +383 @@
                                         xDelete<IssmDouble>(values);
                                 }
-                                else if (vertices_type[i]==SIAApproximationEnum){
+                                else if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==SIAApproximationEnum){
                                         constraints->AddObject(new SpcDynamic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,StressbalanceAnalysisEnum));
                                         count++;
                                 }
 
-                                if (reCast<int,IssmDouble>(vertices_type[i])==FSApproximationEnum ||  (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum)){
+                                if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==FSApproximationEnum ||  (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum)){
                                         if (Mz==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvz[i])){
                                                 constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvz[i],StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
@@ -409 +409 @@
 
                                 }
-                                if (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum){
+                                if (IoCodeToEnumVertexEquation(reCast<int>(vertices_type[i]))==NoneApproximationEnum){
                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+iomodel->numberofvertices+i+1,0,g*rho_ice*(surface[i]-z[i])/FSreconditioning,StressbalanceAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
                                         count++;
@@ -560 +560 @@
                         for(int i=0;i<iomodel->numberofvertices;i++){
                                 if(iomodel->my_vertices[i]){
-                                        approximation=reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]);
+                                        approximation=IoCodeToEnumVertexEquation(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]));
                                         if(approximation==FSApproximationEnum)  approximation=FSvelocityEnum;
                                         nodes->AddObject(new Node(iomodel->nodecounter+i+1,i,lid++,i,iomodel,StressbalanceAnalysisEnum,approximation));
@@ -575 +575 @@
                         for(int i=0;i<iomodel->numberofvertices;i++){
                                 if(iomodel->my_vertices[i]){
-                                        approximation=reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]);
+                                        approximation=IoCodeToEnumVertexEquation(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]));
                                         node = new Node(iomodel->nodecounter+iomodel->numberofvertices+iomodel->numberofelements+i+1,iomodel->numberofvertices+iomodel->numberofelements+i,lid++,i,iomodel,StressbalanceAnalysisEnum,FSpressureEnum);
                                         if(approximation==HOApproximationEnum || approximation==SSAApproximationEnum){
@@ -587 +587 @@
                         for(int i=0;i<iomodel->numberofvertices;i++){
                                 if(iomodel->my_vertices[i]){
-                                        nodes->AddObject(new Node(iomodel->nodecounter+i+1,i,lid++,i,iomodel,StressbalanceAnalysisEnum,reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i])));
+                                        nodes->AddObject(new Node(iomodel->nodecounter+i+1,i,lid++,i,iomodel,StressbalanceAnalysisEnum,IoCodeToEnumVertexEquation(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]))));
                                 }
                         }
@@ -717 +717 @@
                 if(isFS){
                         for(int i=0;i<iomodel->numberofelements;i++){
-                                approximation=reCast<int>(iomodel->Data("md.flowequation.element_equation")[i]);
+                                approximation=IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[i]));
                                 if(approximation==FSApproximationEnum || approximation==HOFSApproximationEnum || approximation==SSAFSApproximationEnum){
                                         finiteelement_list[i]=MINIcondensedEnum;

issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp ¶

@@ -44 +44 @@
                         /*keep only this partition's nodes:*/
                         if((iomodel->my_vertices[i])){
-                                if (reCast<int,IssmDouble>(iomodel->Data("md.flowequation.vertex_equation")[i])!=SIAApproximationEnum){
+                                if (IoCodeToEnumVertexEquation(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]))!=SIAApproximationEnum){
 
                                         constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,0,0,StressbalanceSIAAnalysisEnum));
@@ -99 +99 @@
 
                         /*Create new node if is in this processor's partition*/
-                        node = new Node(iomodel->nodecounter+i+1,i,lid++,i,iomodel,StressbalanceSIAAnalysisEnum,reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]));
+                        node = new Node(iomodel->nodecounter+i+1,i,lid++,i,iomodel,StressbalanceSIAAnalysisEnum,IoCodeToEnumVertexEquation(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i])));
 
                         /*Deactivate node if not SIA*/
-                        if(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i])!=SIAApproximationEnum){
+                        if(IoCodeToEnumVertexEquation(reCast<int>(iomodel->Data("md.flowequation.vertex_equation")[i]))!=SIAApproximationEnum){
                                 node->Deactivate();
                         }

issm/trunk-jpl/src/c/classes/Elements/Penta.cpp ¶

@@ -1483 +1483 @@
         /*Need to know the type of approximation for this element*/
         if(iomodel->Data("md.flowequation.element_equation")){
-                this->inputs->AddInput(new IntInput(ApproximationEnum,reCast<int>(iomodel->Data("md.flowequation.element_equation")[index])));
+                this->inputs->AddInput(new IntInput(ApproximationEnum,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index]))));
         }
 
@@ -3077 +3077 @@
                         _assert_(iomodel->Data("md.flowequation.element_equation"));
 
-                        if(*(iomodel->Data("md.flowequation.element_equation")+index)==HOFSApproximationEnum){
+                        if((IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index])))==HOFSApproximationEnum){
                                 /*Create VzHO and VzFS Enums*/
                                 if(iomodel->Data("md.initialization.vz") && iomodel->Data("md.flowequation.borderFS")){
@@ -3091 +3091 @@
                                 }
                         }
-                        if(*(iomodel->Data("md.flowequation.element_equation")+index)==SSAFSApproximationEnum){
+                        if((IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index])))==SSAFSApproximationEnum){
                                 /*Create VzSSA and VzFS Enums*/
                                 if(iomodel->Data("md.initialization.vz") && iomodel->Data("md.flowequation.borderFS")){

issm/trunk-jpl/src/c/classes/Elements/PentaRef.cpp ¶

@@ -225 +225 @@
         z6=xyz_list[3*5+2];
 
-        /* DEBUG
-         * REMOVE BEFORE SUBMITTING
-         * ----------
-         *  CHANGE SQRT3/12 TO MULTIPLY BY RECIPROCAL
-         */
         j_const_reciprocal=SQRT3/12;
 

issm/trunk-jpl/src/c/classes/Elements/Tetra.cpp ¶

@@ -447 +447 @@
         /*Need to know the type of approximation for this element*/
         if(iomodel->Data("md.flowequation.element_equation")){
-                this->inputs->AddInput(new IntInput(ApproximationEnum,reCast<int>(iomodel->Data("md.flowequation.element_equation")[index])));
+                this->inputs->AddInput(new IntInput(ApproximationEnum,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index]))));
         }
 

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

@@ -1747 +1747 @@
         /*Need to know the type of approximation for this element*/
         if(iomodel->Data("md.flowequation.element_equation")){
-                this->inputs->AddInput(new IntInput(ApproximationEnum,reCast<int>(iomodel->Data("md.flowequation.element_equation")[index])));
+                this->inputs->AddInput(new IntInput(ApproximationEnum,IoCodeToEnumElementEquation(reCast<int>(iomodel->Data("md.flowequation.element_equation")[index]))));
         }
 

issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.cpp ¶

@@ -90 +90 @@
 }/*}}}*/
 
+int IoCodeToEnumVertexEquation(int enum_in){/*{{{*/
+        switch(enum_in){
+                case 0: return NoneApproximationEnum;
+                case 1: return SIAApproximationEnum;
+                case 2: return SSAApproximationEnum;
+                case 3: return L1L2ApproximationEnum;
+                case 4: return HOApproximationEnum;
+                case 5: return FSApproximationEnum;
+                case 6: return SSAHOApproximationEnum;
+                case 7: return HOFSApproximationEnum;
+                case 8: return SSAFSApproximationEnum;
+                default: _error_("Marshalled vertex equation code \""<<enum_in<<"\" not supported yet.");
+        }
+}/*}}}*/
+int IoCodeToEnumElementEquation(int enum_in){/*{{{*/
+        switch(enum_in){
+                case 0: return NoneApproximationEnum;
+                case 1: return SIAApproximationEnum;
+                case 2: return SSAApproximationEnum;
+                case 3: return L1L2ApproximationEnum;
+                case 4: return HOApproximationEnum;
+                case 5: return FSApproximationEnum;
+                case 6: return SSAHOApproximationEnum;
+                case 7: return SSAFSApproximationEnum;
+                case 8: return HOFSApproximationEnum;
+                default: _error_("Marshalled element equation code \""<<enum_in<<"\" not supported yet.");
+        }
+
+}/*}}}*/

issm/trunk-jpl/src/c/shared/io/Marshalling/IoCodeConversions.h ¶

@@ -10 +10 @@
 int IoCodeToEnumMaterials(int enum_in);
 
+int IoCodeToEnumVertexEquation(int enum_in);
+int IoCodeToEnumElementEquation(int enum_in);
 #endif  

issm/trunk-jpl/src/m/classes/flowequation.js ¶

@@ -118 +118 @@
 
                         //convert approximations to enums
-                        data=this.vertex_equation;
-                        
-                        //some optimization: 
-                        var noneap=NoneApproximationEnum();
-                        var siaap=SIAApproximationEnum();
-                        var ssaap=SSAApproximationEnum();
-                        var l1l2ap=L1L2ApproximationEnum();
-                        var hoap=HOApproximationEnum();
-                        var fsap=FSApproximationEnum();
-                        var ssahoap=SSAHOApproximationEnum();
-                        var hofsaap=HOFSApproximationEnum();
-                        var ssafsap=SSAFSApproximationEnum();
-
-                        for(var i=0;i<data.length;i++){
-                                if(data[i]==0)data[i]=nonap;
-                                if(data[i]==1) data[i]=siaap;
-                                if(data[i]==2) data[i]=ssaap;
-                                if(data[i]==3) data[i]=l1l2ap;
-                                if(data[i]==4) data[i]=hoap;
-                                if(data[i]==5) data[i]=fsap;
-                                if(data[i]==6) data[i]=ssahoap;
-                                if(data[i]==7) data[i]=hofsaap;
-                                if(data[i]==8) data[i]=ssafsap;
-                        }
-                        WriteData(fid,prefix,'data',data,'name','md.flowequation.vertex_equation','format','DoubleMat','mattype',1);
-
-                        data=this.element_equation;
-                        for(var i=0;i<data.length;i++){
-                                if(data[i]==0) data[i]=nonap;
-                                if(data[i]==1) data[i]=siaap;
-                                if(data[i]==2) data[i]=ssaap;
-                                if(data[i]==3) data[i]=l1l2ap;
-                                if(data[i]==4) data[i]=hoap;
-                                if(data[i]==5) data[i]=fsap;
-                                if(data[i]==6) data[i]=ssahoap;
-                                if(data[i]==7) data[i]=ssafsap;
-                                if(data[i]==8) data[i]=hofsaap;
-                        }
-                        WriteData(fid,prefix,'data',data,'name','md.flowequation.element_equation','format','DoubleMat','mattype',2);
+                        WriteData(fid,prefix,'data',this.vertex_equation,'name','md.flowequation.vertex_equation','format','DoubleMat','mattype',1);
+                        WriteData(fid,prefix,'data',this.element_equation,'name','md.flowequation.element_equation','format','DoubleMat','mattype',2);
 
                 }//}}}

issm/trunk-jpl/src/m/classes/flowequation.m ¶

@@ -172 +172 @@
                         WriteData(fid,prefix,'object',self,'fieldname','borderFS','format','DoubleMat','mattype',1);
                         %convert approximations to enums
-                        data=self.vertex_equation;
-                        pos=find(data==0); data(pos,end)=NoneApproximationEnum();
-                        pos=find(data==1); data(pos,end)=SIAApproximationEnum();
-                        pos=find(data==2); data(pos,end)=SSAApproximationEnum();
-                        pos=find(data==3); data(pos,end)=L1L2ApproximationEnum();
-                        pos=find(data==4); data(pos,end)=HOApproximationEnum();
-                        pos=find(data==5); data(pos,end)=FSApproximationEnum();
-
-                        pos=find(data==6); data(pos,end)=SSAHOApproximationEnum();
-                        pos=find(data==7); data(pos,end)=HOFSApproximationEnum();
-                        pos=find(data==8); data(pos,end)=SSAFSApproximationEnum();
-                        WriteData(fid,prefix,'data',data,'name','md.flowequation.vertex_equation','format','DoubleMat','mattype',1);
-                        data=self.element_equation;
-                        pos=find(data==0); data(pos,end)=NoneApproximationEnum();
-                        pos=find(data==1); data(pos,end)=SIAApproximationEnum();
-                        pos=find(data==2); data(pos,end)=SSAApproximationEnum();
-                        pos=find(data==3); data(pos,end)=L1L2ApproximationEnum();
-                        pos=find(data==4); data(pos,end)=HOApproximationEnum();
-                        pos=find(data==5); data(pos,end)=FSApproximationEnum();
-
-                        pos=find(data==6); data(pos,end)=SSAHOApproximationEnum();
-                        pos=find(data==7); data(pos,end)=SSAFSApproximationEnum();
-                        pos=find(data==8); data(pos,end)=HOFSApproximationEnum();
-                        WriteData(fid,prefix,'data',data,'name','md.flowequation.element_equation','format','DoubleMat','mattype',2);
+                        WriteData(fid,prefix,'data',self.vertex_equation,'name','md.flowequation.vertex_equation','format','DoubleMat','mattype',1);
+                        WriteData(fid,prefix,'data',self.element_equation,'name','md.flowequation.element_equation','format','DoubleMat','mattype',2);
                 end % }}}
                 function savemodeljs(self,fid,modelname) % {{{

issm/trunk-jpl/src/m/classes/flowequation.py ¶

@@ -138 +138 @@
                 WriteData(fid,prefix,'object',self,'fieldname','borderFS','format','DoubleMat','mattype',1)
                 #convert approximations to enums
-                data=copy.deepcopy(self.vertex_equation); 
+                WriteData(fid,prefix,'data',self.vertex_equation,'name','md.flowequation.vertex_equation','format','DoubleMat','mattype',1)
+                WriteData(fid,prefix,'data',self.element_equation,'name','md.flowequation.element_equation','format','DoubleMat','mattype',2)
 
-                if isinstance(data, (list, tuple, numpy.ndarray)):
-                        data[numpy.nonzero(data==0)]=NoneApproximationEnum()
-                        data[numpy.nonzero(data==1)]=SIAApproximationEnum()
-                        data[numpy.nonzero(data==2)]=SSAApproximationEnum()
-                        data[numpy.nonzero(data==3)]=L1L2ApproximationEnum()
-                        data[numpy.nonzero(data==4)]=HOApproximationEnum()
-                        data[numpy.nonzero(data==5)]=FSApproximationEnum()
-                        data[numpy.nonzero(data==6)]=SSAHOApproximationEnum()
-                        data[numpy.nonzero(data==7)]=HOFSApproximationEnum()
-                        data[numpy.nonzero(data==8)]=SSAFSApproximationEnum()
-                WriteData(fid,prefix,'data',data,'name','md.flowequation.vertex_equation','format','DoubleMat','mattype',1)
-                data=copy.deepcopy(self.element_equation)
-                if isinstance(data, (list, tuple, numpy.ndarray)):
-                        data[numpy.nonzero(data==0)]=NoneApproximationEnum()
-                        data[numpy.nonzero(data==1)]=SIAApproximationEnum()
-                        data[numpy.nonzero(data==2)]=SSAApproximationEnum()
-                        data[numpy.nonzero(data==3)]=L1L2ApproximationEnum()
-                        data[numpy.nonzero(data==4)]=HOApproximationEnum()
-                        data[numpy.nonzero(data==5)]=FSApproximationEnum()
-                        data[numpy.nonzero(data==6)]=SSAHOApproximationEnum()
-                        data[numpy.nonzero(data==7)]=SSAFSApproximationEnum()
-                        data[numpy.nonzero(data==8)]=HOFSApproximationEnum()
-                WriteData(fid,prefix,'data',data,'name','md.flowequation.element_equation','format','DoubleMat','mattype',2)
         # }}}