Changeset 17513

Timestamp:

03/21/14 09:07:07 (11 years ago)

Author:

Mathieu Morlighem

Message:

CHG: working on spawnTria function of Tetra

Location:

issm/trunk-jpl/src/c

Files:

• analyses/L2ProjectionBaseAnalysis.cpp (modified) (4 diffs)
• classes/Elements/ElementHook.cpp (modified) (1 diff)
• classes/Elements/ElementHook.h (modified) (1 diff)
• classes/Elements/Tetra.cpp (modified) (1 diff)
• classes/Elements/Tetra.h (modified) (1 diff)
• classes/Inputs/BoolInput.cpp (modified) (1 diff)
• classes/Inputs/BoolInput.h (modified) (1 diff)
• classes/Inputs/ControlInput.cpp (modified) (1 diff)
• classes/Inputs/ControlInput.h (modified) (1 diff)
• classes/Inputs/DatasetInput.cpp (modified) (1 diff)
• classes/Inputs/DatasetInput.h (modified) (1 diff)
• classes/Inputs/DoubleInput.cpp (modified) (1 diff)
• classes/Inputs/DoubleInput.h (modified) (1 diff)
• classes/Inputs/Input.h (modified) (1 diff)
• classes/Inputs/Inputs.cpp (modified) (1 diff)
• classes/Inputs/Inputs.h (modified) (1 diff)
• classes/Inputs/IntInput.cpp (modified) (1 diff)
• classes/Inputs/IntInput.h (modified) (1 diff)
• classes/Inputs/PentaInput.cpp (modified) (1 diff)
• classes/Inputs/PentaInput.h (modified) (1 diff)
• classes/Inputs/SegInput.h (modified) (1 diff)
• classes/Inputs/TetraInput.cpp (modified) (1 diff)
• classes/Inputs/TetraInput.h (modified) (1 diff)
• classes/Inputs/TransientInput.cpp (modified) (1 diff)
• classes/Inputs/TransientInput.h (modified) (1 diff)
• classes/Inputs/TriaInput.cpp (modified) (1 diff)
• classes/Inputs/TriaInput.h (modified) (1 diff)
• classes/Node.cpp (modified) (2 diffs)
• shared/Exceptions/exceptions.h (modified) (1 diff)

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

@@ -36 +36 @@
 void L2ProjectionBaseAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel){/*{{{*/
 
-        if(iomodel->meshtype==Mesh3DEnum){
+        if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh3DtetrasEnum){
                 iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
         }
@@ -82 +82 @@
                         break;
                 case Mesh3DEnum:
+                        if(!element->IsOnBed()) return NULL;
+                        basalelement = element->SpawnBasalElement();
+                        break;
+                case Mesh3DtetrasEnum:
                         if(!element->IsOnBed()) return NULL;
                         basalelement = element->SpawnBasalElement();
@@ -141 +145 @@
                         break;
                 case Mesh3DEnum:
+                        if(!element->IsOnBed()) return NULL;
+                        basalelement = element->SpawnBasalElement();
+                        break;
+                case Mesh3DtetrasEnum:
                         if(!element->IsOnBed()) return NULL;
                         basalelement = element->SpawnBasalElement();
@@ -213 +221 @@
                         break;
                 case Mesh2DverticalEnum:
+                case Mesh3DtetrasEnum:
                         element->InputUpdateFromSolutionOneDof(solution,inputenum);
                         break;

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

@@ -128 +128 @@
 }
 /*}}}*/
+/*FUNCTION ElementHook::SpawnTriaHook{{{*/
+void ElementHook::SpawnTriaHook(ElementHook* triahook,int index1,int index2,int index3){
+
+        /*Create arrow of indices depending on location (0=base 1=surface)*/
+        int indices[3];
+        indices[0] = index1;
+        indices[1] = index2;
+        indices[2] = index3;
+
+        triahook->numanalyses=this->numanalyses;
+
+        /*Spawn nodes hook*/
+        triahook->hnodes=new Hook*[this->numanalyses];
+        for(int i=0;i<this->numanalyses;i++){
+                /*Do not do anything if Hook is empty*/
+                if (!this->hnodes[i] || this->hnodes[i]->GetNum()==0){
+                        triahook->hnodes[i]=NULL;
+                }
+                else{
+                        triahook->hnodes[i]=this->hnodes[i]->Spawn(indices,3);
+                }
+        }
+
+        /*do not spawn hmaterial. material will be taken care of by Penta*/
+        triahook->hmaterial=NULL;
+        triahook->hvertices=(Hook*)this->hvertices->Spawn(indices,3);
+        triahook->hmatpar=(Hook*)this->hmatpar->copy();
+}
+/*}}}*/
 /*FUNCTION ElementHook::SpawnSegHook{{{*/
 void ElementHook::SpawnSegHook(ElementHook* triahook,int index1,int index2){

issm/trunk-jpl/src/c/classes/Elements/ElementHook.h ¶

@@ -25 +25 @@
 
                 void SetHookNodes(int* node_ids,int numnodes,int analysis_counter);
-                void SpawnTriaHook(ElementHook* triahook,int location); //3d only
+                void SpawnTriaHook(ElementHook* triahook,int location); //3d only TO BE REMOVED (replaced by the one below)
+                void SpawnTriaHook(ElementHook* triahook,int index1,int index2,int index3); //3d only
                 void SpawnSegHook(ElementHook* triahook,int ndex1,int index2); //2d only
                 void InitHookNeighbors(int* element_ids);               //3d only

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

@@ -763 +763 @@
 }
 /*}}}*/
