Changeset 4974


Ignore:
Timestamp:
08/04/10 12:01:29 (15 years ago)
Author:
Eric.Larour
Message:

New conversion of unites for MassFlux, Misfit and all the MaxVel, MinVel, etc ... modules.

Location:
issm/trunk
Files:
40 edited

Legend:

Unmodified
Added
Removed

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

    r4573 r4974  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void CostFunctionx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     13void CostFunctionx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1414
    1515        /*Intermediary*/
    … …  
    2222        double J=0;
    2323        double J_sum;
    24        
     24
    2525        /*Compute surface area: */
    2626        SurfaceAreax(&S,elements,nodes,vertices, loads,materials,parameters);
    … …  
    3535        for (i=0;i<elements->Size();i++){
    3636                element=(Element*)elements->GetObjectByOffset(i);
    37                 J+=element->CostFunction();
     37                J+=element->CostFunction(process_units);
    3838        }
    3939

  • issm/trunk/src/c/modules/CostFunctionx/CostFunctionx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void CostFunctionx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void CostFunctionx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MISFITX_H */

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

    r4863 r4974  
    2020void DakotaResponsesx(double* responses,Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,char** responses_descriptors,int numresponses){
    2121
    22         int        i,j;
     22        int        i,j,k;
    2323        int        dummy;
    2424        int        counter;
    2525        extern int my_rank;
     26        bool       process_units = true;
    2627
    2728        /*intermediary: */
    … …  
    3637
    3738                if(strcmp(response_descriptor,"MinVel")==0){
    38                         MinVelx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     39                        MinVelx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    3940                }
    4041                else if(strcmp(response_descriptor,"MaxVel")==0){
    41                         MaxVelx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     42                        MaxVelx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    4243                }
    4344                else if(strcmp(response_descriptor,"MinVx")==0){
    44                         MinVxx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     45                        MinVxx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    4546                }
    4647                else if(strcmp(response_descriptor,"MaxVx")==0){
    47                         MaxVxx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     48                        MaxVxx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    4849                }
    4950                else if(strcmp(response_descriptor,"MaxAbsVx")==0){
    50                         MaxAbsVxx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     51                        MaxAbsVxx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    5152                }
    5253                else if(strcmp(response_descriptor,"MinVy")==0){
    53                         MinVyx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     54                        MinVyx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    5455                }
    5556                else if(strcmp(response_descriptor,"MaxVy")==0){
    56                         MaxVyx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     57                        MaxVyx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    5758                }
    5859                else if(strcmp(response_descriptor,"MaxAbsVy")==0){
    59                         MaxAbsVyx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     60                        MaxAbsVyx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    6061                }
    6162                else if(strcmp(response_descriptor,"MinVz")==0){
    62                         MinVzx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     63                        MinVzx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    6364                }
    6465                else if(strcmp(response_descriptor,"MaxVz")==0){
    65                         MaxVzx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     66                        MaxVzx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    6667                }
    6768                else if(strcmp(response_descriptor,"MaxAbsVz")==0){
    68                         MaxAbsVzx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     69                        MaxAbsVzx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    6970                }
    7071                else if(strcmp(response_descriptor,"Misfit")==0){
    71                         Misfitx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters);
     72                        Misfitx( &femmodel_response, elements,nodes, vertices, loads, materials, parameters,process_units);
    7273                }
    7374                else if(strlen(response_descriptor)>=8){
    … …  
    8586                                /*retrieve qmu_mass_flux_segments: */
    8687                                parameters->FindParam(&array,&M,&mdims_array,&ndims_array,QmuMassFluxSegmentsEnum);
    87 
     88       
    8889                                /*figure out counter after MassFlux: */
    8990                                sscanf(response_descriptor,"MassFlux%i",&counter);
    … …  
    9495
    9596                                /*call mass flux module: */
    96                                 MassFluxx(&femmodel_response,elements,nodes,vertices,loads,materials,parameters,segments,num_segments);
     97                                MassFluxx(&femmodel_response,elements,nodes,vertices,loads,materials,parameters,segments,num_segments,process_units);
    9798
    9899                                /*Free ressources:*/

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

    r4573 r4974  
    1010#include "../../EnumDefinitions/EnumDefinitions.h"
    1111
    12 void MassFluxx(double* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,  double* segments,int num_segments){
     12void MassFluxx(double* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials,Parameters* parameters,  double* segments,int num_segments,bool process_units){
    1313
    1414        int i,j;
    … …  
    3232                        if (element->Id()==element_id){
    3333                                /*We found the element which owns this segment, use it to compute the mass flux: */
    34                                 mass_flux+=element->MassFlux(segments+5*i+0);
     34                                mass_flux+=element->MassFlux(segments+5*i+0,process_units);
    3535                                break;
    3636                        }

  • issm/trunk/src/c/modules/MassFluxx/MassFluxx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MassFluxx(double* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,double* segments,int num_segments);
     12void MassFluxx(double* pmass_flux, Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,double* segments,int num_segments,bool process_units);
    1313
    1414

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

    r4573 r4974  
    1010#include "../SurfaceAreax/SurfaceAreax.h"
    1111
    12 void MaxAbsVxx( double* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     12void MaxAbsVxx( double* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    1515        double maxabsvx;
    1616        double node_maxabsvx;
    17         bool   process_units=true;
    1817        double element_maxabsvx;
    1918

  • issm/trunk/src/c/modules/MaxAbsVxx/MaxAbsVxx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MaxAbsVxx( double* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MaxAbsVxx( double* pmaxabsvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXABSVXX_H */

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

    r4573 r4974  
    1010#include "../SurfaceAreax/SurfaceAreax.h"
    1111
    12 void MaxAbsVyx( double* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     12void MaxAbsVyx( double* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    1515        double maxabsvy;
    1616        double node_maxabsvy;
    17         bool   process_units=true;
    1817        double element_maxabsvy;
    1918

  • issm/trunk/src/c/modules/MaxAbsVyx/MaxAbsVyx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MaxAbsVyx( double* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MaxAbsVyx( double* pmaxabsvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXABSVYX_H */

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

    r4573 r4974  
    1010#include "../SurfaceAreax/SurfaceAreax.h"
    1111
    12 void MaxAbsVzx( double* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     12void MaxAbsVzx( double* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    1515        double maxabsvz;
    1616        double node_maxabsvz;
    17         bool   process_units=true;
    1817        double element_maxabsvz;
    1918

  • issm/trunk/src/c/modules/MaxAbsVzx/MaxAbsVzx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MaxAbsVzx( double* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MaxAbsVzx( double* pmaxabsvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXABSVZX_H */

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

    r4573 r4974  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void MaxVelx( double* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     13void MaxVelx( double* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1414       
    1515        int i;
    1616        double maxvel;
    1717        double node_maxvel;
    18         bool   process_units=true;
    1918        double element_maxvel;
    2019

  • issm/trunk/src/c/modules/MaxVelx/MaxVelx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MaxVelx( double* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MaxVelx( double* pmaxvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXVELX_H */

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

    r4573 r4974  
    1010#include "../SurfaceAreax/SurfaceAreax.h"
    1111
    12 void MaxVxx( double* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     12void MaxVxx( double* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    1515        double maxvx;
    1616        double node_maxvx;
    17         bool   process_units=true;
    1817        double element_maxvx;
    1918

  • issm/trunk/src/c/modules/MaxVxx/MaxVxx.h

    r4236 r4974  
    99
    1010/* local prototypes: */
    11 void MaxVxx( double* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     11void MaxVxx( double* pmaxvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1212
    1313#endif  /* _MAXVXX_H */

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

    r4573 r4974  
    11/*!\file MaxVyx
    2  */
     2*/
    33
    44#include "./MaxVyx.h"
    … …  
    1010#include "../SurfaceAreax/SurfaceAreax.h"
    1111
    12 void MaxVyx( double* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
    13        
     12void MaxVyx( double* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
     13
    1414        int i;
    1515        double maxvy;
    1616        double node_maxvy;
    17         bool   process_units=true;
    1817        double element_maxvy;
    1918

  • issm/trunk/src/c/modules/MaxVyx/MaxVyx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MaxVyx( double* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MaxVyx( double* pmaxvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXVYX_H */

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

    r4573 r4974  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void MaxVzx( double* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     13void MaxVzx( double* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1414       
    1515        int i;
    1616        double maxvz;
    1717        double node_maxvz;
    18         bool   process_units=true;
    1918        double element_maxvz;
    2019

  • issm/trunk/src/c/modules/MaxVzx/MaxVzx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MaxVzx( double* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MaxVzx( double* pmaxvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MAXVZX_H */

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

    r4573 r4974  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void MinVelx( double* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     13void MinVelx( double* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1414       
    1515        int i;
    1616        double minvel;
    1717        double node_minvel;
    18         bool   process_units=true;
    1918        double element_minvel;
    2019

  • issm/trunk/src/c/modules/MinVelx/MinVelx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MinVelx( double* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MinVelx( double* pminvel, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MINVELX_H */

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

    r4573 r4974  
    1010#include "../SurfaceAreax/SurfaceAreax.h"
    1111
    12 void MinVxx( double* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     12void MinVxx( double* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    1515        double minvx;
    1616        double node_minvx;
    17         bool   process_units=true;
    1817        double element_minvx;
    1918

  • issm/trunk/src/c/modules/MinVxx/MinVxx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MinVxx( double* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MinVxx( double* pminvx, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MINVX_H */

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

    r4573 r4974  
    1010#include "../SurfaceAreax/SurfaceAreax.h"
    1111
    12 void MinVyx( double* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     12void MinVyx( double* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    1515        double minvy;
    1616        double node_minvy;
    17         bool   process_units=true;
    1817        double element_minvy;
    1918

  • issm/trunk/src/c/modules/MinVyx/MinVyx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MinVyx( double* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MinVyx( double* pminvy, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MINVYX_H */

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

    r4573 r4974  
    1010#include "../SurfaceAreax/SurfaceAreax.h"
    1111
    12 void MinVzx( double* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     12void MinVzx( double* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1313       
    1414        int i;
    1515        double minvz;
    1616        double node_minvz;
    17         bool   process_units=true;
    1817        double element_minvz;
    1918

  • issm/trunk/src/c/modules/MinVzx/MinVzx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void MinVzx( double* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void MinVzx( double* pminvz, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MINVZX_H */

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

    r4573 r4974  
    1111#include "../SurfaceAreax/SurfaceAreax.h"
    1212
    13 void Misfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters){
     13void Misfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials,Parameters* parameters,bool process_units){
    1414       
    1515        /*Intermediary*/
    … …  
    3535        for (i=0;i<elements->Size();i++){
    3636                element=(Element*)elements->GetObjectByOffset(i);
    37                 J+=element->Misfit();
     37                J+=element->Misfit(process_units);
    3838        }
    3939

  • issm/trunk/src/c/modules/Misfitx/Misfitx.h

    r4236 r4974  
    1010
    1111/* local prototypes: */
    12 void Misfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     12void Misfitx( double* pJ, Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units);
    1313
    1414#endif  /* _MISFITX_H */

  • issm/trunk/src/c/objects/Elements/Element.h

    r4970 r4974  
    4242                virtual void   GradjDrag(Vec gradient)=0;
    4343                virtual void   GradjB(Vec gradient)=0;
    44                 virtual double Misfit(void)=0;
    45                 virtual double CostFunction(void)=0;
     44                virtual double Misfit(bool process_units)=0;
     45                virtual double CostFunction(bool process_units)=0;
    4646                virtual double SurfaceArea(void)=0;
    4747                virtual void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum)=0;
    … …  
    4949                virtual void   ComputePressure(Vec p_g)=0;
    5050                virtual void   ComputeStrainRate(Vec eps)=0;
    51                 virtual double MassFlux(double* segment)=0;
     51                virtual double MassFlux(double* segment,bool process_units)=0;
    5252                virtual void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes)=0;
    5353                virtual void   PatchFill(int* pcount, Patch* patch)=0;

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

    r4970 r4974  
    667667/*}}}*/
    668668/*FUNCTION Penta::CostFunction {{{1*/
    669 double Penta::CostFunction(void){
     669double Penta::CostFunction(bool process_units){
    670670
    671671        double J;
    … …  
    698698                 * and compute CostFunction*/
    699699                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face).
    700                 J=tria->CostFunction();
     700                J=tria->CostFunction(process_units);
    701701                delete tria;
    702702                return J;
    … …  
    705705
    706706                tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face).
    707                 J=tria->CostFunction();
     707                J=tria->CostFunction(process_units);
    708708                delete tria;
    709709                return J;
    … …  
    11881188/*}}}*/
    11891189/*FUNCTION Penta::MassFlux {{{1*/
    1190 double Penta::MassFlux( double* segment){
     1190double Penta::MassFlux( double* segment,bool process_units){
    11911191        ISSMERROR(" not supported yet!");
    11921192}
    … …  
    15201520/*}}}*/
    15211521/*FUNCTION Penta::Misfit {{{1*/
    1522 double Penta::Misfit(void){
     1522double Penta::Misfit(bool process_units){
    15231523
    15241524        double J;
    … …  
    15511551                 * and compute Misfit*/
    15521552                tria=(Tria*)SpawnTria(0,1,2); //grids 0, 1 and 2 make the new tria (lower face).
    1553                 J=tria->Misfit();
     1553                J=tria->Misfit(process_units);
    15541554                delete tria;
    15551555                return J;
    … …  
    15581558
    15591559                tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face).
    1560                 J=tria->Misfit();
     1560                J=tria->Misfit(process_units);
    15611561                delete tria;
    15621562                return J;

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

    r4970 r4974  
    7171                void   Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
    7272                void   SetCurrentConfiguration(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
    73                 double CostFunction(void);
     73                double CostFunction(bool process_units);
    7474                void   CreateKMatrix(Mat Kgg);
    7575                void   CreatePVector(Vec pg);
    … …  
    9292                void   InputScale(int enum_type,double scale_factor);
    9393                void   InputToResult(int enum_type,int step,double time);
    94                 double MassFlux(double* segment);
     94                double MassFlux(double* segment,bool process_units);
    9595                void   MaxAbsVx(double* pmaxabsvx, bool process_units);
    9696                void   MaxAbsVy(double* pmaxabsvy, bool process_units);
    … …  
    104104                void   MinVy(double* pminvy, bool process_units);
    105105                void   MinVz(double* pminvz, bool process_units);
    106                 double Misfit(void);
     106                double Misfit(bool process_units);
    107107                void   PatchFill(int* pcount, Patch* patch);
    108108                void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);

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

    r4970 r4974  
    551551/*}}}*/
    552552/*FUNCTION Tria::CostFunction {{{1*/
    553 double Tria::CostFunction(void){
     553double Tria::CostFunction(bool process_units){
    554554
    555555        int i;
    … …  
    608608
    609609        /*First, get Misfit*/
    610         Jelem=Misfit();
    611 
    612           /* Get gaussian points and weights (make this a statically initialized list of points? fstd): */
    613           GaussTria( &num_gauss, &first_gauss_area_coord, &second_gauss_area_coord, &third_gauss_area_coord, &gauss_weights, 2);
     610        Jelem=Misfit(process_units);
     611
     612        /* Get gaussian points and weights (make this a statically initialized list of points? fstd): */
     613        GaussTria( &num_gauss, &first_gauss_area_coord, &second_gauss_area_coord, &third_gauss_area_coord, &gauss_weights, 2);
    614614
    615615        /* Start  looping on the number of gaussian points: */
    … …  
    13811381/*}}}*/
    13821382/*FUNCTION Tria::MassFlux {{{1*/
    1383 double Tria::MassFlux( double* segment){
     1383double Tria::MassFlux( double* segment,bool process_units){
    13841384
    13851385        int i;
    … …  
    14361436                                (ONETHIRD*(h1-h2)*(vy1-vy2)+0.5*h2*(vy1-vy2)+0.5*(h1-h2)*vy2+h2*vy2)*normal[1]
    14371437                                );
     1438
     1439        /*Process units: */
     1440        NodalValuesUnitConversion(&mass_flux,1,MassFluxEnum,this->parameters);
     1441
    14381442        return mass_flux;
    14391443}
    … …  
    17671771/*}}}*/
    17681772/*FUNCTION Tria::Misfit {{{1*/
    1769 double Tria::Misfit(void){
     1773double Tria::Misfit(bool process_units){
    17701774
    17711775        int i;
    … …  
    17871791        double obs_vx_list[numgrids];
    17881792        double obs_vy_list[numgrids];
     1793        double misfit_square_list[numgrids];
    17891794        double misfit_list[numgrids];
    17901795        double weights_list[numgrids];
    … …  
    18621867                        misfit_list[i]=0.5*(pow((vx_list[i]-obs_vx_list[i]),(double)2)+pow((vy_list[i]-obs_vy_list[i]),(double)2));
    18631868                }
     1869                /*Process units: */
     1870                if(process_units)NodalValuesUnitConversion(&misfit_list[0],numgrids,MisfitEnum,this->parameters);
     1871
    18641872        }
    18651873        else if(fit==1){
    … …  
    18781886                        misfit_list[i]=0.5*(scalex*pow((vx_list[i]-obs_vx_list[i]),2)+scaley*pow((vy_list[i]-obs_vy_list[i]),2));
    18791887                }
     1888
     1889                /*Process units: */
     1890                if(process_units)NodalValuesUnitConversion(&misfit_list[0],numgrids,MisfitEnum,this->parameters);
     1891
    18801892        }
    18811893        else if(fit==2){
    … …  
    18921904                        misfit_list[i]=4*pow(meanvel,(double)2)*pow(log(velocity_mag/obs_velocity_mag),(double)2);
    18931905                }
     1906               
     1907                /*Process units: */
     1908                if(process_units)NodalValuesUnitConversion(&misfit_list[0],numgrids,MisfitEnum,this->parameters);
     1909
    18941910        }
    18951911        else if(fit==3){
    1896                 /*We are using an spacially average absolute misfit:
     1912                /*We are using a spacially average absolute misfit:
    18971913                 *
    18981914                 *      1                    2              2
    … …  
    19001916                 *      S                obs            obs
    19011917                 */
    1902                 for (i=0;i<numgrids;i++){
    1903                         misfit_list[i]=sqrt(pow(vx_list[i]-obs_vx_list[i],2)+pow(vy_list[i]-obs_vx_list[i],2))/S;
    1904                 }
     1918                for (i=0;i<numgrids;i++) misfit_square_list[i]=pow(vx_list[i]-obs_vx_list[i],2)+pow(vy_list[i]-obs_vx_list[i],2);
     1919               
     1920                /*Process units: */
     1921                if(process_units)NodalValuesUnitConversion(&misfit_square_list[0],numgrids,MisfitEnum,this->parameters);
     1922       
     1923                /*Take the square root, and scale by surface: */
     1924                for (i=0;i<numgrids;i++)misfit_list[i]=pow(misfit_square_list[i],2)/S;
    19051925        }
    19061926        else if(fit==4){
    … …  
    19171937                          pow(log((fabs(vy_list[i])+epsvel)/(fabs(obs_vy_list[i])+epsvel)),(double)2) );
    19181938                }
     1939               
     1940                /*Process units: */
     1941                if(process_units)NodalValuesUnitConversion(&misfit_list[0],numgrids,MisfitEnum,this->parameters);
     1942
    19191943        }
    19201944        else{

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

    r4970 r4974  
    6868                void   Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
    6969                void   SetCurrentConfiguration(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
    70                 double CostFunction(void);
     70                double CostFunction(bool process_units);
    7171                void   CreateKMatrix(Mat Kgg);
    7272                void   CreatePVector(Vec pg);
    … …  
    9090                void   DeleteResults(void);
    9191                void   MaterialUpdateFromTemperature(void){ISSMERROR("not implemented yet");};
    92                 double MassFlux(double* segment);
     92                double MassFlux(double* segment,bool process_units);
    9393                void   MaxAbsVx(double* pmaxabsvx, bool process_units);
    9494                void   MaxAbsVy(double* pmaxabsvy, bool process_units);
    … …  
    102102                void   MinVy(double* pminvy, bool process_units);
    103103                void   MinVz(double* pminvz, bool process_units);
    104                 double Misfit(void);
     104                double Misfit(bool process_units);
    105105                void   PatchFill(int* pcount, Patch* patch);
    106106                void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);

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

    r4967 r4974  
    3737        bool  isstokes=false;
    3838        bool    conserve_loads=true;
     39        bool    process_units=false;
    3940       
    4041        /*Recover finite element model: */
    … …  
    6465        /*Compute misfit for this velocity field.*/
    6566        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,(int)fit[n],FitEnum);
    66         CostFunctionx( &J, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
     67        CostFunctionx( &J, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters,process_units);
    6768
    6869        /*Free ressources:*/

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

    r4573 r4974  
    1414        Materials* materials=NULL;
    1515        Parameters* parameters=NULL;
     16        bool process_units=false;
    1617
    1718        /* output datasets: */
    … …  
    3839
    3940        /*!Call core code: */
    40         CostFunctionx(&J, elements,nodes,vertices, loads,materials,parameters);
     41        CostFunctionx(&J, elements,nodes,vertices, loads,materials,parameters,process_units);
    4142
    4243        /*write output : */

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

    r4573 r4974  
    1414        Materials* materials=NULL;
    1515        Parameters* parameters=NULL;
     16        bool process_units=false;
    1617
    1718        double*  segments=NULL;
    … …  
    4243
    4344        /*!Compute mass flux along the profile: */
    44         MassFluxx(&mass_flux, elements,nodes,vertices,loads,materials,parameters,segments,num_segments);
     45        MassFluxx(&mass_flux, elements,nodes,vertices,loads,materials,parameters,segments,num_segments,process_units);
    4546
    4647

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

    r4573 r4974  
    1414        Materials* materials=NULL;
    1515        Parameters* parameters=NULL;
     16
     17        bool process_units=false;
    1618
    1719        /* output datasets: */
    … …  
    3840
    3941        /*!Call core code: */
    40         Misfitx(&J, elements,nodes,vertices,loads,materials,parameters);
     42        Misfitx(&J, elements,nodes,vertices,loads,materials,parameters,process_units);
    4143
    4244        /*write output : */

  • issm/trunk/test/Verification/test28_IceSheetIceFrontM2dDakotaPartition/Square.par

    r4612 r4974  
    3838md.waitonlock=30;
    3939
     40%spc everything
     41md.spcvelocity(:,1:3)=1;
     42md.spcvelocity(:,4)=0;
     43md.spcvelocity(:,5)=100;
     44md.spcvelocity(:,6)=0;
    4045
    4146%Dakota:

  • issm/trunk/test/Verification/test28_IceSheetIceFrontM2dDakotaPartition/testpostsolve.m

    r4794 r4974  
    11md=tres(md,'dakota');
    2 md.results.dakota.importancefactors=importancefactors(md,'DragCoefficient','MaxVel')';
     2%md.results.dakota.importancefactors=importancefactors(md,'DragCoefficient','MaxVel')';
Note: See TracChangeset for help on using the changeset viewer.