Changeset 9650


Ignore:
Timestamp:
09/07/11 10:22:21 (14 years ago)
Author:
Mathieu Morlighem
Message:

Added qmu object

Location:
issm/trunk
Files:
7 added
14 deleted
77 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h

    r9646 r9650  
    7272        MaskVertexonfloatingiceEnum,
    7373        MaskVertexonwaterEnum,
     74        QmuIsdakotaEnum,
     75        QmuMassFluxSegmentsEnum,
     76        QmuPartitionEnum,
     77        QmuNumberofpartitionsEnum,
     78        QmuNumberofresponsesEnum,
     79        QmuResponsedescriptorsEnum,
     80        QmuVariabledescriptorsEnum,
    7481        BalancethicknessSpcthicknessEnum,
    7582        BalancethicknessThickeningRateEnum,
    … …  
    373380        NumberOfVerticesEnum,
    374381        OutputFilePointerEnum,
    375         DakotaAnalysisEnum,
    376382        QmuErrNameEnum,
    377383        QmuInNameEnum,
    378         QmuMassFluxSegmentsEnum,
    379384        QmuOutNameEnum,
    380         QmuPartEnum,
    381         QmuNumberOfResponsesEnum,
    382385        IndexedEnum,
    383386        RegularEnum,
    … …  
    385388        ScaledEnum,
    386389        NodalEnum,
    387         ResponsedescriptorsEnum,
    388         VariabledescriptorsEnum,
    389390        VerboseEnum,
    390391        PetscOptionsStringsEnum,
    … …  
    469470        WaitonlockEnum,
    470471        NumberOfResponsesEnum,
    471         NpartEnum,
    472         PartEnum,
     472
    473473        MaxSteadystateIterationsEnum,
    474474        RequestedOutputsEnum,

  • issm/trunk/src/c/modules/AverageOntoPartitionx/AverageOntoPartitionx.cpp

    r9356 r9650  
    3535
    3636        /*First, recover qmu partition of vertices: */
    37         parameters->FindParam(&qmu_part,&dummy,QmuPartEnum);
     37        parameters->FindParam(&qmu_part,&dummy,QmuPartitionEnum);
    3838
    3939        /*Some parameters: */
    4040        numberofvertices=vertices->NumberOfVertices();
    41         parameters->FindParam(&npart,NpartEnum);
     41        parameters->FindParam(&npart,QmuNumberofpartitionsEnum);
    4242
    4343        /*average onto the separate areas. The result will be a npart sized vector. */

  • issm/trunk/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp

    r9356 r9650  
    3636
    3737        /*retrieve npart: */
    38         parameters->FindParam(&npart,NpartEnum);
     38        parameters->FindParam(&npart,QmuNumberofpartitionsEnum);
    3939
    4040        /*save the d_responses pointer: */

  • issm/trunk/src/c/modules/Dakotax/SpawnCoreParallel.cpp

    r9571 r9650  
    5555       
    5656        /*retrieve parameters: */
    57         femmodel->parameters->FindParam(&responses_descriptors,&numresponsedescriptors,ResponsedescriptorsEnum);
     57        femmodel->parameters->FindParam(&responses_descriptors,&numresponsedescriptors,QmuResponsedescriptorsEnum);
    5858        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    5959        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);

  • issm/trunk/src/c/modules/EnumToStringx/EnumToStringx.cpp

    r9646 r9650  
    7676                case MaskVertexonfloatingiceEnum : return "MaskVertexonfloatingice";
    7777                case MaskVertexonwaterEnum : return "MaskVertexonwater";
     78                case QmuIsdakotaEnum : return "QmuIsdakota";
     79                case QmuMassFluxSegmentsEnum : return "QmuMassFluxSegments";
     80                case QmuPartitionEnum : return "QmuPartition";
     81                case QmuNumberofpartitionsEnum : return "QmuNumberofpartitions";
     82                case QmuNumberofresponsesEnum : return "QmuNumberofresponses";
     83                case QmuResponsedescriptorsEnum : return "QmuResponsedescriptors";
     84                case QmuVariabledescriptorsEnum : return "QmuVariabledescriptors";
    7885                case BalancethicknessSpcthicknessEnum : return "BalancethicknessSpcthickness";
    7986                case BalancethicknessThickeningRateEnum : return "BalancethicknessThickeningRate";
    … …  
    325332                case NumberOfVerticesEnum : return "NumberOfVertices";
    326333                case OutputFilePointerEnum : return "OutputFilePointer";
    327                 case DakotaAnalysisEnum : return "DakotaAnalysis";
    328334                case QmuErrNameEnum : return "QmuErrName";
    329335                case QmuInNameEnum : return "QmuInName";
    330                 case QmuMassFluxSegmentsEnum : return "QmuMassFluxSegments";
    331336                case QmuOutNameEnum : return "QmuOutName";
    332                 case QmuPartEnum : return "QmuPart";
    333                 case QmuNumberOfResponsesEnum : return "QmuNumberOfResponses";
    334337                case IndexedEnum : return "Indexed";
    335338                case RegularEnum : return "Regular";
    … …  
    337340                case ScaledEnum : return "Scaled";
    338341                case NodalEnum : return "Nodal";
    339                 case ResponsedescriptorsEnum : return "Responsedescriptors";
    340                 case VariabledescriptorsEnum : return "Variabledescriptors";
    341342                case VerboseEnum : return "Verbose";
    342343                case PetscOptionsStringsEnum : return "PetscOptionsStrings";
    … …  
    413414                case WaitonlockEnum : return "Waitonlock";
    414415                case NumberOfResponsesEnum : return "NumberOfResponses";
    415                 case NpartEnum : return "Npart";
    416                 case PartEnum : return "Part";
    417416                case MaxSteadystateIterationsEnum : return "MaxSteadystateIterations";
    418417                case RequestedOutputsEnum : return "RequestedOutputs";

  • issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp

    r9356 r9650  
    2525
    2626        /*retrieve parameters: */
    27         parameters->FindParam(&npart,NpartEnum);
    28         parameters->FindParam(&qmu_part,&dummy,QmuPartEnum);
     27        parameters->FindParam(&npart,QmuNumberofpartitionsEnum);
     28        parameters->FindParam(&qmu_part,&dummy,QmuPartitionEnum);
    2929        numberofvertices=vertices->NumberOfVertices();
    3030

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

    r9641 r9650  
    2929        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    3030        iomodel->Constant(&control_analysis,ControlAnalysisEnum);
    31         iomodel->Constant(&dakota_analysis,DakotaAnalysisEnum);
     31        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    3232
    3333        /*Now, is the flag macayaealpattyn on? otherwise, do nothing: */

  • issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp

    r9625 r9650  
    6363
    6464        /*recover parameters: */
    65         iomodel->Constant(&dakota_analysis,DakotaAnalysisEnum);
    66         parameters->AddObject(new BoolParam(DakotaAnalysisEnum,dakota_analysis));
     65        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
     66        parameters->AddObject(new BoolParam(QmuIsdakotaEnum,dakota_analysis));
    6767
    6868        if(dakota_analysis){
    … …  
    8686                /*}}}*/
    8787                /*Fetch variable descriptors: {{{1*/
    88                 iomodel->FetchData(&variabledescriptors,&numvariabledescriptors,VariabledescriptorsEnum);
     88                iomodel->FetchData(&variabledescriptors,&numvariabledescriptors,QmuVariabledescriptorsEnum);
    8989
    9090                /*Ok, we have all the variable descriptors. Build a parameter with it: */
    91                 parameters->AddObject(new StringArrayParam(VariabledescriptorsEnum,variabledescriptors,numvariabledescriptors));
     91                parameters->AddObject(new StringArrayParam(QmuVariabledescriptorsEnum,variabledescriptors,numvariabledescriptors));
    9292
    9393                /*}}}*/
    9494                /*Fetch response descriptors: {{{1*/
    95                 iomodel->FetchData(&responsedescriptors,&numresponsedescriptors,ResponsedescriptorsEnum);
     95                iomodel->FetchData(&responsedescriptors,&numresponsedescriptors,QmuResponsedescriptorsEnum);
    9696
    9797                /*Ok, we have all the response descriptors. Build a parameter with it: */
    98                 parameters->AddObject(new StringArrayParam(ResponsedescriptorsEnum,responsedescriptors,numresponsedescriptors));
    99                 parameters->AddObject(new    IntParam(QmuNumberOfResponsesEnum,numberofresponses));
     98                parameters->AddObject(new StringArrayParam(QmuResponsedescriptorsEnum,responsedescriptors,numresponsedescriptors));
     99                parameters->AddObject(new    IntParam(QmuNumberofresponsesEnum,numberofresponses));
    100100                /*}}}*/
    101101                /*Deal with partitioning: {{{1*/
    102102                /*partition vertices in iomodel->qmu_npart parts, unless a partition is already present: */
    103103               
    104                 parameters->AddObject(iomodel->CopyConstantObject(NpartEnum));
    105                 iomodel->FetchData(&dpart,NULL,NULL,PartEnum);
     104                parameters->AddObject(iomodel->CopyConstantObject(QmuNumberofpartitionsEnum));
     105                iomodel->FetchData(&dpart,NULL,NULL,QmuPartitionEnum);
    106106
    107107                if(!dpart){
    … …  
    113113                        for(i=0;i<numberofvertices;i++)dpart[i]=iomodel->my_vertices[i];
    114114                }
    115                 parameters->AddObject(new DoubleVecParam(QmuPartEnum,dpart,numberofvertices));
     115                parameters->AddObject(new DoubleVecParam(QmuPartitionEnum,dpart,numberofvertices));
    116116                /*}}}*/
    117117                /*Deal with data needed because of qmu variables: {{{1*/

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

    r9641 r9650  
    2323        iomodel->Constant(&dim,DimEnum);
    2424        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    25         iomodel->Constant(&dakota_analysis,DakotaAnalysisEnum);
     25        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    2626
    2727        /*Now, is the model 3d? otherwise, do nothing: */

  • issm/trunk/src/c/modules/OutputResultsx/OutputResultsx.cpp

    r9622 r9650  
    4242
    4343        /*retrieve parameters: */
    44         parameters->FindParam(&dakota_analysis,DakotaAnalysisEnum);
     44        parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    4545
    4646        if(dakota_analysis){

  • issm/trunk/src/c/modules/StringToEnumx/StringToEnumx.cpp

    r9646 r9650  
    7474        else if (strcmp(name,"MaskVertexonfloatingice")==0) return MaskVertexonfloatingiceEnum;
    7575        else if (strcmp(name,"MaskVertexonwater")==0) return MaskVertexonwaterEnum;
     76        else if (strcmp(name,"QmuIsdakota")==0) return QmuIsdakotaEnum;
     77        else if (strcmp(name,"QmuMassFluxSegments")==0) return QmuMassFluxSegmentsEnum;
     78        else if (strcmp(name,"QmuPartition")==0) return QmuPartitionEnum;
     79        else if (strcmp(name,"QmuNumberofpartitions")==0) return QmuNumberofpartitionsEnum;
     80        else if (strcmp(name,"QmuNumberofresponses")==0) return QmuNumberofresponsesEnum;
     81        else if (strcmp(name,"QmuResponsedescriptors")==0) return QmuResponsedescriptorsEnum;
     82        else if (strcmp(name,"QmuVariabledescriptors")==0) return QmuVariabledescriptorsEnum;
    7683        else if (strcmp(name,"BalancethicknessSpcthickness")==0) return BalancethicknessSpcthicknessEnum;
    7784        else if (strcmp(name,"BalancethicknessThickeningRate")==0) return BalancethicknessThickeningRateEnum;
    … …  
    323330        else if (strcmp(name,"NumberOfVertices")==0) return NumberOfVerticesEnum;
    324331        else if (strcmp(name,"OutputFilePointer")==0) return OutputFilePointerEnum;
    325         else if (strcmp(name,"DakotaAnalysis")==0) return DakotaAnalysisEnum;
    326332        else if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum;
    327333        else if (strcmp(name,"QmuInName")==0) return QmuInNameEnum;
    328         else if (strcmp(name,"QmuMassFluxSegments")==0) return QmuMassFluxSegmentsEnum;
    329334        else if (strcmp(name,"QmuOutName")==0) return QmuOutNameEnum;
    330         else if (strcmp(name,"QmuPart")==0) return QmuPartEnum;
    331         else if (strcmp(name,"QmuNumberOfResponses")==0) return QmuNumberOfResponsesEnum;
    332335        else if (strcmp(name,"Indexed")==0) return IndexedEnum;
    333336        else if (strcmp(name,"Regular")==0) return RegularEnum;
    … …  
    335338        else if (strcmp(name,"Scaled")==0) return ScaledEnum;
    336339        else if (strcmp(name,"Nodal")==0) return NodalEnum;
    337         else if (strcmp(name,"Responsedescriptors")==0) return ResponsedescriptorsEnum;
    338         else if (strcmp(name,"Variabledescriptors")==0) return VariabledescriptorsEnum;
    339340        else if (strcmp(name,"Verbose")==0) return VerboseEnum;
    340341        else if (strcmp(name,"PetscOptionsStrings")==0) return PetscOptionsStringsEnum;
    … …  
    411412        else if (strcmp(name,"Waitonlock")==0) return WaitonlockEnum;
    412413        else if (strcmp(name,"NumberOfResponses")==0) return NumberOfResponsesEnum;
    413         else if (strcmp(name,"Npart")==0) return NpartEnum;
    414         else if (strcmp(name,"Part")==0) return PartEnum;
    415414        else if (strcmp(name,"MaxSteadystateIterations")==0) return MaxSteadystateIterationsEnum;
    416415        else if (strcmp(name,"RequestedOutputs")==0) return RequestedOutputsEnum;

  • issm/trunk/src/c/objects/Elements/Penta.cpp

    r9646 r9650  
    75057505        iomodel->Constant(&yts,ConstantsYtsEnum);
    75067506        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
    7507         iomodel->Constant(&dakota_analysis,DakotaAnalysisEnum);
     7507        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    75087508        iomodel->Constant(&isstokes,IsstokesEnum);
    75097509        iomodel->Constant(&beta,MaterialsBetaEnum);

  • issm/trunk/src/c/objects/Elements/Tria.cpp

    r9646 r9650  
    52205220        iomodel->Constant(&yts,ConstantsYtsEnum);
    52215221        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
    5222         iomodel->Constant(&dakota_analysis,DakotaAnalysisEnum);
     5222        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    52235223
    52245224        /*Recover element type*/

  • issm/trunk/src/c/solutions/CorePointerFromSolutionEnum.cpp

    r9594 r9650  
    2929        /*retrieve some parameters: */
    3030        parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    31         parameters->FindParam(&dakota_analysis,DakotaAnalysisEnum);
     31        parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    3232
    3333        switch(solutiontype){

  • issm/trunk/src/c/solutions/control_core.cpp

    r9571 r9650  
    5757        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    5858        femmodel->parameters->FindParam(&isstokes,IsstokesEnum);
    59         femmodel->parameters->FindParam(&dakota_analysis,DakotaAnalysisEnum);
     59        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    6060
    6161        /*out of solution_type, figure out solution core and adjoint function pointer*/

  • issm/trunk/src/c/solutions/controlrestart.cpp

    r9571 r9650  
    1818        femmodel->parameters->FindParam(&control_type,NULL,ControlTypeEnum);
    1919        femmodel->parameters->FindParam(&nsteps,NstepsEnum);
    20         femmodel->parameters->FindParam(&dakota_analysis,DakotaAnalysisEnum);
     20        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    2121
    2222        /*only save if we are not running qmu analysis. We certainly don't want to save control results each time we

  • issm/trunk/src/c/solutions/diagnostic_core.cpp

    r9571 r9650  
    3030        femmodel->parameters->FindParam(&ismacayealpattyn,IsmacayealpattynEnum);
    3131        femmodel->parameters->FindParam(&isstokes,IsstokesEnum);
    32         femmodel->parameters->FindParam(&dakota_analysis,DakotaAnalysisEnum);
     32        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    3333        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    3434        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);

  • issm/trunk/src/c/solutions/issm.cpp

    r9594 r9650  
    8787        /*get parameters: */
    8888        femmodel->parameters->FindParam(&waitonlock,WaitonlockEnum);
    89         femmodel->parameters->FindParam(&dakota_analysis,DakotaAnalysisEnum);
     89        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    9090        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    9191

  • issm/trunk/src/c/solutions/thermal_core.cpp

    r9628 r9650  
    3131        femmodel->parameters->FindParam(&control_analysis,ControlAnalysisEnum);
    3232        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    33         femmodel->parameters->FindParam(&dakota_analysis,DakotaAnalysisEnum);
     33        femmodel->parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
    3434
    3535        /*Compute number of time steps: */

  • issm/trunk/src/m/classes/clusters/castor.m

    r9625 r9650  
    9494                                %compress the files into one zip.
    9595                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.miscellaneous.name '.bin ' md.miscellaneous.name '.queue '  md.miscellaneous.name '.petsc '];
    96                                 if md.dakota_analysis,
     96                                if md.qmu.isdakota,
    9797                                        compressstring=[compressstring md.miscellaneous.name '.qmu.in'];
    9898                                end
    … …  
    124124                        %What packages are we picking up from remote cluster
    125125                        packages={[md.miscellaneous.name '.outlog'],[md.miscellaneous.name '.errlog']};
    126                         if md.dakota_analysis,
     126                        if md.qmu.isdakota,
    127127                                packages{end+1}=[md.miscellaneous.name '.qmu.err'];
    128128                                packages{end+1}=[md.miscellaneous.name '.qmu.out'];
    129                                 if isfield(md.qmu_params,'tabular_graphics_data'),
    130                                         if md.qmu_params.tabular_graphics_data==true,
     129                                if isfield(md.qmu.params,'tabular_graphics_data'),
     130                                        if md.qmu.params.tabular_graphics_data==true,
    131131                                                packages{end+1}='dakota_tabular.dat';
    132132                                        end

  • issm/trunk/src/m/classes/clusters/cosmos.m

    r9625 r9650  
    9393                                %compress the files into one zip.
    9494                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.miscellaneous.name '.bin ' md.miscellaneous.name '.queue '  md.miscellaneous.name '.petsc '];
    95                                 if md.dakota_analysis,
     95                                if md.qmu.isdakota,
    9696                                        compressstring=[compressstring md.miscellaneous.name '.qmu.in'];
    9797                                end
    … …  
    123123                        %What packages are we picking up from remote cluster
    124124                        packages={[md.miscellaneous.name '.outlog'],[md.miscellaneous.name '.errlog']};
    125                         if md.dakota_analysis,
     125                        if md.qmu.isdakota,
    126126                                packages{end+1}=[md.miscellaneous.name '.qmu.err'];
    127127                                packages{end+1}=[md.miscellaneous.name '.qmu.out'];
    128                                 if isfield(md.qmu_params,'tabular_graphics_data'),
    129                                         if md.qmu_params.tabular_graphics_data==true,
     128                                if isfield(md.qmu.params,'tabular_graphics_data'),
     129                                        if md.qmu.params.tabular_graphics_data==true,
    130130                                                packages{end+1}='dakota_tabular.dat';
    131131                                        end

  • issm/trunk/src/m/classes/clusters/gemini.m

    r9625 r9650  
    9494                                %compress the files into one zip.
    9595                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.miscellaneous.name '.bin ' md.miscellaneous.name '.queue '  md.miscellaneous.name '.petsc '];
    96                                 if md.dakota_analysis,
     96                                if md.qmu.isdakota,
    9797                                        compressstring=[compressstring md.miscellaneous.name '.qmu.in'];
    9898                                end
    … …  
    124124                        %What packages are we picking up from remote cluster
    125125                        packages={[md.miscellaneous.name '.outlog'],[md.miscellaneous.name '.errlog']};
    126                         if md.dakota_analysis,
     126                        if md.qmu.isdakota,
    127127                                packages{end+1}=[md.miscellaneous.name '.qmu.err'];
    128128                                packages{end+1}=[md.miscellaneous.name '.qmu.out'];
    129                                 if isfield(md.qmu_params,'tabular_graphics_data'),
    130                                         if md.qmu_params.tabular_graphics_data==true,
     129                                if isfield(md.qmu.params,'tabular_graphics_data'),
     130                                        if md.qmu.params.tabular_graphics_data==true,
    131131                                                packages{end+1}='dakota_tabular.dat';
    132132                                        end

  • issm/trunk/src/m/classes/clusters/generic.m

    r9625 r9650  
    123123                                %compress the files into one zip.
    124124                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.miscellaneous.name '.bin ' md.miscellaneous.name '.queue '  md.miscellaneous.name '.petsc '];
    125                                 if md.dakota_analysis,
     125                                if md.qmu.isdakota,
    126126                                        compressstring=[compressstring md.miscellaneous.name '.qmu.in'];
    127127                                end
    … …  
    154154                        %What packages are we picking up from remote cluster
    155155                        packages={[md.miscellaneous.name '.outlog'],[md.miscellaneous.name '.errlog']};
    156                         if md.dakota_analysis,
     156                        if md.qmu.isdakota,
    157157                                packages{end+1}=[md.miscellaneous.name '.qmu.err'];
    158158                                packages{end+1}=[md.miscellaneous.name '.qmu.out'];
    159                                 if isfield(md.qmu_params,'tabular_graphics_data'),
    160                                         if md.qmu_params.tabular_graphics_data==true,
     159                                if isfield(md.qmu.params,'tabular_graphics_data'),
     160                                        if md.qmu.params.tabular_graphics_data==true,
    161161                                                packages{end+1}='dakota_tabular.dat';
    162162                                        end

  • issm/trunk/src/m/classes/clusters/pfe.m

    r9625 r9650  
    182182                                %compress the files into one zip.
    183183                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.miscellaneous.name '.bin ' md.miscellaneous.name '.queue '  md.miscellaneous.name '.petsc '];
    184                                 if md.dakota_analysis,
     184                                if md.qmu.isdakota,
    185185                                        compressstring=[compressstring md.miscellaneous.name '.qmu.in '];
    186186                                end
    … …  
    234234                                packages={};
    235235                        end
    236                         if md.dakota_analysis,
     236                        if md.qmu.isdakota,
    237237                                packages{end+1}=[md.miscellaneous.name '.qmu.err'];
    238238                                packages{end+1}=[md.miscellaneous.name '.qmu.out'];
    239                                 if isfield(md.qmu_params,'tabular_graphics_data'),
    240                                         if md.qmu_params.tabular_graphics_data==true,
     239                                if isfield(md.qmu.params,'tabular_graphics_data'),
     240                                        if md.qmu.params.tabular_graphics_data==true,
    241241                                                packages{end+1}='dakota_tabular.dat';
    242242                                        end

  • issm/trunk/src/m/classes/clusters/pollux.m

    r9625 r9650  
    9494                                %compress the files into one zip.
    9595                                compressstring=['tar -zcf ' md.private.runtimename '.tar.gz ' md.miscellaneous.name '.bin ' md.miscellaneous.name '.queue '  md.miscellaneous.name '.petsc '];
    96                                 if md.dakota_analysis,
     96                                if md.qmu.isdakota,
    9797                                        compressstring=[compressstring md.miscellaneous.name '.qmu.in'];
    9898                                end
    … …  
    124124                        %What packages are we picking up from remote cluster
    125125                        packages={[md.miscellaneous.name '.outlog'],[md.miscellaneous.name '.errlog']};
    126                         if md.dakota_analysis,
     126                        if md.qmu.isdakota,
    127127                                packages{end+1}=[md.miscellaneous.name '.qmu.err'];
    128128                                packages{end+1}=[md.miscellaneous.name '.qmu.out'];
    129                                 if isfield(md.qmu_params,'tabular_graphics_data'),
    130                                         if md.qmu_params.tabular_graphics_data==true,
     129                                if isfield(md.qmu.params,'tabular_graphics_data'),
     130                                        if md.qmu.params.tabular_graphics_data==true,
    131131                                                packages{end+1}='dakota_tabular.dat';
    132132                                        end

  • issm/trunk/src/m/classes/model/model.m

    r9649 r9650  
    3030                 materials = modelfield('default',0,'marshall',true);
    3131                 mask = modelfield('default',0,'marshall',true);
     32                 qmu = modelfield('default',0,'marshall',true);
    3233                 balancethickness = modelfield('default',0,'marshall',true);
    3334
    … …  
    174175                 waitonlock    = modelfield('default',0,'marshall',true,'format','Boolean');
    175176
    176                  %qmu
    177                  variables                       = modelfield('default',struct(),'marshall',false);
    178                  responses                       = modelfield('default',struct(),'marshall',false);
    179                  qmu_method                      = modelfield('default',struct(),'marshall',false);
    180                  qmu_params                      = modelfield('default',struct(),'marshall',false);
    181                  dakotaresults                   = modelfield('default',struct(),'marshall',false);
    182                  dakota_analysis                    = modelfield('default',0,'marshall',true,'format','Boolean');
    183                  part                            = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    184                  npart                           = modelfield('default',0,'marshall',true,'format','Integer');
    185                  numberofresponses               = modelfield('default',0,'marshall',true,'format','Integer');
    186                  variabledescriptors             = modelfield('default',{},'marshall',true,'format','StringArray');
    187                  responsedescriptors             = modelfield('default',{},'marshall',true,'format','StringArray');
    188                  qmu_mass_flux_profile_directory = modelfield('default',NaN,'marshall',false);
    189                  qmu_mass_flux_profiles          = modelfield('default',NaN,'marshall',false);
    190                  qmu_mass_flux_segments          = modelfield('default',{},'marshall',true,'format','MatArray');
    191 
    192177                 %ad: automatic differentiation
    193178                 ad_analysis = modelfield('default',false,'marshall',true,'format','Boolean');
    194179                 ad_forward = modelfield('default',true,'marshall',true,'format','Boolean');
    195180                 ad_reverse = modelfield('default',false,'marshall',true,'format','Boolean');
    196 
    197                  %partitioner:
    198                  adjacency = modelfield('default',NaN,'marshall',false);
    199                  vwgt      = modelfield('default',NaN,'marshall',false);
    200181                 %}}}
    201182         end
    … …  
    311292                         disp(sprintf('%s%s%s','      Parameters: type ''',inputname(1),'.par'' to display'));
    312293                         disp(sprintf('   Solution parameters: %s'));
    313                          disp(sprintf('%s%s%s','      Qmu: type ''',inputname(1),'.qmu'' to display'));
    314294                         disp(sprintf('%s%s%s','      Diagnostic solution parameters: type ''',inputname(1),'.diagnostic'' to display'));
    315295                         disp(sprintf('%s%s%s','      Thermal solution parameters: type ''',inputname(1),'.thermal'' to display'));
    … …  
    357337                         if isfield(structmd,'g'), md.constants.g=structmd.g; end
    358338                         if isfield(structmd,'yts'), md.constants.yts=structmd.yts; end
    359                          if isfield(structmd,'dakota_analysis'), md.dakota_analysis=structmd.dakota_analysis; end
    360339                         if isfield(structmd,'surface_mass_balance'), md.surfaceforcings.mass_balance=structmd.surface_mass_balance; end
    361340                         if isfield(structmd,'basal_melting_rate'), md.basalforcings.melting_rate=structmd.basal_melting_rate; end
    … …  
    527506                         md.materials=materials;
    528507                         md.mask=mask;
     508                         md.qmu=qmu;
    529509                         md.balancethickness=balancethickness;
    530510
    … …  
    654634                                 if(strcmp(index1.subs,'res')), displayresults(md);return; end
    655635                                 if(strcmp(index1.subs,'obs')), displayobservations(md);return; end
    656                                  if(strcmp(index1.subs,'qmu')), displayqmu(md);return; end
    657636                                 if(strcmp(index1.subs,'diagnostic')), displaydiagnostic(md);return; end
    658637                                 if(strcmp(index1.subs,'transient')), displaytransient(md);return; end

  • issm/trunk/src/m/enum/EnumToModelField.m

    r9636 r9650  
    1515                case MaterialsRheologyBEnum(), string='rheology_B'; return
    1616                case MaterialsRheologyBbarEnum(), string='rheology_B'; return
    17                 case DhdtEnum(), string='dhdt'; return
     17                case BalancethicknessThickeningRateEnum: string='dhdt'; return
    1818                case VxEnum(), string='vx'; return
    1919                case VxObsEnum(), string='vx_obs'; return

  • issm/trunk/src/m/kml/kml_mesh_write.m

    r9625 r9650  
    220220
    221221if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    222     md.npart
     222    md.qmu.numberofpartitions
    223223    kdoc.feature{1}(end+1)=kml_part_flagedges(md,varargin{3:end});
    224224end
    … …  
    227227
    228228if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    229     md.npart
     229    md.qmu.numberofpartitions
    230230    kdoc.feature{1}(end+1)=kml_unsh_edges(md,varargin{3:end});
    231231end
    … …  
    234234
    235235if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    236     md.npart
     236    md.qmu.numberofpartitions
    237237    kdoc.feature{1}(end+1)=kml_part_elems(md,varargin{3:end});
    238238end
    … …  
    241241
    242242if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    243     md.npart
     243    md.qmu.numberofpartitions
    244244    kdoc.feature{1}(end+1)=kml_part_edges(md,varargin{3:end});
    245245end
    … …  
    248248
    249249if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    250     md.npart
     250    md.qmu.numberofpartitions
    251251    kdoc.feature{1}(end+1)=kml_partitions(md,varargin{3:end});
    252252end

  • issm/trunk/src/m/kml/kml_part_edges.m

    r8298 r9650  
    118118
    119119if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    120     md.npart
     120    md.qmu.numberofpartitions
    121121    kfold=kml_folder();
    122122    kfold.name      ='Partition Edges';
    123123    kfold.visibility=1;
    124124    kfold.descript  =sprintf('Partitions=%d, Nodes=%d',...
    125         md.npart,md.numberofnodes);
    126     kfold.feature   ={repmat(kml_placemark(),1,md.npart)};
     125        md.qmu.numberofpartitions,md.numberofnodes);
     126    kfold.feature   ={repmat(kml_placemark(),1,md.qmu.numberofpartitions)};
    127127
    128128%  write each partition as a linestring multigeometry placemark
    129129
    130     disp(['Writing ' num2str(md.npart) ' partitions as KML linestrings.']);
    131     epart=md.part(md.elements)+1;
     130    disp(['Writing ' num2str(md.qmu.numberofpartitions) ' partitions as KML linestrings.']);
     131    epart=md.qmu.partition(md.elements)+1;
    132132    if exist('ndata','var') || exist('edata','var')
    133         pdata=zeros(1,md.npart);
     133        pdata=zeros(1,md.qmu.numberofpartitions);
    134134        pdata(:)=NaN;
    135135    end
    … …  
    137137%  loop over each partition
    138138
    139     for k=1:md.npart
     139    for k=1:md.qmu.numberofpartitions
    140140%        disp(['partition k=' int2str(k)])
    141141       
    … …  
    158158
    159159        if exist('ndata','var')
    160             pdata(k)=ndata(find(md.part+1==k,1));
     160            pdata(k)=ndata(find(md.qmu.partition+1==k,1));
    161161        elseif exist('edata','var')
    162162            for i=1:size(epartp,1)

  • issm/trunk/src/m/kml/kml_part_elems.m

    r8298 r9650  
    118118
    119119if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    120     md.npart
     120    md.qmu.numberofpartitions
    121121    kfold=kml_folder();
    122122    kfold.name      ='Partition Elements';
    123123    kfold.visibility=1;
    124124    kfold.descript  =sprintf('Partitions=%d, Nodes=%d\n',...
    125         md.npart,md.numberofnodes);
    126     kfold.feature   ={repmat(kml_placemark(),1,md.npart)};
     125        md.qmu.numberofpartitions,md.numberofnodes);
     126    kfold.feature   ={repmat(kml_placemark(),1,md.qmu.numberofpartitions)};
    127127
    128128%  write each partition loop as a polygon multigeometry placemark
    129129
    130     disp(['Writing ' num2str(md.npart) ' partitions as KML polygons.']);
    131     epart=md.part(md.elements)+1;
     130    disp(['Writing ' num2str(md.qmu.numberofpartitions) ' partitions as KML polygons.']);
     131    epart=md.qmu.partition(md.elements)+1;
    132132    if exist('ndata','var') || exist('edata','var')
    133         pdata=zeros(1,md.npart);
     133        pdata=zeros(1,md.qmu.numberofpartitions);
    134134        pdata(:)=NaN;
    135135    end
    … …  
    137137%  loop over each partition
    138138
    139     for k=1:md.npart
     139    for k=1:md.qmu.numberofpartitions
    140140
    141141%  for each partition, find all the included elements
    … …  
    151151
    152152        if exist('ndata','var')
    153             pdata(k)=ndata(find(md.part+1==k,1));
     153            pdata(k)=ndata(find(md.qmu.partition+1==k,1));
    154154        elseif exist('edata','var')
    155155            for i=1:size(epart,1)

  • issm/trunk/src/m/kml/kml_part_flagedges.m

    r7461 r9650  
    7373
    7474if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    75     md.npart
    76     [latseg,lonseg]=flagedges(md.elements,md.lat,md.long,md.part);
     75    md.qmu.numberofpartitions
     76    [latseg,lonseg]=flagedges(md.elements,md.lat,md.long,md.qmu.partition);
    7777    kfold=kml_folder();
    7878    kfold.name      ='Partition Segments';
    7979    kfold.visibility=1;
    8080    kfold.descript  =sprintf('Partitions=%d, Segments=%d',...
    81         md.npart,size(latseg,1));
     81        md.qmu.numberofpartitions,size(latseg,1));
    8282    kfold.feature   ={repmat(kml_placemark(),1,size(latseg,1))};
    8383

  • issm/trunk/src/m/kml/kml_partitions.m

    r8298 r9650  
    119119
    120120if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    121     md.npart
     121    md.qmu.numberofpartitions
    122122    kfold=kml_folder();
    123123    kfold.name      ='Partitions';
    124124    kfold.visibility=1;
    125125    kfold.descript  =sprintf('Partitions=%d, Nodes=%d',...
    126         md.npart,md.numberofnodes);
    127     kfold.feature   ={repmat(kml_placemark(),1,md.npart)};
     126        md.qmu.numberofpartitions,md.numberofnodes);
     127    kfold.feature   ={repmat(kml_placemark(),1,md.qmu.numberofpartitions)};
    128128
    129129%  write each partition as a polygon multigeometry placemark
    130130
    131     disp(['Writing ' num2str(md.npart) ' partitions as KML polygons.']);
    132     epart=md.part(md.elements)+1;
     131    disp(['Writing ' num2str(md.qmu.numberofpartitions) ' partitions as KML polygons.']);
     132    epart=md.qmu.partition(md.elements)+1;
    133133    if exist('ndata','var') || exist('edata','var')
    134         pdata=zeros(1,md.npart);
     134        pdata=zeros(1,md.qmu.numberofpartitions);
    135135        pdata(:)=NaN;
    136136    end
    … …  
    138138%  loop over each partition
    139139
    140     for k=1:md.npart
     140    for k=1:md.qmu.numberofpartitions
    141141%        disp(['partition k=' int2str(k)])
    142142       
    … …  
    159159
    160160        if exist('ndata','var')
    161             pdata(k)=ndata(find(md.part+1==k,1));
     161            pdata(k)=ndata(find(md.qmu.partition+1==k,1));
    162162        elseif exist('edata','var')
    163163            for i=1:size(epartp,1)

  • issm/trunk/src/m/kml/kml_unsh_edges.m

    r7461 r9650  
    7373
    7474if (~exist('prtplt','var') || strncmpi(prtplt,'on' ,2) || strncmpi(prtplt,'y',1)) && ...
    75     md.npart
     75    md.qmu.numberofpartitions
    7676    [edgeadj]=edgeadjacency(md.elements,md.nodeconnectivity);
    7777    [icol,irow]=find(edgeadj'==0);
    … …  
    8585    kfold.visibility=1;
    8686    kfold.descript  =sprintf('Partitions=%d, Edges=%d',...
    87         md.npart,size(edgeuns,1));
     87        md.qmu.numberofpartitions,size(edgeuns,1));
    8888    kfold.feature   ={repmat(kml_placemark(),1,size(edgeuns,1))};
    8989

  • issm/trunk/src/m/model/ismodelselfconsistent.m

    r9648 r9650  
    252252%}}}
    253253%QMU {{{1
    254 if md.dakota_analysis,
    255         if md.qmu_params.evaluation_concurrency~=1,
     254if md.qmu.isdakota,
     255        if md.qmu.params.evaluation_concurrency~=1,
    256256                message(['model not consistent: concurrency should be set to 1 when running dakota in library mode']);
    257257        end
    258         if ~isempty(md.part),
    259                 if numel(md.part)~=md.numberofnodes,
     258        if ~isempty(md.qmu.partition),
     259                if numel(md.qmu.partition)~=md.numberofnodes,
    260260                        message(['model not consistent: user supplied partition for qmu analysis should have size md.numberofnodes x 1 ']);
    261261                end
    262                 if find(md.part)>=md.numberofnodes,
     262                if find(md.qmu.partition)>=md.numberofnodes,
    263263                        message(['model not consistent: user supplied partition should be indexed from 0 (c-convention)']);
    264264                end
    265                 if min(md.part)~=0,
     265                if min(md.qmu.partition)~=0,
    266266                        message(['model not consistent: partition vector not indexed from 0 on']);
    267267                end
    268                 if max(md.part)>=md.numberofnodes,
     268                if max(md.qmu.partition)>=md.numberofnodes,
    269269                        message(['model not consistent: partition vector cannot have maximum index larger than number of nodes']);
    270270                end
    271                 if ~isempty(find(md.part<0)),
     271                if ~isempty(find(md.qmu.partition<0)),
    272272                        message(['model not consistent: partition vector cannot have values less than 0']);
    273273                end
    274                 if ~isempty(find(md.part>=md.npart)),
    275                         message(['model not consistent: partition vector cannot have values more than md.npart-1']);
    276                 end
    277                 if max(md.part)>=md.npart,
     274                if ~isempty(find(md.qmu.partition>=md.qmu.numberofpartitions)),
     275                        message(['model not consistent: partition vector cannot have values more than md.qmu.numberofpartitions-1']);
     276                end
     277                if max(md.qmu.partition)>=md.qmu.numberofpartitions,
    278278                        message(['model not consistent: for qmu analysis, partitioning vector cannot go over npart, number of partition areas']);
    279279                end

  • issm/trunk/src/m/model/isresultconsistent.m

    r9632 r9650  
    2121
    2222%do not check results if qmu analysis
    23 if md.dakota_analysis,
     23if md.qmu.isdakota,
    2424        return
    2525end

  • issm/trunk/src/m/model/loadresultsfromcluster.m

    r9625 r9650  
    3636
    3737%erase the log and output files
    38 if md.dakota_analysis,
     38if md.qmu.isdakota,
    3939        delete([['qmu' num2str(feature('GetPid')) '/'] md.miscellaneous.name '.outlog']);
    4040        delete([['qmu' num2str(feature('GetPid')) '/']  md.miscellaneous.name '.errlog']);
    … …  
    4949hostname=oshostname();
    5050if strcmpi(hostname,cluster.name),
    51         if md.dakota_analysis,
     51        if md.qmu.isdakota,
    5252                delete([['qmu' num2str(feature('GetPid')) '/'] md.miscellaneous.name '.bin']);
    5353                delete([['qmu' num2str(feature('GetPid')) '/'] md.miscellaneous.name '.queue']);

  • issm/trunk/src/m/model/loadresultsfromdisk.m

    r9622 r9650  
    1111end
    1212
    13 if ~md.dakota_analysis,
     13if ~md.qmu.isdakota,
    1414
    1515        %initialize md.results if not a structure yet

  • issm/trunk/src/m/model/partition/AreaAverageOntoPartition.m

    r9190 r9650  
    2121        md.numberofnodes=md.numberofnodes2d;
    2222        md.numberofelements=md.numberofelements2d;
    23         md.vwgt=[];
     23        md.vertex_weight=[];
    2424        md.nodeconnectivity=[];
    2525
    … …  
    2929        %finally, project vector:
    3030        vector=project2d(md3d,vector,layer);
    31         md.part=project2d(md3d,md3d.part,layer);
     31        md.qmu.partition=project2d(md3d,md3d.part,layer);
    3232end
    3333
    3434%ok, first check that part is Matlab indexed
    35 part=md.part+1;
     35part=md.qmu.partition+1;
    3636
    3737%some check:
    38 if md.npart~=max(part),
    39         error('AreaAverageOntoPartition error message: ''npart'' should be equal to max(md.part)');
     38if md.qmu.numberofpartitions~=max(part),
     39        error('AreaAverageOntoPartition error message: ''npart'' should be equal to max(md.qmu.partition)');
    4040end
    4141
    … …  
    4444
    4545%start weight average
    46 weightedvector=vector.*md.vwgt;
     46weightedvector=vector.*md.vertex_weight;
    4747for i=1:max(part),
    4848        pos=find(part==i);
    49         partvector(i)=sum(weightedvector(pos))/sum(md.vwgt(pos));
     49        partvector(i)=sum(weightedvector(pos))/sum(md.vertex_weight(pos));
    5050end
    5151

  • issm/trunk/src/m/model/partition/adjacency.m

    r9190 r9650  
    66%  the required output is:
    77%    md.adj_mat     (double [sparse nv x nv], vertex adjacency matrix)
    8 %    md.vwgt        (double [nv], vertex weights)
     8%    md.vertex_weight        (double [nv], vertex weights)
    99
    1010indi=[md.elements(:,1);md.elements(:,2);md.elements(:,3)];
    … …  
    1212values=1;
    1313
    14 md.adjacency=sparse(indi,indj,values,md.numberofnodes,md.numberofnodes);
    15 md.adjacency=double([md.adjacency | md.adjacency']);
     14md.qmu.adjacency=sparse(indi,indj,values,md.numberofnodes,md.numberofnodes);
     15md.qmu.adjacency=double([md.qmu.adjacency | md.qmu.adjacency']);
    1616
    1717%now, build vwgt:
    … …  
    2424pos=find(connectivity);
    2525connectivity(pos)=areas(connectivity(pos))/3;
    26 md.vwgt=sum(connectivity,2);
     26md.vertex_weight=sum(connectivity,2);

  • issm/trunk/src/m/model/partition/partitioner.m

    r9207 r9650  
    1 function md=partitioner(md,varargin)
     1function md.qmu.partitionitioner(md,varargin)
    22%PARTITIONER - partition mesh
    33%
    … …  
    99%   section:  1 by defaults(1=bisection, 2=quadrisection, 3=octasection)
    1010%   recomputeadjacency:  'on' by default (set to 'off' to compute existing one)
    11 %   Output: md.part recover the partition vector
     11%   Output: md.qmu.partition recover the partition vector
    1212%   
    1313%   Usage:
    14 %      md=partitioner(md,'package','chaco','npart',100,'weighting','on');
     14%      md.qmu.partitionitioner(md,'package','chaco','npart',100,'weighting','on');
    1515%
    1616
    … …  
    3939        md.numberofnodes=md.numberofnodes2d;
    4040        md.numberofelements=md.numberofelements2d;
    41         md.vwgt=[];
     41        md.vertex_weight=[];
    4242        md.nodeconnectivity=[];
    4343end
    … …  
    6363        %are we using weights?
    6464        if strcmpi(getfieldvalue(options,'weighting'),'on'),
    65                 weights=floor(md.vwgt/min(md.vwgt));
     65                weights=floor(md.vertex_weight/min(md.vertex_weight));
    6666                method(3)=1;
    6767        else
    … …  
    7070       
    7171        %  partition into nparts
    72         part=Chaco(md.adjacency,weights,[],md.x, md.y ,md.z,method,npart,[])'+1; %index partitions from 1 up. like metis.
     72        part=Chaco(md.qmu.adjacency,weights,[],md.x, md.y ,md.z,method,npart,[])'+1; %index partitions from 1 up. like metis.
    7373
    7474elseif strcmpi(package,'scotch'),
    … …  
    7676        %are we using weights?
    7777        if strcmpi(getfieldvalue(options,'weighting'),'on'),
    78                 weights=floor(md.vwgt/min(md.vwgt));
     78                weights=floor(md.vertex_weight/min(md.vertex_weight));
    7979        end
    80         maptab=Scotch(md.adjacency,[],weights,[],'cmplt',[npart]);
     80        maptab=Scotch(md.qmu.adjacency,[],weights,[],'cmplt',[npart]);
    8181       
    8282        part=maptab(:,2);%index partitions from 1 up. like metis.
    … …  
    8989elseif strcmpi(package,'metis'),
    9090
    91         [element_partitioning,part]=MeshPartition(md,npart);
     91        [element_partitioning,part]=MeshPartition(md.qmu.numberofpartitions);
    9292
    9393else
    … …  
    103103end
    104104
    105 md.part=part;
     105md.qmu.partition=part;

  • issm/trunk/src/m/model/plot/applyoptions.m

    r9289 r9650  
    437437%flag edges of a partition
    438438if exist(options,'partitionedges')
    439 [xsegments ysegments]=flagedges(md.elements,md.x,md.y,md.part);
     439[xsegments ysegments]=flagedges(md.elements,md.x,md.y,md.qmu.partition);
    440440xsegments=xsegments*getfieldvalue(options,'unit',1);
    441441ysegments=ysegments*getfieldvalue(options,'unit',1);

  • issm/trunk/src/m/model/plot/plot_importancefactors.m

    r8472 r9650  
    2323
    2424%go through all response functions and find the one corresponding to the correct responsefunctiondescriptor
    25 responsefunctions=md.dakotaresults{2};
     25responsefunctions=md.qmu.results{2};
    2626found=0;
    2727for i=1:length(responsefunctions),
    … …  
    3838
    3939%Now recover response to the correct desgin variable
    40 importancefactors=zeros(md.npart,1);
     40importancefactors=zeros(md.qmu.numberofpartitions,1);
    4141count=0;
    4242for i=1:nfun,
    … …  
    5858
    5959%Ok, get partitioning.
    60 [epart npart]=MeshPartition(md,md.npart);
     60[epart npart]=MeshPartition(md,md.qmu.numberofpartitions);
    6161
    6262%distribute importance factor

  • issm/trunk/src/m/model/plot/plot_parthist.m

    r8472 r9650  
    1313subplot(nlines,ncols,i);
    1414
    15 imin=min(md.part);
    16 imax=max(md.part);
     15imin=min(md.qmu.partition);
     16imax=max(md.qmu.partition);
    1717
    1818part=zeros(imax-imin+1,2);
    1919
    2020for i=imin:imax
    21     ind=find(md.part == i);
     21    ind=find(md.qmu.partition == i);
    2222    part(i-imin+1,1)=length(ind);
    23         part(i-imin+1,2)=sum(md.vwgt(ind));
     23        part(i-imin+1,2)=sum(md.vertex_weight(ind));
    2424end
    2525

  • issm/trunk/src/m/model/plot/plot_parthistn.m

    r8472 r9650  
    1313subplot(nlines,ncols,i);
    1414
    15 imin=min(md.part);
    16 imax=max(md.part);
     15imin=min(md.qmu.partition);
     16imax=max(md.qmu.partition);
    1717
    1818part=zeros(imax-imin+1,2);
    1919
    2020for i=imin:imax
    21     ind=find(md.part == i);
     21    ind=find(md.qmu.partition == i);
    2222    part(i-imin+1,1)=length(ind);
    23         part(i-imin+1,2)=sum(md.vwgt(ind));
     23        part(i-imin+1,2)=sum(md.vertex_weight(ind));
    2424end
    2525

  • issm/trunk/src/m/model/plot/plot_parthistw.m

    r8472 r9650  
    1313subplot(nlines,ncols,i);
    1414
    15 imin=min(md.part);
    16 imax=max(md.part);
     15imin=min(md.qmu.partition);
     16imax=max(md.qmu.partition);
    1717
    1818part=zeros(imax-imin+1,2);
    1919
    2020for i=imin:imax
    21     ind=find(md.part == i);
     21    ind=find(md.qmu.partition == i);
    2222    part(i-imin+1,1)=length(ind);
    23         part(i-imin+1,2)=sum(md.vwgt(ind));
     23        part(i-imin+1,2)=sum(md.vertex_weight(ind));
    2424end
    2525

  • issm/trunk/src/m/model/plot/plot_qmu_mass_flux_segments.m

    r8472 r9650  
    1111[x y z elements is2d isplanet]=processmesh(md,[],options);
    1212
    13 allsegments=md.qmu_mass_flux_segments;
     13allsegments=md.qmu.mass_flux_segments;
    1414
    1515if (md.dim==2),

  • issm/trunk/src/m/model/plot/plot_qmumean.m

    r8472 r9650  
    2727
    2828%go pick up the response:
    29 allresponses=md.dakotaresults.dresp_out;
    30 responses=zeros(md.npart,1);
     29allresponses=md.qmu.results.dresp_out;
     30responses=zeros(md.qmu.numberofpartitions,1);
    3131
    3232count=1;
    … …  
    4848
    4949%now, project onto vertices
    50 responses_on_node=responses(md.part+1);
     50responses_on_node=responses(md.qmu.partition+1);
    5151
    5252%plot

  • issm/trunk/src/m/model/plot/plot_qmustddev.m

    r8472 r9650  
    2727
    2828%go pick up the response:
    29 allresponses=md.dakotaresults.dresp_out;
    30 responses=zeros(md.npart,1);
     29allresponses=md.qmu.results.dresp_out;
     30responses=zeros(md.qmu.numberofpartitions,1);
    3131
    3232count=1;
    … …  
    4949
    5050%now, project onto vertices
    51 responses_on_node=responses(md.part+1);
     51responses_on_node=responses(md.qmu.partition+1);
    5252
    5353%plot

  • issm/trunk/src/m/model/solve.m

    r9625 r9650  
    4040%if running qmu analysis, some preprocessing of dakota files using
    4141%models fields needs to be carried out.
    42 if md.dakota_analysis,
     42if md.qmu.isdakota,
    4343        md=preqmu(md,options);
    4444end
    … …  
    7474
    7575%post processes qmu results if necessary
    76 if md.dakota_analysis,
     76if md.qmu.isdakota,
    7777        md=postqmu(md);
    7878        cd ..

  • issm/trunk/src/m/model/solveparallel.m

    r9625 r9650  
    3939
    4040                %post processes qmu results if necessary
    41                 if md.dakota_analysis,
     41                if md.qmu.isdakota,
    4242                        if ~strncmpi(options.keep,'y',1)
    4343                                system(['rm -rf qmu' num2str(feature('GetPid'))]);

  • issm/trunk/src/m/model/tres.m

    r9629 r9650  
    4747
    4848elseif strcmpi(string,'dakota'),
    49         md.dakotaresults=md.results.dakota;
     49        md.qmu.results=md.results.dakota;
    5050
    5151elseif strcmpi(string,'flaim'),

  • issm/trunk/src/m/qmu/examples/all_parameters.m

    r9619 r9650  
    1616nonlinear_equality_constraint;
    1717
    18 md.variables=struct();
    19 md.variables.nuv=normal_uncertain.empty();
    20 md.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85);
    21 md.variables.nuv(end+1)=normal_uncertain('thickness',1,0.05);
    22 md.variables.nuv(end+1)=normal_uncertain('drag',1,0.05);
    23 md.variables.cdv=continuous_design.empty();
    24 md.variables.cdv(end+1)=continuous_design('thickness',1,0.9,1.1);
    25 md.variables.cdv(end+1)=continuous_design('drag',1,0.5,1.5);
    26 md.variables.csv=continuous_state.empty();
    27 md.variables.csv(end+1)=continuous_state('gravity',9.8);
    28 md.variables.lic=linear_inequality_constraint.empty();
    29 md.variables.lic(end+1)=linear_inequality_constraint([1 2 3],4,5);
    30 md.variables.lic(end+1)=linear_inequality_constraint([1 2],4,5);
    31 md.variables.lic(end+1)=linear_inequality_constraint([1 2 3 4],4,5);
    32 md.variables.lec=linear_equality_constraint.empty();
    33 md.variables.lec(end+1)=linear_equality_constraint([1 2 3],4);
     18md.qmu.variables=struct();
     19md.qmu.variables.nuv=normal_uncertain.empty();
     20md.qmu.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85);
     21md.qmu.variables.nuv(end+1)=normal_uncertain('thickness',1,0.05);
     22md.qmu.variables.nuv(end+1)=normal_uncertain('drag',1,0.05);
     23md.qmu.variables.cdv=continuous_design.empty();
     24md.qmu.variables.cdv(end+1)=continuous_design('thickness',1,0.9,1.1);
     25md.qmu.variables.cdv(end+1)=continuous_design('drag',1,0.5,1.5);
     26md.qmu.variables.csv=continuous_state.empty();
     27md.qmu.variables.csv(end+1)=continuous_state('gravity',9.8);
     28md.qmu.variables.lic=linear_inequality_constraint.empty();
     29md.qmu.variables.lic(end+1)=linear_inequality_constraint([1 2 3],4,5);
     30md.qmu.variables.lic(end+1)=linear_inequality_constraint([1 2],4,5);
     31md.qmu.variables.lic(end+1)=linear_inequality_constraint([1 2 3 4],4,5);
     32md.qmu.variables.lec=linear_equality_constraint.empty();
     33md.qmu.variables.lec(end+1)=linear_equality_constraint([1 2 3],4);
    3434
    3535%%  a variety of responses
    3636
    37 md.responses=struct();
    38 md.responses.rf =response_function.empty();
    39 md.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    40 md.responses.rf (end+1)=response_function('max_abs_vy',[100 200 300],[]);
    41 md.responses.rf (end+1)=response_function('max_vel'   ,[100 200 300],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    42 md.responses.of =objective_function.empty();
    43 md.responses.of (end+1)=objective_function('max_vel');
    44 md.responses.lst=least_squares_term.empty();
    45 md.responses.lst(end+1)=least_squares_term('max_vel');
    46 md.responses.nic=nonlinear_inequality_constraint.empty();
    47 md.responses.nic(end+1)=nonlinear_inequality_constraint('max_abs_vx',0,1000);
    48 md.responses.nic(end+1)=nonlinear_inequality_constraint('max_abs_vy',0,1000);
    49 md.responses.nec=nonlinear_equality_constraint.empty();
    50 md.responses.nec(end+1)=nonlinear_equality_constraint('max_abs_vx',500);
    51 md.responses.nec(end+1)=nonlinear_equality_constraint('max_abs_vy',500);
     37md.qmu.responses=struct();
     38md.qmu.responses.rf =response_function.empty();
     39md.qmu.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     40md.qmu.responses.rf (end+1)=response_function('max_abs_vy',[100 200 300],[]);
     41md.qmu.responses.rf (end+1)=response_function('max_vel'   ,[100 200 300],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     42md.qmu.responses.of =objective_function.empty();
     43md.qmu.responses.of (end+1)=objective_function('max_vel');
     44md.qmu.responses.lst=least_squares_term.empty();
     45md.qmu.responses.lst(end+1)=least_squares_term('max_vel');
     46md.qmu.responses.nic=nonlinear_inequality_constraint.empty();
     47md.qmu.responses.nic(end+1)=nonlinear_inequality_constraint('max_abs_vx',0,1000);
     48md.qmu.responses.nic(end+1)=nonlinear_inequality_constraint('max_abs_vy',0,1000);
     49md.qmu.responses.nec=nonlinear_equality_constraint.empty();
     50md.qmu.responses.nec(end+1)=nonlinear_equality_constraint('max_abs_vx',500);
     51md.qmu.responses.nec(end+1)=nonlinear_equality_constraint('max_abs_vy',500);
    5252
    5353%%  a variety of studies
    … …  
    5555%  a sampling study
    5656
    57 md.qmu_method       =dakota_method('nond_samp');
    58 md.qmu_method(end)=dmeth_params_set(md.qmu_method(end),...
     57md.qmu.method       =dakota_method('nond_samp');
     58md.qmu.method(end)=dmeth_params_set(md.qmu.method(end),...
    5959    'seed',1234,...
    6060    'samples',10);
    … …  
    6262%  a local reliability study
    6363
    64 md.qmu_method(end+1)=dakota_method('nond_l');
     64md.qmu.method(end+1)=dakota_method('nond_l');
    6565
    6666%  a multidimensional parameter study
    6767
    68 md.qmu_method(end+1)=dakota_method('multi');
    69 md.qmu_method(end)=dmeth_params_set(md.qmu_method(end),...
     68md.qmu.method(end+1)=dakota_method('multi');
     69md.qmu.method(end)=dmeth_params_set(md.qmu.method(end),...
    7070    'partitions',2);
    7171
    7272%  an optimization study
    7373
    74 md.qmu_method(end+1)=dakota_method('conmin_f');
    75 md.qmu_method(end)=dmeth_params_set(md.qmu_method(end),...
     74md.qmu.method(end+1)=dakota_method('conmin_f');
     75md.qmu.method(end)=dmeth_params_set(md.qmu.method(end),...
    7676    'max_iterations',10,...
    7777    'max_function_evaluations',50,...
    … …  
    8080%%  a variety of parameters
    8181
    82 md.qmu_params.evaluation_concurrency=4;
    83 md.qmu_params.analysis_driver='';
    84 md.qmu_params.analysis_components='';
    85 md.qmu_params.interval_type='forward';
    86 md.qmu_params.fd_gradient_step_size=0.001;
     82md.qmu.params.evaluation_concurrency=4;
     83md.qmu.params.analysis_driver='';
     84md.qmu.params.analysis_components='';
     85md.qmu.params.interval_type='forward';
     86md.qmu.params.fd_gradient_step_size=0.001;
    8787
    88 md.npart=10;
     88md.qmu.numberofpartitions=10;
    8989md.rifts.numrifts=5;
    9090

  • issm/trunk/src/m/qmu/examples/direct.m

    r4759 r9650  
    11%using library mode of Dakota, only for parallel runs.
    2 md.qmu_params.direct=true;
    3 md.qmu_params.analysis_driver='diagnostic';
    4 md.qmu_params.evaluation_concurrency=1;
     2md.qmu.params.direct=true;
     3md.qmu.params.analysis_driver='diagnostic';
     4md.qmu.params.evaluation_concurrency=1;
    55
    66
    77
    88%or for matlab direct driver
    9 md.qmu_params.direct=true;
    10 md.qmu_params.analysis_driver='matlab';
    11 md.qmu_params.evaluation_concurrency=2; %launch 2 matlabs
     9md.qmu.params.direct=true;
     10md.qmu.params.analysis_driver='matlab';
     11md.qmu.params.evaluation_concurrency=2; %launch 2 matlabs

  • issm/trunk/src/m/qmu/examples/lrel.m

    r4759 r9650  
    1616nonlinear_equality_constraint;
    1717
    18 md.variables=struct();
    19 md.variables.nuv=normal_uncertain.empty();
    20 md.variables.nuv(end+1)=normal_uncertain('RhoIce',917,45.85);
    21 md.variables.nuv(end+1)=normal_uncertain('RhoWater',1023,51.15);
    22 md.variables.nuv(end+1)=normal_uncertain('HeatCapacity',2009,100.45);
    23 md.variables.nuv(end+1)=normal_uncertain('ThermalConductivity',2.2,0.11);
    24 md.variables.nuv(end+1)=normal_uncertain('Gravity',9.8,0.49);
    25 md.variables.nuv(end+1)=normal_uncertain('Thickness',1,0.05);
    26 md.variables.nuv(end+1)=normal_uncertain('Drag',1,0.05);
     18md.qmu.variables=struct();
     19md.qmu.variables.nuv=normal_uncertain.empty();
     20md.qmu.variables.nuv(end+1)=normal_uncertain('RhoIce',917,45.85);
     21md.qmu.variables.nuv(end+1)=normal_uncertain('RhoWater',1023,51.15);
     22md.qmu.variables.nuv(end+1)=normal_uncertain('HeatCapacity',2009,100.45);
     23md.qmu.variables.nuv(end+1)=normal_uncertain('ThermalConductivity',2.2,0.11);
     24md.qmu.variables.nuv(end+1)=normal_uncertain('Gravity',9.8,0.49);
     25md.qmu.variables.nuv(end+1)=normal_uncertain('Thickness',1,0.05);
     26md.qmu.variables.nuv(end+1)=normal_uncertain('Drag',1,0.05);
    2727
    2828%%  a variety of responses
    2929
    30 md.responses=struct();
    31 md.responses.rf =response_function.empty();
    32 md.responses.rf (end+1)=response_function('min_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    33 md.responses.rf (end+1)=response_function('max_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    34 md.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    35 md.responses.rf (end+1)=response_function('min_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    36 md.responses.rf (end+1)=response_function('max_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    37 md.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    38 md.responses.rf (end+1)=response_function('min_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    39 md.responses.rf (end+1)=response_function('max_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     30md.qmu.responses=struct();
     31md.qmu.responses.rf =response_function.empty();
     32md.qmu.responses.rf (end+1)=response_function('min_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     33md.qmu.responses.rf (end+1)=response_function('max_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     34md.qmu.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     35md.qmu.responses.rf (end+1)=response_function('min_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     36md.qmu.responses.rf (end+1)=response_function('max_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     37md.qmu.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     38md.qmu.responses.rf (end+1)=response_function('min_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     39md.qmu.responses.rf (end+1)=response_function('max_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    4040
    4141%%  nond_local_reliability study
    4242
    43 md.qmu_method     =dakota_method('nond_l');
     43md.qmu.method     =dakota_method('nond_l');
    4444
    4545%%  a variety of parameters
    4646
    47 md.qmu_params.evaluation_concurrency=1;
    48 md.qmu_params.analysis_driver='';
    49 md.qmu_params.analysis_components='';
    50 md.qmu_params.interval_type='forward';
    51 md.qmu_params.fd_gradient_step_size=0.01;
     47md.qmu.params.evaluation_concurrency=1;
     48md.qmu.params.analysis_driver='';
     49md.qmu.params.analysis_components='';
     50md.qmu.params.interval_type='forward';
     51md.qmu.params.fd_gradient_step_size=0.01;
    5252
    53 md.npart=10;
     53md.qmu.numberofpartitions=10;
    5454
    5555md.qmu

  • issm/trunk/src/m/qmu/examples/lrel_mmf.m

    r9571 r9650  
    1616nonlinear_equality_constraint;
    1717
    18 md.variables=struct();
    19 md.variables.nuv=normal_uncertain.empty();
    20 %md.variables.nuv(end+1)=normal_uncertain('RhoIce',917,45.85);
    21 %md.variables.nuv(end+1)=normal_uncertain('RhoWater',1023,51.15);
    22 %md.variables.nuv(end+1)=normal_uncertain('HeatCapacity',2009,100.45);
    23 %md.variables.nuv(end+1)=normal_uncertain('ThermalConductivity',2.2,0.11);
    24 %md.variables.nuv(end+1)=normal_uncertain('Gravity',9.8,0.49);
    25 md.variables.nuv(end+1)=normal_uncertain('Thickness',1,0.05);
    26 %md.variables.nuv(end+1)=normal_uncertain('Drag',1,0.05);
     18md.qmu.variables=struct();
     19md.qmu.variables.nuv=normal_uncertain.empty();
     20%md.qmu.variables.nuv(end+1)=normal_uncertain('RhoIce',917,45.85);
     21%md.qmu.variables.nuv(end+1)=normal_uncertain('RhoWater',1023,51.15);
     22%md.qmu.variables.nuv(end+1)=normal_uncertain('HeatCapacity',2009,100.45);
     23%md.qmu.variables.nuv(end+1)=normal_uncertain('ThermalConductivity',2.2,0.11);
     24%md.qmu.variables.nuv(end+1)=normal_uncertain('Gravity',9.8,0.49);
     25md.qmu.variables.nuv(end+1)=normal_uncertain('Thickness',1,0.05);
     26%md.qmu.variables.nuv(end+1)=normal_uncertain('Drag',1,0.05);
    2727
    2828%%  a variety of responses
    2929
    30 md.responses=struct();
    31 md.responses.rf =response_function.empty();
    32 md.responses.rf (end+1)=response_function('min_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    33 md.responses.rf (end+1)=response_function('max_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    34 md.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    35 md.responses.rf (end+1)=response_function('min_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    36 md.responses.rf (end+1)=response_function('max_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    37 md.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    38 md.responses.rf (end+1)=response_function('min_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    39 md.responses.rf (end+1)=response_function('max_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    40 md.responses.rf (end+1)=response_function('mass_flux1',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    41 md.responses.rf (end+1)=response_function('mass_flux_2',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    42 md.responses.rf (end+1)=response_function('mass_flux(3)',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    43 md.responses.rf (end+1)=response_function('mass_flux4 (repeat)',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    44 md.responses.rf (end+1)=response_function('mass_flux-5',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    45 md.responses.rf (end+1)=response_function('mass_flux^6',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    46 md.responses.rf (end+1)=response_function('mass_flux[7]',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     30md.qmu.responses=struct();
     31md.qmu.responses.rf =response_function.empty();
     32md.qmu.responses.rf (end+1)=response_function('min_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     33md.qmu.responses.rf (end+1)=response_function('max_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     34md.qmu.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     35md.qmu.responses.rf (end+1)=response_function('min_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     36md.qmu.responses.rf (end+1)=response_function('max_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     37md.qmu.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     38md.qmu.responses.rf (end+1)=response_function('min_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     39md.qmu.responses.rf (end+1)=response_function('max_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     40md.qmu.responses.rf (end+1)=response_function('mass_flux1',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     41md.qmu.responses.rf (end+1)=response_function('mass_flux_2',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     42md.qmu.responses.rf (end+1)=response_function('mass_flux(3)',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     43md.qmu.responses.rf (end+1)=response_function('mass_flux4 (repeat)',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     44md.qmu.responses.rf (end+1)=response_function('mass_flux-5',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     45md.qmu.responses.rf (end+1)=response_function('mass_flux^6',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     46md.qmu.responses.rf (end+1)=response_function('mass_flux[7]',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    4747
    4848%%  create mass flux profile
    … …  
    5151%expcreateprofile('mass_flux.exp')
    5252%expdisp('mass_flux.exp')
    53 %md.qmu_mass_flux_profile='mass_flux.exp';
    54 %md.qmu_mass_flux_profile={'mass_flux.exp','mass_flux2.exp','mass_flux3.exp'};
    55 md.qmu_mass_flux_profile={'mass_flux.exp','mass_flux2.exp','mass_flux3.exp','mass_flux.exp','mass_flux5.exp','mass_flux6.exp','mass_flux7.exp'};
     53%md.qmu.mass_flux_profile='mass_flux.exp';
     54%md.qmu.mass_flux_profile={'mass_flux.exp','mass_flux2.exp','mass_flux3.exp'};
     55md.qmu.mass_flux_profile={'mass_flux.exp','mass_flux2.exp','mass_flux3.exp','mass_flux.exp','mass_flux5.exp','mass_flux6.exp','mass_flux7.exp'};
    5656
    5757%%  nond_local_reliability study
    5858
    59 md.qmu_method     =dakota_method('nond_l');
     59md.qmu.method     =dakota_method('nond_l');
    6060
    6161%%  a variety of parameters
    6262
    63 %md.qmu_params.evaluation_concurrency=4;
    64 md.qmu_params.evaluation_concurrency=1;
    65 md.qmu_params.analysis_driver='';
    66 md.qmu_params.analysis_components='';
    67 md.qmu_params.interval_type='forward';
    68 md.qmu_params.fd_gradient_step_size=0.01;
     63%md.qmu.params.evaluation_concurrency=4;
     64md.qmu.params.evaluation_concurrency=1;
     65md.qmu.params.analysis_driver='';
     66md.qmu.params.analysis_components='';
     67md.qmu.params.interval_type='forward';
     68md.qmu.params.fd_gradient_step_size=0.01;
    6969
    70 md.dakota_analysis=1;
    71 md.npart=10;
    72 if isempty(md.adjacency)
     70md.qmu.isdakota=1;
     71md.qmu.numberofpartitions=10;
     72if isempty(md.qmu.adjacency)
    7373        md=adjacency(md);
    7474end
    75 if isempty(md.part)
    76 %    md.part=partitioner(md,'package','metis','npart',md.npart);
    77     md.part=partitioner(md,'package','chaco','npart',md.npart,'weighting','on');
     75if isempty(md.qmu.partition)
     76%    md.qmu.partition=partitioner(md,'package','metis','npart',md.qmu.numberofpartitions);
     77    md.qmu.partition=partitioner(md,'package','chaco','npart',md.qmu.numberofpartitions,'weighting','on');
    7878% SpawnCore.m assumes partition vector starting at zero
    79     md.part=md.part-1;
     79    md.qmu.partition=md.qmu.partition-1;
    8080end
    8181md.eps_rel=1.e-5;
    … …  
    8989
    9090%plotmodel(md,'data','mesh')
    91 %plotmodel(md,'data',md.part)
     91%plotmodel(md,'data',md.qmu.partition)
    9292%plotmodel(md,'data','mesh','partitionedges','on','linewidth',2)
    93 %part_hist(md.part,md.vwgt)
    94 %plotmodel(md,'data',log10(md.results.dakota.dresp_out(9).impfac(md.part+1)))
     93%part_hist(md.qmu.partition,md.vertex_weight)
     94%plotmodel(md,'data',log10(md.results.dakota.dresp_out(9).impfac(md.qmu.partition+1)))
    9595

  • issm/trunk/src/m/qmu/examples/lsq.m

    r4759 r9650  
    1616nonlinear_equality_constraint;
    1717
    18 md.variables=struct();
    19 md.variables.cdv=continuous_design.empty();
    20 md.variables.cdv(end+1)=continuous_design('thickness',1,0.9,1.1);
    21 md.variables.cdv(end+1)=continuous_design('drag',1,0.5,1.5);
    22 md.variables.csv=continuous_state.empty();
    23 md.variables.csv(end+1)=continuous_state('gravity',9.8);
     18md.qmu.variables=struct();
     19md.qmu.variables.cdv=continuous_design.empty();
     20md.qmu.variables.cdv(end+1)=continuous_design('thickness',1,0.9,1.1);
     21md.qmu.variables.cdv(end+1)=continuous_design('drag',1,0.5,1.5);
     22md.qmu.variables.csv=continuous_state.empty();
     23md.qmu.variables.csv(end+1)=continuous_state('gravity',9.8);
    2424
    2525%%  a variety of responses
    2626
    27 md.responses=struct();
    28 md.responses.lst=least_squares_term.empty();
    29 md.responses.lst(end+1)=least_squares_term('max_vx');
    30 md.responses.lst(end+1)=least_squares_term('max_vy');
     27md.qmu.responses=struct();
     28md.qmu.responses.lst=least_squares_term.empty();
     29md.qmu.responses.lst(end+1)=least_squares_term('max_vx');
     30md.qmu.responses.lst(end+1)=least_squares_term('max_vy');
    3131
    3232%%  a least-squares study
    3333
    34 md.qmu_method     =dakota_method('nl2sol');
    35 md.qmu_method(end)=dmeth_params_set(md.qmu_method(end),...
     34md.qmu.method     =dakota_method('nl2sol');
     35md.qmu.method(end)=dmeth_params_set(md.qmu.method(end),...
    3636    'max_iterations',10,...
    3737    'max_function_evaluations',50,...
    … …  
    4040%%  a variety of parameters
    4141
    42 md.qmu_params.evaluation_concurrency=4;
    43 md.qmu_params.analysis_driver='';
    44 md.qmu_params.analysis_components='';
    45 md.qmu_params.interval_type='forward';
    46 md.qmu_params.fd_gradient_step_size=0.01;
     42md.qmu.params.evaluation_concurrency=4;
     43md.qmu.params.analysis_driver='';
     44md.qmu.params.analysis_components='';
     45md.qmu.params.interval_type='forward';
     46md.qmu.params.fd_gradient_step_size=0.01;
    4747
    48 md.npart=10;
     48md.qmu.numberofpartitions=10;
    4949
    5050md.qmu

  • issm/trunk/src/m/qmu/examples/opt.m

    r4759 r9650  
    1616nonlinear_equality_constraint;
    1717
    18 md.variables=struct();
    19 md.variables.cdv=continuous_design.empty();
    20 md.variables.cdv(end+1)=continuous_design('thickness',1,0.9,1.1);
    21 md.variables.cdv(end+1)=continuous_design('drag',1,0.5,1.5);
    22 md.variables.csv=continuous_state.empty();
    23 md.variables.csv(end+1)=continuous_state('gravity',9.8);
     18md.qmu.variables=struct();
     19md.qmu.variables.cdv=continuous_design.empty();
     20md.qmu.variables.cdv(end+1)=continuous_design('thickness',1,0.9,1.1);
     21md.qmu.variables.cdv(end+1)=continuous_design('drag',1,0.5,1.5);
     22md.qmu.variables.csv=continuous_state.empty();
     23md.qmu.variables.csv(end+1)=continuous_state('gravity',9.8);
    2424
    2525%%  a variety of responses
    2626
    27 md.responses=struct();
    28 md.responses.of =objective_function.empty();
    29 md.responses.of (end+1)=objective_function('max_vel');
     27md.qmu.responses=struct();
     28md.qmu.responses.of =objective_function.empty();
     29md.qmu.responses.of (end+1)=objective_function('max_vel');
    3030
    3131%%  an optimization study
    3232
    33 md.qmu_method     =dakota_method('conmin_f');
    34 md.qmu_method(end)=dmeth_params_set(md.qmu_method(end),...
     33md.qmu.method     =dakota_method('conmin_f');
     34md.qmu.method(end)=dmeth_params_set(md.qmu.method(end),...
    3535    'max_iterations',10,...
    3636    'max_function_evaluations',50,...
    … …  
    3939%%  a variety of parameters
    4040
    41 md.qmu_params.evaluation_concurrency=4;
    42 md.qmu_params.analysis_driver='';
    43 md.qmu_params.analysis_components='';
    44 md.qmu_params.interval_type='forward';
    45 md.qmu_params.fd_gradient_step_size=0.01;
     41md.qmu.params.evaluation_concurrency=4;
     42md.qmu.params.analysis_driver='';
     43md.qmu.params.analysis_components='';
     44md.qmu.params.interval_type='forward';
     45md.qmu.params.fd_gradient_step_size=0.01;
    4646
    47 md.npart=10;
     47md.qmu.numberofpartitions=10;
    4848
    4949md.qmu

  • issm/trunk/src/m/qmu/examples/paramc.m

    r4759 r9650  
    1616nonlinear_equality_constraint;
    1717
    18 md.variables=struct();
    19 md.variables.nuv=normal_uncertain.empty();
    20 md.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85);
    21 md.variables.nuv(end+1)=normal_uncertain('rho_water',1023,51.15);
    22 md.variables.nuv(end+1)=normal_uncertain('heatcapacity',2009,100.45);
    23 md.variables.nuv(end+1)=normal_uncertain('thermalconductivity',2.2,0.11);
    24 md.variables.cdv=continuous_design.empty();
    25 md.variables.cdv(end+1)=continuous_design('thickness',1,0.9,1.1);
    26 md.variables.cdv(end+1)=continuous_design('drag',1,0.5,1.5);
    27 md.variables.csv=continuous_state.empty();
    28 md.variables.csv(end+1)=continuous_state('gravity',9.8);
     18md.qmu.variables=struct();
     19md.qmu.variables.nuv=normal_uncertain.empty();
     20md.qmu.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85);
     21md.qmu.variables.nuv(end+1)=normal_uncertain('rho_water',1023,51.15);
     22md.qmu.variables.nuv(end+1)=normal_uncertain('heatcapacity',2009,100.45);
     23md.qmu.variables.nuv(end+1)=normal_uncertain('thermalconductivity',2.2,0.11);
     24md.qmu.variables.cdv=continuous_design.empty();
     25md.qmu.variables.cdv(end+1)=continuous_design('thickness',1,0.9,1.1);
     26md.qmu.variables.cdv(end+1)=continuous_design('drag',1,0.5,1.5);
     27md.qmu.variables.csv=continuous_state.empty();
     28md.qmu.variables.csv(end+1)=continuous_state('gravity',9.8);
    2929
    3030%%  a variety of responses
    3131
    32 md.responses=struct();
    33 md.responses.rf =response_function.empty();
    34 md.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    35 md.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    36 md.responses.rf (end+1)=response_function('max_vel'   ,[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     32md.qmu.responses=struct();
     33md.qmu.responses.rf =response_function.empty();
     34md.qmu.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     35md.qmu.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     36md.qmu.responses.rf (end+1)=response_function('max_vel'   ,[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    3737
    3838%%  a parameter study
    3939
    40 md.qmu_method     =dakota_method('centered');
    41 md.qmu_method(end)=dmeth_params_set(md.qmu_method(end),...
     40md.qmu.method     =dakota_method('centered');
     41md.qmu.method(end)=dmeth_params_set(md.qmu.method(end),...
    4242    'percent_delta',10.,...
    4343    'deltas_per_variable',1);
    … …  
    4545%%  a variety of parameters
    4646
    47 md.qmu_params.evaluation_concurrency=4;
    48 md.qmu_params.analysis_driver='';
    49 md.qmu_params.analysis_components='';
     47md.qmu.params.evaluation_concurrency=4;
     48md.qmu.params.analysis_driver='';
     49md.qmu.params.analysis_components='';
    5050
    51 md.npart=10;
     51md.qmu.numberofpartitions=10;
    5252
    5353md.qmu

  • issm/trunk/src/m/qmu/examples/paramm.m

    r4759 r9650  
    1616nonlinear_equality_constraint;
    1717
    18 md.variables=struct();
    19 md.variables.nuv=normal_uncertain.empty();
    20 md.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85,900,1000);
    21 md.variables.nuv(end+1)=normal_uncertain('rho_water',1023,51.15,1000,1100);
     18md.qmu.variables=struct();
     19md.qmu.variables.nuv=normal_uncertain.empty();
     20md.qmu.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85,900,1000);
     21md.qmu.variables.nuv(end+1)=normal_uncertain('rho_water',1023,51.15,1000,1100);
    2222
    2323%%  a variety of responses
    2424
    25 md.responses=struct();
    26 md.responses.rf =response_function.empty();
    27 md.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    28 md.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    29 md.responses.rf (end+1)=response_function('max_vel'   ,[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     25md.qmu.responses=struct();
     26md.qmu.responses.rf =response_function.empty();
     27md.qmu.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     28md.qmu.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     29md.qmu.responses.rf (end+1)=response_function('max_vel'   ,[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    3030
    3131%%  a parameter study
    3232
    33 md.qmu_method     =dakota_method('multidim');
    34 md.qmu_method(end)=dmeth_params_set(md.qmu_method(end),...
     33md.qmu.method     =dakota_method('multidim');
     34md.qmu.method(end)=dmeth_params_set(md.qmu.method(end),...
    3535    'partitions',[4 4]);
    3636
    3737%%  a variety of parameters
    3838
    39 md.qmu_params.evaluation_concurrency=4;
    40 md.qmu_params.analysis_driver='';
    41 md.qmu_params.analysis_components='';
     39md.qmu.params.evaluation_concurrency=4;
     40md.qmu.params.analysis_driver='';
     41md.qmu.params.analysis_components='';
    4242
    43 md.npart=10;
     43md.qmu.numberofpartitions=10;
    4444
    4545md.qmu

  • issm/trunk/src/m/qmu/examples/samp.m

    r4759 r9650  
    1616nonlinear_equality_constraint;
    1717
    18 md.variables=struct();
    19 md.variables.nuv=normal_uncertain.empty();
    20 md.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85);
    21 md.variables.nuv(end+1)=normal_uncertain('rho_water',1023,51.15);
    22 md.variables.nuv(end+1)=normal_uncertain('heatcapacity',2009,100.45);
    23 md.variables.nuv(end+1)=normal_uncertain('thermalconductivity',2.2,0.11);
    24 md.variables.nuv(end+1)=normal_uncertain('gravity',9.8,0.49);
    25 md.variables.nuv(end+1)=normal_uncertain('thickness',1,0.05);
    26 md.variables.nuv(end+1)=normal_uncertain('drag',1,0.05);
     18md.qmu.variables=struct();
     19md.qmu.variables.nuv=normal_uncertain.empty();
     20md.qmu.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85);
     21md.qmu.variables.nuv(end+1)=normal_uncertain('rho_water',1023,51.15);
     22md.qmu.variables.nuv(end+1)=normal_uncertain('heatcapacity',2009,100.45);
     23md.qmu.variables.nuv(end+1)=normal_uncertain('thermalconductivity',2.2,0.11);
     24md.qmu.variables.nuv(end+1)=normal_uncertain('gravity',9.8,0.49);
     25md.qmu.variables.nuv(end+1)=normal_uncertain('thickness',1,0.05);
     26md.qmu.variables.nuv(end+1)=normal_uncertain('drag',1,0.05);
    2727
    2828%%  a variety of responses
    2929
    30 md.responses=struct();
    31 md.responses.rf =response_function.empty();
    32 md.responses.rf (end+1)=response_function('min_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    33 md.responses.rf (end+1)=response_function('max_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    34 md.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    35 md.responses.rf (end+1)=response_function('min_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    36 md.responses.rf (end+1)=response_function('max_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    37 md.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    38 md.responses.rf (end+1)=response_function('min_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    39 md.responses.rf (end+1)=response_function('max_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     30md.qmu.responses=struct();
     31md.qmu.responses.rf =response_function.empty();
     32md.qmu.responses.rf (end+1)=response_function('min_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     33md.qmu.responses.rf (end+1)=response_function('max_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     34md.qmu.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     35md.qmu.responses.rf (end+1)=response_function('min_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     36md.qmu.responses.rf (end+1)=response_function('max_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     37md.qmu.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     38md.qmu.responses.rf (end+1)=response_function('min_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     39md.qmu.responses.rf (end+1)=response_function('max_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    4040
    4141%%  nond_sampling study
    4242
    43 md.qmu_method     =dakota_method('nond_samp');
    44 md.qmu_method(end)=dmeth_params_set(md.qmu_method(end),...
     43md.qmu.method     =dakota_method('nond_samp');
     44md.qmu.method(end)=dmeth_params_set(md.qmu.method(end),...
    4545    'seed',1234,...
    4646    'samples',20,...
    … …  
    4949%%  a variety of parameters
    5050
    51 md.qmu_params.evaluation_concurrency=4;
    52 md.qmu_params.analysis_driver='';
    53 md.qmu_params.analysis_components='';
     51md.qmu.params.evaluation_concurrency=4;
     52md.qmu.params.analysis_driver='';
     53md.qmu.params.analysis_components='';
    5454
    55 md.npart=10;
     55md.qmu.numberofpartitions=10;
    5656
    5757md.qmu

  • issm/trunk/src/m/qmu/examples/samp_direct.m

    r4759 r9650  
    1616nonlinear_equality_constraint;
    1717
    18 md.variables=struct();
    19 md.variables.nuv=normal_uncertain.empty();
    20 md.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85);
    21 md.variables.nuv(end+1)=normal_uncertain('rho_water',1023,51.15);
    22 md.variables.nuv(end+1)=normal_uncertain('heatcapacity',2009,100.45);
    23 md.variables.nuv(end+1)=normal_uncertain('thermalconductivity',2.2,0.11);
    24 md.variables.nuv(end+1)=normal_uncertain('gravity',9.8,0.49);
    25 md.variables.nuv(end+1)=normal_uncertain('thickness',1,0.05);
    26 md.variables.nuv(end+1)=normal_uncertain('drag',1,0.05);
     18md.qmu.variables=struct();
     19md.qmu.variables.nuv=normal_uncertain.empty();
     20md.qmu.variables.nuv(end+1)=normal_uncertain('rho_ice',917,45.85);
     21md.qmu.variables.nuv(end+1)=normal_uncertain('rho_water',1023,51.15);
     22md.qmu.variables.nuv(end+1)=normal_uncertain('heatcapacity',2009,100.45);
     23md.qmu.variables.nuv(end+1)=normal_uncertain('thermalconductivity',2.2,0.11);
     24md.qmu.variables.nuv(end+1)=normal_uncertain('gravity',9.8,0.49);
     25md.qmu.variables.nuv(end+1)=normal_uncertain('thickness',1,0.05);
     26md.qmu.variables.nuv(end+1)=normal_uncertain('drag',1,0.05);
    2727
    2828%%  a variety of responses
    2929
    30 md.responses=struct();
    31 md.responses.rf =response_function.empty();
    32 md.responses.rf (end+1)=response_function('min_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    33 md.responses.rf (end+1)=response_function('max_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    34 md.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    35 md.responses.rf (end+1)=response_function('min_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    36 md.responses.rf (end+1)=response_function('max_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    37 md.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    38 md.responses.rf (end+1)=response_function('min_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    39 md.responses.rf (end+1)=response_function('max_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     30md.qmu.responses=struct();
     31md.qmu.responses.rf =response_function.empty();
     32md.qmu.responses.rf (end+1)=response_function('min_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     33md.qmu.responses.rf (end+1)=response_function('max_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     34md.qmu.responses.rf (end+1)=response_function('max_abs_vx',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     35md.qmu.responses.rf (end+1)=response_function('min_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     36md.qmu.responses.rf (end+1)=response_function('max_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     37md.qmu.responses.rf (end+1)=response_function('max_abs_vy',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     38md.qmu.responses.rf (end+1)=response_function('min_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
     39md.qmu.responses.rf (end+1)=response_function('max_vel',[],[0.0001 0.001 0.01 0.25 0.5 0.75 0.99 0.999 0.9999]);
    4040
    4141%%  nond_sampling study
    4242
    43 md.qmu_method     =dakota_method('nond_samp');
    44 md.qmu_method(end)=dmeth_params_set(md.qmu_method(end),...
     43md.qmu.method     =dakota_method('nond_samp');
     44md.qmu.method(end)=dmeth_params_set(md.qmu.method(end),...
    4545    'seed',1234,...
    4646    'samples',20,...
    … …  
    4949%%  a variety of parameters
    5050
    51 md.qmu_params.direct=true;
    52 md.qmu_params.analysis_driver='diagnostic';
    53 md.qmu_params.evaluation_concurrency=1;
     51md.qmu.params.direct=true;
     52md.qmu.params.analysis_driver='diagnostic';
     53md.qmu.params.evaluation_concurrency=1;
    5454
    55 md.npart=10;
     55md.qmu.numberofpartitions=10;
    5656
    5757md.qmu

  • issm/trunk/src/m/qmu/expandresponses.m

    r5487 r9650  
    1 function dresp=expandresponses(md,responses)
     1function dresp=expandresponses(md.qmu.responses)
    22
    33fnames=fieldnames(responses);

  • issm/trunk/src/m/qmu/expandvariables.m

    r5487 r9650  
    1 function dvar=expandvariables(md,variables)
     1function dvar=expandvariables(md.qmu.variables)
    22
    33fnames=fieldnames(variables);

  • issm/trunk/src/m/qmu/importancefactors.m

    r8298 r9650  
    1313
    1414%go through all response functions and find the one corresponding to the correct responsename
    15 responsefunctions=md.dakotaresults.dresp_out;
     15responsefunctions=md.qmu.results.dresp_out;
    1616found=0;
    1717for i=1:length(responsefunctions),
    … …  
    4747else
    4848        %distribute importance factor
    49         factors=importancefactors(md.part'+1); %md.part was created to index "c" style
     49        factors=importancefactors(md.qmu.partition'+1); %md.qmu.partition was created to index "c" style
    5050end
    5151

  • issm/trunk/src/m/qmu/postqmu.m

    r9630 r9650  
    4949
    5050%  move all the individual function evalutations into zip files
    51 if ~md.dakota_analysis,
     51if ~md.qmu.isdakota,
    5252        system('zip -mq params.in.zip params.in.[1-9]*');
    5353        system('zip -mq results.out.zip results.out.[1-9]*');

  • issm/trunk/src/m/qmu/preqmu.m

    r9625 r9650  
    3737
    3838%retrieve variables and resposnes for this particular analysis.
    39 variables=md.variables(options.ivar);
    40 responses=md.responses(options.iresp);
     39variables=md.qmu.variables(options.ivar);
     40responses=md.qmu.responses(options.iresp);
    4141
    4242%expand variables and responses
    43 variables=expandvariables(md,variables);
    44 responses=expandresponses(md,responses);
     43variables=expandvariables(md.qmu.variables);
     44responses=expandresponses(md.qmu.responses);
    4545
    46 %go through variables and responses, and check they don't have more than md.npart values. Also determine numvariables and numresponses{{{1
     46%go through variables and responses, and check they don't have more than md.qmu.numberofpartitions values. Also determine numvariables and numresponses{{{1
    4747numvariables=0;
    4848variable_fieldnames=fieldnames(variables);
    … …  
    5151        fieldvariables=variables.(field_name);
    5252        for j=1:numel(fieldvariables)
    53                 if strncmpi(fieldvariables(j).descriptor,'scaled_',7) && str2int(fieldvariables(j).descriptor,'last')>md.npart,
    54                         error('preqmu error message: one of the expanded variables has more values than the number of partitions (setup in md.npart)');
     53                if strncmpi(fieldvariables(j).descriptor,'scaled_',7) && str2int(fieldvariables(j).descriptor,'last')>md.qmu.numberofpartitions,
     54                        error('preqmu error message: one of the expanded variables has more values than the number of partitions (setup in md.qmu.numberofpartitions)');
    5555                end
    5656        end
    … …  
    6464        fieldresponses=responses.(field_name);
    6565        for j=1:numel(fieldresponses)
    66                 if strncmpi(fieldresponses(j).descriptor,'scaled_',7) && str2int(fieldresponses(j).descriptor,'last')>md.npart,
    67                         error('preqmu error message: one of the expanded responses has more values than the number of partitions (setup in md.npart)');
     66                if strncmpi(fieldresponses(j).descriptor,'scaled_',7) && str2int(fieldresponses(j).descriptor,'last')>md.qmu.numberofpartitions,
     67                        error('preqmu error message: one of the expanded responses has more values than the number of partitions (setup in md.qmu.numberofpartitions)');
    6868                end
    6969        end
    … …  
    7373
    7474%create in file for dakota
    75 dakota_in_data(md.qmu_method(options.imethod),variables,responses,md.qmu_params(options.iparams),options.qmufile);
     75dakota_in_data(md.qmu.method(options.imethod),variables,responses,md.qmu.params(options.iparams),options.qmufile);
    7676system(['rm -rf ' md.miscellaneous.name '.m']);
    7777
    7878%build a list of variables and responses descriptors. the list is not expanded. {{{1
    7979variabledescriptors={};
    80 variable_fieldnames=fieldnames(md.variables(options.ivar));
     80variable_fieldnames=fieldnames(md.qmu.variables(options.ivar));
    8181for i=1:length(variable_fieldnames),
    8282        field_name=variable_fieldnames{i};
    83         fieldvariables=md.variables(options.ivar).(field_name);
     83        fieldvariables=md.qmu.variables(options.ivar).(field_name);
    8484        for j=1:numel(fieldvariables)
    8585                variabledescriptors{end+1}=fieldvariables(j).descriptor;
    … …  
    8888
    8989responsedescriptors={};
    90 response_fieldnames=fieldnames(md.responses(options.iresp));
     90response_fieldnames=fieldnames(md.qmu.responses(options.iresp));
    9191for i=1:length(response_fieldnames),
    9292        field_name=response_fieldnames{i};
    93         fieldresponses=md.responses(options.iresp).(field_name);
     93        fieldresponses=md.qmu.responses(options.iresp).(field_name);
    9494        for j=1:numel(fieldresponses)
    9595                responsedescriptors{end+1}=fieldresponses(j).descriptor;
    … …  
    9999
    100100%register the fields that will be needed by the Qmu model.
    101 md.numberofresponses=numresponses;
    102 md.variabledescriptors=variabledescriptors;
    103 md.responsedescriptors=responsedescriptors;
     101md.qmu.numberofresponses=numresponses;
     102md.qmu.variabledescriptors=variabledescriptors;
     103md.qmu.responsedescriptors=responsedescriptors;
    104104
    105105%now, we have to provide all the info necessary for the solutions to compute the responses. For ex, if mass_flux

  • issm/trunk/src/m/qmu/process_qmu_response_data.m

    r8936 r9650  
    1313
    1414%loop through response descriptors, and act accordingly
    15 for i=1:numel(md.responsedescriptors),
     15for i=1:numel(md.qmu.responsedescriptors),
    1616
    1717        %Do we have to process  mass flux profiles?
    18         if strncmpi(md.responsedescriptors{i},'indexed_MassFlux',16),
     18        if strncmpi(md.qmu.responsedescriptors{i},'indexed_MassFlux',16),
    1919                num_mass_flux=num_mass_flux+1;
    2020                process_mass_flux_profiles=1;
    … …  
    2727
    2828        %we need a profile of points on which to compute the mass_flux, is it here?
    29         if isnans(md.qmu_mass_flux_profiles),
     29        if isnans(md.qmu.mass_flux_profiles),
    3030                error('process_qmu_response_data error message: could not find a mass_flux exp profile!');
    3131        end
    3232       
    33         if ~iscell(md.qmu_mass_flux_profiles),
     33        if ~iscell(md.qmu.mass_flux_profiles),
    3434                error('process_qmu_response_data error message: qmu_mass_flux_profiles field should be a cell array of domain outline names');
    3535        end
    3636
    37         if isempty(md.qmu_mass_flux_profiles),
     37        if isempty(md.qmu.mass_flux_profiles),
    3838                error('process_qmu_response_data error message: qmu_mass_flux_profiles cannot be empty!');
    3939        end
    4040
    41         if num_mass_flux~=numel(md.qmu_mass_flux_profiles),
     41        if num_mass_flux~=numel(md.qmu.mass_flux_profiles),
    4242                error('process_qmu_response_data error message: qmu_mass_flux_profiles should be of the same size as the number of MassFlux responses asked for in the Qmu analysis');
    4343        end
    4444
    4545        %ok, process the domains named in qmu_mass_flux_profiles,  to build a list of segments (MatArray)
    46         md.qmu_mass_flux_segments=cell(num_mass_flux,1);
     46        md.qmu.mass_flux_segments=cell(num_mass_flux,1);
    4747
    4848        for i=1:num_mass_flux,
    49                 md.qmu_mass_flux_segments{i}=MeshProfileIntersection(md.elements,md.x,md.y,[md.qmu_mass_flux_profile_directory '/' md.qmu_mass_flux_profiles{i}]);
     49                md.qmu.mass_flux_segments{i}=MeshProfileIntersection(md.elements,md.x,md.y,[md.qmu.mass_flux_profile_directory '/' md.qmu.mass_flux_profiles{i}]);
    5050        end
    5151

  • issm/trunk/src/m/qmu/qmu_correlation.m

    r9610 r9650  
    99%      mass_flux_drag_correlation=qmu_correlation(md,'drag','mass_flux');
    1010
    11 if ~isfield(md.dakotaresults,'dresp_dat'),
     11if ~isfield(md.qmu.results,'dresp_dat'),
    1212        error('qmu_correlation error message: could not find dresp_dat field in dakota results. you need to run montecarlo before computing correlations');
    1313end
    1414       
    15 data=md.dakotaresults.dresp_dat;
     15data=md.qmu.results.dresp_dat;
    1616
    1717%go through all the rows and figure which one we are interested in.

  • issm/trunk/src/m/qmu/qmumarshall.m

    r9625 r9650  
    1 function qmumarshall(md,variables,responses)
     1function qmumarshall(md.qmu.variables,responses)
    22%QMUMARSHALL - output ISSM compatible binary file with qmu fields. This is
    33%   in addition to the marshall routine for regular solve routines.
    44%   Usage:
    5 %      qmumarshall(md,variables,responses)
     5%      qmumarshall(md.qmu.variables,responses)
    66%
    77%   where variables and responses are the Dakota variables and responses found in the model @md.
    … …  
    2424WriteData(fid,md.numvariabledescriptors,'Integer','numvariabledescriptors');
    2525for i=1:md.numvariabledescriptors,
    26         field_name=md.variabledescriptors{i};
     26        field_name=md.qmu.variabledescriptors{i};
    2727        WriteData(fid,field_name,'String',['variabledescriptor' num2str(i)]);
    2828end
    … …  
    3131
    3232%write number of responses to disk
    33 WriteData(fid,md.numberofresponses,'Integer','numberofresponses');
    34 WriteData(fid,md.numresponsedescriptors,'Integer','numresponsedescriptors');
    35 for i=1:md.numresponsedescriptors,
    36         field_name=md.responsedescriptors{i};
     33WriteData(fid,md.qmu.numberofresponses,'Integer','numberofresponses');
     34WriteData(fid,md.qmu.numresponsedescriptors,'Integer','numresponsedescriptors');
     35for i=1:md.qmu.numresponsedescriptors,
     36        field_name=md.qmu.responsedescriptors{i};
    3737        WriteData(fid,field_name,'String',['responsedescriptor' num2str(i)]);
    3838end
    … …  
    4141qmu_segments=0;
    4242
    43 for i=1:numel(md.responsedescriptors),
    44         field_name=md.responsedescriptors{i};
     43for i=1:numel(md.qmu.responsedescriptors),
     44        field_name=md.qmu.responsedescriptors{i};
    4545        if strncmpi(field_name,'indexed_MassFlux',16),
    4646                qmu_segments=1;
    … …  
    4949                       
    5050if qmu_segments,
    51         WriteData(fid,md.qmu_mass_flux_num_profiles,'Integer','qmu_mass_flux_num_profiles');
    52         for i=1:md.qmu_mass_flux_num_profiles,
    53                 WriteData(fid,md.qmu_mass_flux_segments{i},'Mat',['qmu_mass_flux_segments' num2str(i)]);
     51        WriteData(fid,md.qmu.mass_flux_num_profiles,'Integer','qmu_mass_flux_num_profiles');
     52        for i=1:md.qmu.mass_flux_num_profiles,
     53                WriteData(fid,md.qmu.mass_flux_segments{i},'Mat',['qmu_mass_flux_segments' num2str(i)]);
    5454        end
    5555else
    56         md.qmu_mass_flux_num_profiles=0;
    57         WriteData(fid,md.qmu_mass_flux_num_profiles,'Integer','qmu_mass_flux_num_profiles');
     56        md.qmu.mass_flux_num_profiles=0;
     57        WriteData(fid,md.qmu.mass_flux_num_profiles,'Integer','qmu_mass_flux_num_profiles');
    5858end
    5959
    6060
    6161%write part and npart to disk
    62 WriteData(fid,md.npart,'Integer','npart');
    63 WriteData(fid,md.part,'Mat','part');
     62WriteData(fid,md.qmu.numberofpartitions,'Integer','npart');
     63WriteData(fid,md.qmu.partition,'Mat','part');
    6464
    6565%close file
    … …  
    7373function qmumarshallusage();
    7474disp(' ');
    75 disp('function qmumarshall(md,variables,responses)');
     75disp('function qmumarshall(md.qmu.variables,responses)');
    7676end

  • issm/trunk/src/m/qmu/sensitivities.m

    r5244 r9650  
    1313
    1414%go through all response functions and find the one corresponding to the correct responsename
    15 responsefunctions=md.dakotaresults.dresp_out;
     15responsefunctions=md.qmu.results.dresp_out;
    1616found=0;
    1717for i=1:length(responsefunctions),
    … …  
    6363else
    6464        %project the sensitivities from the partition onto the mesh
    65         sens=rawsens(md.part'+1); %md.part was created to index "c" style
     65        sens=rawsens(md.qmu.partition'+1); %md.qmu.partition was created to index "c" style
    6666end

  • issm/trunk/src/m/qmu/setupdesign/QmuSetupResponses.m

    r5485 r9650  
    1414        %partitions we want
    1515
    16         for j=1:md.npart
     16        for j=1:md.qmu.numberofpartitions
    1717                dresp(end+1)           =responses;
    1818                dresp(end  ).descriptor=sprintf('%s_%d',responses.descriptor,j);

  • issm/trunk/src/m/qmu/setupdesign/QmuSetupVariables.m

    r7550 r9650  
    1313
    1414        if isa(variables,'uniform_uncertain'),
    15                 if (length(variables.lower)>md.npart || length(variables.upper)>md.npart)
     15                if (length(variables.lower)>md.qmu.numberofpartitions || length(variables.upper)>md.qmu.numberofpartitions)
    1616                        error('QmuSetupDesign error message: stddev should be either a scalar or a ''npart'' length vector');
    1717                end
    1818        elseif isa(variables,'normal_uncertain'),
    19                 if length(variables.stddev)>md.npart,
     19                if length(variables.stddev)>md.qmu.numberofpartitions,
    2020                        error('QmuSetupDesign error message: stddev should be either a scalar or a ''npart'' length vector');
    2121                end
    … …  
    2525        %partitions we want
    2626
    27         for j=1:md.npart
     27        for j=1:md.qmu.numberofpartitions
    2828                dvar(end+1)           =variables;
    2929                dvar(end  ).descriptor=sprintf('%s_%d',variables.descriptor,j);

  • issm/trunk/src/m/solutions/diagnostic_core.m

    r9578 r9650  
    1515        ismacayealpattyn=femmodel.parameters.Ismacayealpattyn;
    1616        isstokes=femmodel.parameters.Isstokes;
    17         dakota_analysis=femmodel.parameters.DakotaAnalysis;
     17        dakota_analysis=femmodel.parameters.QmuIsdakota;
    1818        control_analysis=femmodel.parameters.ControlAnalysis;
    1919        solution_type=femmodel.parameters.SolutionType;

  • issm/trunk/src/m/solutions/flaim.m

    r9625 r9650  
    8080
    8181display('Calling KMLMeshWrite.');
    82 KMLMeshWrite(md.miscellaneous.name,md.miscellaneous.notes,md.elements,md.nodeconnectivity,md.lat,md.long,md.part,md.flaim.criterion,options.cmap,filekml);
     82KMLMeshWrite(md.miscellaneous.name,md.miscellaneous.notes,md.elements,md.nodeconnectivity,md.lat,md.long,md.qmu.partition,md.flaim.criterion,options.cmap,filekml);
    8383%  for testing
    8484%filekml='issm-split-geikie1-targets.kml';

  • issm/trunk/src/m/solutions/issm.m

    r9625 r9650  
    2222
    2323        %retrieve parameters
    24         dakota_analysis=femmodel.parameters.DakotaAnalysis;
     24        dakota_analysis=femmodel.parameters.QmuIsdakota;
    2525        control_analysis=femmodel.parameters.ControlAnalysis;
    2626

  • issm/trunk/src/mex/DakotaResponses/DakotaResponses.cpp

    r8910 r9650  
    3939
    4040        /*number of responses: */
    41         parameters->FindParam(&numresponses,QmuNumberOfResponsesEnum);
     41        parameters->FindParam(&numresponses,QmuNumberofresponsesEnum);
    4242       
    4343        /*dakota input: */

  • issm/trunk/template

    r9647 r9650  
    138138        thickness_obs
    139139}}}
    140 qmu{{{
    141         variables
    142         responses
    143         qmu_method -> remove all qmu_
    144         qmu_params
    145         dakotaresults ->results
    146         qmu_analysis -> isqmu
    147         part ->partition
    148         npart -> numberofpartitions
    149         numberofresponses
    150         variabledescriptors
    151         responsedescriptors
    152         qmu_mass_flux_profile_directory
    153         qmu_mass_flux_profiles
    154         qmu_mass_flux_segments
    155 
    156         adjacency
    157         vwgt -> vertex_weight
    158 }}}
    159140
    160141%To be completed
Note: See TracChangeset for help on using the changeset viewer.