+/*FUNCTION Tetra::SpawnBasalElement{{{*/
+Element*  Tetra::SpawnBasalElement(void){
+
+        _assert_(HasFaceOnBed());
+
+        int index1,index2,index3;
+        this->FaceOnBedIndices(&index1,&index2,&index3);
+        return SpawnTria(index1,index2,index3);
+}/*}}}*/
+/*FUNCTION Tetra::SpawnTopElement{{{*/
+Element*  Tetra::SpawnTopElement(void){
+
+        _assert_(HasFaceOnSurface());
+
+        int index1,index2,index3;
+        this->FaceOnSurfaceIndices(&index1,&index2,&index3);
+        return SpawnTria(index1,index2,index3);
+}/*}}}*/
+/*FUNCTION Tetra::SpawnTria{{{*/
+Tria*  Tetra::SpawnTria(int index1,int index2,int index3){
+
+        int analysis_counter;
+
+        /*go into parameters and get the analysis_counter: */
+        this->parameters->FindParam(&analysis_counter,AnalysisCounterEnum);
+
+        /*Create Tria*/
+        Tria* tria=new Tria();
+        tria->id=this->id;
+        tria->inputs=(Inputs*)this->inputs->SpawnTriaInputs(index1,index2,index3);
+        tria->parameters=this->parameters;
+        tria->element_type=P1Enum; //Only P1 CG for now (TO BE CHANGED)
+        this->SpawnTriaHook(dynamic_cast<ElementHook*>(tria),index1,index2,index3);
+
+        /*Spawn material*/
+        tria->material=(Material*)this->material->copy2(tria);
+
+        /*recover nodes, material and matpar: */
+        tria->nodes    = (Node**)tria->hnodes[analysis_counter]->deliverp();
+        tria->vertices = (Vertex**)tria->hvertices->deliverp();
+        tria->matpar   = (Matpar*)tria->hmatpar->delivers();
+
+        /*Return new Tria*/
+        return tria;
+}
+/*}}}*/
 /*FUNCTION Tetra::Update {{{*/
 void Tetra::Update(int index,IoModel* iomodel,int analysis_counter,int analysis_type,int finiteelement_type){ 

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

@@ -112 +112 @@
                 int         NumberofNodesVelocity(void);
                 int         NumberofNodesPressure(void);
-           Element*    SpawnBasalElement(void){_error_("not implemented yet");};
-                Element*    SpawnTopElement(void){_error_("not implemented yet");};
+           Element*    SpawnBasalElement(void);
+                Element*    SpawnTopElement(void);
+                Tria*       SpawnTria(int index1,int index2,int index3);
                 IssmDouble  StabilizationParameter(IssmDouble u, IssmDouble v, IssmDouble w, IssmDouble diameter, IssmDouble kappa){_error_("not implemented yet");};
                 IssmDouble  PureIceEnthalpy(IssmDouble pressure){_error_("not implemented yet");};

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

@@ -71 +71 @@
 /*FUNCTION BoolInput::SpawnTriaInput{{{*/
 Input* BoolInput::SpawnTriaInput(int location){
+
+                /*output*/
+                BoolInput* outinput=new BoolInput();
+
+                /*only copy current value*/
+                outinput->enum_type=this->enum_type;
+                outinput->value=this->value;
+
+                /*Assign output*/
+                return outinput;
+
+}
+/*}}}*/
+/*FUNCTION BoolInput::SpawnTriaInput{{{*/
+Input* BoolInput::SpawnTriaInput(int index1,int index2,int index3){
 
                 /*output*/

issm/trunk-jpl/src/c/classes/Inputs/BoolInput.h ¶

@@ -31 +31 @@
                 int   InstanceEnum();
                 Input* SpawnTriaInput(int location);
+                Input* SpawnTriaInput(int index1,int index2,int index3);
                 Input* SpawnSegInput(int index1,int index2);
                 Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};

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

@@ -196 +196 @@
         return values->SpawnTriaInput(location);
 }/*}}}*/
