Changeset 19791


Ignore:
Timestamp:
11/23/15 10:31:37 (9 years ago)
Author:
Eric.Larour
Message:

CHG: finished implementation of the marshall routine ,based on writing to a typed array buffer. No file
i/o involved at this point. Fake memory based file i/o is implemented in WriteData.js and used throughout the
classes marshall methods.

Location:
issm/trunk-jpl
Files:
1 added
35 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/m/classes/SMBforcing.js

    r19780 r19791  
    1313                fielddisplay(this,'requested_outputs','additional outputs requested');
    1414        } // }}}
     15        this.defaultoutputs = function(){ // {{{
     16                return '';
     17        }//}}}
     18this.classname = function(){ // {{{
     19        return "SMBforcing";
     20} // }}}
    1521                this.initialize = function(md) {// {{{
    1622
    … …  
    3238
    3339                } // }}}
     40                this.marshall=function(md,fid) { //{{{
     41
     42                        var yts=365.0*24.0*3600.0;
     43
     44                        WriteData(fid,'enum',SmbEnum(),'data',SMBforcingEnum(),'format','Integer');
     45                        WriteData(fid,'object',this,'class','smb','fieldname','mass_balance','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
     46                       
     47                        //process requested outputs
     48                        outputs = this.requested_outputs;
     49                        for (var i=0;i<outputs;i++){
     50                                if (outputs[i] == 'default') {
     51                                        outputs.splice(i,1);
     52                                        outputs.push(this.defaultoutputs());
     53                                }
     54                        }
     55                        WriteData(fid,'data',outputs,'enum',SmbRequestedOutputsEnum,'format','StringArray');
     56
     57                }//}}}
    3458        //properties
    3559        this.mass_balance = NaN;

  • issm/trunk-jpl/src/m/classes/autodiff.js

    r19787 r19791  
    3131
    3232        }// }}}
     33        this.classname= function(){// {{{
     34                return "autodiff";
     35        }// }}}
    3336                this.checkconsistency = function(md,solution,analyses){ //{{{
    3437
    … …  
    5760                        }
    5861                } // }}}
     62                this.marshall=function(md,fid) { //{{{
     63
     64                        WriteData(fid,'object',this,'fieldname','isautodiff','format','Boolean');
     65                        WriteData(fid,'object',this,'fieldname','driver','format','String');
     66
     67                        //early return
     68                        if (!this.isautodiff){
     69                                WriteData(fid,'data',false,'enum',AutodiffMassFluxSegmentsPresentEnum(),'format','Boolean');
     70                                WriteData(fid,'data',false,'enum',AutodiffKeepEnum(),'format','Boolean');
     71                                return;
     72                        }
     73
     74                        //buffer sizes {{{
     75                        WriteData(fid,'object',this,'fieldname','obufsize','format','Double');
     76                        WriteData(fid,'object',this,'fieldname','lbufsize','format','Double');
     77                        WriteData(fid,'object',this,'fieldname','cbufsize','format','Double');
     78                        WriteData(fid,'object',this,'fieldname','tbufsize','format','Double');
     79                        WriteData(fid,'object',this,'fieldname','gcTriggerRatio','format','Double');
     80                        WriteData(fid,'object',this,'fieldname','gcTriggerMaxSize','format','Double');
     81                        //}}}
     82                        //process dependent variables {{{
     83                        num_dependent_objects=this.dependents.length;
     84                        WriteData(fid,'data',num_dependent_objects,'enum',AutodiffNumDependentObjectsEnum(),'format','Integer');
     85
     86                        if(num_dependent_objects){
     87                                var names=[];
     88                                types=NewArrayFill(num_dependent_objects,0);
     89                                indices=NewArrayFill(num_dependent_objects,0);
     90
     91                                for (var i=0;i<num_dependent_objects;i++){
     92                                        dep=this.dependents[i];
     93
     94                                        names.push(dep.name);
     95                                        types[i]=dep.typetoscalar();
     96                                        indices[i]=dep.index;
     97                                }
     98                                WriteData(fid,'data',names,'enum',AutodiffDependentObjectNamesEnum(),'format','StringArray');
     99                                WriteData(fid,'data',types,'enum',AutodiffDependentObjectTypesEnum(),'format','IntMat','mattype',3);
     100                                WriteData(fid,'data',indices,'enum',AutodiffDependentObjectIndicesEnum(),'format','IntMat','mattype',3);
     101                        }
     102                        //}}}
     103                        //process independent variables {{{
     104                        num_independent_objects=this.independents.length;
     105                        WriteData(fid,'data',num_independent_objects,'enum',AutodiffNumIndependentObjectsEnum(),'format','Integer');
     106
     107                        if(num_independent_objects){
     108                                names=NewArrayFill(num_independent_objects,0);
     109                                types=NewArrayFill(num_independent_objects,0);
     110
     111                                for (var i=0;i<num_independent_objects;i++){
     112                                        indep=this.independents[i];
     113
     114                                        names[i]=StringToEnum(indep.name);
     115                                        types[i]=indep.typetoscalar();
     116                                }
     117                                WriteData(fid,'data',names,'enum',AutodiffIndependentObjectNamesEnum(),'format','IntMat','mattype',3);
     118                                WriteData(fid,'data',types,'enum',AutodiffIndependentObjectTypesEnum(),'format','IntMat','mattype',3);
     119                        }
     120                        //}}}
     121                        //if driver is fos_forward, build index:  {{{
     122                        if (this.driver == 'fos_forward'){
     123                                var index=0;
     124
     125                                for (var i=0;i<num_independent_objects;i++){
     126                                        indep=this.independents[i];
     127                                        if (!(isNaN(indep.fos_forward_index))){
     128                                                index=index+indep.fos_forward_index;
     129                                                break;
     130                                        }
     131                                        else{
     132                                                if (indep.type=='scalar') index=index+1;
     133                                                else index=index+indep.nods;
     134                                        }
     135                                }
     136                                index=index-1; //get c-index numbering going
     137                                WriteData(fid,'data',index,'enum',AutodiffFosForwardIndexEnum(),'format','Integer');
     138                        }
     139                        //}}}
     140                        //if driver is fos_reverse, build index:  {{{
     141                        if (this.driver  == 'fos_reverse'){
     142                                var index=0;
     143
     144                                for (var i=0;i<num_dependent_objects;i++){
     145                                        dep=this.dependents[i];
     146                                        if (!(isNaN(dep.fos_reverse_index))){
     147                                                index=index+dep.fos_reverse_index;
     148                                                break;
     149                                        }
     150                                        else{
     151                                                if (dep.type =='scalar') index=index+1;
     152                                                else index=index+dep.nods;
     153                                        }
     154                                }
     155                                index=index-1; //get c-index numbering going
     156                                WriteData(fid,'data',index,'enum',AutodiffFosReverseIndexEnum(),'format','Integer');
     157                        }
     158                        //}}}
     159                        //if driver is fov_forward, build indices:  {{{
     160                        if (this.driver == 'fov_forward'){
     161                                var indices=0;
     162
     163                                for (var i=0;i<num_independent_objects;i++){
     164                                        indep=this.independents[i];
     165                                        if (!indep.fos_forward_index.length){
     166                                                indices=indices+indep.fov_forward_indices;
     167                                                break;
     168                                        }
     169                                        else{
     170                                                if (indep.type =='scalar') indices=indices+1;
     171                                                else indices=indices+indep.nods;
     172                                        }
     173                                }
     174                                indices=indices-1; //get c-indices numbering going
     175                                WriteData(fid,'data',indices,'enum',AutodiffFovForwardIndicesEnum(),'format','IntMat','mattype',3);
     176                        }
     177                        //}}}
     178                        //deal with mass fluxes:  {{{
     179                        mass_flux_segments=[];
     180                        for (var i=0;i<num_dependent_objects;i++){
     181                                dep=this.dependents[i];
     182                                if (dep.name =='MassFlux'){
     183                                        mass_flux_segments.push(dep.segments);
     184                                }
     185                        }
     186                        if (mass_flux_segments.length){
     187                                WriteData(fid,'data',mass_flux_segments,'enum',MassFluxSegmentsEnum(),'format','MatArray');
     188                                flag=true;
     189                        }
     190                        else flag=false;
     191                        WriteData(fid,'data',flag,'enum',AutodiffMassFluxSegmentsPresentEnum(),'format','Boolean');
     192                        //}}}
     193                        //deal with trace keep on: {{{
     194                        keep=false;
     195
     196                        //From ADOLC userdoc:
     197                        // The optional integer argument keep of trace on determines whether the numerical values of all active variables are
     198                        // recorded in a buffered temporary array or file called the taylor stack. This option takes effect if keep = 1 and
     199                        // prepares the scene for an immediately following gradient evaluation by a call to a routine implementing the reverse
     200                        // mode as described in the Section 4 and Section 5.
     201                        //
     202
     203                        if (this.driver.length<=3) keep=false; //there is no "_reverse" string within the driver string:
     204                        else{
     205                                if (this.driver.splice(4) == '_reverse') keep=true;
     206                                else keep=false;
     207                        }
     208                        WriteData(fid,'data',keep,'enum',AutodiffKeepEnum(),'format','Boolean');
     209                        //}}}
     210                }//}}}
    59211        //properties
    60212        // {{{

  • issm/trunk-jpl/src/m/classes/balancethickness.js

    r19787 r19791  
    2020
    2121        }// }}}
     22        this.classname= function(){// {{{
     23                return "balancethickness";
     24
     25        }// }}}
    2226                this.checkconsistency = function(md,solution,analyses){ // {{{
    2327                        //Early return
    … …  
    2933                        //checkfield(md,'fieldname','balancethickness.omega','size',[md.mesh.numberofvertices ,1],'NaN',1,'>=',0);
    3034                } //}}}
     35                this.marshall=function(md,fid) { //{{{
     36
     37                        var yts=365.0*24.0*3600.0;
     38
     39                        WriteData(fid,'object',this,'fieldname','spcthickness','format','DoubleMat','mattype',1);
     40                        WriteData(fid,'object',this,'fieldname','thickening_rate','format','DoubleMat','mattype',1,'scale',1./yts);
     41                        WriteData(fid,'object',this,'fieldname','stabilization','format','Integer');
     42                        WriteData(fid,'object',this,'fieldname','omega','format','DoubleMat','mattype',1);
     43
     44                }//}}}
    3145        //properties
    3246        // {{{

  • issm/trunk-jpl/src/m/classes/basalforcings.js

    r19780 r19791  
    1616                fielddisplay(this,'geothermalflux','geothermal heat flux [W/m^2]');
    1717
     18        } // }}}
     19        this.classname = function(){ // {{{
     20                return "basalforcings";
    1821        } // }}}
    1922                this.initialize = function (md){ // {{{
    … …  
    5154                        }
    5255                } // }}}
     56                this.marshall=function(md,fid) { //{{{
     57
     58                        var yts=365.0*24.0*3600.0;
     59
     60                        WriteData(fid,'enum',BasalforcingsEnum(),'data',FloatingMeltRateEnum(),'format','Integer');
     61                        WriteData(fid,'object',this,'fieldname','groundedice_melting_rate','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1)
     62                        WriteData(fid,'object',this,'fieldname','floatingice_melting_rate','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1)
     63                        WriteData(fid,'object',this,'fieldname','geothermalflux','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
     64                }//}}}
    5365        //properties
    5466        //{{{

  • issm/trunk-jpl/src/m/classes/calving.js

    r19787 r19791  
    2121
    2222        }// }}}
     23        this.classname= function(){// {{{
     24                return "calving";
     25        }// }}}
    2326        this.checkconsistency = function(md,solution,analyses) { // {{{
    2427                //Early return
    … …  
    3033                checkfield(md,'fieldname','calving.meltingrate(1:md.mesh.numberofvertices,:)','>=',0,'timeseries',1,'NaN',1);
    3134        } //}}}
     35                this.marshall=function(md,fid) { //{{{
     36                        yts=365.0*24.0*3600.0;
     37                        WriteData(fid,'enum',CalvingLawEnum(),'data',DefaultCalvingEnum(),'format','Integer');
     38                        WriteData(fid,'enum',LevelsetStabilizationEnum(),'data',this.stabilization,'format','Integer');
     39                        WriteData(fid,'enum',SpcLevelsetEnum(),'data',this.spclevelset,'format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
     40                        WriteData(fid,'object',this,'fieldname','calvingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
     41                        WriteData(fid,'object',this,'fieldname','meltingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
     42                }//}}}
    3243        //properties
    3344        // {{{

  • issm/trunk-jpl/src/m/classes/constants.js

    r19780 r19791  
    2929
    3030                } //}}}
     31                this.classname = function () { //{{{
     32                        return "constants";
     33
     34                } //}}}
    3135                this.checkconsistency = function(md,solution,analyses) {//% {{{
    3236
    … …  
    3741
    3842                } // }}}
     43                this.marshall=function(md,fid) { //{{{
     44                        WriteData(fid,'object',this,'fieldname','g','format','Double');
     45                        WriteData(fid,'object',this,'fieldname','yts','format','Double');
     46                        WriteData(fid,'object',this,'fieldname','referencetemperature','format','Double');
     47                }//}}}
    3948        //properties
    4049        // {{{

  • issm/trunk-jpl/src/m/classes/damage.js

    r19780 r19791  
    6262                }
    6363        }// }}}
     64        this.classname= function(){// {{{
     65                return "damage";
     66        }// }}}
    6467                this.checkconsistency = function(md,solution,analyses) { //{{{
    6568                       
    … …  
    8992                        }
    9093                } //}}}
     94                this.marshall=function(md,fid) { //{{{
     95               
     96                        WriteData(fid,'object',this,'fieldname','isdamage','format','Boolean');
     97                        if (this.isdamage){
     98                                WriteData(fid,'object',this,'fieldname','law','format','Integer');
     99                                WriteData(fid,'object',this,'fieldname','D','format','DoubleMat','mattype',1);
     100                                WriteData(fid,'object',this,'fieldname','spcdamage','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
     101                                WriteData(fid,'object',this,'fieldname','max_damage','format','Double');
     102
     103                                WriteData(fid,'object',this,'fieldname','stabilization','format','Integer');
     104                                WriteData(fid,'object',this,'fieldname','maxiter','format','Integer');
     105                                WriteData(fid,'enum',DamageElementinterpEnum(),'data',StringToEnum(this.elementinterp),'format','Integer');
     106                                WriteData(fid,'object',this,'fieldname','stress_threshold','format','Double');
     107                                WriteData(fid,'object',this,'fieldname','kappa','format','Double');
     108                                WriteData(fid,'object',this,'fieldname','c1','format','Double');
     109                                WriteData(fid,'object',this,'fieldname','c2','format','Double');
     110                                WriteData(fid,'object',this,'fieldname','c3','format','Double');
     111                                WriteData(fid,'object',this,'fieldname','c4','format','Double');
     112                                WriteData(fid,'object',this,'fieldname','healing','format','Double');
     113                                WriteData(fid,'object',this,'fieldname','equiv_stress','format','Integer');
     114                        }
     115
     116                        //process requested outputs
     117                        outputs = this.requested_outputs;
     118                        for (var i=0;i<outputs;i++){
     119                                if (outputs[i] == 'default') {
     120                                        outputs.splice(i,1);
     121                                        outputs.push(this.defaultoutputs(md));
     122                                }
     123                        }
     124                        if (this.isdamage){
     125                                WriteData(fid,'data',outputs,'enum',DamageEvolutionRequestedOutputsEnum,'format','StringArray');
     126                        }
     127
     128                }//}}}
     129                this.defaultoutputs = function(md){ //{{{
     130
     131                        if (md.domaintype() == '2Dhorizontal') return 'DamageDbar';
     132                        else return 'DamageD';
     133
     134                }//}}}
    91135        //properties
    92136        // {{{

  • issm/trunk-jpl/src/m/classes/debug.js

    r19753 r19791  
    77        //methods
    88        this.setdefaultparameters = function(){// {{{
     9        }// }}}
     10        this.classname= function(){// {{{
     11                return "debug";
    912        }// }}}
    1013        this.disp= function(){// {{{
    … …  
    1720
    1821        }// }}}
     22                this.marshall=function(md,fid) { //{{{
     23                        WriteData(fid,'object',this,'fieldname','profiling','format','Boolean');
     24                }//}}}
    1925        //properties
    2026        // {{{

  • issm/trunk-jpl/src/m/classes/flowequation.js

    r19780 r19791  
    3232                fielddisplay(this,'borderHO',"vertices on HO's border (for tiling)");
    3333                fielddisplay(this,'borderFS',"vertices on FS' border (for tiling)");
     34
     35        }// }}}
     36        this.classname= function(){// {{{
     37                return "flowequation";
    3438
    3539        }// }}}
    … …  
    8690                        }
    8791                } // }}}
     92                this.marshall=function(md,fid) { //{{{
     93                        WriteData(fid,'object',this,'fieldname','isSIA','format','Boolean');
     94                        WriteData(fid,'object',this,'fieldname','isSSA','format','Boolean');
     95                        WriteData(fid,'object',this,'fieldname','isL1L2','format','Boolean');
     96                        WriteData(fid,'object',this,'fieldname','isHO','format','Boolean');
     97                        WriteData(fid,'object',this,'fieldname','isFS','format','Boolean');
     98                        WriteData(fid,'enum',FlowequationFeSSAEnum(),'data',StringToEnum(this.fe_SSA),'format','Integer');
     99                        WriteData(fid,'enum',FlowequationFeHOEnum() ,'data',StringToEnum(this.fe_HO) ,'format','Integer');
     100                        WriteData(fid,'enum',FlowequationFeFSEnum() ,'data',StringToEnum(this.fe_FS) ,'format','Integer');
     101                        WriteData(fid,'enum',AugmentedLagrangianREnum(),'data',this.augmented_lagrangian_r ,'format','Double');
     102                        WriteData(fid,'enum',AugmentedLagrangianRhopEnum(),'data',this.augmented_lagrangian_rhop ,'format','Double');
     103                        WriteData(fid,'enum',AugmentedLagrangianRlambdaEnum(),'data',this.augmented_lagrangian_rlambda ,'format','Double');
     104                        WriteData(fid,'enum',AugmentedLagrangianRholambdaEnum(),'data',this.augmented_lagrangian_rholambda ,'format','Double');
     105                        WriteData(fid,'enum',AugmentedLagrangianThetaEnum() ,'data',this.XTH_theta ,'format','Double');
     106                        WriteData(fid,'object',this,'fieldname','borderSSA','format','DoubleMat','mattype',1);
     107                        WriteData(fid,'object',this,'fieldname','borderHO','format','DoubleMat','mattype',1);
     108                        WriteData(fid,'object',this,'fieldname','borderFS','format','DoubleMat','mattype',1);
     109
     110                        //convert approximations to enums
     111                        data=this.vertex_equation;
     112                       
     113                        //some optimization:
     114                        noneap=NoneApproximationEnum();
     115                        siaap=SIAApproximationEnum();
     116                        ssaap=SSAApproximationEnum();
     117                        l1l2ap=L1L2ApproximationEnum();
     118                        hoap=HOApproximationEnum();
     119                        fsap=FSApproximationEnum();
     120                        ssahoap=SSAHOApproximationEnum();
     121                        hofsaap=HOFSApproximationEnum();
     122                        ssafsap=SSAFSApproximationEnum();
     123
     124                        for(var i=0;i<data.length;i++){
     125                                if(data[i]==0)data[i]=nonap;
     126                                if(data[i]==1) data[i]=siaap;
     127                                if(data[i]==2) data[i]=ssaap;
     128                                if(data[i]==3) data[i]=l1l2ap;
     129                                if(data[i]==4) data[i]=hoap;
     130                                if(data[i]==5) data[i]=fsap;
     131                                if(data[i]==6) data[i]=ssahoap;
     132                                if(data[i]==7) data[i]=hofsaap;
     133                                if(data[i]==8) data[i]=ssafsap;
     134                        }
     135                        WriteData(fid,'data',data,'enum',FlowequationVertexEquationEnum(),'format','DoubleMat','mattype',1);
     136
     137                        data=this.element_equation;
     138                        for(var i=0;i<data.length;i++){
     139                                if(data[i]==0) data[i]=nonap;
     140                                if(data[i]==1) data[i]=siaap;
     141                                if(data[i]==2) data[i]=ssaap;
     142                                if(data[i]==3) data[i]=l1l2ap;
     143                                if(data[i]==4) data[i]=hoap;
     144                                if(data[i]==5) data[i]=fsap;
     145                                if(data[i]==6) data[i]=ssahoap;
     146                                if(data[i]==7) data[i]=ssafsap;
     147                                if(data[i]==8) data[i]=hofsaap;
     148                        }
     149                        WriteData(fid,'data',data,'enum',FlowequationElementEquationEnum(),'format','DoubleMat','mattype',2);
     150
     151                }//}}}
    88152        //properties
    89153        // {{{

  • issm/trunk-jpl/src/m/classes/friction.js

    r19780 r19791  
    1515                fielddisplay(this,'q','q exponent');
    1616        } // }}}
     17        this.classname= function (){// {{{
     18                return "friction";
     19        } // }}}
    1720                this.checkconsistency = function(md,solution,analyses){ //{{{
    1821
    … …  
    2629
    2730                } // }}}
     31                this.marshall=function(md,fid) { //{{{
     32                        var yts=365.0*24.0*3600.0;
     33
     34                        WriteData(fid,'enum',FrictionLawEnum,'data',1,'format','Integer');
     35                        WriteData(fid,'object',this,'fieldname','coefficient','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
     36                        //WriteData(fid,'object',this,'fieldname','coefficient','format','DoubleMat','mattype',1);
     37                        WriteData(fid,'object',this,'fieldname','p','format','DoubleMat','mattype',2);
     38                        WriteData(fid,'object',this,'fieldname','q','format','DoubleMat','mattype',2);
     39                       
     40
     41                }//}}}
    2842        //properties
    2943        //{{{

  • issm/trunk-jpl/src/m/classes/geometry.js

    r19780 r19791  
    1515                        fielddisplay(this,'base','ice base elevation [m]');
    1616                        fielddisplay(this,'bed','bed elevation [m]');
     17                } //}}}
     18                this.classname = function () { //{{{
     19                        return 'geometry';
    1720                } //}}}
    1821                this.checkconsistency = function(md,solution,analyses) { //{{{
    … …  
    3639                        }
    3740                } // }}}
     41                this.marshall=function(md,fid) { //{{{
     42                        WriteData(fid,'data',this.surface,'format','DoubleMat','mattype',1,'enum',SurfaceEnum());
     43                        WriteData(fid,'data',this.thickness,'format','DoubleMat','mattype',1,'enum',ThicknessEnum(),'timeserieslength',md.mesh.numberofvertices+1);
     44                        WriteData(fid,'data',this.base,'format','DoubleMat','mattype',1,'enum',BaseEnum());
     45                        WriteData(fid,'data',this.bed,'format','DoubleMat','mattype',1,'enum',BedEnum());
     46                        WriteData(fid,'object',this,'fieldname','hydrostatic_ratio','format','DoubleMat','mattype',1);
     47                }//}}}
    3848        //properties
    3949        // {{{

  • issm/trunk-jpl/src/m/classes/gia.js

    r19787 r19791  
    1919                fielddisplay(this,'cross_section_shape','1: square-edged (default). 2: elliptical.  See iedge in GiaDeflectionCore');
    2020
     21        }// }}}
     22        this.classname= function(){// {{{
     23                return "gia";
    2124        }// }}}
    2225        this.checkconsistency = function(md,solution,analyses) { // {{{
    … …  
    4144                }
    4245        } // }}}
     46                this.marshall=function(md,fid) { //{{{
     47                        WriteData(fid,'object',this,'fieldname','mantle_viscosity','format','DoubleMat','mattype',1);
     48                        WriteData(fid,'object',this,'fieldname','lithosphere_thickness','format','DoubleMat','mattype',1,'scale',Math.pow(10,3)); //from km to m
     49                        WriteData(fid,'object',this,'fieldname','cross_section_shape','format','Integer');
     50                }//}}}
    4351        //properties
    4452        // {{{

  • issm/trunk-jpl/src/m/classes/groundingline.js

    r19787 r19791  
    1616
    1717
     18        }// }}}
     19        this.classname= function(){// {{{
     20                return "groundingline";
    1821        }// }}}
    1922                this.checkconsistency = function(md,solution,analyses) {// {{{
    … …  
    3740                        }
    3841                } // }}}
     42                this.marshall=function(md,fid) { //{{{
     43                        WriteData(fid,'data',StringToEnum(this.migration),'enum',GroundinglineMigrationEnum(),'format','Integer');
     44                }//}}}
    3945        //properties
    4046        // {{{

  • issm/trunk-jpl/src/m/classes/hydrologyshreve.js

    r19787 r19791  
    1212
    1313        }// }}}
    14         this.disp= function(){// {{{
     14                this.disp= function(){// {{{
    1515
    1616                console.log(sprintf('   hydrologyshreve solution parameters:'));
    … …  
    1919
    2020        }// }}}
     21                this.classname= function(){// {{{
     22                        return "hydrologyshreve";
     23
     24                }// }}}
    2125        this.type= function(){// {{{
    2226
    … …  
    3236
    3337                } // }}}
     38                this.marshall=function(md,fid) { //{{{
     39                        WriteData(fid,'enum',HydrologyModelEnum(),'data',HydrologyshreveEnum(),'format','Integer');
     40                        WriteData(fid,'object',this,'fieldname','spcwatercolumn','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
     41                        WriteData(fid,'object',this,'fieldname','stabilization','format','Double');
     42                }//}}}
    3443        //properties
    3544        // {{{

  • issm/trunk-jpl/src/m/classes/initialization.js

    r19780 r19791  
    8181                        }
    8282                } //}}}
     83                this.marshall=function(md,fid) { //{{{
     84
     85                        var yts=365.0*24.0*3600.0;
     86
     87                        WriteData(fid,'data',this.vx,'format','DoubleMat','mattype',1,'enum',VxEnum,'scale',1./yts);
     88                        WriteData(fid,'data',this.vy,'format','DoubleMat','mattype',1,'enum',VyEnum,'scale',1./yts);
     89                        WriteData(fid,'data',this.vz,'format','DoubleMat','mattype',1,'enum',VzEnum,'scale',1./yts);
     90                        WriteData(fid,'data',this.pressure,'format','DoubleMat','mattype',1,'enum',PressureEnum);
     91                        WriteData(fid,'data',this.temperature,'format','DoubleMat','mattype',1,'enum',TemperatureEnum);
     92                        WriteData(fid,'data',this.waterfraction,'format','DoubleMat','mattype',1,'enum',WaterfractionEnum);
     93                        WriteData(fid,'data',this.sediment_head,'format','DoubleMat','mattype',1,'enum',SedimentHeadEnum);
     94                        WriteData(fid,'data',this.epl_head,'format','DoubleMat','mattype',1,'enum',EplHeadEnum);
     95                        WriteData(fid,'data',this.epl_thickness,'format','DoubleMat','mattype',1,'enum',HydrologydcEplThicknessEnum);
     96                        WriteData(fid,'data',this.watercolumn,'format','DoubleMat','mattype',1,'enum',WatercolumnEnum);
     97
     98                        if (md.thermal.isenthalpy){
     99                                tpmp=NewArrayFill(md.mesh.numberofvertices,0);
     100                                for (var i=0;i<md.mesh.numberofvertices;i++) tpmp[i]= md.materials.meltingpoint - md.materials.beta*md.initialization.pressure[i];
     101                                enthalpy=NewArrayFill(md.mesh.numberofvertices,0);
     102                                for (var i=0;i<md.mesh.numberofvertices;i++)enthalpy[i] = md.materials.heatcapacity*(md.initialization.temperature[i]-md.constants.referencetemperature);
     103                               
     104                                for (var i=0;i<md.mesh.numberofvertices;i++)if(md.initialization.temperature[i]>=tpmp[i]){
     105                                        enthalpy[i] = md.materials.heatcapacity*(tpmp[i] - md.constants.referencetemperature) + md.materials.latentheat*md.initialization.waterfraction[i];
     106                                }
     107                                WriteData(fid,'data',enthalpy,'format','DoubleMat','mattype',1,'enum',EnthalpyEnum());
     108                        }
     109                }//}}}
    83110        //properties
    84111        // {{{

  • issm/trunk-jpl/src/m/classes/inversion.js

    r19787 r19791  
    7575
    7676        }// }}}
     77        this.classname= function(){// {{{
     78                return "inversion";
     79        }// }}}
    7780                this.checkconsistency = function(md,solution,analyses) { //{{{
    7881
    … …  
    113116                        }
    114117                } // }}}
     118                this.marshall=function(md,fid) { //{{{
     119
     120                        var yts=365.0*24.0*3600.0;
     121
     122                        WriteData(fid,'enum',InversionTypeEnum(),'data',0,'format','Integer');
     123                        WriteData(fid,'object',this,'fieldname','iscontrol','format','Boolean');
     124                        WriteData(fid,'object',this,'fieldname','incomplete_adjoint','format','Boolean');
     125                        if (!this.iscontrol) return;
     126                        WriteData(fid,'object',this,'fieldname','nsteps','format','Integer');
     127                        WriteData(fid,'object',this,'fieldname','maxiter_per_step','format','IntMat','mattype',3);
     128                        WriteData(fid,'object',this,'fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
     129                        WriteData(fid,'object',this,'fieldname','gradient_scaling','format','DoubleMat','mattype',3);
     130                        WriteData(fid,'object',this,'fieldname','cost_function_threshold','format','Double');
     131                        WriteData(fid,'object',this,'fieldname','min_parameters','format','DoubleMat','mattype',3);
     132                        WriteData(fid,'object',this,'fieldname','max_parameters','format','DoubleMat','mattype',3);
     133                        WriteData(fid,'object',this,'fieldname','step_threshold','format','DoubleMat','mattype',3);
     134                        WriteData(fid,'object',this,'fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
     135                        WriteData(fid,'object',this,'fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
     136                        WriteData(fid,'object',this,'fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
     137                        if(this.thickness_obs.length==md.mesh.numberofelements) mattype=2;
     138                        else mattype=1;
     139                        WriteData(fid,'object',this,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',mattype);
     140                        WriteData(fid,'object',this,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',mattype);
     141
     142
     143                        //process control parameters
     144                        num_control_parameters=this.control_parameters.length;
     145                        data=NewArrayFill(num_control_parameters,0);
     146                        for (var i=0;i<num_control_parameters;i++){
     147                                data[i]=StringToEnum(this.control_parameters[i]);
     148                        }
     149                        WriteData(fid,'data',data,'enum',InversionControlParametersEnum(),'format','DoubleMat','mattype',3);
     150                        WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum(),'format','Integer');
     151
     152                        //process cost functions
     153                        num_cost_functions=this.cost_functions[0].length;
     154                        data=marshallcostfunctions(this.cost_functions);
     155                        WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum(),'format','DoubleMat','mattype',3);
     156                        WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum(),'format','Integer');
     157                }//}}}
    115158        //properties
    116159        // {{{

  • issm/trunk-jpl/src/m/classes/mask.js

    r19780 r19791  
    1818                        fielddisplay(this,"groundedice_levelset","is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0");
    1919                        fielddisplay(this,"ice_levelset","presence of ice if < 0, icefront position if = 0, no ice if > 0");
     20                } //}}}
     21                this.classname = function () { //{{{
     22                        return "mask";
    2023                } //}}}
    2124                this.checkconsistency = function(md,solution,analyses){ //{{{
    … …  
    4851                        }
    4952                } // }}}
     53                this.marshall=function(md,fid) { //{{{
     54                        WriteData(fid,'object',this,'fieldname','groundedice_levelset','format','DoubleMat','mattype',1);
     55                        WriteData(fid,'object',this,'fieldname','ice_levelset','format','DoubleMat','mattype',1);
     56
     57                        // get mask of vertices of elements with ice
     58                        isice= NewArrayFill(md.mesh.numberofvertices,0);
     59                        for(var i=0;i<md.mesh.numberofvertices;i++)if(md.mask.ice_levelset[i]<=0)isice[i]=1;
     60                       
     61                        vlist = NewArrayFill(md.mesh.numberofvertices,0);
     62                        var pos=[];
     63                        for(var i=0;i<md.mesh.numberofelements;i++){
     64                                var sum=0;
     65                                for(var j=0;j<md.mesh.elements[0].length;j++){
     66                                        sum+=isice[md.mesh.elements[i][j]-1];
     67                                }
     68                                if(sum>0)pos.push(i);
     69                        }
     70                        for(var i=0;i<pos.length;i++){
     71                                for(var j=0;j<md.mesh.elements[0].length;j++){
     72                                        vlist[md.mesh.elements[pos[i]][j]-1]=1;
     73                                }
     74                        }
     75                        WriteData(fid,'data',vlist,'enum',IceMaskNodeActivationEnum(),'format','DoubleMat','mattype',1);
     76                }//}}}
    5077}

  • issm/trunk-jpl/src/m/classes/masstransport.js

    r19787 r19791  
    3838
    3939        }// }}}
     40        this.classname= function(){// {{{
     41                return "masstransport";
     42        }// }}}
    4043                this.checkconsistency = function (md,solution,analyses){  // {{{
    4144
    … …  
    5154
    5255                } // }}}
    53         //properties
     56                this.marshall=function(md,fid) { //{{{
     57
     58                        yts=365.*24.*3600.;
     59
     60                        WriteData(fid,'object',this,'fieldname','spcthickness','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
     61                        WriteData(fid,'object',this,'fieldname','isfreesurface','format','Boolean');
     62                        WriteData(fid,'object',this,'fieldname','min_thickness','format','Double');
     63                        WriteData(fid,'data',StringToEnum(this.hydrostatic_adjustment),'format','Integer','enum',MasstransportHydrostaticAdjustmentEnum());
     64                        WriteData(fid,'object',this,'fieldname','stabilization','format','Integer');
     65                        WriteData(fid,'object',this,'fieldname','vertex_pairing','format','DoubleMat','mattype',3);
     66                        WriteData(fid,'object',this,'fieldname','penalty_factor','format','Double');
     67
     68                        //process requested outputs
     69                        outputs = this.requested_outputs;
     70                        for (var i=0;i<outputs;i++){
     71                                if (outputs[i] == 'default') {
     72                                        outputs.splice(i,1);
     73                                        outputs.push(this.defaultoutputs());
     74                                }
     75                        }
     76                        WriteData(fid,'data',outputs,'enum',MasstransportRequestedOutputsEnum,'format','StringArray');
     77                }//}}}
     78                this.defaultoutputs = function(md) { //{{{
     79                        return ['Thickness','Surface','Base'];
     80                }//}}}
     81//properties
    5482        // {{{
    5583

  • issm/trunk-jpl/src/m/classes/matice.js

    r19780 r19791  
    7878                        fielddisplay(this,'mantle_density','Mantle density [g/cm^-3]');
    7979                } // }}}
     80                this.classname = function() {// {{{
     81                        return "matice";
     82                } // }}}
    8083                this.checkconsistency = function(md,solution,analyses) { // {{{
    8184                        checkfield(md,'fieldname','materials.rho_ice','>',0);
    … …  
    9598
    9699                } // }}}
     100                this.marshall=function(md,fid) { //{{{
     101                        WriteData(fid,'enum',MaterialsEnum(),'data',MaticeEnum(),'format','Integer');
     102                        WriteData(fid,'object',this,'class','materials','fieldname','rho_ice','format','Double');
     103                        WriteData(fid,'object',this,'class','materials','fieldname','rho_water','enum',MaterialsRhoSeawaterEnum(),'format','Double');
     104                        WriteData(fid,'object',this,'class','materials','fieldname','rho_freshwater','format','Double');
     105                        WriteData(fid,'object',this,'class','materials','fieldname','mu_water','format','Double');
     106                        WriteData(fid,'object',this,'class','materials','fieldname','heatcapacity','format','Double');
     107                        WriteData(fid,'object',this,'class','materials','fieldname','latentheat','format','Double');
     108                        WriteData(fid,'object',this,'class','materials','fieldname','thermalconductivity','format','Double');
     109                        WriteData(fid,'object',this,'class','materials','fieldname','temperateiceconductivity','format','Double');
     110                        WriteData(fid,'object',this,'class','materials','fieldname','meltingpoint','format','Double');
     111                        WriteData(fid,'object',this,'class','materials','fieldname','beta','format','Double');
     112                        WriteData(fid,'object',this,'class','materials','fieldname','mixed_layer_capacity','format','Double');
     113                        WriteData(fid,'object',this,'class','materials','fieldname','thermal_exchange_velocity','format','Double');
     114                        WriteData(fid,'object',this,'class','materials','fieldname','rheology_B','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
     115                        WriteData(fid,'object',this,'class','materials','fieldname','rheology_n','format','DoubleMat','mattype',2);
     116                        WriteData(fid,'data',StringToEnum(this.rheology_law),'enum',MaterialsRheologyLawEnum(),'format','Integer');
     117                        WriteData(fid,'object',this,'class','materials','fieldname','lithosphere_shear_modulus','format','Double');
     118                        WriteData(fid,'object',this,'class','materials','fieldname','lithosphere_density','format','Double','scale',10^3);
     119                        WriteData(fid,'object',this,'class','materials','fieldname','mantle_shear_modulus','format','Double');
     120                        WriteData(fid,'object',this,'class','materials','fieldname','mantle_density','format','Double','scale',10^3);
     121                }//}}}
    97122        //properties
    98123        // {{{

  • issm/trunk-jpl/src/m/classes/mesh2d.js

    r19780 r19791  
    4444                        fielddisplay(this,"epsg","EPSG code (ex: 3413 for UPS Greenland, 3031 for UPS Antarctica)");
    4545                } //}}}
     46                this.classname = function () { //{{{
     47                        return "mesh2d";
     48                } //}}}
    4649                this.domaintype=function (){ // {{{
    4750                        return '2Dhorizontal';
    … …  
    7578                        }
    7679                } // }}}
     80                this.marshall=function(md,fid) { //{{{
     81                        WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum('Domain' + this.domaintype()),'format','Integer');
     82                        WriteData(fid,'enum',DomainDimensionEnum(),'data',this.dimension(),'format','Integer');
     83                        WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(this.elementtype()),'format','Integer');
     84                        WriteData(fid,'object',this,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
     85                        WriteData(fid,'object',this,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
     86                        WriteData(fid,'enum',MeshZEnum(),'data',NewArrayFill(this.numberofvertices,0),'format','DoubleMat','mattype',1);
     87                        WriteData(fid,'object',this,'class','mesh','fieldname','elements','format','DoubleMat','mattype',2);
     88                        WriteData(fid,'object',this,'class','mesh','fieldname','numberofelements','format','Integer');
     89                        WriteData(fid,'object',this,'class','mesh','fieldname','numberofvertices','format','Integer');
     90                        WriteData(fid,'object',this,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
     91                        WriteData(fid,'object',this,'class','mesh','fieldname','vertexonboundary','format','DoubleMat','mattype',1);
     92                        WriteData(fid,'object',this,'class','mesh','fieldname','segments','format','DoubleMat','mattype',3);
     93                }//}}}
     94
    7795        //properties
    7896        // {{{

  • issm/trunk-jpl/src/m/classes/miscellaneous.js

    r19787 r19791  
    1717
    1818        }// }}}
     19        this.classname= function(){// {{{
     20                return "miscellaneous";
     21        }// }}}
    1922                this.checkconsistency= function(md,solution,analyses) {// {{{
    2023
    2124                        checkfield(md,'fieldname','miscellaneous.name','empty',1);
    2225                }// }}}
     26                this.marshall=function(md,fid) { //{{{
     27                        WriteData(fid,'object',this,'fieldname','name','format','String');
     28                }//}}}
    2329        //properties
    2430        // {{{

  • issm/trunk-jpl/src/m/classes/outputdefinition.js

    r19787 r19791  
    1515
    1616        }// }}}
     17        this.classname= function(){// {{{
     18                return "outputdefinition";
     19        }// }}}
    1720                this.checkconsistency = function(md,solution,analyses) { //{{{
    1821
    … …  
    2427
    2528                } // }}}
     29                this.marshall=function(md,fid) { //{{{
     30
     31                enums=NewArrayFill(this.definitions.length,0);
     32                for (var i=0;i<this.definitions.length;i++){
     33                        this.definitions[i].marshall(md,fid);
     34                        classdefinition=this.definitions[i].classname();
     35                        classdefinition=classdefinition.charAt(0).tuUpperCase() + classdefinition.slice(1); //so it matches our enums definitions.
     36                        enums[i]=StringToEnum(classdefinition);
     37                }
     38                enums=ArrayUnique(enums);
     39                WriteData(fid,'data',enums,'enum',OutputdefinitionListEnum(),'format','DoubleMat','mattype',1);
     40                }//}}}
    2641        //properties
    2742        // {{{

  • issm/trunk-jpl/src/m/classes/qmu.js

    r19787 r19791  
    9090
    9191        }// }}}
     92        this.classname= function(){// {{{
     93                return "qmu";
     94        }// }}}
    9295                this.checkconsistency = function(md,solution,analyses) { //{{{
    9396
    … …  
    97100
    98101                } // }}}
     102                this.marshall=function(md,fid) { //{{{
     103                        WriteData(fid,'object',this,'fieldname','isdakota','format','Boolean');
     104                        if (!this.isdakota){
     105                                WriteData(fid,'data',false,'enum',QmuMassFluxSegmentsPresentEnum,'format','Boolean');
     106                                return;
     107                        }
     108                        WriteData(fid,'object',this,'fieldname','partition','format','DoubleMat','mattype',2);
     109                        WriteData(fid,'object',this,'fieldname','numberofpartitions','format','Integer');
     110                        WriteData(fid,'object',this,'fieldname','numberofresponses','format','Integer');
     111                        WriteData(fid,'object',this,'fieldname','variabledescriptors','format','StringArray');
     112                        WriteData(fid,'object',this,'fieldname','responsedescriptors','format','StringArray');
     113                        if (this.mass_flux_segments.length){
     114                                WriteData(fid,'data',this.mass_flux_segments,'enum',MassFluxSegmentsEnum,'format','MatArray');
     115                                flag=true;
     116                        }
     117                        else flag=false;
     118                        WriteData(fid,'data',flag,'enum',QmuMassFluxSegmentsPresentEnum,'format','Boolean');
     119                }//}}}
    99120        //properties
    100121        // {{{

  • issm/trunk-jpl/src/m/classes/rifts.js

    r19787 r19791  
    77        //methods
    88        this.setdefaultparameters = function(){// {{{
     9        }// }}}
     10        this.classname= function(){// {{{
     11                return "rifts";
    912        }// }}}
    1013        this.disp= function(){// {{{
    … …  
    4245                        }
    4346                } //}}}
     47                this.marshall=function(md,fid) { //{{{
     48
     49                        //Process rift info
     50                        if ((this.riftstruct.length==0) | isNaN(this.riftstruct)){
     51                                numrifts=0;
     52                        }
     53                        else{
     54                                numrifts=this.riftstruct.length;
     55                        }
     56                        var numpairs=0;
     57                        for (var i=0;i<numrifts;i++){
     58                                numpairs=numpairs+this.riftstruct[i].penaltypairs.length;
     59                        }
     60
     61                        // 2 for nodes + 2 for elements+ 2 for  normals + 1 for length + 1 for fill + 1 for friction + 1 for fraction + 1 for fractionincrement + 1 for state.
     62                        data=Create2DArray(numpairs,12);
     63                        count=0;
     64                        for (var i=0;i<numrifts;i++){
     65                                numpairsforthisrift=this.riftstruct[i].penaltypairs.length;
     66                                for(var j=0;j<numpairsforthisrift;j++){
     67                                        for(var k=0;k<7;k++)data[count+j][k]=this.riftstruct[i].penaltypairs;
     68                                        data[count+j][7]=this.riftstruct[i].fill;
     69                                        data[count+j][8]=this.riftstruct[i].friction;
     70                                        data[count+j][9]=this.riftstruct[i].fraction;
     71                                        data[count+j][10]=this.riftstruct[i].fractionincrement;
     72                                        data[count+j][11]=this.riftstruct[i].state;
     73                                        count+=numpairsforthisrift;
     74                                }
     75                        }
     76                        WriteData(fid,'data',numrifts,'enum',RiftsNumriftsEnum(),'format','Integer');
     77                        WriteData(fid,'data',data,'enum',RiftsRiftstructEnum(),'format','DoubleMat','mattype',3);
     78                }//}}}
    4479        //properties
    4580        // {{{

  • issm/trunk-jpl/src/m/classes/settings.js

    r19787 r19791  
    3333
    3434        }// }}}
     35        this.classname= function(){// {{{
     36                return "settings";
     37
     38        }// }}}
    3539                this.checkconsistency = function(md,solution,analyses) { // {{{
    3640
    … …  
    4246                        checkfield(md,'fieldname','settings.waitonlock','numel',[1]);
    4347                } // }}}
     48                this.marshall=function(md,fid) { //{{{
     49                        WriteData(fid,'object',this,'fieldname','results_on_nodes','format','Boolean');
     50                        WriteData(fid,'object',this,'fieldname','io_gather','format','Boolean');
     51                        WriteData(fid,'object',this,'fieldname','lowmem','format','Boolean');
     52                        WriteData(fid,'object',this,'fieldname','output_frequency','format','Integer');
     53                        WriteData(fid,'object',this,'fieldname','recording_frequency','format','Integer');
     54                        if (this.waitonlock>0) WriteData(fid,'enum',SettingsWaitonlockEnum(),'data',true,'format','Boolean');
     55                        else WriteData(fid,'enum',SettingsWaitonlockEnum(),'data',false,'format','Boolean');
     56                }//}}}
    4457        //properties
    4558        // {{{

  • issm/trunk-jpl/src/m/classes/steadystate.js

    r19787 r19791  
    2828
    2929        }// }}}
     30        this.classname= function(){// {{{
     31                return "steadystate";
     32
     33        }// }}}
    3034        this.checkconsistency = function(md,solution,analyses) {// {{{
    3135
    … …  
    4246                }
    4347        } // }}}
     48                this.marshall=function(md,fid) { //{{{
     49                        WriteData(fid,'object',this,'fieldname','reltol','format','Double');
     50                        WriteData(fid,'object',this,'fieldname','maxiter','format','Integer');
     51
     52                        //process requested outputs
     53                        outputs = this.requested_outputs;
     54                        for (var i=0;i<outputs;i++){
     55                                if (outputs[i] == 'default') {
     56                                        outputs.splice(i,1);
     57                                        outputs.push(this.defaultoutputs());
     58                                }
     59                        }
     60                        WriteData(fid,'data',outputs,'enum',SteadystateRequestedOutputsEnum,'format','StringArray');
     61                }//}}}
     62                this.defaultoutputs = function(md) { //{{{
     63
     64                        var list=[];
     65
     66                        for (var i=0;i<md.stressbalance.defaultoutputs().length;i++)list.push(md.stressbalance.defaultoutputs()[i]);
     67                        for (var i=0;i<md.thermal.defaultoutputs().length;i++)list.push(md.thermal.defaultoutputs()[i]);
     68
     69                        return list;
     70
     71                }//}}}
    4472        //properties
    4573        // {{{

  • issm/trunk-jpl/src/m/classes/stressbalance.js

    r19787 r19791  
    7272
    7373
     74        }// }}}
     75        this.classname= function(){// {{{
     76                return "stressbalance";
    7477        }// }}}
    7578                this.checkconsistency = function(md,solution,analyses) { //{{{
    … …  
    133136                        }
    134137                } // }}}
     138                this.marshall=function(md,fid) { //{{{
     139
     140                        WriteData(fid,'object',this,'class','stressbalance','fieldname','vertex_pairing','format','DoubleMat','mattype',3);
     141
     142                        yts=365.0*24.0*3600.0;
     143
     144                        WriteData(fid,'object',this,'class','stressbalance','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
     145                        WriteData(fid,'object',this,'class','stressbalance','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
     146                        WriteData(fid,'object',this,'class','stressbalance','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
     147                        WriteData(fid,'object',this,'class','stressbalance','fieldname','restol','format','Double');
     148                        WriteData(fid,'object',this,'class','stressbalance','fieldname','reltol','format','Double');
     149                        WriteData(fid,'object',this,'class','stressbalance','fieldname','abstol','format','Double','scale',1./yts);
     150                        WriteData(fid,'object',this,'class','stressbalance','fieldname','isnewton','format','Integer');
     151                        WriteData(fid,'object',this,'class','stressbalance','fieldname','FSreconditioning','format','Double');
     152                        WriteData(fid,'object',this,'class','stressbalance','fieldname','viscosity_overshoot','format','Double');
     153                        WriteData(fid,'object',this,'class','stressbalance','fieldname','maxiter','format','Integer');
     154                        WriteData(fid,'object',this,'class','stressbalance','fieldname','shelf_dampening','format','Integer');
     155                        WriteData(fid,'object',this,'class','stressbalance','fieldname','penalty_factor','format','Double');
     156                        WriteData(fid,'object',this,'class','stressbalance','fieldname','rift_penalty_lock','format','Integer');
     157                        WriteData(fid,'object',this,'class','stressbalance','fieldname','rift_penalty_threshold','format','Integer');
     158                        WriteData(fid,'object',this,'class','stressbalance','fieldname','referential','format','DoubleMat','mattype',1);
     159
     160                        lx=NewArrayFill(this.loadingforce.length,0); for(var i=0;i<lx.length;i++)lx[i]=this.loadingforce[i][0];
     161                        ly=NewArrayFill(this.loadingforce.length,0); for(var i=0;i<lx.length;i++)ly[i]=this.loadingforce[i][1];
     162                        lz=NewArrayFill(this.loadingforce.length,0); for(var i=0;i<lx.length;i++)lz[i]=this.loadingforce[i][2];
     163
     164                        WriteData(fid,'data',lx,'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum);
     165                        WriteData(fid,'data',ly,'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum);
     166                        WriteData(fid,'data',lz,'format','DoubleMat','mattype',1,'enum',LoadingforceZEnum);
     167
     168                        //process requested outputs
     169                        outputs = this.requested_outputs;
     170                        for (var i=0;i<outputs;i++){
     171                                if (outputs[i] == 'default') {
     172                                        outputs.splice(i,1);
     173                                        outputs.push(this.defaultoutputs());
     174                                }
     175                        }                       
     176                        WriteData(fid,'data',outputs,'enum',StressbalanceRequestedOutputsEnum,'format','StringArray');
     177                }//}}}
     178                this.defaultoutputs = function(md){ // {{{
     179
     180                        var list;
     181                        if (md.mesh.dimension() == 3) list = ['Vx','Vy','Vz','Vel','Pressure'];
     182                        else if (md.mesh.dimension()==2) list = ['Vx','Vy','Vel','Pressure'];
     183                        else throw Error('mesh type not supported yet');
     184                        return list;
     185
     186                }//}}}
    135187        //properties
    136188        // {{{

  • issm/trunk-jpl/src/m/classes/thermal.js

    r19787 r19791  
    4949
    5050        }// }}}
     51        this.classname= function(){// {{{
     52                return "thermal";
     53        }// }}}
    5154        this.checkconsistency = function(md,solution,analyses){ // {{{
    5255
    … …  
    8184                checkfield(md,'fieldname','thermal.requested_outputs','stringrow',1);
    8285        } // }}}
     86                this.marshall=function(md,fid) { //{{{
     87                        WriteData(fid,'object',this,'fieldname','spctemperature','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
     88                        WriteData(fid,'object',this,'fieldname','penalty_threshold','format','Integer');
     89                        WriteData(fid,'object',this,'fieldname','stabilization','format','Integer');
     90                        WriteData(fid,'object',this,'fieldname','reltol','format','Double');
     91                        WriteData(fid,'object',this,'fieldname','maxiter','format','Integer');
     92                        WriteData(fid,'object',this,'fieldname','penalty_lock','format','Integer');
     93                        WriteData(fid,'object',this,'fieldname','penalty_factor','format','Double');
     94                        WriteData(fid,'object',this,'fieldname','isenthalpy','format','Boolean');
     95                        WriteData(fid,'object',this,'fieldname','isdynamicbasalspc','format','Boolean');
     96
     97                        //process requested outputs
     98                        outputs = this.requested_outputs;
     99                        for (var i=0;i<outputs;i++){
     100                                if (outputs[i] == 'default') {
     101                                        outputs.splice(i,1);
     102                                        outputs.push(this.defaultoutputs());
     103                                }
     104                        }
     105                        WriteData(fid,'data',outputs,'enum',ThermalRequestedOutputsEnum(),'format','StringArray');
     106                }//}}}
     107                this.defaultoutputs = function(md) { //{{{
     108
     109                        if (this.isenthalpy) return ['Enthalpy','Temperature','Waterfraction','Watercolumn','BasalforcingsGroundediceMeltingRate'];
     110                        else return ['Temperature','BasalforcingsGroundediceMeltingRate'];
     111                }//}}}
    83112        //properties
    84113        // {{{

  • issm/trunk-jpl/src/m/classes/timestepping.js

    r19780 r19791  
    3939
    4040        }// }}}
     41        this.classname= function(){// {{{
     42                return "timestepping";
     43
     44        }// }}}
    4145                this.checkconsistency = function(md,solution,analyses) { //{{{
    4246                       
    … …  
    5155                        }
    5256                } // }}}
     57                this.marshall=function(md,fid) { //{{{
     58
     59                        var scale;
     60                        if (this.in_years) scale = 365.0*24.0*3600.0;
     61                        else scale = 1.;
     62                       
     63                        WriteData(fid,'object',this,'fieldname','start_time','format','Double','scale',scale);
     64                        WriteData(fid,'object',this,'fieldname','final_time','format','Double','scale',scale);
     65                        WriteData(fid,'object',this,'fieldname','time_step','format','Double','scale',scale);
     66                        WriteData(fid,'object',this,'fieldname','time_adapt','format','Boolean');
     67                        WriteData(fid,'object',this,'fieldname','cfl_coefficient','format','Double');
     68                        WriteData(fid,'object',this,'fieldname','interp_forcings','format','Boolean');
     69
     70                }//}}}
    5371        //properties
    5472        // {{{

  • issm/trunk-jpl/src/m/classes/transient.js

    r19787 r19791  
    4242
    4343        }// }}}
     44        this.classname= function(){// {{{
     45                return "transient";
     46        }// }}}
    4447                this.checkconsistency = function(md,solution,analyses) { // {{{
    4548
    … …  
    5962                        checkfield(md,'fieldname','transient.requested_outputs','stringrow',1);
    6063                } // }}}
     64                this.marshall=function(md,fid) { //{{{
     65                        WriteData(fid,'object',this,'fieldname','issmb','format','Boolean');
     66                        WriteData(fid,'object',this,'fieldname','ismasstransport','format','Boolean');
     67                        WriteData(fid,'object',this,'fieldname','isstressbalance','format','Boolean');
     68                        WriteData(fid,'object',this,'fieldname','isthermal','format','Boolean');
     69                        WriteData(fid,'object',this,'fieldname','isgroundingline','format','Boolean');
     70                        WriteData(fid,'object',this,'fieldname','isgia','format','Boolean');
     71                        WriteData(fid,'object',this,'fieldname','isdamageevolution','format','Boolean');
     72                        WriteData(fid,'object',this,'fieldname','ishydrology','format','Boolean');
     73                        WriteData(fid,'object',this,'fieldname','islevelset','format','Boolean');
     74                        WriteData(fid,'object',this,'fieldname','iscalving','format','Boolean');
     75
     76                        //process requested outputs
     77                        outputs = this.requested_outputs;
     78                        for (var i=0;i<outputs;i++){
     79                                if (outputs[i] == 'default') {
     80                                        outputs.splice(i,1);
     81                                        outputs.push(this.defaultoutputs());
     82                                }
     83                        }                       
     84                        WriteData(fid,'data',outputs,'enum',TransientRequestedOutputsEnum,'format','StringArray');
     85                }//}}}
     86                this.defaultoutputs = function(md) { //{{{
     87                        if(this.issmb)return ['SmbMassBalance'];
     88                        else return [];
     89                }//}}}
    6190        //properties
    6291        // {{{

  • issm/trunk-jpl/src/m/classes/verbose.js

    r19787 r19791  
    4343
    4444                } // }}}
     45                this.marshall=function(md,fid) { //{{{
     46                        WriteData(fid,'data',this.VerboseToBinary(),'enum',VerboseEnum(),'format','Integer');
     47                }//}}}
     48                this.VerboseToBinary = function () { //{{{
     49
     50                        //BEGINVERB2BIN
     51                        var binary=0;
     52                        if (verbose.mprocessor) binary=Math.bitOr(binary1);
     53                        if (verbose.module) binary=Math.bitOr(binary2);
     54                        if (verbose.solution) binary=Math.bitOr(binary4);
     55                        if (verbose.solver) binary=Math.bitOr(binary8);
     56                        if (verbose.convergence) binary=Math.bitOr(binary16);
     57                        if (verbose.control) binary=Math.bitOr(binary32);
     58                        if (verbose.qmu) binary=Math.bitOr(binary64);
     59                        if (verbose.autodiff) binary=Math.bitOr(binary128);
     60                        if (verbose.smb) binary=Math.bitOr(binary256);
     61                        //ENDVERB2BIN
     62                        return binary;
     63
     64                } //}}}
    4565        //properties
    4666        // {{{

  • issm/trunk-jpl/src/m/io/fileptr.js

    r19787 r19791  
    2525                this.setdefaultparameters = function (options) { //{{{
    2626
    27                         this.increment=options.getfieldvalue('increment',8000); //8000 bytes,  1000 doubles.
     27                        this.increment=options.getfieldvalue('increment',80000); //80000 bytes,  10000 doubles.
    2828                        this.buffer=new ArrayBuffer(this.increment);
    2929                        this.ptr=0;
    … …  
    3333                this.fwrite = function (value,format) { //{{{
    3434
    35                         if(this.ptr==this.buffer.byteLength){
    36                                 //need to resize the buffer:
    37                                 var  newbuffer = new ArrayBuffer(this.buffer.byteLength+this.increment);
    38                                 newbuffer.set(this.buffer);
    39                                 this.buffer=newbuffer;
    40                         }
    4135                       
    4236                        if(format == 'int'){
     37                                if(this.ptr+4>=this.buffer.byteLength)this.resize();
    4338                                this.view.setUint32(this.ptr,value,true); this.ptr+=4;
    4439                        }
    4540                        else if(format == 'char'){
     41                                if(this.ptr+value.length>=this.buffer.byteLength)this.resize();
    4642                                for(var i=0;i<value.length;i++){
    4743                                        this.view.setUint8(this.ptr,value.charCodeAt(i),true);
    … …  
    5046                        }
    5147                        else if(format == 'double'){
     48                                if(this.ptr+8>=this.buffer.byteLength)this.resize();
    5249                                if (!IsArray(value)){
    5350                                        this.view.setFloat64(this.ptr,value,true);
    … …  
    5653                                else{
    5754                                        if (!IsArray(value[0])){
     55                                                if(this.ptr+value.length*8>=this.buffer.byteLength)this.resize();
    5856                                                for(var i=0;i<value.length;i++){
    5957                                                        this.view.setFloat64(this.ptr,value[i],true);
    … …  
    6260                                        }
    6361                                        else{
     62                                                if(this.ptr+value.length*value[0].length*8>=this.buffer.byteLength)this.resize();
    6463                                                for(var i=0;i<value.length;i++){
    6564                                                        for(var j=0;j<value[0].length;j++){
    … …  
    7675                        return this.buffer;
    7776                } //}}}
     77                this.resize = function () { //{{{
     78                        var  newbuffer = new ArrayBuffer(this.buffer.byteLength+this.increment);
     79                        new Uint8Array(newbuffer).set(new Uint8Array(this.buffer));
     80                        this.buffer=newbuffer;
     81                        this.view=new DataView(this.buffer);
     82                } //}}}
    7883        //set defaults
    7984        this.setdefaultparameters(this.options);

  • issm/trunk-jpl/src/m/solve/WriteData.js

    r19787 r19791  
    1414                obj       = options.getfieldvalue('object');
    1515                fieldname = options.getfieldvalue('fieldname');
    16                 classname = options.getfieldvalue('class',obj.classname());
    1716                if (options.exist('enum')){
    1817                        enumm = options.getfieldvalue('enum');
    1918                }
    2019                else{
     20                        classname = options.getfieldvalue('class',obj.classname());
    2121                        enumm = BuildEnum(classname  + '_' + fieldname);
    2222                }
    … …  
    121121
    122122                //if matrix = NaN, then do not write anything
    123                 if (s[0]==1 & s[1]==1 & isNan(data)){
    124                         s[0]=0; s[1]=0;
    125                 }
    126                 if (s[0]==1 & s[1]==1 & isNan(data[0])){
     123                if (s[0]==1 & s[1]==1 & isNaN(data)){
     124                        s[0]=0; s[1]=0;
     125                }
     126                if (s[0]==1 & s[1]==1 & isNaN(data[0])){
    127127                        s[0]=0; s[1]=0;
    128128                }
    … …  
    147147
    148148                //if matrix = NaN, then do not write anything
    149                 if (s[0]==1 & s[1]==1 & isNan(data)){
    150                         s[0]=0; s[1]=0;
    151                 }
    152                 if (s[0]==1 & s[1]==1 & isNan(data[0])){
     149                if (s[0]==1 & s[1]==1 & isNaN(data)){
     150                        s[0]=0; s[1]=0;
     151                }
     152                if (s[0]==1 & s[1]==1 & isNaN(data[0])){
    153153                        s[0]=0; s[1]=0;
    154154                }
    … …  
    174174
    175175                //if matrix = NaN, then do not write anything
    176                 if (s[0]==1 & s[1]==1 & isNan(data)){
    177                         s[0]=0; s[1]=0;
    178                 }
    179                 if (s[0]==1 & s[1]==1 & isNan(data[0])){
     176                if (s[0]==1 & s[1]==1 & isNaN(data)){
     177                        s[0]=0; s[1]=0;
     178                }
     179                if (s[0]==1 & s[1]==1 & isNaN(data[0])){
    180180                        s[0]=0; s[1]=0;
    181181                }
    … …  
    279279
    280280        //take first letter of string and make it uppercase:
    281         string = string.charAt(0).toUpperCase() + this.slice(1);
     281        string = string.charAt(0).toUpperCase() + string.slice(1);
    282282
    283283        //Get Enum

  • issm/trunk-jpl/src/m/solve/marshall.js

    r19787 r19791  
    2828                        continue;
    2929                }
    30                 console.log(field);
    3130
    3231                //Marshall current object
    … …  
    3635        //Last, write MaximumNumberOfEnum+1 to make sure that the binary file is not corrupt
    3736        WriteData(fid,'enum',MaximumNumberOfDefinitionsEnum()+1,'data',true,'format','Boolean');
    38 
    3937        return fid;
    4038}

  • issm/trunk-jpl/test/NightlyRun/test101.html

    r19787 r19791  
    7171<script type="text/javascript" src="../../src/m/io/fileptr.js"></script>
    7272<script type="text/javascript" src="../../src/m/solve/solve.js"></script>
     73<script type="text/javascript" src="../../src/m/inversions/marshallcostfunctions.js"></script>
    7374<script type="text/javascript" src="../../src/m/solve/marshall.js"></script>
    7475<script type="text/javascript" src="../../src/m/solve/WriteData.js"></script>
    … …  
    8384<script type="text/javascript" src="../../src/c/main/issm.js"></script>
    8485<script type="text/javascript" src="../../externalpackages/javascript/src/sprintf.js"></script>
    85 <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
    86 <script src="https://raw.githubusercontent.com/toji/gl-matrix/master/dist/gl-matrix-min.js"></script>
     86<script type="text/javascript" src="../../externalpackages/javascript/src/jquery.min.js"></script>
     87<script type="text/javascript" src="../../externalpackages/javascript/src/gl-matrix-min.js"></script>
    8788<!-- Includes }}}-->
    8889</head>
    … …  
    9697        parameterize(md);
    9798        setflowequation(md,'SSA','all');
    98         md=solve(md,StressbalanceSolutionEnum());
     99        md=solve(md,StressbalanceSolutionEnum(),'checkconsistency','no');
    99100
    100101        /*plotmodel(md,'data',md.initialization.vel,'colorbar','on','data',md.initialization.vx,
Note: See TracChangeset for help on using the changeset viewer.