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.