+/*FUNCTION ControlInput::SpawnTriaInput{{{*/
+Input* ControlInput::SpawnTriaInput(int index1,int index2,int index3){
+        return values->SpawnTriaInput(index1,index2,index3);
+}/*}}}*/
 /*FUNCTION ControlInput::SpawnSegInput{{{*/
 Input* ControlInput::SpawnSegInput(int index1,int index2){

issm/trunk-jpl/src/c/classes/Inputs/ControlInput.h ¶

@@ -39 +39 @@
                 int    InstanceEnum();
                 Input* SpawnTriaInput(int location);
+                Input* SpawnTriaInput(int index1,int index2,int index3);
                 Input* SpawnSegInput(int index1,int index2);
                 Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};

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

@@ -96 +96 @@
 }
 /*}}}*/
+/*FUNCTION DatasetInput::SpawnTriaInput{{{*/
+Input* DatasetInput::SpawnTriaInput(int index1,int index2,int index3){
+
+        /*output*/
+        DatasetInput* outinput=NULL;
+
+        /*Create new Datasetinput (copy of current input)*/
+        outinput=new DatasetInput();
+        outinput->enum_type=this->enum_type;
+        outinput->inputs=dynamic_cast<Inputs*>(this->inputs->SpawnTriaInputs(index1,index2,index3));
+        outinput->numids=this->numids;
+        outinput->ids=xNew<int>(this->numids);
+        xMemCpy(outinput->ids,this->ids,this->numids);
+
+        /*Assign output*/
+        return outinput;
+}
+/*}}}*/
 /*FUNCTION DatasetInput::SpawnSegInput{{{*/
 Input* DatasetInput::SpawnSegInput(int index1,int index2){

issm/trunk-jpl/src/c/classes/Inputs/DatasetInput.h ¶

@@ -37 +37 @@
                 int    InstanceEnum();
                 Input* SpawnTriaInput(int location);
+                Input* SpawnTriaInput(int index1,int index2,int index3);
                 Input* SpawnSegInput(int index1,int index2);
                 Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};

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

@@ -84 +84 @@
 }
 /*}}}*/
+/*FUNCTION DoubleInput::SpawnTriaInput{{{*/
+Input* DoubleInput::SpawnTriaInput(int index1,int index2,int index3){
+
+        /*output*/
+        DoubleInput* outinput=new DoubleInput();
+
+        /*only copy current value*/
+        outinput->enum_type=this->enum_type;
+        outinput->value=this->value;
+
+        /*Assign output*/
+        return outinput;
+
+}
+/*}}}*/
 /*FUNCTION DoubleInput::SpawnSegInput{{{*/
 Input* DoubleInput::SpawnSegInput(int index1,int index2){

issm/trunk-jpl/src/c/classes/Inputs/DoubleInput.h ¶

@@ -34 +34 @@
                 int   InstanceEnum();
                 Input* SpawnTriaInput(int location);
+                Input* SpawnTriaInput(int index1,int index2,int index3);
                 Input* SpawnSegInput(int index1,int index2);
                 Input* PointwiseDivide(Input* inputB);

issm/trunk-jpl/src/c/classes/Inputs/Input.h ¶

@@ -55 +55 @@
 
                 virtual Input* SpawnTriaInput(int location)=0;
+                virtual Input* SpawnTriaInput(int index1,int index2,int index3)=0;
                 virtual Input* SpawnSegInput(int index1,int index2)=0;
                 virtual Input* PointwiseDivide(Input* inputB)=0;

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

@@ -395 +395 @@
 }
 /*}}}*/
