Changeset 4006


Ignore:
Timestamp:
06/03/10 07:56:16 (15 years ago)
Author:
Mathieu Morlighem
Message:

Updated CreateLoads

Location:
issm/trunk/src/c/modules/ModelProcessorx
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/modules/ModelProcessorx/Balancedthickness/CreateLoadsBalancedthickness.cpp

    r3913 r4006  
    1111#include "../ModelProcessorx.h"
    1212
    13 
    1413void    CreateLoadsBalancedthickness(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1514
     15        /*DataSet*/
    1616        DataSet*    loads    = NULL;
    1717
    18         /*Create loads: */
    19         loads   = new DataSet(LoadsEnum);
     18        /*Recover pointer: */
     19        loads=*ploads;
     20
     21        /*Create loads if they do not exist yet*/
     22        if(!loads) loads = new DataSet(LoadsEnum);
    2023       
    21         /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    22          * datasets, it will not be redone: */
    23         loads->Presort();
    24 
    25         cleanup_and_return:
    26 
    2724        /*Assign output pointer: */
    2825        *ploads=loads;
    29 
    3026}

  • issm/trunk/src/c/modules/ModelProcessorx/Balancedthickness2/CreateLoadsBalancedthickness2.cpp

    r3913 r4006  
    1919        DataSet* loads=NULL;
    2020
    21         /*Create loads: */
    22         loads   = new DataSet(LoadsEnum);
     21        /*Recover pointer: */
     22        loads=*ploads;
     23
     24        /*Create loads if they do not exist yet*/
     25        if(!loads) loads = new DataSet(LoadsEnum);
    2326
    2427        /*Get edges and elements*/
    … …  
    2932        /*First load data:*/
    3033        for (i=0;i<iomodel->numberofedges;i++){
    31                 loads->AddObject(new Numericalflux(i+1,i,iomodel));
     34                loads->AddObject(new Numericalflux(iomodel->loadcounter+i+1,i,iomodel,Balancedthickness2AnalysisEnum));
    3235        }
    3336
    … …  
    3740        xfree((void**)&iomodel->thickness);
    3841
    39         /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    40          * datasets, it will not be redone: */
    41         loads->Presort();
    42 
    4342        /*Assign output pointer: */
    4443        *ploads=loads;
    45 
    4644}

  • issm/trunk/src/c/modules/ModelProcessorx/Balancedvelocities/CreateLoadsBalancedvelocities.cpp

    r3913 r4006  
    1111#include "../ModelProcessorx.h"
    1212
    13 
    1413void    CreateLoadsBalancedvelocities(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1514
    16         DataSet*    loads    = NULL;
     15        /*DataSet*/
     16        DataSet* loads=NULL;
    1717
    18         /*Create loads: */
    19         loads   = new DataSet(LoadsEnum);
    20        
    21         /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    22          * datasets, it will not be redone: */
    23         loads->Presort();
     18        /*Recover pointer: */
     19        loads=*ploads;
    2420
    25         cleanup_and_return:
     21        /*Create loads if they do not exist yet*/
     22        if(!loads) loads = new DataSet(LoadsEnum);
    2623
    2724        /*Assign output pointer: */
    2825        *ploads=loads;
    29 
    3026}

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateLoadsDiagnosticHoriz.cpp

    r4003 r4006  
    1313void    CreateLoadsDiagnosticHoriz(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1414
     15        /*DataSets*/
    1516        DataSet*    loads    = NULL;
    1617        Icefront*   icefront = NULL;
    1718        Riftfront*  riftfront= NULL;
    1819
     20        /*Intermediary*/
    1921        int segment_width;
    2022        int element;
    … …  
    9698        /*Assign output pointer: */
    9799        *ploads=loads;
    98 
    99100}

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHutter/CreateLoadsDiagnosticHutter.cpp

    r3913 r4006  
    1313void    CreateLoadsDiagnosticHutter(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1414
    15         DataSet*    loads    = NULL;
     15        /*DataSet*/
     16        DataSet* loads=NULL;
    1617
    17         /*Create loads: */
    18         loads   = new DataSet(LoadsEnum);
     18        /*Recover pointer: */
     19        loads=*ploads;
    1920
    20         /*Now, is the flag ishutter on? otherwise, do nothing: */
    21         if (!iomodel->ishutter)goto cleanup_and_return;
    22 
    23         cleanup_and_return:
     21        /*Create loads if they do not exist yet*/
     22        if(!loads) loads = new DataSet(LoadsEnum);
    2423       
    2524        /*Assign output pointer: */
    2625        *ploads=loads;
    27 
    2826}

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticStokes/CreateLoadsDiagnosticStokes.cpp

    r3913 r4006  
    1313void    CreateLoadsDiagnosticStokes(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1414
     15        /*Intermediary*/
    1516        int i;
     17        int segment_width;
     18        int element;
    1619       
     20        /*DataSet*/
    1721        DataSet*    loads    = NULL;
    1822        Pengrid*    pengrid  = NULL;
    1923
    20         int segment_width;
    21         int element;
    22 
    2324        /*pengrid intermediary data: */
    2425        int numberofpressureloads;
    25         int counter=1;
     26        int count;
    2627
    27         /*Create loads: */
    28         loads   = new DataSet(LoadsEnum);
     28        /*Recover pointer: */
     29        loads=*ploads;
     30
     31        /*Create loads if they do not exist yet*/
     32        if(!loads) loads = new DataSet(LoadsEnum);
    2933
    3034        /*Now, is the flag ishutter on? otherwise, do nothing: */
    31         if (!iomodel->isstokes)goto cleanup_and_return;
     35        if (!iomodel->isstokes) goto cleanup_and_return;
    3236
    3337        /*Create pressure loads as boundary conditions. Pay attention to the partitioning if we are running in parallel (the grids
    … …  
    3741        IoModelFetchData(&iomodel->thickness,NULL,NULL,iomodel_handle,"thickness");
    3842        IoModelFetchData(&iomodel->bed,NULL,NULL,iomodel_handle,"bed");
     43
     44        /*Initialize counter: */
     45        count=0;
    3946
    4047        /*First load data:*/
    … …  
    5461
    5562                /*Create and  add load: */
    56                 loads->AddObject(new Icefront(counter,i,iomodel));
    57                 counter++;
     63                loads->AddObject(new Icefront(iomodel->loadcounter+counter+1,i,iomodel,DiagnosticStokesAnalysisEnum));
     64                count++;
    5865
    5966        }
    … …  
    7885                        if ((iomodel->gridonbed[i]) && (iomodel->gridonicesheet[i]) && (iomodel->gridonstokes[i])){
    7986                               
    80                                 loads->AddObject(new Pengrid(counter,i,iomodel));
    81                                 counter++;
     87                                loads->AddObject(new Pengrid(iomodel->loadcounter+counter+1,i,iomodel,DiagnosticStokesAnalysisEnum));
     88                                count++;
    8289                        }
    8390                } //if((iomodel->my_vertices[i]==1))
    … …  
    9097        xfree((void**)&iomodel->singlenodetoelementconnectivity);
    9198
    92         /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    93          * datasets, it will not be redone: */
    94         loads->Presort();
    95 
    9699        cleanup_and_return:
    97100
    98101        /*Assign output pointer: */
    99102        *ploads=loads;
    100 
    101103}

  • issm/trunk/src/c/modules/ModelProcessorx/DiagnosticVert/CreateLoadsDiagnosticVert.cpp

    r3913 r4006  
    1313void    CreateLoadsDiagnosticVert(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1414
    15         DataSet*    loads    = NULL;
     15        /*DataSet*/
     16        DataSet* loads=NULL;
    1617
    17         /*Create loads: */
    18         loads   = new DataSet(LoadsEnum);
     18        /*Recover pointer: */
     19        loads=*ploads;
     20
     21        /*Create loads if they do not exist yet*/
     22        if(!loads) loads = new DataSet(LoadsEnum);
    1923
    2024        /*Assign output pointer: */
    2125        *ploads=loads;
    22 
    2326}

  • issm/trunk/src/c/modules/ModelProcessorx/Melting/CreateLoadsMelting.cpp

    r3984 r4006  
    1313void    CreateLoadsMelting(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1414
     15        /*Intermediary*/
    1516        int i;
    1617
     18        /*DataSet*/
    1719        DataSet*    loads    = NULL;
    1820
    19         /*if 2d: return*/
    20         if (iomodel->dim==2)goto cleanup_and_return;
     21        /*if 2d: Error*/
     22        if (iomodel->dim==2) ISSMERROR("2d meshes not supported yet");
    2123
    22         /*Create loads: */
    23         loads   = new DataSet(LoadsEnum);
     24        /*Recover pointer: */
     25        loads=*ploads;
     26
     27        /*Create loads if they do not exist yet*/
     28        if(!loads) loads = new DataSet(LoadsEnum);
    2429
    2530        //create penalties for grids: no grid can have a temperature over the melting point
    … …  
    3439                        if (iomodel->gridonbed[i]){
    3540                               
    36                                 loads->AddObject(new Pengrid(i+1,i,iomodel));
     41                                loads->AddObject(new Pengrid(iomodel->loadcounter+i+1,i,iomodel,MeltingAnalysisEnum));
    3742                        }
    3843                }
    … …  
    4247        xfree((void**)&iomodel->singlenodetoelementconnectivity);
    4348
    44         /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    45          * datasets, it will not be redone: */
    46         loads->Presort();
    47 
    48         cleanup_and_return:
    49 
    5049        /*Assign output pointer: */
    5150        *ploads=loads;
    52 
    5351}

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic/CreateLoadsPrognostic.cpp

    r3913 r4006  
    1313void    CreateLoadsPrognostic(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1414
     15        /*DataSet*/
    1516        DataSet*    loads    = NULL;
    1617
    17         /*Create loads: */
    18         loads   = new DataSet(LoadsEnum);
    19        
    20         /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    21          * datasets, it will not be redone: */
    22         loads->Presort();
     18        /*Recover pointer: */
     19        loads=*ploads;
    2320
    24         cleanup_and_return:
     21        /*Create loads if they do not exist yet*/
     22        if(!loads) loads = new DataSet(LoadsEnum);
    2523
    2624        /*Assign output pointer: */
    2725        *ploads=loads;
    28 
    2926}

  • issm/trunk/src/c/modules/ModelProcessorx/Prognostic2/CreateLoadsPrognostic2.cpp

    r3913 r4006  
    2020        DataSet* loads=NULL;
    2121
    22         /*Create loads: */
    23         loads   = new DataSet(LoadsEnum);
     22        /*Recover pointer: */
     23        loads=*ploads;
     24
     25        /*Create loads if they do not exist yet*/
     26        if(!loads) loads = new DataSet(LoadsEnum);
    2427
    2528        /*Get edges and elements*/
    … …  
    3841
    3942                /* Add load */
    40                 loads->AddObject(new Numericalflux(i+1,i,iomodel));
     43                loads->AddObject(new Numericalflux(iomodel->loadcounter+i+1,i,iomodel,Prognostic2AnalysisEnum));
    4144        }
    4245
    … …  
    4649        xfree((void**)&iomodel->thickness);
    4750
    48         /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    49          * datasets, it will not be redone: */
    50         loads->Presort();
    51 
    5251        /*Assign output pointer: */
    5352        *ploads=loads;
    54 
    5553}

  • issm/trunk/src/c/modules/ModelProcessorx/SlopeCompute/CreateLoadsSlopeCompute.cpp

    r3913 r4006  
    1313void    CreateLoadsSlopeCompute(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1414
     15        /*DataSet*/
    1516        DataSet*    loads    = NULL;
    1617
    17         /*Create loads: */
    18         loads   = new DataSet(LoadsEnum);
     18        /*Recover pointer: */
     19        loads=*ploads;
    1920
    20         /*Now, is the flag isstokes on? otherwise, do nothing: */
    21         if (!iomodel->isstokes)goto cleanup_and_return;
     21        /*Create loads if they do not exist yet*/
     22        if(!loads) loads = new DataSet(LoadsEnum);
    2223
    23         cleanup_and_return:
    24        
    2524        /*Assign output pointer: */
    2625        *ploads=loads;
    27 
    2826}
    29 
    30 

  • issm/trunk/src/c/modules/ModelProcessorx/Thermal/CreateLoadsThermal.cpp

    r3984 r4006  
    1313void    CreateLoadsThermal(DataSet** ploads, IoModel* iomodel,ConstDataHandle iomodel_handle){
    1414
     15        /*Intermediary*/
    1516        int i;
    1617
     18        /*DataSet*/
    1719        DataSet*    loads    = NULL;
    1820        Pengrid*    pengrid  = NULL;
    1921
     22        /*Recover pointer: */
     23        loads=*ploads;
     24
     25        /*Create loads if they do not exist yet*/
     26        if(!loads) loads = new DataSet(LoadsEnum);
     27
    2028        /*return if 2d mesh*/
    21         if (iomodel->dim==2)goto cleanup_and_return;
    22 
    23         /*Create loads: */
    24         loads   = new DataSet(LoadsEnum);
     29        if (iomodel->dim==2) ISSMERROR("2d meshes not supported yet");
    2530
    2631        //create penalties for grids: no grid can have a temperature over the melting point
    … …  
    3641                        if (!iomodel->spctemperature[2*i]){ //No penalty applied on spc grids!
    3742
    38                                 loads->AddObject(new Pengrid(i+1,i,iomodel));
     43                                loads->AddObject(new Pengrid(iomodel->loadcounter+i+1,i,iomodel,ThermalAnalysisEnum));
    3944                                               
    4045                        }
    … …  
    4550        xfree((void**)&iomodel->singlenodetoelementconnectivity);
    4651
    47         /*All our datasets are already order by ids. Set presort flag so that later on, when sorting is requested on these
    48          * datasets, it will not be redone: */
    49         loads->Presort();
    50 
    51         cleanup_and_return:
    52 
    5352        /*Assign output pointer: */
    5453        *ploads=loads;
    55 
    5654}
Note: See TracChangeset for help on using the changeset viewer.