+/*FUNCTION Inputs::SpawnTriaInputs{{{*/
+Inputs* Inputs::SpawnTriaInputs(int index1,int index2,int index3){
+
+        /*Intermediary*/
+        vector<Object*>::iterator object;
+        Input* inputin=NULL;
+        Input* inputout=NULL;
+
+        /*Output*/
+        Inputs* newinputs=new Inputs();
+
+        /*Go through inputs and call Spawn function*/
+        for ( object=objects.begin() ; object < objects.end(); object++ ){
+
+                /*Create new input*/
+                inputin=dynamic_cast<Input*>(*object);
+                inputout=inputin->SpawnTriaInput(index1,index2,index3);
+
+                /*Add input to new inputs*/
+                newinputs->AddObject(inputout);
+        }
+
+        /*Assign output pointer*/
+        return newinputs;
+}
+/*}}}*/
 /*FUNCTION Inputs::SpawnSegInputs{{{*/
 Inputs* Inputs::SpawnSegInputs(int index1,int index2){

issm/trunk-jpl/src/c/classes/Inputs/Inputs.h ¶

@@ -28 +28 @@
                 void        DuplicateInput(int original_enum,int new_enum);
                 Input*      GetInput(int enum_name);
-                Inputs*     SpawnTriaInputs(int position);
+                Inputs*     SpawnTriaInputs(int position);//TO BE REMOVED (replaced by the other one)
+                Inputs*     SpawnTriaInputs(int index1,int index2,int index3);
                 Inputs*     SpawnSegInputs(int index1,int index2);
                 Inputs*     SpawnSegInputs(int position);

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

@@ -71 +71 @@
 /*FUNCTION IntInput::SpawnTriaInput{{{*/
 Input* IntInput::SpawnTriaInput(int location){
+
+        /*output*/
+        IntInput* outinput=new IntInput();
+
+        /*only copy current value*/
+        outinput->enum_type=this->enum_type;
+        outinput->value=this->value;
+
+        /*Assign output*/
+        return outinput;
+}
+/*}}}*/
+/*FUNCTION IntInput::SpawnTriaInput{{{*/
+Input* IntInput::SpawnTriaInput(int index1,int index2,int index3){
 
         /*output*/

issm/trunk-jpl/src/c/classes/Inputs/IntInput.h ¶

@@ -35 +35 @@
                 int   InstanceEnum();
                 Input* SpawnTriaInput(int location);
+                Input* SpawnTriaInput(int index1,int index2,int index3);
                 Input* SpawnSegInput(int index1,int index2);
                 Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};

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

@@ -123 +123 @@
 }
 /*}}}*/
+/*FUNCTION PentaInput::SpawnTriaInput{{{*/
+Input* PentaInput::SpawnTriaInput(int index1,int index2,int index3){
+
+        /*output*/
+        TriaInput* outinput=NULL;
+
+        if(this->element_type==P0Enum){ 
+                outinput=new TriaInput(this->enum_type,&this->values[0],P0Enum);
+        }
+        else{
+                /*Assume P1 interpolation only for now*/
+                IssmDouble newvalues[3]; 
+
+                /*Create array of indices depending on location (0=base 1=surface)*/
+                int indices[3];
+                indices[0] = index1;
+                indices[1] = index2;
+                indices[2] = index3;
+
+                /*Create new input*/
+                for(int i=0;i<3;i++){
+                        _assert_(indices[i]>=0 && indices[i]<6);
+                        newvalues[i]=this->values[indices[i]];
+                }
+                outinput=new TriaInput(this->enum_type,&newvalues[0],P1Enum);
+        }
+
+        /*Assign output*/
+        return outinput;
+}
+/*}}}*/
 /*FUNCTION PentaInput::SpawnSegInput{{{*/
 Input* PentaInput::SpawnSegInput(int index1,int index2){

issm/trunk-jpl/src/c/classes/Inputs/PentaInput.h ¶

@@ -35 +35 @@
                 int   InstanceEnum();
                 Input* SpawnTriaInput(int location);
+                Input* SpawnTriaInput(int index1,int index2,int index3);
                 Input* SpawnSegInput(int index1,int index2);
                 Input* PointwiseDivide(Input* inputB);

issm/trunk-jpl/src/c/classes/Inputs/SegInput.h ¶

@@ -35 +35 @@
                 int    InstanceEnum();
                 Input* SpawnTriaInput(int location){_error_("not supported yet");};
+                Input* SpawnTriaInput(int index1,int index2,int index3){_error_("not supported yet");};
                 Input* SpawnSegInput(int index1,int index2){_error_("not implemented yet");};
                 Input* PointwiseDivide(Input* inputB){_error_("not supported yet");};

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

@@ -185 +185 @@
 }
 /*}}}*/
+/*FUNCTION TetraInput::SpawnTriaInput{{{*/
+Input* TetraInput::SpawnTriaInput(int index1,int index2,int index3){
+
+        /*output*/
+        TriaInput* outinput=NULL;
+
+        if(this->element_type==P0Enum){ 
+                outinput=new TriaInput(this->enum_type,&this->values[0],P0Enum);
+        }
+        else{
+                /*Assume P1 interpolation only for now*/
+                IssmDouble newvalues[3]; 
+
+                /*Create array of indices depending on location (0=base 1=surface)*/
+                int indices[3];
+                indices[0] = index1;
+                indices[1] = index2;
+                indices[2] = index3;
+
+                /*Create new input*/
+                for(int i=0;i<3;i++){
+                        _assert_(indices[i]>=0 && indices[i]<4);
+                        newvalues[i]=this->values[indices[i]];
+                }
+                outinput=new TriaInput(this->enum_type,&newvalues[0],P1Enum);
+        }
+
+        /*Assign output*/
+        return outinput;
+}
+/*}}}*/
 
 /*Intermediary*/

issm/trunk-jpl/src/c/classes/Inputs/TetraInput.h ¶

@@ -35 +35 @@
                 int    InstanceEnum();
                 Input* SpawnTriaInput(int location){_error_("not supported yet");};
+                Input* SpawnTriaInput(int index1,int index2,int index3);
                 Input* SpawnSegInput(int index1,int index2){_error_("not supported yet");};
                 Input* PointwiseDivide(Input* inputB);

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

@@ -135 +135 @@
         xMemCpy(outinput->timesteps,this->timesteps,this->numtimesteps);
         outinput->inputs=(Inputs*)this->inputs->SpawnTriaInputs(location);
+        outinput->parameters=this->parameters;
+
+        /*Assign output*/
+        return outinput;
+
+}
+/*}}}*/
+/*FUNCTION TransientInput::SpawnTriaInput{{{*/
+Input* TransientInput::SpawnTriaInput(int index1,int index2,int index3){
+
+        /*output*/
+        TransientInput* outinput=NULL;
+
+        /*Create new Transientinput (copy of current input)*/
+        outinput=new TransientInput();
+        outinput->enum_type=this->enum_type;
+        outinput->numtimesteps=this->numtimesteps;
+        outinput->timesteps=xNew<IssmDouble>(this->numtimesteps);
+        xMemCpy(outinput->timesteps,this->timesteps,this->numtimesteps);
+        outinput->inputs=(Inputs*)this->inputs->SpawnTriaInputs(index1,index2,index3);
         outinput->parameters=this->parameters;
 

issm/trunk-jpl/src/c/classes/Inputs/TransientInput.h ¶

@@ -41 +41 @@
                 int    InstanceEnum();
                 Input* SpawnTriaInput(int location);
+                Input* SpawnTriaInput(int index1,int index2,int index3);
                 Input* SpawnSegInput(int index1,int index2);
                 Input* PointwiseDivide(Input* forcingB){_error_("not implemented yet");};

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

@@ -95 +95 @@
 }
 /*}}}*/
+/*FUNCTION TriaInput::SpawnTriaInput{{{*/
+Input* TriaInput::SpawnTriaInput(int index1,int index2,int index3){
+
+        /*output*/
+        TriaInput* outinput=NULL;
+
+        /*Create new Tria input (copy of current input)*/
+        outinput=new TriaInput(this->enum_type,&this->values[0],this->element_type);
+
+        /*Assign output*/
+        return outinput;
+
+}
+/*}}}*/
 /*FUNCTION TriaInput::SpawnSegInput{{{*/
 Input* TriaInput::SpawnSegInput(int index1,int index2){

issm/trunk-jpl/src/c/classes/Inputs/TriaInput.h ¶

@@ -35 +35 @@
                 int    InstanceEnum();
                 Input* SpawnTriaInput(int location);
+                Input* SpawnTriaInput(int index1,int index2,int index3);
                 Input* SpawnSegInput(int index1,int index2);
                 Input* PointwiseDivide(Input* inputB);

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

@@ -101 +101 @@
                                 analysis_enum==ExtrapolationAnalysisEnum
                                 ){
-                if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh2DverticalEnum){
+                if(iomodel->meshtype!=Mesh2DhorizontalEnum){
                         /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
                         _assert_(iomodel->Data(MeshVertexonbedEnum));
@@ -112 +112 @@
                                 analysis_enum==FreeSurfaceTopAnalysisEnum
                                 ){
-                if(iomodel->meshtype==Mesh3DEnum || iomodel->meshtype==Mesh2DverticalEnum){
+                if(iomodel->meshtype!=Mesh2DhorizontalEnum){
                         /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
                         _assert_(iomodel->Data(MeshVertexonsurfaceEnum));

issm/trunk-jpl/src/c/shared/Exceptions/exceptions.h ¶

@@ -63 +63 @@
                 return 0;\
         }\
-        catch (exception& e) {\
+        catch(exception& e) {\
                 _printf_("Standard exception: " << e.what() << "\n\n");\
                 return 0;\