Changeset 27458 for issm/trunk-jpl/src


Ignore:
Timestamp:
12/08/22 00:23:36 (2 years ago)
Author:
jdquinn
Message:

CHG: MATLAB > Python translation; cleanup

Location:
issm/trunk-jpl/src/m
Files:
137 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/m/boundaryconditions/getlovenumbers.py

    r26301 r27458  
    44
    55
    6 def getlovenumbers(*args): #{{{
     6def getlovenumbers(*args):  # {{{
    77    """GETLOVENUMBERS - provide love numbers retrieved from:
    88    http://www.srosat.com/iag-jsg/loveNb.php in a chosen reference frame
    … …  
    1008510085
    1008610086    return series
    10087 #}}}
     10087# }}}

  • issm/trunk-jpl/src/m/classes/SMBarma.py

    r27417 r27458  
    6161    # }}}
    6262
    63     def setdefaultparameters(self): #{{{
     63    def setdefaultparameters(self):  # {{{
    6464        self.ar_order = 0.0 # Autoregression model of order 0
    6565        self.ma_order = 0.0 # Moving-average model of order 0

  • issm/trunk-jpl/src/m/classes/SMBcomponents.py

    r27417 r27458  
    103103        self.requested_outputs = ['default']
    104104        return self
    105     #}}}
     105    # }}}

  • issm/trunk-jpl/src/m/classes/SMBd18opdd.py

    r27455 r27458  
    4444        else:
    4545            raise Exception('constructor not supported')
    46     #}}}
     46    # }}}
    4747    def __repr__(self):  # {{{
    4848        s = '   surface forcings parameters:\n'
    … …  
    8181        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    8282        return s
    83     #}}}
     83    # }}}
    8484    def extrude(self, md):  # {{{
    8585        if self.isd18opd:
    … …  
    9494        self.s0t = project3d(md, 'vector', self.s0t, 'type', 'node')
    9595        return self
    96     #}}}
     96    # }}}
    9797    def defaultoutputs(self, md):  # {{{
    9898        return ['SmbMassBalance']
    99     #}}}
     99    # }}}
    100100    def initialize(self, md):  # {{{
    101101        if np.all(np.isnan(self.s0p)):
    … …  
    122122        self.requested_outputs = ['default']
    123123        return self
    124     #}}}
     124    # }}}
    125125    def checkconsistency(self, md, solution, analyses):  # {{{
    126126        if 'MasstransportAnalysis' in analyses:

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

    r27453 r27458  
    2828        else:
    2929            raise Exception('constructor not supported')
    30     #}}}
     30    # }}}
    3131
    3232    def __repr__(self):  # {{{
    … …  
    4040        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    4141        return s
    42     #}}}
     42    # }}}
    4343
    4444    def extrude(self, md):  # {{{
    4545        self.mass_balance = project3d(md, 'vector', self.mass_balance, 'type', 'node')
    4646        return self
    47     #}}}
     47    # }}}
    4848
    4949    def defaultoutputs(self, md):  # {{{
    5050        return ['SmbMassBalance']
    51     #}}}
     51    # }}}
    5252
    5353    def initialize(self, md):  # {{{
    … …  
    5656            print("      no smb.mass_balance specified: values set as zero")
    5757        return self
    58     #}}}
     58    # }}}
    5959
    6060    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/SMBgemb.py

    r27448 r27458  
    156156        else:
    157157            raise Exception('constructor not supported: need mesh and geometry to set defaults')
    158         #}}}
     158        # }}}
    159159
    160160    def __repr__(self):  # {{{
    … …  
    267267        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    268268        return s
    269     #}}}
     269    # }}}
    270270
    271271    def extrude(self, md):  # {{{
    … …  
    316316
    317317        return self
    318     #}}}
     318    # }}}
    319319
    320320    def defaultoutputs(self, md):  # {{{
    321321        return ['SmbMassBalance','SmbAccumulatedMassBalance']
    322     #}}}
     322    # }}}
    323323
    324324    def setdefaultparameters(self, mesh, geometry):  # {{{
    … …  
    390390        #           Element.cpp
    391391        self.Sizeini = 2 * np.ones((mesh.numberofelements,))
    392     #}}}
     392    # }}}
    393393
    394394    def checkconsistency(self, md, solution, analyses):    # {{{

  • issm/trunk-jpl/src/m/classes/SMBgradients.py

    r27415 r27458  
    2323        # Set defaults
    2424        self.setdefaultparameters()
    25     #}}}
     25    # }}}
    2626
    2727    def __repr__(self):  # {{{
    … …  
    4141
    4242        return string
    43     #}}}
     43    # }}}
    4444
    4545    def extrude(self, md):  # {{{
    4646        #Nothing for now
    4747        return self
    48     #}}}
     48    # }}}
    4949
    5050    def defaultoutputs(self, md):  # {{{
    5151        return ['SmbMassBalance']
    52     #}}}
     52    # }}}
    5353
    5454    def setdefaultparameters(self):  # {{{
    … …  
    5656        self.requested_outputs = ['default']
    5757        return self
    58     #}}}
     58    # }}}
    5959
    6060    def initialize(self, md):  # {{{
    6161        #Nothing for now
    6262        return self
    63     #}}}
     63    # }}}
    6464
    6565    def checkconsistency(self, md, solution, analyses):    # {{{

  • issm/trunk-jpl/src/m/classes/SMBgradientscomponents.py

    r27414 r27458  
    2323        self.averaging = 0
    2424        self.requested_outputs = ['default']
    25     #}}}
     25    # }}}
    2626
    2727    def __repr__(self):  # {{{
    … …  
    4141
    4242        return string
    43     #}}}
     43    # }}}
    4444
    4545    def extrude(self, md):  # {{{
    4646        #Nothing for now
    4747        return self
    48     #}}}
     48    # }}}
    4949
    5050    def defaultoutputs(self, md):  # {{{
    … …  
    5353            list.extend(['SmbMassBalanceSubstep'])
    5454        return list
    55     #}}}
     55    # }}}
    5656
    5757    def initialize(self, md):  # {{{
    5858        #Nothing for now
    5959        return self
    60     #}}}
     60    # }}}
    6161
    6262    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/SMBgradientsela.py

    r27415 r27458  
    2525        else:
    2626            error('constructor not supported')
    27     #}}}
     27    # }}}
    2828
    2929    def __repr__(self):  # {{{
    … …  
    4444        string = "%s\n%s" % (string, fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    4545        return string
    46     #}}}
     46    # }}}
    4747
    4848    def extrude(self, md):  # {{{
    4949        #Nothing for now
    5050        return self
    51     #}}}
     51    # }}}
    5252
    5353    def defaultoutputs(self, md):  # {{{
    5454        return ['SmbMassBalance']
    55     #}}}
     55    # }}}
    5656
    5757    def initialize(self, md):  # {{{
    5858        #Nothing for now
    5959        return self
    60     #}}}
     60    # }}}
    6161
    6262    def setdefaultparameters(self):  # {{{
    … …  
    6565        self.requested_outputs = ['default']
    6666        return self
    67     #}}}
     67    # }}}
    6868
    6969    def checkconsistency(self, md, solution, analyses):    # {{{

  • issm/trunk-jpl/src/m/classes/SMBhenning.py

    r27453 r27458  
    2828        else:
    2929            raise Exception('constructor not supported')
    30     #}}}
     30    # }}}
    3131
    3232    def __repr__(self):  # {{{
    … …  
    4040        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    4141        return s
    42     #}}}
     42    # }}}
    4343
    4444    def extrude(self, md):  # {{{
    4545        self.smbref = project3d(md, 'vector', self.smbref, 'type', 'node')
    4646        return self
    47     #}}}
     47    # }}}
    4848
    4949    def defaultoutputs(self, md):  # {{{
    5050        return ['SmbMassBalance']
    51     #}}}
     51    # }}}
    5252
    5353    def initialize(self, md):  # {{{
    … …  
    5656            print("      no smb.smbref specified: values set as zero")
    5757        return self
    58     #}}}
     58    # }}}
    5959
    6060    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/SMBmeltcomponents.py

    r27415 r27458  
    2727        else:
    2828            error('constructor not supported')
    29     #}}}
     29    # }}}
    3030
    3131    def __repr__(self):  # {{{
    … …  
    4242        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    4343        return s
    44     #}}}
     44    # }}}
    4545
    4646    def extrude(self, md):  # {{{
    … …  
    5050        self.refreeze = project3d(md, 'vector', self.refreeze, 'type', 'node')
    5151        return self
    52     #}}}
     52    # }}}
    5353
    5454    def defaultoutputs(self, md):  # {{{
    5555        return ['SmbMassBalance']
    56     #}}}
     56    # }}}
    5757
    5858    def initialize(self, md):  # {{{
    … …  
    7474
    7575        return self
    76     #}}}
     76    # }}}
    7777
    7878    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    118118        self.requested_outputs = ['default']
    119119        return self
    120     #}}}
     120    # }}}

  • issm/trunk-jpl/src/m/classes/SMBpdd.py

    r27415 r27458  
    4242        # Set defaults
    4343        self.setdefaultparameters()
    44     #}}}
     44    # }}}
    4545
    4646    def __repr__(self):  # {{{
    … …  
    112112        self.s0t = project3d(md, 'vector', self.s0t, 'type', 'node')
    113113        return self
    114     #}}}
     114    # }}}
    115115
    116116    def defaultoutputs(self, md):  # {{{
    117117        return ['SmbMassBalance']
    118     #}}}
     118    # }}}
    119119
    120120    def initialize(self, md):  # {{{
    … …  
    128128
    129129        return self
    130     #}}}
     130    # }}}
    131131
    132132    def setdefaultparameters(self):  # {{{
    … …  
    141141
    142142        return self
    143     #}}}
     143    # }}}
    144144
    145145    def checkconsistency(self, md, solution, analyses):    # {{{
    … …  
    181181        md = checkfield(md, 'fieldname', 'masstransport.requested_outputs', 'stringrow', 1)
    182182        return md
    183     #}}}
     183    # }}}
    184184
    185185    def marshall(self, prefix, md, fid):    # {{{

  • issm/trunk-jpl/src/m/classes/SMBsemic.py

    r27453 r27458  
    3737        else:
    3838            raise Exception('constructor not supported')
    39     #}}}
     39    # }}}
    4040
    4141    def __repr__(self):  # {{{
    … …  
    6464        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    6565        return s
    66     #}}}
     66    # }}}
    6767
    6868    def extrude(self, md):  # {{{
    … …  
    7878        self.s0gcm = project3d(md, 'vector', self.s0gcm, 'type', 'node')
    7979        return self
    80     #}}}
     80    # }}}
    8181
    8282    def defaultoutputs(self, md):  # {{{
    8383        return ['SmbMassBalance']
    84     #}}}
     84    # }}}
    8585
    8686    def initialize(self, md):  # {{{
    … …  
    8989            print("      no SMBsemic.s0gcm specified: values set as zero")
    9090        return self
    91     #}}}
     91    # }}}
    9292
    9393    def setdefaultparameters(self):  #{{{

  • issm/trunk-jpl/src/m/classes/amr.py

    r26301 r27458  
    1111    """
    1212
    13     def __init__(self): #{{{
     13    def __init__(self):  # {{{
    1414        self.hmin = 0
    1515        self.hmax = 0
    … …  
    3333
    3434        self.setdefaultparameters()
    35     #}}}
     35    # }}}
    3636
    37     def __repr__(self): #{{{
     37    def __repr__(self):  # {{{
    3838        s = '   amr parameters:\n'
    3939        s += '{}\n'.format(fielddisplay(self, 'hmin', 'minimum element length'))
    … …  
    5656        s += '{}\n'.format(fielddisplay(self, 'restart', 'indicates if ReMesh() will call before first time step'))
    5757        return s
    58     #}}}
     58    # }}}
    5959
    60     def setdefaultparameters(self): #{{{
     60    def setdefaultparameters(self):  # {{{
    6161        self.hmin = 100
    6262        self.hmax = 100e3
    … …  
    8989        self.restart = 0
    9090        return self
    91     #}}}
     91    # }}}
    9292
    93     def checkconsistency(self, md, solution, analyses): #{{{
     93    def checkconsistency(self, md, solution, analyses):  # {{{
    9494        md = checkfield(md, 'fieldname', 'amr.hmax', 'numel', [1], '>', 0, 'NaN', 1)
    9595        md = checkfield(md, 'fieldname', 'amr.hmin', 'numel', [1], '>', 0, '<', self.hmax, 'NaN', 1)
    … …  
    112112   # }}}
    113113
    114     def marshall(self, prefix, md, fid): #{{{
     114    def marshall(self, prefix, md, fid):  # {{{
    115115        WriteData(fid, prefix, 'name', 'md.amr.type', 'data', 1, 'format', 'Integer')
    116116        WriteData(fid, prefix, 'object', self, 'fieldname', 'hmin', 'format', 'Double')
    … …  
    133133        WriteData(fid, prefix, 'object', self, 'fieldname', 'deviatoricerror_maximum', 'format', 'Double')
    134134        WriteData(fid, prefix, 'object', self, 'class', 'amr', 'fieldname', 'restart', 'format', 'Integer')
    135     #}}}
     135    # }}}

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

    r25585 r27458  
    104104        WriteData(fid, prefix, 'object', self, 'fieldname', 'gcTriggerMaxSize', 'format', 'Double')
    105105        WriteData(fid, prefix, 'object', self, 'fieldname', 'tapeAlloc', 'format', 'Integer')
    106         #}}}
     106        # }}}
    107107        #process dependent variables {{{
    108108        num_dependent_objects = len(self.dependents)
    … …  
    119119            WriteData(fid, prefix, 'data', names, 'name', 'md.autodiff.dependent_object_names', 'format', 'StringArray')
    120120            WriteData(fid, prefix, 'data', indices, 'name', 'md.autodiff.dependent_object_indices', 'format', 'IntMat', 'mattype', 3)
    121             #}}}
     121            # }}}
    122122        #process independent variables {{{
    123123        num_independent_objects = len(self.independents)
    … …  
    134134            WriteData(fid, prefix, 'data', names, 'name', 'md.autodiff.independent_object_names', 'format', 'StringArray')
    135135            WriteData(fid, prefix, 'data', types, 'name', 'md.autodiff.independent_object_types', 'format', 'IntMat', 'mattype', 3)
    136             #}}}
     136            # }}}
    137137        #if driver is fos_forward, build index:  {{{
    138138        if strcmpi(self.driver, 'fos_forward'):
    … …  
    151151            index -= 1  #get c - index numbering going
    152152            WriteData(fid, prefix, 'data', index, 'name', 'md.autodiff.fos_forward_index', 'format', 'Integer')
    153             #}}}
     153            # }}}
    154154        #if driver is fos_reverse, build index:  {{{
    155155        if strcmpi(self.driver, 'fos_reverse'):
    … …  
    165165            index -= 1  #get c - index numbering going
    166166            WriteData(fid, prefix, 'data', index, 'name', 'md.autodiff.fos_reverse_index', 'format', 'Integer')
    167             #}}}
     167            # }}}
    168168        #if driver is fov_forward, build indices:  {{{
    169169        if strcmpi(self.driver, 'fov_forward'):
    … …  
    182182            indices -= 1  #get c - indices numbering going
    183183            WriteData(fid, prefix, 'data', indices, 'name', 'md.autodiff.fov_forward_indices', 'format', 'IntMat', 'mattype', 3)
    184             #}}}
     184            # }}}
    185185        #deal with mass fluxes:  {{{
    186186        mass_flux_segments = [dep.segments for dep in self.dependents if strcmpi(dep.name, 'MassFlux')]
    … …  
    192192            flag = False
    193193        WriteData(fid, prefix, 'data', flag, 'name', 'md.autodiff.mass_flux_segments_present', 'format', 'Boolean')
    194         #}}}
     194        # }}}
    195195        #deal with trace keep on: {{{
    196196        keep = False
    … …  
    210210                keep = False
    211211        WriteData(fid, prefix, 'data', keep, 'name', 'md.autodiff.keep', 'format', 'Boolean')
    212     #}}}
     212    # }}}
    213213
    214214        return

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

    r24213 r27458  
    2323        self.setdefaultparameters()
    2424
    25     #}}}
     25    # }}}
    2626
    2727    def __repr__(self):  # {{{
    … …  
    3232        string = "%s\n%s" % (string, fielddisplay(self, 'stabilization', "0: None, 1: SU, 2: SSA's artificial diffusivity, 3:DG"))
    3333        return string
    34     #}}}
     34    # }}}
    3535
    3636    def setdefaultparameters(self):  # {{{
    … …  
    3838        self.stabilization = 1
    3939        return self
    40     #}}}
     40    # }}}
    4141
    4242    def checkconsistency(self, md, solution, analyses):  # {{{

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

    r26358 r27458  
    2020
    2121        self.setdefaultparameters()
    22     #}}}
     22    # }}}
    2323    def __repr__(self):  # {{{
    2424        s = '   basal forcings parameters:\n'
    … …  
    2727        s += '{}\n'.format(fielddisplay(self, 'geothermalflux', 'geothermal heat flux [W/m^2]'))
    2828        return s
    29     #}}}
     29    # }}}
    3030    def extrude(self, md):  # {{{
    3131        self.groundedice_melting_rate = project3d(md, 'vector', self.groundedice_melting_rate, 'type', 'node', 'layer', 1)
    … …  
    3333        self.geothermalflux = project3d(md, 'vector', self.geothermalflux, 'type', 'node', 'layer', 1) # Bedrock only gets geothermal flux
    3434        return self
    35     #}}}
     35    # }}}
    3636    def initialize(self, md):  # {{{
    3737        if np.all(np.isnan(self.groundedice_melting_rate)):
    … …  
    4242            print('      no basalforcings.floatingice_melting_rate specified: values set as zero')
    4343        return self
    44     #}}}
     44    # }}}
    4545    def setdefaultparameters(self):  # {{{
    4646        return self
    47     #}}}
     47    # }}}
    4848    def checkconsistency(self, md, solution, analyses):  # {{{
    4949        if 'MasstransportAnalysis' in analyses and not solution == 'TransientSolution' and not md.transient.ismasstransport:

  • issm/trunk-jpl/src/m/classes/basin.py

    r25455 r27458  
    1818
    1919
    20 class basin(object): #{{{
     20class basin(object):  # {{{
    2121    """BASIN class definition
    2222
    … …  
    2525    """
    2626
    27     def __init__(self, *args): #{{{
     27    def __init__(self, *args):  # {{{
    2828        self.boundaries = []
    2929        self.name       = ''
    … …  
    5555
    5656            self.proj = proj
    57     #}}}
    58 
    59     def __repr__(self): # {{{
     57    # }}}
     58
     59    def __repr__(self):  # {{{
    6060        s = '   basin parameters:\n'
    6161        s += '{}\n'.format(fielddisplay(self, 'continent', 'continent name'))
    … …  
    6767
    6868        return s
    69     #}}}
    70 
    71     def setdefaultparameters(self): # {{{
     69    # }}}
     70
     71    def setdefaultparameters(self):  # {{{
    7272        self.name       = ''
    7373        self.continent  = ''
    … …  
    7676
    7777        return self
    78     #}}}
    79 
    80     def isnameany(self, *args): #{{{
     78    # }}}
     79
     80    def isnameany(self, *args):  # {{{
    8181        boolean = 0
    8282        for arg in args:
    … …  
    9090                break
    9191        return boolean
    92     #}}}
    93 
    94     def iscontinentany(self, *args): #{{{
     92    # }}}
     93
     94    def iscontinentany(self, *args):  # {{{
    9595        boolean = 0
    9696        for arg in args:
    … …  
    104104                break
    105105        return boolean
    106     #}}}
    107 
    108     def outputname(self, *args): #{{{
     106    # }}}
     107
     108    def outputname(self, *args):  # {{{
    109109        #recover options
    110110        options = pairoptions(*args)
    … …  
    118118
    119119        return output
    120     #}}}
    121 
    122     def plot(self, *args): #{{{
     120    # }}}
     121
     122    def plot(self, *args):  # {{{
    123123        #add option
    124124        for i in range(len(self.boundaries)):
    125125            self.boundaries[i].plot('proj', self.proj, *args)
    126     #}}}
    127 
    128     def plot3d(self, *args): #{{{
     126    # }}}
     127
     128    def plot3d(self, *args):  # {{{
    129129        #add option
    130130        for i in range(len(self.boundaries)):
    131131            self.boundaries[i].plot3d(*args)
    132     #}}}
    133 
    134     def contour(self, *args): #{{{
     132    # }}}
     133
     134    def contour(self, *args):  # {{{
    135135        #recover options
    136136        options = pairoptions(*args)
    … …  
    162162
    163163        return out
    164     #}}}
    165 
    166     def checkconsistency(self, *args): #{{{
     164    # }}}
     165
     166    def checkconsistency(self, *args):  # {{{
    167167        #recover options
    168168        options = pairoptions(*args)
    … …  
    180180            boundary == self.boundaries[i]
    181181            boundary.checkconsistency()
    182     #}}}
    183 
    184     def contourplot(self, *args): #{{{
     182    # }}}
     183
     184    def contourplot(self, *args):  # {{{
    185185        contour = self.contour()
    186186        plot(contour.x, contour.y, 'r*-')
    187     #}}}
    188 
    189     def shapefilecrop(self, *args): #{{{
     187    # }}}
     188
     189    def shapefilecrop(self, *args):  # {{{
    190190        #recover options
    191191        options = pairoptions(*args)
    … …  
    252252
    253253        return output
    254     #}}}
    255 #}}}
     254    # }}}
     255# }}}

  • issm/trunk-jpl/src/m/classes/boundary.py

    r25455 r27458  
    1010
    1111
    12 class boundary(object): #{{{
     12class boundary(object):  # {{{
    1313    """BOUNDARY class definition
    1414
    … …  
    1717    """
    1818
    19     def __init__(self, *args): #{{{
     19    def __init__(self, *args):  # {{{
    2020        self.boundaries = []
    2121        self.name       = ''
    … …  
    5151
    5252            self.proj = proj
    53     #}}}
     53    # }}}
    5454
    55     def __repr__(self): #{{{
     55    def __repr__(self):  # {{{
    5656        s = '   boundary parameters:\n'
    5757        s += '{}\n'.format(fielddisplay(self, 'shppath', 'path to filename for this boundary'))
    … …  
    6161
    6262        return s
    63     #}}}
     63    # }}}
    6464
    65     def setdefaultparameters(self): #{{{
     65    def setdefaultparameters(self):  # {{{
    6666        self.shppath = ''
    6767        self.shpfilename = ''
    … …  
    7070
    7171        return self
    72     #}}}
     72    # }}}
    7373
    74     def name(self): #{{{
     74    def name(self):  # {{{
    7575        output = self.shpfilename
    7676
    7777        return output
    78     #}}}
     78    # }}}
    7979
    80     def edges(self): #{{{
     80    def edges(self):  # {{{
    8181        #read domain
    8282        path, name, ext = fileparts(self.shpfilename)
    … …  
    9292
    9393        return output
    94     #}}}
     94    # }}}
    9595
    96     def plot(self, *args): #{{{
     96    def plot(self, *args):  # {{{
    9797        #recover options
    9898        options = pairoptions(*args)
    … …  
    131131            # y = domain[i].y * unitmultiplier
    132132            # if len(x) == 1:
    133         #}}}
     133        # }}}
    134134
    135135        #TODO: Finish translating from MATLAB after test2004.py runs without plot
    136     #}}}
     136    # }}}
    137137
    138     def checkconsistency(self, *args): #{{{
     138    def checkconsistency(self, *args):  # {{{
    139139        #recover options
    140140        options = pairoptions(*args)
    … …  
    157157                    raise Exception('boundary {} has two vertices extermely close to one another'.format(shpfilename))
    158158
    159     def plot3d(self, *args): #{{{
     159    def plot3d(self, *args):  # {{{
    160160        #recover options
    161161        options = pairoptions(*args)
    … …  
    181181
    182182        #TODO: Finish translating from MATLAB after test2004.py runs without plot
    183     #}}}
    184 #}}}
     183    # }}}
     184# }}}

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

    r25844 r27458  
    1717        self.calvingrate = np.nan
    1818        #self.setdefaultparameters() # Uncomment if/when setdefaultparameters is used
    19     #}}}
     19    # }}}
    2020
    2121    def __repr__(self):  # {{{
    … …  
    2323        s += '{}\n'.format(fielddisplay(self, 'calvingrate', 'calving rate at given location [m/a]'))
    2424        return s
    25     #}}}
     25    # }}}
    2626
    2727    def setdefaultparameters(self):  # {{{
    2828        return self
    29     #}}}
     29    # }}}
    3030
    3131    def extrude(self, md):  # {{{
    3232        self.calvingrate = project3d(md, 'vector', self.calvingrate, 'type', 'node')
    3333        return self
    34     #}}}
     34    # }}}
    3535
    3636    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/calvingcrevassedepth.py

    r26444 r27458  
    1818
    1919        #self.setdefaultparameters() # Uncomment if/when setdefaultparameters is used
    20     #}}}
     20    # }}}
    2121    def __repr__(self):  # {{{
    2222        s = '   Calving Pi parameters:'
    … …  
    2525        s += '{}\n'.format(fielddisplay(self, 'water_height', 'water height in the crevasse [m]'))
    2626        return s
    27     #}}}
     27    # }}}
    2828    def setdefaultparameters(self):  # {{{
    2929        return self
    30     #}}}
     30    # }}}
    3131    def extrude(self, md):  # {{{
    3232        return self
    33     #}}}
     33    # }}}
    3434    def checkconsistency(self, md, solution, analyses):  # {{{
    3535        #Early return

  • issm/trunk-jpl/src/m/classes/calvingdev.py

    r24305 r27458  
    2121        self.setdefaultparameters()
    2222
    23     #}}}
     23    # }}}
    2424
    2525    def __repr__(self):  # {{{
    … …  
    2929
    3030        return string
    31     #}}}
     31    # }}}
    3232
    3333    def extrude(self, md):  # {{{
    3434        return self
    35     #}}}
     35    # }}}
    3636
    3737    def setdefaultparameters(self):  # {{{
    … …  
    4040        self.stress_threshold_floatingice = 150e3
    4141        return self
    42     #}}}
     42    # }}}
    4343
    4444    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/calvinglevermann.py

    r24305 r27458  
    2020        self.setdefaultparameters()
    2121
    22     #}}}
     22    # }}}
    2323
    2424    def __repr__(self):  # {{{
    … …  
    2727
    2828        return string
    29     #}}}
     29    # }}}
    3030
    3131    def extrude(self, md):  # {{{
    3232        self.coeff = project3d(md, 'vector', self.coeff, 'type', 'node')
    3333        return self
    34     #}}}
     34    # }}}
    3535
    3636    def setdefaultparameters(self):  # {{{
    3737        #Proportionality coefficient in Levermann model
    3838        self.coeff = 2e13
    39     #}}}
     39    # }}}
    4040
    4141    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/calvingminthickness.py

    r24305 r27458  
    1919        self.setdefaultparameters()
    2020
    21     #}}}
     21    # }}}
    2222
    2323    def __repr__(self):  # {{{
    … …  
    2525        string = "%s\n%s" % (string, fielddisplay(self, 'min_thickness', 'minimum thickness below which no ice is allowed'))
    2626        return string
    27     #}}}
     27    # }}}
    2828
    2929    def extrude(self, md):  # {{{
    3030        return self
    31     #}}}
     31    # }}}
    3232
    3333    def setdefaultparameters(self):  # {{{
    3434        #minimum thickness is 100 m by default
    3535        self.min_thickness = 100.
    36     #}}}
     36    # }}}
    3737
    3838    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/calvingparameterization.m

    r27280 r27458  
    11%CALVINGPARAMETERIZATION class definition
    2 %       For test calving laws and coefficients
     2%   For test calving laws and coefficients
    33%   Usage:
    44%      calvingparameterization=calvingparameterization();

  • issm/trunk-jpl/src/m/classes/calvingparameterization.py

    r27417 r27458  
    55
    66class calvingparameterization(object):
    7     """CALVINGPARAMETERIZATION class definition
     7    """calvingparameterization class definition
    88    For test calving laws and coefficients
    99
    … …  
    2222        self.nonlinearlaw = 0
    2323
    24     #set defaults
    25         self.setdefaultparameters()
    26 
    27     #}}}
     24        nargs = len(args)
     25        if nargs == 0:
     26            self.setdefaultparameters()
     27        elif nargs == 1:
     28            # TODO: Replace the following with constructor
     29            self.setdefaultparameters()
     30        else:
     31            raise Exception('constructor not supported')
     32    # }}}
    2833
    2934    def __repr__(self):  # {{{
    … …  
    3338        s += '{}\n'.format(fielddisplay(self, 'min_thickness', 'minimum thickness below which no ice is allowed [m]'))
    3439        return s
    35     #}}}
     40    # }}}
    3641
    3742    def extrude(self, md):  # {{{
    3843        return self
    39     #}}}
     44    # }}}
    4045
    4146    def setdefaultparameters(self):  # {{{
    … …  
    4752        self.min_thickness = 0.
    4853        return self
    49     #}}}
     54    # }}}
    5055
    5156    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/calvingvonmises.py

    r26804 r27458  
    1919        self.setdefaultparameters()
    2020
    21     #}}}
     21    # }}}
    2222
    2323    def __repr__(self):  # {{{
    … …  
    2727        s += '{}\n'.format(fielddisplay(self, 'min_thickness', 'minimum thickness below which no ice is allowed [m]'))
    2828        return s
    29     #}}}
     29    # }}}
    3030
    3131    def extrude(self, md):  # {{{
    3232        return self
    33     #}}}
     33    # }}}
    3434
    3535    def setdefaultparameters(self):  # {{{
    … …  
    4141        self.min_thickness = 0.
    4242        return self
    43     #}}}
     43    # }}}
    4444
    4545    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/clusters/local.py

    r25762 r27458  
    88
    99
    10 class local(object): #{{{
     10class local(object):  # {{{
    1111    """LOCAL class definition
    1212
    … …  
    1616    """
    1717
    18     def __init__(self, *args): #{{{
     18    def __init__(self, *args):  # {{{
    1919        self.name           = ''
    2020        self.np             = 1
    … …  
    3434        self = options.AssignObjectFields(self)
    3535
    36     def __repr__(cluster): #{{{
     36    def __repr__(cluster):  # {{{
    3737        # Display the object
    3838        s = 'class {} = \n'.format(type(cluster).__name__)
    … …  
    4646
    4747        return s
    48     #}}}
     48    # }}}
    4949
    50     def checkconsistency(self, md, solution, analyses): #{{{
     50    def checkconsistency(self, md, solution, analyses):  # {{{
    5151        if cluster.np < 1:
    5252            md.checkmessage('number of processors should be at least 1')
    … …  
    5656
    5757        return md
    58     #}}}
     58    # }}}
    5959
    60     def BuildQueueScript(cluster, dirname, modelname, solution, io_gather, isvalgrind, isgporf, isdakota, isoceancoupling): #{{{
     60    def BuildQueueScript(cluster, dirname, modelname, solution, io_gather, isvalgrind, isgporf, isdakota, isoceancoupling):  # {{{
    6161        # Which executable are we calling?
    6262        executable = 'issm.exe' # Default
    … …  
    7070        fid.close()
    7171
    72     def UploadQueueJob(cluster, modelname, dirname, filelist): #{{{
     72    def UploadQueueJob(cluster, modelname, dirname, filelist):  # {{{
    7373        # Do nothing really
    7474        pass
    75     #}}}
     75    # }}}
    7676
    77     def LaunchQueueJob(cluster, modelname, dirname, filelist, restart, batch): #{{{
     77    def LaunchQueueJob(cluster, modelname, dirname, filelist, restart, batch):  # {{{
    7878        subprocess.call('source ' + modelname + '.queue')
    79     #}}}
     79    # }}}
    8080
    81     def Download(cluster, dirname, filelist): #{{{
     81    def Download(cluster, dirname, filelist):  # {{{
    8282        pass
    83     #}}}
     83    # }}}

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

    r26358 r27458  
    2020        #set defaults
    2121        self.setdefaultparameters()
    22     #}}}
     22    # }}}
    2323    def __repr__(self):  # {{{
    2424        s = '   constants parameters:\n'
    … …  
    2929        s += '{}\n'.format(fielddisplay(self, 'gravitational_constant', 'Newtonian constant of gravitation [m^3/kg/s^2]'))
    3030        return s
    31     #}}}
     31    # }}}
    3232    def setdefaultparameters(self):  # {{{
    3333        # Acceleration due to gravity (m / s^2)
    … …  
    4747
    4848        return self
    49     #}}}
     49    # }}}
    5050    def checkconsistency(self, md, solution, analyses):  # {{{
    5151        md = checkfield(md, 'fieldname', 'constants.g', '>=', 0, 'size', [1]) # We allow 0 for validation tests

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

    r26571 r27458  
    7474            self.spcdamage = project3d(md, 'vector', self.spcdamage, 'type', 'node')
    7575            return self
    76     #}}}
     76    # }}}
    7777
    7878    def setdefaultparameters(self):  # {{{
    … …  
    109109            list = ['DamageD']
    110110        return list
    111     #}}}
     111    # }}}
    112112
    113113    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/debris.py

    r27453 r27458  
    127127        self.spcthickness = project3d(md, 'vector', self.spcthickness, 'type', 'node')
    128128        return
    129     #}}}
     129    # }}}

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

    r24240 r27458  
    1919        self.setdefaultparameters()
    2020
    21     #}}}
     21    # }}}
    2222
    2323    def __repr__(self):  # {{{
    … …  
    2828        string = "%s\n%s" % (string, fielddisplay(self, 'profiling', 'enables profiling (memory, flops, time)'))
    2929        return string
    30     #}}}
     30    # }}}
    3131
    3232    def setdefaultparameters(self):  # {{{
    3333        return self
    34     #}}}
     34    # }}}
    3535
    3636    def marshall(self, prefix, md, fid):  # {{{

  • issm/trunk-jpl/src/m/classes/dsl.py

    r26359 r27458  
    2323        else:
    2424            raise Exception('constructor not supported')
    25     #}}}
     25    # }}}
    2626
    2727    def __repr__(self):  #{{{
    … …  
    3131        s += '{}\n'.format(fielddisplay(self, 'sea_water_pressure_at_sea_floor', 'Corresponds to bpo field in CMIP5 archives. Specified as a spatio-temporally variable quantity (in m equivalent, not in Pa!).'))
    3232        return s
    33     #}}}
     33    # }}}
    3434
    3535    def setdefaultparameters(self):  #{{{
    … …  
    3737        self.sea_surface_height_above_geoid = np.nan
    3838        self.sea_water_pressure_at_sea_floor = np.nan
    39     #}}}
     39    # }}}
    4040
    4141    def checkconsistency(self, md, solution, analyses):  #{{{
    … …  
    6565        self.sea_water_pressure_at_sea_floor = project3d(md, 'vector', self.sea_water_pressure_at_sea_floor, 'type', 'node', 'layer', 1)
    6666        return self
    67     #}}}
     67    # }}}
    6868
    6969    def initialize(self, md):  #{{{
    … …  
    7979            self.sea_water_pressure_at_sea_floor = np.append(np.zeros((md.mesh.numberofvertices, 1)), 0).reshape(-1, 1)
    8080            print('      no dsl.sea_water_pressure_at_sea_floor specified: transient values set at zero')
    81     #}}}
     81    # }}}

  • issm/trunk-jpl/src/m/classes/dslmme.py

    r27417 r27458  
    2222        else:
    2323            raise Exception('constructor not supported')
    24     #}}}
     24    # }}}
    2525
    2626    def __repr__(self):  # {{{
    … …  
    3131        s += '{}\n'.format(fielddisplay(self, 'sea_water_pressure_at_sea_floor', 'Corresponds to bpo field in CMIP5 archives. Specified as a spatio-temporally variable quantity (in m equivalent, not in Pa!) for each ensemble.'))
    3232        return s
    33     #}}}
     33    # }}}
    3434
    3535    def setdefaultparameters(self):  #{{{
    3636        return self
    37     #}}}
     37    # }}}
    3838
    3939    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    5252
    5353        return md
    54     #}}}
     54    # }}}
    5555
    5656    def marshall(self, prefix, md, fid):  #{{{
    … …  
    6161        WriteData(fid, prefix, 'object', self, 'fieldname', 'sea_water_pressure_at_sea_floor', 'format', 'MatArray', 'timeserieslength', md.mesh.numberofvertices + 1)
    6262        WriteData(fid, prefix, 'object', self, 'fieldname', 'sea_surface_height_above_geoid', 'format', 'MatArray', 'timeserieslength', md.mesh.numberofvertices + 1)
    63     #}}}
     63    # }}}
    6464
    6565    def extrude(self, md):  #{{{
    … …  
    6969
    7070        return self
    71     #}}}
     71    # }}}

  • issm/trunk-jpl/src/m/classes/esa.py

    r24255 r27458  
    2525    #set defaults
    2626        self.setdefaultparameters()
    27     #}}}
     27    # }}}
    2828
    2929    def __repr__(self):  # {{{
    … …  
    5252        self.requested_outputs = ['default']
    5353        return self
    54     #}}}
     54    # }}}
    5555
    5656    def checkconsistency(self, md, solution, analyses):  # {{{

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

    r27031 r27458  
    3939       
    4040        self.setdefaultparameters()
    41     #}}}
     41    # }}}
    4242
    4343    def __repr__(self):  # {{{
    … …  
    6060        s += '{}\n'.format(fielddisplay(self, 'borderFS', "vertices on FS' border (for tiling)"))
    6161        return s
    62     #}}}
     62    # }}}
    6363
    6464    def setdefaultparameters(self):  # {{{
    … …  
    7272        self.fe_FS = 'MINIcondensed'
    7373        return self
    74     #}}}
     74    # }}}
    7575
    7676    def extrude(self, md):  # {{{
    … …  
    8181        self.borderFS = project3d(md, 'vector', self.borderFS, 'type', 'node')
    8282        return self
    83     #}}}
     83    # }}}
    8484
    8585    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/fourierlove.py

    r27327 r27458  
    1313    """
    1414
    15     def __init__(self): #{{{
     15    def __init__(self):  # {{{
    1616        self.nfreq = 0
    1717        self.frequencies = 0
    … …  
    3737
    3838        self.setdefaultparameters()
    39     #}}}
     39    # }}}
    4040
    41     def __repr__(self): #{{{
     41    def __repr__(self):  # {{{
    4242        # TODO:
    4343        # - Correct display to match MATLAB
    … …  
    7878
    7979        return s
    80     #}}}
     80    # }}}
    8181
    82     def setdefaultparameters(self): #{{{
     82    def setdefaultparameters(self):  # {{{
    8383        # We setup an elastic love number computation by default
    8484        self.nfreq = 1
    … …  
    104104        self.core_mantle_boundary = 2
    105105        self.complex_computation = 0
    106     #}}}
     106    # }}}
    107107
    108     def checkconsistency(self, md, solution, analyses): #{{{
     108    def checkconsistency(self, md, solution, analyses):  # {{{
    109109        if 'LoveAnalysis' not in analyses:
    110110            return md
    … …  
    149149
    150150        return md
    151     #}}}
     151    # }}}
    152152
    153     def marshall(self, prefix, md, fid): #{{{
     153    def marshall(self, prefix, md, fid):  # {{{
    154154        WriteData(fid, prefix, 'object', self, 'fieldname', 'nfreq', 'format', 'Integer')
    155155        WriteData(fid, prefix, 'object', self, 'fieldname', 'frequencies', 'format', 'DoubleMat', 'mattype',3)
    … …  
    173173        WriteData(fid, prefix, 'object', self, 'fieldname', 'inner_core_boundary', 'format', 'Integer')
    174174        WriteData(fid, prefix, 'object', self, 'fieldname', 'core_mantle_boundary', 'format', 'Integer')
    175     #}}}
     175    # }}}
    176176
    177     def extrude(self, md): #{{{
     177    def extrude(self, md):  # {{{
    178178        return self
    179     #}}}
     179    # }}}
    180180
    181     def build_frequencies_from_time(self): #{{{
     181    def build_frequencies_from_time(self):  # {{{
    182182        if not self.istemporal:
    183183            raise RuntimeError('cannot build frequencies for temporal love numbers if love.istemporal==0')
    … …  
    192192                    self.frequencies[(i - 1) * 2 * self.n_temporal_iterations + j] = j * np.log(2) / self.time[i] / 2 / np.pi
    193193        return self
    194     #}}}
     194    # }}}

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

    r26187 r27458  
    2222        self.effective_pressure_limit = 0
    2323        self.setdefaultparameters()
    24     #}}}
     24    # }}}
    2525    def __repr__(self):  # {{{
    2626        s = 'Basal shear stress parameters: Sigma_b = coefficient^2 * Neff ^r * |u_b|^(s - 1) * u_b,\n'
    … …  
    3333        s += '{}\n'.format(fielddisplay(self, 'effective_pressure_limit', 'Neff do not allow to fall below a certain limit: effective_pressure_limit * rho_ice * g * thickness (default 0)'))
    3434        return s
    35     #}}}
     35    # }}}
    3636    def setdefaultparameters(self):  # {{{
    3737        self.effective_pressure_limit = 0
    3838        return self
    39     #}}}
     39    # }}}
    4040    def extrude(self, md):  # {{{
    4141        self.coefficient = project3d(md, 'vector', self.coefficient, 'type', 'node', 'layer', 1)
    … …  
    4545            self.effective_pressure = project3d(md, 'vector', self.effective_pressure, 'type', 'node', 'layer', 1)
    4646        return self
    47     #}}}
     47    # }}}
    4848    def defaultoutputs(self, md):  # {{{
    4949        list = []
    5050        return list
    51     #}}}
     51    # }}}
    5252    def checkconsistency(self, md, solution, analyses):  # {{{
    5353        # Early return

  • issm/trunk-jpl/src/m/classes/frictioncoulomb.py

    r27164 r27458  
    2424
    2525        self.setdefaultparameters()
    26     #}}}
     26    # }}}
    2727
    2828    def __repr__(self):  # {{{
    … …  
    3737        s += '{}\n'.format(fielddisplay(self, 'effective_pressure_limit', 'Neff do not allow to fall below a certain limit: effective_pressure_limit * rho_ice * g * thickness (default 0)'))
    3838        return s
    39     #}}}
     39    # }}}
    4040
    4141    def setdefaultparameters(self):  # {{{
    4242        self.effective_pressure_limit = 0
    4343        return self
    44     #}}}
     44    # }}}
    4545
    4646    def extrude(self, md):  # {{{
    … …  
    5656            raise ValueError('not supported yet')
    5757        return self
    58     #}}}
     58    # }}}
    5959    def checkconsistency(self, md, solution, analyses):  # {{{
    6060        # Early return

  • issm/trunk-jpl/src/m/classes/frictionhydro.py

    r24668 r27458  
    8181        elif self.coupling > 4:
    8282            raise ValueError('md.friction.coupling larger than 4, not supported yet')
    83     #}}}
     83    # }}}

  • issm/trunk-jpl/src/m/classes/frictionjosh.py

    r25688 r27458  
    2222        self.setdefaultparameters()
    2323        #self.requested_outputs = []
    24     #}}}
     24    # }}}
    2525
    2626    def __repr__(self):  # {{{
    … …  
    3333        #s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    3434        return s
    35     #}}}
     35    # }}}
    3636
    3737    def extrude(self, md):  # {{{
    … …  
    3939        self.pressure_adjusted_temperature = project3d(md, 'vector', self.pressure_adjusted_temperature, 'type', 'node', 'layer', 1)
    4040        return self
    41     #}}}
     41    # }}}
    4242
    4343    def setdefaultparameters(self):  # {{{
    … …  
    4646        self.effective_pressure_limit = 0
    4747        return self
    48     #}}}
     48    # }}}
    4949
    5050    def defaultoutputs(self, md):  # {{{
    5151        list = []
    5252        return list
    53     #}}}
     53    # }}}
    5454
    5555    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/frictionpism.py

    r25688 r27458  
    2424        self.setdefaultparameters()
    2525        self.requested_outputs = []
    26     #}}}
     26    # }}}
    2727
    2828    def extrude(self, md):  # {{{

  • issm/trunk-jpl/src/m/classes/frictionschoof.py

    r27173 r27458  
    2929        else:
    3030            raise Exception('constructor not supported')
    31     #}}}
     31    # }}}
    3232    def __repr__(self):  # {{{
    3333        # See Brondex et al. 2019 https://www.the-cryosphere.net/13/177/2019/
    … …  
    4545        s += "{}\n".format(fielddisplay(self, 'effective_pressure_limit', 'fNeff do not allow to fall below a certain limit: effective_pressure_limit*rho_ice*g*thickness (default 0)'))
    4646        return s
    47     #}}}
     47    # }}}
    4848    def setdefaultparameters(self):  # {{{
    4949        self.effective_pressure_limit = 0
    5050        return self
    51     #}}}
     51    # }}}
    5252    def extrude(self, md):  # {{{
    5353        self.C = project3d(md, 'vector', self.C, 'type', 'node')
    … …  
    5757            self.effective_pressure = project3d(md, 'vector', self.effective_pressure, 'type', 'node', 'layer', 1)
    5858        return self
    59     #}}}
     59    # }}}
    6060    def checkconsistency(self, md, solution, analyses):  # {{{
    6161        # Early return

  • issm/trunk-jpl/src/m/classes/frictionshakti.py

    r25806 r27458  
    2323        elif nargs == 1:
    2424            self = structtoobj(self, args[0])
    25     #}}}
     25    # }}}
    2626
    2727    def __repr__(self):  # {{{
    … …  
    3030        s += '{}\n'.format(fielddisplay(self, 'coefficient', 'friction coefficient [SI]'))
    3131        return s
    32     #}}}
     32    # }}}
    3333
    3434    def setdefaultparameters(self):  # {{{
    3535        return self
    36     #}}}
     36    # }}}
    3737
    3838    def extrude(self, md):  # {{{
    3939        self.coefficient = project3d(md, 'vector', self.coefficient, 'type', 'node', 'layer', 1)
    4040        return self
    41     #}}}
     41    # }}}
    4242
    4343    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/frictionwaterlayer.py

    r25688 r27458  
    2727        elif nargs == 1:
    2828            self = structtoobj(self, args[0])
    29     #}}}
     29    # }}}
    3030
    3131    def __repr__(self):  # {{{
    … …  
    3737        s = "{}\n".format(fielddisplay(self, 'water_layer', 'water thickness at the base of the ice (m)'))
    3838        return s
    39     #}}}
     39    # }}}
    4040
    4141    def setdefaultparameters(self):  # {{{
    4242        return self
    43     #}}}
     43    # }}}
    4444
    4545    def checkconsistency(self, md, solution, analyses):  #{{{
    … …  
    7070        WriteData(fid, prefix, 'class', 'friction', 'object', self, 'fieldname', 'q', 'format', 'DoubleMat', 'mattype', 2)
    7171        WriteData(fid, prefix, 'class', 'friction', 'object', self, 'fieldname', 'water_layer', 'format', 'DoubleMat', 'mattype', 1, 'timeserieslength', md.mesh.numberofvertices + 1, 'yts', md.constants.yts)
    72     #}}}
     72    # }}}

  • issm/trunk-jpl/src/m/classes/frictionweertman.py

    r24668 r27458  
    1919        self.setdefaultparameters()
    2020
    21     #}}}
     21    # }}}
    2222
    2323    def __repr__(self):  # {{{
    … …  
    2727        string = "%s\n%s" % (string, fielddisplay(self, "m", "m exponent"))
    2828        return string
    29     #}}}
     29    # }}}
    3030
    3131    def setdefaultparameters(self):  # {{{
    3232        return self
    33     #}}}
     33    # }}}
    3434
    3535    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/frontalforcings.py

    r27453 r27458  
    2626        else:
    2727            raise Exception('constructor not supported')
    28     #}}}
     28    # }}}
    2929
    3030    def __repr__(self):  # {{{
    … …  
    3434
    3535        return s
    36     #}}}
     36    # }}}
    3737
    3838    def extrude(self, md):  # {{{
    … …  
    4040        self.ablationrate = project3d(md, 'vector', self.ablationrate, 'type', 'node')
    4141        return self
    42     #}}}
     42    # }}}
    4343
    4444    def setdefaultparameters(self):  # {{{
    … …  
    4646        self.ablationrate = np.nan
    4747        return self
    48     #}}}
     48    # }}}
    4949
    5050    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/frontalforcingsrignot.py

    r26905 r27458  
    2626            error('constructor not supported')
    2727
    28     #}}}
     28    # }}}
    2929
    3030    def __repr__(self):  # {{{
    … …  
    3535        s += '{}\n'.format(fielddisplay(self, 'thermalforcing', 'thermal forcing [∘C]'))
    3636        return s
    37     #}}}
     37    # }}}
    3838
    39     def setdefaultparameters(self): # {{{
     39    def setdefaultparameters(self):  # {{{
    4040        self.basin_id = np.nan
    4141        self.num_basins = 0
    … …  
    4444
    4545        return self
    46     #}}}
     46    # }}}
    4747
    4848    def extrude(self, md):  # {{{
    4949        return self
    50     #}}}
     50    # }}}
    5151
    5252    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/frontalforcingsrignotarma.py

    r27354 r27458  
    7474        s += '{}\n'.format(fielddisplay(self, 'sd_polynomialparams','coefficients for the sd_polynomial (const,trend,quadratic,etc.),dim1 for basins,dim2 for periods,dim3 for orders'))
    7575        return s
    76     #}}}
     76    # }}}
    7777
    7878    def setdefaultparameters(self):  # {{{
    … …  
    8383        self.ma_order = 0.0  # Moving-average model of order 0
    8484        return self
    85     #}}}
     85    # }}}
    8686
    8787    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/giacaron.py

    r25455 r27458  
    1616    """
    1717
    18     def __init__(self, *args): #{{{
     18    def __init__(self, *args):  # {{{
    1919        #Physical constants
    2020        self.gravitational_constant         = np.nan
    … …  
    5151        else:
    5252            raise Exception('constructor not supported')
    53     #}}}
     53    # }}}

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

    r26826 r27458  
    3737        return ['Surface', 'Base','MaskOceanLevelset']
    3838
    39     #}}}
     39    # }}}
    4040
    4141    def setdefaultparameters(self):  # {{{

  • issm/trunk-jpl/src/m/classes/hydrologyglads.py

    r27393 r27458  
    77
    88class hydrologyglads(object):
    9     """HYDROLOGYGLADS class definition
     9    """hydrologyglads class definition
    1010
    1111    Usage:
    … …  
    1313    """
    1414
    15     def __init__(self):  # {{{
    16         #Sheet
     15    def __init__(self, *args):  # {{{
     16        # Sheet
    1717        self.pressure_melt_coefficient = 0.
    1818        self.sheet_conductivity = np.nan
    … …  
    2020        self.bump_height = np.nan
    2121
    22         #Channels
     22        # Channels
    2323        self.ischannels = 0
    2424        self.channel_conductivity = np.nan
    2525        self.channel_sheet_width = 0.
    2626
    27         #Other
     27        # Other
    2828        self.spcphi = np.nan
    2929        self.moulin_input = np.nan
    … …  
    3333        self.melt_flag = 0
    3434
    35         # set defaults
    36         self.setdefaultparameters()
     35        nargs = len(args)
     36        if nargs == 0:
     37            self.setdefaultparameters()
     38        elif nargs == 1:
     39            # TODO: Replace the following with constructor
     40            self.setdefaultparameters()
     41        else:
     42            raise Exception('constructor not supported')
    3743        # }}}
    3844

  • issm/trunk-jpl/src/m/classes/hydrologyshakti.py

    r24213 r27458  
    2929        self.setdefaultparameters()
    3030
    31     #}}}
     31    # }}}
    3232    def __repr__(self):  # {{{
    3333        string = '   hydrologyshakti solution parameters:'
    … …  
    4545        string = "%s\n%s" % (string, fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    4646        return string
    47     #}}}
     47    # }}}
    4848
    4949    def extrude(self, md):  # {{{
    5050        return self
    51     #}}}
     51    # }}}
    5252
    5353    def setdefaultparameters(self):  # {{{
    … …  
    5757        self.requested_outputs = ['default']
    5858        return self
    59     #}}}
     59    # }}}
    6060
    6161    def defaultoutputs(self, md):  # {{{
    6262        list = ['HydrologyHead', 'HydrologyGapHeight', 'EffectivePressure', 'HydrologyBasalFlux', 'DegreeOfChannelization']
    6363        return list
    64     #}}}
     64    # }}}
    6565
    6666    def checkconsistency(self, md, solution, analyses):  # {{{

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

    r26301 r27458  
    1313    """
    1414
    15     def __init__(self, *args): #{{{
     15    def __init__(self, *args):  # {{{
    1616        self.spcwatercolumn = np.nan
    1717        self.stabilization = 0
    … …  
    2525        else:
    2626            raise RuntimeError('constructor not supported')
    27     #}}}
     27    # }}}
    2828
    29     def __repr__(self): #{{{
     29    def __repr__(self):  # {{{
    3030        s = '   hydrologyshreve solution parameters:\n'
    3131        s += '{}\n'.format(fielddisplay(self, 'spcwatercolumn', 'water thickness constraints (NaN means no constraint) [m]'))
    … …  
    3333        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    3434        return s
    35     #}}}
     35    # }}}
    3636
    37     def setdefaultparameters(self): #{{{
     37    def setdefaultparameters(self):  # {{{
    3838        # Type of stabilization to use 0:nothing 1:artificial_diffusivity
    3939        self.stabilization = 1
    4040        self.requested_outputs = ['default']
    41     #}}}
     41    # }}}
    4242
    43     def checkconsistency(self, md, solution, analyses): #{{{
     43    def checkconsistency(self, md, solution, analyses):  # {{{
    4444        #Early return
    4545        if 'HydrologyShreveAnalysis' not in analyses or (solution == 'TransientSolution' and not md.transient.ishydrology):
    … …  
    5151    # }}}
    5252
    53     def defaultoutputs(self, md): #{{{
     53    def defaultoutputs(self, md):  # {{{
    5454        return ['Watercolumn', 'HydrologyWaterVx', 'HydrologyWaterVy']
    55     #}}}
     55    # }}}
    5656
    57     def marshall(self, prefix, md, fid): #{{{
     57    def marshall(self, prefix, md, fid):  # {{{
    5858        WriteData(fid, prefix, 'name', 'md.hydrology.model', 'data', 2, 'format', 'Integer')
    5959        WriteData(fid, prefix, 'object', self, 'fieldname', 'spcwatercolumn', 'format', 'DoubleMat', 'mattype', 1, 'timeserieslength', md.mesh.numberofvertices + 1, 'yts', md.constants.yts)
    … …  
    6767    # }}}
    6868
    69     def extrude(self, md): #{{{
     69    def extrude(self, md):  # {{{
    7070        return self
    71     #}}}
     71    # }}}

  • issm/trunk-jpl/src/m/classes/hydrologytws.py

    r26840 r27458  
    2121        else:
    2222            raise RuntimeError('constructor not supported')
    23     #}}}
     23    # }}}
    2424
    2525    def __repr__(self):  # {{{
    … …  
    2828        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    2929        return s
    30     #}}}
     30    # }}}
    3131
    32     def defaultoutputs(self, md): # {{{
     32    def defaultoutputs(self, md):  # {{{
    3333        return ['']
    34     #}}}
     34    # }}}
    3535
    3636    def setdefaultparameters(self):  # {{{
    3737        self.requested_outputs = ['defualt']
    3838        return self
    39     #}}}
     39    # }}}
    4040
    4141    def extrude(self, md):  # {{{
    4242        return self
    43     #}}}
     43    # }}}
    4444
    4545    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    4848            return
    4949        md = checkfield(md, 'fieldname', 'hydrology.spcwatercolumn', 'Inf', 1, 'timeseries', 1)
    50     #}}}
     50    # }}}
    5151
    5252    def marshall(self, prefix, md, fid):  # {{{

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

    r27434 r27458  
    3737
    3838        self.setdefaultparameters()
    39     #}}}
     39    # }}}
    4040
    4141    def __repr__(self):  #{{{
    … …  
    5858        s += '{}\n'.format(fielddisplay(self, 'debris', 'Surface debris layer [m]'))
    5959        return s
    60     #}}}
     60    # }}}
    6161
    6262    def setdefaultparameters(self):  #{{{
    6363        return
    64     #}}}
     64    # }}}
    6565
    6666    def checkconsistency(self, md, solution, analyses):  #{{{
    … …  
    128128                    md = checkfield(md, 'fieldname', 'initialization.debris', 'NaN', 1,'Inf', 1, 'size', [md.mesh.numberofvertices])
    129129        return md
    130     #}}}
     130    # }}}
    131131
    132     def marshall(self, prefix, md, fid): #{{{
     132    def marshall(self, prefix, md, fid):  # {{{
    133133        yts = md.constants.yts
    134134
    … …  
    161161
    162162            WriteData(fid, prefix, 'data', self.enthalpy, 'format', 'DoubleMat', 'mattype', 1, 'name', 'md.initialization.enthalpy')
    163     #}}}
     163    # }}}
    164164
    165     def extrude(self, md): #{{{
     165    def extrude(self, md):  # {{{
    166166        self.vx = project3d(md, 'vector', self.vx, 'type', 'node')
    167167        self.vy = project3d(md, 'vector', self.vy, 'type', 'node')
    … …  
    189189
    190190        return self
    191     #}}}
     191    # }}}

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

    r27031 r27458  
    3838
    3939        self.setdefaultparameters()
    40     #}}}
     40    # }}}
    4141
    4242    def __repr__(self):  # {{{
    … …  
    7070        s += '{}\n'.format('   503: ThicknessAbsGradient')
    7171        return s
    72     #}}}
     72    # }}}
    7373
    7474    def setdefaultparameters(self):  # {{{
    … …  
    100100        self.cost_function_threshold = np.nan  #not activated
    101101        return self
    102     #}}}
     102    # }}}
    103103
    104104    def extrude(self, md):  # {{{
    … …  
    114114            self.max_parameters = project3d(md, 'vector', self.max_parameters, 'type', 'node')
    115115        return self
    116     #}}}
     116    # }}}
    117117
    118118    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/issmsettings.py

    r26358 r27458  
    2323        # Set defaults
    2424        self.setdefaultparameters()
    25     #}}}
     25    # }}}
    2626
    2727    def __repr__(self):  # {{{
    … …  
    3636        s += '{}\n'.format(fielddisplay(self, "solver_residue_threshold", "throw an error if solver residue exceeds this value (NaN to deactivate)"))
    3737        return s
    38     #}}}
     38    # }}}
    3939
    4040    def setdefaultparameters(self):  # {{{
    … …  
    5858
    5959        return self
    60     #}}}
     60    # }}}
    6161
    6262    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/levelset.py

    r27417 r27458  
    2424        # Set defaults
    2525        self.setdefaultparameters()
    26     #}}}
     26    # }}}
    2727    def __repr__(self):  # {{{
    2828        s = '   Level-set parameters:\n'
    … …  
    3535
    3636        return s
    37     #}}}
     37    # }}}
    3838
    3939    def setdefaultparameters(self):  # {{{
    … …  
    4848
    4949        return self
    50     #}}}
     50    # }}}
    5151
    5252    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    6767        self.spclevelset = project3d(md, 'vector', self.spclevelset, 'type', 'node')
    6868        return self
    69     #}}}
     69    # }}}
    7070
    7171    def marshall(self, prefix, md, fid):  # {{{

  • issm/trunk-jpl/src/m/classes/linearbasalforcings.py

    r25688 r27458  
    1414    """
    1515
    16     def __init__(self, *args): #{{{
     16    def __init__(self, *args):  # {{{
    1717        nargs = len(args)
    1818        if nargs == 0:
    … …  
    4343        else:
    4444            raise Exception('constructor not supported')
    45     #}}}
     45    # }}}
    4646
    47     def __repr__(self): #{{{
     47    def __repr__(self):  # {{{
    4848        s = '   linear basal forcings parameters:\n'
    4949        s += '{}\n'.format(fielddisplay(self, "deepwater_melting_rate", "basal melting rate (positive if melting applied for floating ice whith base < deepwater_elevation) [m/yr]"))
    … …  
    5555        s += '{}\n'.format(fielddisplay(self, "geothermalflux", "geothermal heat flux [W/m^2]"))
    5656        return s
    57     #}}}
     57    # }}}
    5858
    59     def extrude(self, md): #{{{
     59    def extrude(self, md):  # {{{
    6060        self.perturbation_melting_rate = project3d(md, 'vector', self.perturbation_melting_rate, 'type', 'node', 'layer', 1)
    6161        self.groundedice_melting_rate = project3d(md, 'vector', self.groundedice_melting_rate, 'type', 'node', 'layer', 1)
    6262        self.geothermalflux = project3d(md, 'vector', self.geothermalflux, 'type', 'node', 'layer', 1) # Bedrock only gets geothermal flux
    6363        return self
    64     #}}}
     64    # }}}
    6565
    66     def initialize(self, md): #{{{
     66    def initialize(self, md):  # {{{
    6767        if np.all(np.isnan(self.groundedice_melting_rate)):
    6868            self.groundedice_melting_rate = np.zeros((md.mesh.numberofvertices))
    6969            print("      no basalforcings.groundedice_melting_rate specified: values set as zero")
    7070        return self
    71     #}}}
     71    # }}}
    7272
    7373    def setdefaultparameters(self):  # {{{
    … …  
    7777        self.upperwater_elevation = -400.0
    7878        return self
    79     #}}}
     79    # }}}
    8080
    81     def checkconsistency(self, md, solution, analyses): #{{{
     81    def checkconsistency(self, md, solution, analyses):  # {{{
    8282        if not np.all(np.isnan(self.perturbation_melting_rate)):
    8383            md = checkfield(md, 'fieldname', 'basalforcings.perturbation_melting_rate', 'NaN', 1, 'Inf', 1, 'timeseries', 1)
    … …  
    103103
    104104        return md
    105     #}}}
     105    # }}}
    106106
    107     def marshall(self, prefix, md, fid): #{{{
     107    def marshall(self, prefix, md, fid):  # {{{
    108108        yts = md.constants.yts
    109109
    … …  
    116116        WriteData(fid, prefix, 'object', self, 'fieldname', 'upperwater_melting_rate', 'format', 'DoubleMat', 'mattype', 3, 'timeserieslength', 2, 'name', 'md.basalforcings.upperwater_melting_rate', 'scale', 1. / yts, 'yts', yts)
    117117        WriteData(fid, prefix, 'object', self, 'fieldname', 'upperwater_elevation', 'format', 'DoubleMat', 'mattype', 3, 'name', 'md.basalforcings.upperwater_elevation', 'yts', yts)
    118     #}}}
     118    # }}}

  • issm/trunk-jpl/src/m/classes/linearbasalforcingsarma.py

    r27417 r27458  
    5959    # }}}
    6060
    61     def setdefaultparameters(self): #{{{
     61    def setdefaultparameters(self):  # {{{
    6262        self.ar_order = 0.0 # Autoregression model of order 0
    6363        self.ma_order = 0.0 # Moving-average model of order 0

  • issm/trunk-jpl/src/m/classes/love.py

    r27333 r27458  
    1212    """
    1313
    14     def __init__(self): #{{{
     14    def __init__(self):  # {{{
    1515        self.nfreq = 0
    1616        self.frequencies = 0
    … …  
    4444
    4545        self.setdefaultparameters()
    46     #}}}
    47 
    48     def __repr__(self): #{{{
     46    # }}}
     47
     48    def __repr__(self):  # {{{
    4949        s = '{}\n'.format(fielddisplay(self, 'nfreq', 'number of frequencies sampled (default: 1, elastic) [Hz]'))
    5050        s += '{}\n'.format(fielddisplay(self, 'frequencies', 'frequencies sampled (convention defaults to 0 for the elastic case) [Hz]'))
    … …  
    9090
    9191        return s
    92     #}}}
    93 
    94     def setdefaultparameters(self): #{{{
     92    # }}}
     93
     94    def setdefaultparameters(self):  # {{{
    9595        # We setup an elastic love number computation by default
    9696        self.nfreq = 1
    … …  
    125125        self.hypergeom_nz = 1
    126126        self.hypergeom_z = 0
    127     #}}}
    128 
    129     def checkconsistency(self, md, solution, analyses): #{{{
     127    # }}}
     128
     129    def checkconsistency(self, md, solution, analyses):  # {{{
    130130        if 'LoveAnalysis' not in analyses:
    131131            return md
    … …  
    178178
    179179        return md
    180     #}}}
    181 
    182     def marshall(self, prefix, md, fid): #{{{
     180    # }}}
     181
     182    def marshall(self, prefix, md, fid):  # {{{
    183183        WriteData(fid, prefix, 'object', self, 'fieldname', 'nfreq', 'format', 'Integer')
    184184        WriteData(fid, prefix, 'object', self, 'fieldname', 'frequencies', 'format', 'DoubleMat', 'mattype',3)
    … …  
    211211        WriteData(fid, prefix, 'object', self, 'fieldname', 'hypergeom_nz', 'format', 'Integer')
    212212        WriteData(fid, prefix, 'object', self, 'fieldname', 'hypergeom_z', 'format', 'DoubleMat', 'mattype', 3)
    213     #}}}
    214 
    215     def extrude(self, md): #{{{
     213    # }}}
     214
     215    def extrude(self, md):  # {{{
    216216        return self
    217     #}}}
    218 
    219     def build_frequencies_from_time(self): #{{{
     217    # }}}
     218
     219    def build_frequencies_from_time(self):  # {{{
    220220        if not self.istemporal:
    221221            raise RuntimeError('cannot build frequencies for temporal love numbers if love.istemporal==0')
    … …  
    230230                    self.frequencies[(i - 1) * 2 * self.n_temporal_iterations + j] = j * np.log(2) / self.time[i] / 2 / np.pi
    231231        return self
    232     #}}}
     232    # }}}

  • issm/trunk-jpl/src/m/classes/lovenumbers.py

    r27453 r27458  
    4040        referenceframe = options.getfieldvalue('referenceframe', 'CM')
    4141        self.setdefaultparameters(maxdeg, referenceframe)
    42     #}}}
     42    # }}}
    4343
    4444    def __repr__(self):  #{{{
    … …  
    5858        s += '{}\n'.format(fielddisplay(self, 'pmtf_ortho', 'Orthogonal component of the Polar Motion Transfer Function (couples x and y components, only used for Chandler Wobble)'))
    5959        return s
    60     #}}}
     60    # }}}
    6161
    6262    def setdefaultparameters(self, maxdeg, referenceframe):  #{{{
    … …  
    8181        self.timefreq = np.zeros(1) # Elastic case by default
    8282        return self
    83     #}}}
     83    # }}}
    8484
    8585    def checkconsistency(self, md, solution, analyses):  #{{{
    … …  
    110110            raise ValueError('temporal love numbers must start with elastic response, i.e. timefreq[0] = 0')
    111111        return md
    112     #}}}
     112    # }}}
    113113
    114114    def defaultoutputs(self, md):  #{{{
    115115        return[]
    116     #}}}
     116    # }}}
    117117
    118118    def marshall(self, prefix, md, fid):  #{{{
    … …  
    134134        WriteData(fid, prefix, 'object', self, 'fieldname', 'istime', 'name', 'md.solidearth.lovenumbers.istime', 'format', 'Boolean')
    135135        WriteData(fid, prefix, 'object', self, 'fieldname', 'timefreq', 'name', 'md.solidearth.lovenumbers.timefreq', 'format', 'DoubleMat', 'mattype', 1, 'scale', scale);
    136     #}}}
     136    # }}}
    137137
    138138    def extrude(self, md):  #{{{
    139139        return
    140     #}}}
     140    # }}}

  • issm/trunk-jpl/src/m/classes/m1qn3inversion.py

    r26904 r27458  
    6060        else:
    6161            raise Exception('constructor not supported')
    62     #}}}
     62    # }}}
    6363
    6464    def __repr__(self):  # {{{
    … …  
    9191        s += '{}\n'.format('   503: ThicknessAbsGradient')
    9292        return s
    93     #}}}
     93    # }}}
    9494
    9595    def setdefaultparameters(self):  # {{{
    … …  
    111111
    112112        return self
    113     #}}}
     113    # }}}
    114114
    115115    def extrude(self, md):  # {{{
    … …  
    125125            self.max_parameters = project3d(md, 'vector', self.max_parameters, 'type', 'node')
    126126        return self
    127     #}}}
     127    # }}}
    128128
    129129    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/massfluxatgate.py

    r26904 r27458  
    3232        self = options.AssignObjectFields(self)
    3333
    34     #}}}
     34    # }}}
    3535
    3636    def __repr__(self):  # {{{
    … …  
    4141        string = "%s\n%s" % (string, fielddisplay(self, 'profilename', 'name of file (shapefile or argus file) defining a profile (or gate)'))
    4242        return string
    43     #}}}
     43    # }}}
    4444
    4545    def extrude(self, md):  # {{{
    4646        return self
    47     #}}}
     47    # }}}
    4848
    4949    def setdefaultparameters(self):  # {{{
    5050        return self
    51     #}}}
     51    # }}}
    5252
    5353    def checkconsistency(self, md, solution, analyses):  # {{{

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

    r27424 r27458  
    2727        self.setdefaultparameters()
    2828
    29     #}}}
     29    # }}}
    3030
    3131    def __repr__(self):  # {{{
    … …  
    3838        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    3939        return s
    40     #}}}
     40    # }}}
    4141
    4242    def extrude(self, md):  # {{{
    4343        self.spcthickness = project3d(md, 'vector', self.spcthickness, 'type', 'node')
    4444        return self
    45     #}}}
     45    # }}}
    4646
    4747    def defaultoutputs(self, md):  # {{{
    4848        return ['Thickness', 'Surface', 'Base']
    4949
    50     #}}}
     50    # }}}
    5151
    5252    def setdefaultparameters(self):  # {{{
    … …  
    6262        self.requested_outputs = ['default']
    6363        return self
    64     #}}}
     64    # }}}
    6565
    6666    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/matdamageice.py

    r26928 r27458  
    3636
    3737        self.setdefaultparameters()
    38     #}}}
     38    # }}}
    3939
    4040    def __repr__(self):  # {{{
    … …  
    5858        s += '{}\n'.format(fielddisplay(self, 'earth_density', 'Mantle density [kg m^-3]'))
    5959        return s
    60     #}}}
     60    # }}}
    6161
    6262    def extrude(self, md):  # {{{
    … …  
    6464        self.rheology_n = project3d(md, 'vector', self.rheology_n, 'type', 'element')
    6565        return self
    66     #}}}
     66    # }}}
    6767
    6868    def setdefaultparameters(self):  # {{{
    … …  
    100100        self.earth_density = 5512  # average density of the Earth (kg/m^3)
    101101        return self
    102     #}}}
     102    # }}}
    103103
    104104    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/materials.py

    r26928 r27458  
    1313    """
    1414
    15     def __init__(self, *args): #{{{
     15    def __init__(self, *args):  # {{{
    1616        self.nature = []
    1717        if len(args) == 0:
    … …  
    6868
    6969        self.setdefaultparameters()
    70     #}}}
    71 
    72     def __repr__(self): #{{{
     70    # }}}
     71
     72    def __repr__(self):  # {{{
    7373        s = '   Materials:\n'
    7474        for i in range(len(self.nature)):
    … …  
    119119                raise RuntimeError('materials constructor error message: nature of the material not supported yet! (\'ice\' or \'litho\' or \'hydro\')')
    120120        return s
    121     #}}}
    122 
    123     def setdefaultparameters(self): #{{{
     121    # }}}
     122
     123    def setdefaultparameters(self):  # {{{
    124124        for i in range(len(self.nature)):
    125125            nat = self.nature[i]
    … …  
    208208            # Average density of the Earth (kg/m^3)
    209209            self.earth_density = 5512
    210     #}}}
    211 
    212     def checkconsistency(self, md, solution, analyses): #{{{
     210    # }}}
     211
     212    def checkconsistency(self, md, solution, analyses):  # {{{
    213213        for i in range(len(self.nature)):
    214214            nat = self.nature[i]
    … …  
    261261
    262262        return md
    263     #}}}
    264 
    265     def marshall(self, prefix, md, fid): #{{{
     263    # }}}
     264
     265    def marshall(self, prefix, md, fid):  # {{{
    266266        #1: MatdamageiceEnum 2: MatestarEnum 3: MaticeEnum 4: MatenhancediceEnum 5: MaterialsEnum
    267267        WriteData(fid, prefix, 'name', 'md.materials.nature', 'data', naturetointeger(self.nature), 'format', 'IntMat', 'mattype', 3)
    … …  
    314314                raise RuntimeError('materials constructor error message: nature of the material not supported yet! (\'ice\' or \'litho\' or \'hydro\')')
    315315        WriteData(fid, prefix, 'data', self.earth_density, 'name', 'md.materials.earth_density', 'format', 'Double')
    316     #}}}
    317 
    318     def extrude(self, md): #{{{
     316    # }}}
     317
     318    def extrude(self, md):  # {{{
    319319        for i in range(len(self.nature)):
    320320            nat = self.nature[i]
    … …  
    323323                self.rheology_n = project3d(md, 'vector', self.rheology_n, 'type', 'element')
    324324            return self
    325     #}}}
    326 #}}}
    327 
    328 def naturetointeger(strnat): #{{{
     325    # }}}
     326# }}}
     327
     328def naturetointeger(strnat):  # {{{
    329329    intnat = np.zeros(len(strnat))
    330330
    … …  
    349349
    350350    return intnat
    351 #}}}
     351# }}}

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

    r24213 r27458  
    4141        self.setdefaultparameters()
    4242
    43     #}}}
     43    # }}}
    4444
    4545    def __repr__(self):  # {{{
    … …  
    7373        string = "%s\n%s" % (string, fielddisplay(self, "scale_factor", "Projection correction for volume, area, etc. computation"))
    7474        return string
    75     #}}}
     75    # }}}
    7676
    7777    def setdefaultparameters(self):  # {{{
    … …  
    8484
    8585        return self
    86     #}}}
     86    # }}}
    8787
    8888    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    111111    def domaintype(self):  # {{{
    112112        return "2Dhorizontal"
    113     #}}}
     113    # }}}
    114114
    115115    def dimension(self):  # {{{
    116116        return 2
    117     #}}}
     117    # }}}
    118118
    119119    def elementtype(self):  # {{{
    120120        return "Tria"
    121     #}}}
     121    # }}}
    122122
    123123    def marshall(self, prefix, md, fid):  # {{{

  • issm/trunk-jpl/src/m/classes/mesh2dvertical.py

    r24213 r27458  
    4141        self.setdefaultparameters()
    4242
    43     #}}}
     43    # }}}
    4444    def __repr__(self):  # {{{
    4545        string = "   2D tria Mesh (vertical):"
    … …  
    7070        string = "%s\n%s" % (string, fielddisplay(self, "scale_factor", "Projection correction for volume, area, etc. computation"))
    7171        return string
    72     #}}}
     72    # }}}
    7373
    7474    def setdefaultparameters(self):  # {{{
    … …  
    8181
    8282        return self
    83     #}}}
     83    # }}}
    8484
    8585    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    109109    def domaintype(self):  # {{{
    110110        return "2Dvertical"
    111     #}}}
     111    # }}}
    112112
    113113    def dimension(self):  # {{{
    114114        return 2
    115     #}}}
     115    # }}}
    116116
    117117    def elementtype(self):  # {{{
    118118        return "Tria"
    119     #}}}
     119    # }}}
    120120
    121121    def vertexflags(self, value):  # {{{
    … …  
    124124        flags[pos] = 1
    125125        return flags
    126     #}}}
     126    # }}}
    127127
    128128    def marshall(self, prefix, md, fid):  # {{{

  • issm/trunk-jpl/src/m/classes/mesh3dprisms.py

    r24213 r27458  
    5151    #set defaults
    5252        self.setdefaultparameters()
    53     #}}}
     53    # }}}
    5454
    5555    def __repr__(self):  # {{{
    … …  
    9595        string = "%s\n%s" % (string, fielddisplay(self, "scale_factor", "Projection correction for volume, area, etc. computation"))
    9696        return string
    97     #}}}
     97    # }}}
    9898
    9999    def setdefaultparameters(self):  # {{{
    … …  
    106106
    107107        return self
    108     #}}}
     108    # }}}
    109109
    110110    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    130130    def domaintype(self):  # {{{
    131131        return "3D"
    132     #}}}
     132    # }}}
    133133
    134134    def dimension(self):  # {{{
    135135        return 3
    136     #}}}
     136    # }}}
    137137
    138138    def elementtype(self):  # {{{
    139139        return "Penta"
    140     #}}}
     140    # }}}
    141141
    142142    def marshall(self, prefix, md, fid):  # {{{

  • issm/trunk-jpl/src/m/classes/mesh3dsurface.py

    r27417 r27458  
    1515    """
    1616
    17     def __init__(self, *args): #{{{
     17    def __init__(self, *args):  # {{{
    1818        self.x = np.nan
    1919        self.y = np.nan
    … …  
    5252        else:
    5353            raise RuntimeError('constructor not supported')
    54     #}}}
    55 
    56     def __repr__(self): #{{{
     54    # }}}
     55
     56    def __repr__(self):  # {{{
    5757        s = '   2D tria Mesh (surface):'
    5858
    … …  
    8484
    8585        return s
    86     #}}}
    87 
    88     def setdefaultparameters(self): #{{{
     86    # }}}
     87
     88    def setdefaultparameters(self):  # {{{
    8989        #The connectivity is the average number of nodes linked to a given node
    9090        #through an edge. This connectivity is used to initially allocate
    … …  
    9393        #test/NightlyRun/runme.py.
    9494        self.average_vertex_connectivity = 25
    95     #}}}
    96 
    97     def checkconsistency(self, md, solution, analyses): #{{{
     95    # }}}
     96
     97    def checkconsistency(self, md, solution, analyses):  # {{{
    9898        md = checkfield(md, 'fieldname', 'mesh.x', 'NaN', 1, 'Inf', 1, 'size', [md.mesh.numberofvertices])
    9999        md = checkfield(md, 'fieldname', 'mesh.y', 'NaN', 1, 'Inf', 1, 'size', [md.mesh.numberofvertices])
    … …  
    115115
    116116        return md
    117     #}}}
    118 
    119     def marshall(self, prefix, md, fid): #{{{
     117    # }}}
     118
     119    def marshall(self, prefix, md, fid):  # {{{
    120120        WriteData(fid, prefix, 'name', 'md.mesh.domain_type', 'data', 'Domain' + self.domaintype(), 'format', 'String')
    121121        WriteData(fid, prefix, 'name', 'md.mesh.domain_dimension', 'data', self.dimension(), 'format', 'Integer')
    … …  
    133133        WriteData(fid, prefix, 'object', self, 'fieldname', 'average_vertex_connectivity', 'format', 'Integer')
    134134        WriteData(fid, prefix, 'object', self, 'fieldname', 'vertexonboundary', 'format', 'DoubleMat', 'mattype', 1)
    135     #}}}
    136 
    137     def domaintype(self): #{{{
     135    # }}}
     136
     137    def domaintype(self):  # {{{
    138138        return '3Dsurface'
    139     #}}}
    140 
    141     def dimension(self): #{{{
     139    # }}}
     140
     141    def dimension(self):  # {{{
    142142        return 2
    143     #}}}
    144 
    145     def elementtype(self): #{{{
     143    # }}}
     144
     145    def elementtype(self):  # {{{
    146146        return 'Tria'
    147     #}}}
    148 
    149     def processmesh(self, options): #{{{
     147    # }}}
     148
     149    def processmesh(self, options):  # {{{
    150150        isplanet = 1
    151151        is2d = 0
    … …  
    157157
    158158        return x, y, z, elements, is2d, isplanet
    159     #}}}
    160 
    161     def savemodeljs(self, fid, modelname): #{{{
     159    # }}}
     160
     161    def savemodeljs(self, fid, modelname):  # {{{
    162162        fid.write('  #s.mesh = new mesh3dsurface()\n' % modelname)
    163163        writejs1Darray(fid, [modelname, '.mesh.x'], self.x)
    … …  
    180180        writejs1Darray(fid, [modelname, '.mesh.extractedvertices'], self.extractedvertices)
    181181        writejs1Darray(fid, [modelname, '.mesh.extractedelements'], self.extractedelements)
    182     #}}}
    183 
    184     def export(self, *args): #{{{
     182    # }}}
     183
     184    def export(self, *args):  # {{{
    185185        options = pairoptions(*args)
    186186
    … …  
    269269        #write style file:
    270270        applyqgisstyle(filename, 'mesh')
    271     #}}}
     271    # }}}

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

    r24213 r27458  
    2121        self.setdefaultparameters()
    2222
    23     #}}}
     23    # }}}
    2424    def __repr__(self):  # {{{
    2525        string = '   miscellaneous parameters:'
    … …  
    2929        string = "%s\n%s" % (string, fielddisplay(self, 'dummy', 'empty field to store some data'))
    3030        return string
    31     #}}}
     31    # }}}
    3232
    3333    def setdefaultparameters(self):  # {{{
    3434        return self
    35     #}}}
     35    # }}}
    3636
    3737    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/misfit.py

    r24213 r27458  
    4141        #do we cumulate misfit through time?
    4242        self.cumulated = cumulated if cumulated is not None else float('NaN')
    43     #}}}
     43    # }}}
    4444
    4545    def __repr__(self):  # {{{
    … …  
    5656        string = "%s\n%s" % (string, fielddisplay(self, 'weights_string', 'string for weights for identification purposes'))
    5757        return string
    58     #}}}
     58    # }}}
    5959
    6060    def extrude(self, md):  # {{{
    … …  
    6464            self.observation = project3d(md, 'vector', self.observation, 'type', 'node')
    6565        return self
    66     #}}}
     66    # }}}
    6767
    6868    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/mismipbasalforcings.py

    r25775 r27458  
    2121        self.geothermalflux           = np.nan
    2222        self.setdefaultparameters()
    23     #}}}
     23    # }}}
    2424    def __repr__(self):  # {{{
    2525        s = '   MISMIP + basal melt parameterization\n'
    … …  
    3030        s += '{}\n'.format(fielddisplay(self, "geothermalflux", "Geothermal heat flux [W / m^2]"))
    3131        return s
    32     #}}}
     32    # }}}
    3333    def extrude(self, md):  # {{{
    3434        self.groundedice_melting_rate = project3d(md, 'vector', self.groundedice_melting_rate, 'type', 'node', 'layer', 1)
    3535        self.geothermalflux = project3d(md, 'vector', self.geothermalflux, 'type', 'node', 'layer', 1)  #bedrock only gets geothermal flux
    3636        return self
    37     #}}}
     37    # }}}
    3838    def initialize(self, md):  # {{{
    3939        if np.all(np.isnan(self.groundedice_melting_rate)):
    … …  
    4444            print("      no basalforcings.geothermalflux specified: values set as zero")
    4545        return self
    46     #}}}
     46    # }}}
    4747    def setdefaultparameters(self):  # {{{
    4848        # default values for melting parameterization
    … …  
    5151        self.upperdepth_melt = -100.
    5252        return self
    53     #}}}
     53    # }}}
    5454    def checkconsistency(self, md, solution, analyses):  # {{{
    5555        # Early return

  • issm/trunk-jpl/src/m/classes/model.py

    r27453 r27458  
    7171from sampling import sampling
    7272from stochasticforcing import stochasticforcing
    73 #}}}
     73# }}}
    7474
    7575
    … …  
    135135            planet = options.getfieldvalue('planet', 'earth')
    136136            self.setdefaultparameters(planet)
    137     #}}}
     137    # }}}
    138138
    139139    def __repr__(obj):  #{{{
    … …  
    186186        s = '%s\n%s' % (s, '%19s: %-23s -- %s' % ('stochasticforcing', '[%s %s]' % ('1x1', obj.stochasticforcing.__class__.__name__), 'stochasticity applied to model forcings'))
    187187        return s
    188     #}}}
     188    # }}}
    189189
    190190    def properties(self):  #{{{
    … …  
    237237            'stochasticforcing'
    238238        ]
    239     #}}}
     239    # }}}
    240240
    241241    def setdefaultparameters(self, planet):  #{{{
    … …  
    285285        self.private = private()
    286286        self.stochasticforcing = stochasticforcing()
    287     #}}}
     287    # }}}
    288288
    289289    def checkmessage(self, string):  #{{{
    … …  
    291291        self.private.isconsistent = False
    292292        return self
    293     #}}}
     293    # }}}
    294294    #@staticmethod
    295295
    … …  
    571571
    572572        return md2
    573     #}}}
     573    # }}}
    574574
    575575    def extrude(md, *args):  #{{{
    … …  
    760760
    761761        return md
    762     #}}}
     762    # }}}
    763763
    764764    def collapse(md):  #{{{
    … …  
    990990
    991991        return md
    992     #}}}
     992    # }}}

  • issm/trunk-jpl/src/m/classes/nodalvalue.py

    r26317 r27458  
    3333        self.model_string = options.getfieldvalue('model_string', '')
    3434        self.node = options.getfieldvalue('node', '')
    35     #}}}
     35    # }}}
    3636
    3737    def __repr__(self):  # {{{
    … …  
    4242        s += '{}\n'.format(fielddisplay(self, 'node', 'vertex index at which we retrieve the value'))
    4343        return s
    44     #}}}
     44    # }}}
    4545
    4646    def setdefaultparameters(self):  # {{{
    4747        return self
    48     #}}}
     48    # }}}
    4949
    5050    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    5757        md = checkfield(md, 'fieldname', 'self.node', 'field', self.node, 'values', range(md.mesh.numberofvertices))
    5858        return md
    59     #}}}
     59    # }}}
    6060
    6161    def marshall(self, prefix, md, fid):  #{{{
    … …  
    6464        WriteData(fid, prefix, 'data', self.model_string, 'name', 'md.nodalvalue.model_enum', 'format', 'String')
    6565        WriteData(fid, prefix, 'data', self.node, 'name', 'md.nodalvalue.node', 'format', 'Integer')
    66     #}}}
     66    # }}}

  • issm/trunk-jpl/src/m/classes/offlinesolidearthsolution.py

    r26352 r27458  
    1313    """
    1414
    15     def __init__(self, *args): #{{{
     15    def __init__(self, *args):  # {{{
    1616        self.displacementeast = None
    1717        self.displacementnorth = None
    … …  
    2323        else:
    2424            raise RuntimeError('constructor not supported')
    25     #}}}
     25    # }}}
    2626
    27     def __repr__(self): #{{{
     27    def __repr__(self):  # {{{
    2828        s = '         units for time series is (yr)\n       external: offlinesolidearth solution\n'
    2929        s += '{}\n'.format(fielddisplay(self, 'displacementeast', 'solid-Earth Eastwards bedrock displacement series (m)'))
    … …  
    3333
    3434        return s
    35     #}}}
     35    # }}}
    3636
    37     def setdefaultparameters(self): #{{{
     37    def setdefaultparameters(self):  # {{{
    3838        self.displacementeast = []
    3939        self.displacementnorth = []
    4040        self.displacementup = []
    4141        self.geoid = []
    42     #}}}
     42    # }}}
    4343
    44     def checkconsistency(self, md, solution, analyses): #{{{
     44    def checkconsistency(self, md, solution, analyses):  # {{{
    4545        if ('SealevelchangeAnalysis' not in analyses) or ((solution=='TransientSolution') and (md.solidearth.settings.isgrd==1)):
    4646            print('offlinesolidearthsolution checkconsistency error message: trying to run GRD patterns while supplying an offline solution for those patterns!')
    … …  
    5050        md = checkfield(md, 'fieldname', 'solidearth.external.displacementup', 'Inf', 1, 'timeseries', 1)
    5151        md = checkfield(md, 'fieldname', 'solidearth.external.geoid', 'Inf', 1, 'timeseries', 1)
    52     #}}}
     52    # }}}
    5353
    54     def marshall(self, prefix, md, fid): #{{{
     54    def marshall(self, prefix, md, fid):  # {{{
    5555        yts = md.constants.yts
    5656
    … …  
    7979        WriteData(fid, prefix, 'object', self, 'fieldname', 'displacementnorth', 'data', displacementnorth_rate,'format', 'DoubleMat', 'name', 'md.solidearth.external.displacementnorth', 'mattype', 1, 'scale', 1 / yts,'timeserieslength', md.mesh.numberofvertices + 1, 'yts', yts);
    8080        WriteData(fid, prefix, 'object', self, 'fieldname', 'geoid', 'data', geoid_rate,'format', 'DoubleMat', 'name', 'md.solidearth.external.geoid', 'mattype', 1, 'scale', 1 / yts,'timeserieslength', md.mesh.numberofvertices + 1, 'yts', yts);
    81     #}}}
     81    # }}}
    8282
    83     def extrude(self, md): #{{{
     83    def extrude(self, md):  # {{{
    8484        return self
    85     #}}}
     85    # }}}

  • issm/trunk-jpl/src/m/classes/organizer.py

    r26390 r27458  
    7272                raise TypeError("trunkprefix should not have any white space")
    7373            self.trunkprefix = trunkprefix
    74     #}}}
     74    # }}}
    7575
    7676    def __repr__(self):  # {{{
    … …  
    8383            for step in self.steps:
    8484                s += "%s\n" % "   step  #%2i: '%s'", step['id'], step['string']
    85     #}}}
     85    # }}}
    8686
    8787    def load(self, string):  # {{{
    … …  
    100100
    101101        return md
    102     #}}}
     102    # }}}
    103103
    104104    def loadmodel(self, string):  # {{{
    … …  
    128128        else:
    129129            raise IOError("Could not find '%s'" % path1)
    130     #}}}
     130    # }}}
    131131
    132132    def perform(self, string):  # {{{
    … …  
    165165
    166166        return bool
    167     #}}}
     167    # }}}
    168168
    169169    def savemodel(self, md, name='default'):  # {{{
    … …  
    188188    #save model
    189189        savevars(name, 'md', md)
    190     #}}}
     190    # }}}

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

    r24213 r27458  
    1515    def __init__(self):  # {{{
    1616        self.definitions = []
    17     #}}}
     17    # }}}
    1818
    1919    def __repr__(self):  # {{{
    … …  
    2323
    2424        return string
    25     #}}}
     25    # }}}
    2626
    2727    def extrude(self, md):  # {{{
    … …  
    3030
    3131        return self
    32     #}}}
     32    # }}}
    3333
    3434    def setdefaultparameters(self):  # {{{
    3535        return self
    36     #}}}
     36    # }}}
    3737
    3838    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/pairoptions.py

    r26909 r27458  
    9999    # }}}
    100100
    101     def displayunused(self): #{{{
     101    def displayunused(self):  # {{{
    102102        """DISPLAYUNUSED - display unused options
    103103        """

  • issm/trunk-jpl/src/m/classes/plotoptions.py

    r25816 r27458  
    1818
    1919        self.buildlist(*arg)
    20     #}}}
     20    # }}}
    2121
    2222    def __repr__(self):  #{{{
    … …  
    3232            s += "    list: empty\n"
    3333        return s
    34     #}}}
     34    # }}}
    3535
    3636    def buildlist(self, *arg):  #{{{
    … …  
    125125                if j + 1 > numberofplots:
    126126                    print(("WARNING: too many instances of '%s' in options" % rawlist[i][0]))
    127     #}}}
     127    # }}}

  • issm/trunk-jpl/src/m/classes/private.py

    r24213 r27458  
    2020        self.setdefaultparameters()
    2121
    22     #}}}
     22    # }}}
    2323
    2424    def __repr__(self):  # {{{
    … …  
    3030        string = "%s\n%s" % (string, fielddisplay(self, 'solution', 'type of solution launched'))
    3131        return string
    32     #}}}
     32    # }}}
    3333
    3434    def setdefaultparameters(self):  # {{{
    3535        return self
    36     #}}}
     36    # }}}
    3737
    3838    def checkconsistency(self, md, solution, analyses):  # {{{

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

    r26339 r27458  
    4444
    4545        self.setdefaultparameters()
    46     #}}}
     46    # }}}
    4747    def __repr__(self):  # {{{
    4848        s = '   qmu parameters:\n'
    … …  
    128128    def extrude(self, md):  # {{{
    129129        return self
    130     #}}}
     130    # }}}
    131131
    132132    def setdefaultparameters(self):  # {{{
    133133        return self
    134     #}}}
     134    # }}}
    135135
    136136    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/qmu/histogram_bin_uncertain.py

    r25097 r27458  
    2727    '''
    2828
    29     def __init__(self): #{{{
     29    def __init__(self):  # {{{
    3030        self.descriptor = ''
    3131        self.pairs_per_variable = []
    3232        self.abscissas = []
    3333        self.counts = []
    34     #}}}
    35 
    36     @staticmethod
    37     def histogram_bin_uncertain(*args): #{{{
     34    # }}}
     35
     36    @staticmethod
     37    def histogram_bin_uncertain(*args):  # {{{
    3838        nargin = len(args)
    3939
    … …  
    6969
    7070    @staticmethod
    71     def __repr__(hbu): #{{{
     71    def __repr__(hbu):  # {{{
    7272        s = ""
    7373        for i in range(len(hbu)):
    … …  
    7979
    8080        return s
    81     #}}}
    82 
    83     def checkconsistency(self, md, solution, analyses): #{{{
     81    # }}}
     82
     83    def checkconsistency(self, md, solution, analyses):  # {{{
    8484        return
    85     #}}}
     85    # }}}
    8686
    8787    #virtual functions needed by qmu processing algorithms
    … …  
    8989
    9090    @staticmethod
    91     def prop_desc(hbu, dstr): #{{{
     91    def prop_desc(hbu, dstr):  # {{{
    9292        desc = ['' for i in range(np.size(hbu))]
    9393        for i in range(np.size(hbu)):
    … …  
    102102
    103103        return desc
    104     #}}}
    105 
    106     @staticmethod
    107     def prop_mean(hbu): #{{{
     104    # }}}
     105
     106    @staticmethod
     107    def prop_mean(hbu):  # {{{
    108108        mean = np.zeros(np.size(hbu))
    109109        for i in range(np.size(hbu)):
    110110            mean[i] = hbu[i].mean
    111111        return mean
    112     #}}}
    113 
    114     @staticmethod
    115     def prop_stddev(hbu): #{{{
     112    # }}}
     113
     114    @staticmethod
     115    def prop_stddev(hbu):  # {{{
    116116        stddev = np.zeros(np.size(hbu))
    117117        for i in range(np.size(hbu)):
    118118            stddev[i] = hbu[i].stddev
    119119        return stddev
    120     #}}}
    121 
    122     @staticmethod
    123     def prop_lower(hbu): #{{{
     120    # }}}
     121
     122    @staticmethod
     123    def prop_lower(hbu):  # {{{
    124124        lower = []
    125125        return
    126     #}}}
    127 
    128     @staticmethod
    129     def prop_upper(hbu): #{{{
     126    # }}}
     127
     128    @staticmethod
     129    def prop_upper(hbu):  # {{{
    130130        upper = []
    131131        return upper
    132     #}}}
     132    # }}}
    133133
    134134    #default
    135135    @staticmethod
    136     def prop_abscissas(hbu): #{{{
     136    def prop_abscissas(hbu):  # {{{
    137137        abscissas = []
    138138        for i in range(len(hbu)):
    … …  
    140140        abscissas = allequal(abscissas, -np.inf)
    141141        return abscissas
    142     #}}}
    143 
    144     @staticmethod
    145     def prop_pairs_per_variable(hbu): #{{{
     142    # }}}
     143
     144    @staticmethod
     145    def prop_pairs_per_variable(hbu):  # {{{
    146146        pairs_per_variable = np.zeros((1, len(hbu)))
    147147        for i in range(len(hbu)):
    … …  
    149149        abscissas = allequal(pairs_per_variable, -np.inf)
    150150        return pairs_per_variable
    151     #}}}
    152 
    153     @staticmethod
    154     def prop_counts(hbu): #{{{
     151    # }}}
     152
     153    @staticmethod
     154    def prop_counts(hbu):  # {{{
    155155        counts = []
    156156        for i in range(len(hbu)):
    … …  
    158158        counts = allequal(counts, -np.inf)
    159159        return counts
    160     #}}}
    161 
    162     @staticmethod
    163     def prop_initpt(hbu): #{{{
     160    # }}}
     161
     162    @staticmethod
     163    def prop_initpt(hbu):  # {{{
    164164        initpt = []
    165165        return initpt
    166     #}}}
    167 
    168     @staticmethod
    169     def prop_initst(hbu): #{{{
     166    # }}}
     167
     168    @staticmethod
     169    def prop_initst(hbu):  # {{{
    170170        inist = []
    171171        return inist
    172     #}}}
    173 
    174     @staticmethod
    175     def prop_stype(hbu): #{{{
     172    # }}}
     173
     174    @staticmethod
     175    def prop_stype(hbu):  # {{{
    176176        stype = []
    177177        return stype
    178     #}}}
    179 
    180     @staticmethod
    181     def prop_scale(hbu): #{{{
     178    # }}}
     179
     180    @staticmethod
     181    def prop_scale(hbu):  # {{{
    182182        scale = []
    183183        return scale
    184     #}}}
     184    # }}}
    185185
    186186    #new methods:
    187     def isscaled(self): #{{{
     187    def isscaled(self):  # {{{
    188188        if strncmp(self.descriptor, 'scaled_', 7):
    189189            return True
    190190        else:
    191191            return False
    192     #}}}
     192    # }}}
    193193
    194194    @staticmethod
    … …  
    204204        if len(hbu) > 0:
    205205            vlist_write(fidi, 'histogram_bin_uncertain', 'hbu', hbu)
    206     #}}}
     206    # }}}

  • issm/trunk-jpl/src/m/classes/qmu/normal_uncertain.py

    r25688 r27458  
    3939    """
    4040
    41     def __init__(self): #{{{
     41    def __init__(self):  # {{{
    4242        self.descriptor = ''
    4343        self.mean       = np.nan
    … …  
    4545        self.partition  = []
    4646        self.nsteps     = 0
    47     #}}}
    48 
    49     @staticmethod
    50     def normal_uncertain(*args): #{{{
     47    # }}}
     48
     49    @staticmethod
     50    def normal_uncertain(*args):  # {{{
    5151        nargin = len(args)
    5252
    … …  
    9191
    9292        return [nuv] # Always return a list, so we have something akin to a MATLAB single row matrix
    93     #}}}
    94 
    95     def __repr__(self): #{{{
     93    # }}}
     94
     95    def __repr__(self):  # {{{
    9696        string = '   normal uncertain variable: '
    9797        string = "%s\n%s" % (string, fielddisplay(self, 'descriptor', 'name tag'))
    … …  
    103103
    104104        return string
    105     #}}}
    106 
    107     def __len__(self): #{{{
     105    # }}}
     106
     107    def __len__(self):  # {{{
    108108        if type(self.mean) in [list, np.ndarray]:
    109109            return len(self.mean)
    110110        else:
    111111            return 1
    112     #}}}
    113 
    114     def checkconsistency(self, md, solution, analyses): #{{{
     112    # }}}
     113
     114    def checkconsistency(self, md, solution, analyses):  # {{{
    115115        md = checkfield(md, 'field', self.mean, 'fieldname', 'normal_uncertain.mean', 'NaN', 1, 'Inf', 1, '>=', 0)
    116116        md = checkfield(md, 'field', self.stddev, 'fieldname', 'normal_uncertain.stddev', 'NaN', 1, 'Inf', 1, '>=', 0)
    … …  
    139139            if partmax > nmax:
    140140                raise Exception("normal_uncertain error message: partition vector's values cannot go over the number of vertices or elements")
    141     #}}}
     141    # }}}
    142142
    143143    #virtual functions needed by qmu processing algorithms
    … …  
    145145
    146146    @staticmethod
    147     def prop_desc(nuv, dstr): #{{{
     147    def prop_desc(nuv, dstr):  # {{{
    148148        desc = ['' for i in range(np.size(nuv))]
    149149        for i in range(np.size(nuv)):
    … …  
    158158
    159159        return desc
    160     #}}}
    161 
    162     @staticmethod
    163     def prop_mean(nuv): #{{{
     160    # }}}
     161
     162    @staticmethod
     163    def prop_mean(nuv):  # {{{
    164164        mean = np.zeros(np.size(nuv))
    165165        for i in range(np.size(nuv)):
    166166            mean[i] = nuv[i].mean
    167167        return mean
    168     #}}}
    169 
    170     @staticmethod
    171     def prop_stddev(nuv): #{{{
     168    # }}}
     169
     170    @staticmethod
     171    def prop_stddev(nuv):  # {{{
    172172        stddev = np.zeros(np.size(nuv))
    173173        for i in range(np.size(nuv)):
    174174            stddev[i] = nuv[i].stddev
    175175        return stddev
    176     #}}}
    177 
    178     @staticmethod
    179     def prop_lower(nuv): #{{{
     176    # }}}
     177
     178    @staticmethod
     179    def prop_lower(nuv):  # {{{
    180180        lower = []
    181181        return lower
    182     #}}}
    183 
    184     @staticmethod
    185     def prop_upper(nuv): #{{{
     182    # }}}
     183
     184    @staticmethod
     185    def prop_upper(nuv):  # {{{
    186186        upper = []
    187187        return upper
    188     #}}}
     188    # }}}
    189189
    190190    #default
    191191    @staticmethod
    192     def prop_abscissas(hbu): #{{{
     192    def prop_abscissas(hbu):  # {{{
    193193        abscissas = []
    194194        return abscissas
    195     #}}}
    196 
    197     @staticmethod
    198     def prop_pairs_per_variable(hbu): #{{{
     195    # }}}
     196
     197    @staticmethod
     198    def prop_pairs_per_variable(hbu):  # {{{
    199199        pairs_per_variable = []
    200200        return pairs_per_variable
    201     #}}}
    202 
    203     @staticmethod
    204     def prop_counts(hbu): #{{{
     201    # }}}
     202
     203    @staticmethod
     204    def prop_counts(hbu):  # {{{
    205205        counts = []
    206206        return counts
    207     #}}}
    208     @staticmethod
    209     def prop_initpt(nuv): #{{{
     207    # }}}
     208    @staticmethod
     209    def prop_initpt(nuv):  # {{{
    210210        initpt = []
    211211        return initpt
    212     #}}}
    213 
    214     @staticmethod
    215     def prop_initst(nuv): #{{{
     212    # }}}
     213
     214    @staticmethod
     215    def prop_initst(nuv):  # {{{
    216216        inist = []
    217217        return inist
    218     #}}}
    219 
    220     @staticmethod
    221     def prop_stype(nuv): #{{{
     218    # }}}
     219
     220    @staticmethod
     221    def prop_stype(nuv):  # {{{
    222222        stype = []
    223223        return stype
    224     #}}}
    225 
    226     @staticmethod
    227     def prop_scale(nuv): #{{{
     224    # }}}
     225
     226    @staticmethod
     227    def prop_scale(nuv):  # {{{
    228228        scale = []
    229229        return scale
    230     #}}}
     230    # }}}
    231231
    232232    #new methods:
    233     def isdistributed(self): #{{{
     233    def isdistributed(self):  # {{{
    234234        if strncmp(self.descriptor, 'distributed_', 12):
    235235            return True
    236236        else:
    237237            return False
    238     #}}}
     238    # }}}
    239239   
    240     def isscaled(self): #{{{
     240    def isscaled(self):  # {{{
    241241        if strncmp(self.descriptor, 'scaled_', 7):
    242242            return True
    243243        else:
    244244            return False
    245     #}}}
     245    # }}}
    246246
    247247    @staticmethod
    … …  
    257257        if len(nuv) > 0:
    258258            vlist_write(fidi, 'normal_uncertain', 'nuv', nuv)
    259     #}}}
    260 
     259    # }}}
     260

  • issm/trunk-jpl/src/m/classes/qmu/response_function.py

    r25011 r27458  
    103103        return [rf] # Always return a list, so we have something akin to a MATLAB single row matrix
    104104
    105     def __repr__(rf): #{{{
     105    def __repr__(rf):  # {{{
    106106        # display the object
    107107        string = 'class "response_function" object = \n'
    … …  
    116116
    117117        return string
    118     #}}}
    119 
    120     def __len__(self): #{{{
     118    # }}}
     119
     120    def __len__(self):  # {{{
    121121        return max(len(self.respl), len(self.probl), len(self.rell), len(self.grell))
    122     #}}}
    123 
    124     @staticmethod
    125     def prop_desc(rf, dstr): #{{{
     122    # }}}
     123
     124    @staticmethod
     125    def prop_desc(rf, dstr):  # {{{
    126126        desc = ['' for i in range(np.size(rf))]
    127127        for i in range(np.size(rf)):
    … …  
    135135        desc = allempty(desc)
    136136        return desc
    137     #}}}
    138 
    139     @staticmethod
    140     def prop_stype(rf): #{{{
     137    # }}}
     138
     139    @staticmethod
     140    def prop_stype(rf):  # {{{
    141141        stype = []
    142142        return stype
    143     #}}}
    144 
    145     @staticmethod
    146     def prop_scale(rf): #{{{
     143    # }}}
     144
     145    @staticmethod
     146    def prop_scale(rf):  # {{{
    147147        scale = []
    148148        return scale
    149     #}}}
    150 
    151     @staticmethod
    152     def prop_weight(rf): #{{{
     149    # }}}
     150
     151    @staticmethod
     152    def prop_weight(rf):  # {{{
    153153        weight = []
    154154        return weight
    155     #}}}
    156 
    157     @staticmethod
    158     def prop_lower(rf): #{{{
     155    # }}}
     156
     157    @staticmethod
     158    def prop_lower(rf):  # {{{
    159159        lower = []
    160160        return lower
    161     #}}}
    162 
    163     @staticmethod
    164     def prop_upper(rf): #{{{
     161    # }}}
     162
     163    @staticmethod
     164    def prop_upper(rf):  # {{{
    165165        upper = []
    166166        return upper
    167     #}}}
    168 
    169     @staticmethod
    170     def prop_target(rf): #{{{
     167    # }}}
     168
     169    @staticmethod
     170    def prop_target(rf):  # {{{
    171171        target = []
    172172        return target
    173     #}}}
     173    # }}}
    174174
    175175    @staticmethod
    … …  
    191191
    192192    #new methods:
    193     def isscaled(self): #{{{
     193    def isscaled(self):  # {{{
    194194        if strncmpi(self.descriptor, 'scaled_', 7):
    195195            return True
    196196        else:
    197197            return False
    198     #}}}
     198    # }}}
    199199
    200200    @staticmethod

  • issm/trunk-jpl/src/m/classes/qmu/uniform_uncertain.py

    r25105 r27458  
    3939            )
    4040    '''
    41     def __init__(self): #{{{
     41    def __init__(self):  # {{{
    4242        self.descriptor = ''
    4343        self.lower      = -np.inf
    … …  
    4545        self.partition  = []
    4646        self.nsteps     = 0
    47     #}}}
    48 
    49     @staticmethod
    50     def uniform_uncertain(*args): #{{{
     47    # }}}
     48
     49    @staticmethod
     50    def uniform_uncertain(*args):  # {{{
    5151        nargin = len(args)
    5252
    … …  
    9191
    9292        return [uuv] # Always return a list, so we have something akin to a MATLAB single row matrix
    93     #}}}
    94 
    95     def __repr__(self): #{{{
     93    # }}}
     94
     95    def __repr__(self):  # {{{
    9696        string = '   uniform uncertain variable: '
    9797        string = "%s\n%s" % (string, fielddisplay(self, 'descriptor', 'name tag'))
    … …  
    103103
    104104        return string
    105     #}}}
    106 
    107     def __len__(self): #{{{
     105    # }}}
     106
     107    def __len__(self):  # {{{
    108108        if type(self.lower) in [list, np.ndarray]:
    109109            return len(self.lower)
    110110        else:
    111111            return 1
    112     #}}}
     112    # }}}
    113113   
    114     def checkconsistency(self, md, solution, analyses): #{{{
     114    def checkconsistency(self, md, solution, analyses):  # {{{
    115115        md = checkfield(md, 'field', self.upper, 'fieldname', 'uniform_uncertain.upper', 'NaN', 1, 'Inf', 1, '>', self.lower, 'numel', len(self.lower))
    116116        md = checkfield(md, 'field', self.lower, 'fieldname', 'uniform_uncertain.upper', 'NaN', 1, 'Inf', 1, '<', self.upper, 'numel', len(self.upper))
    … …  
    140140            if partmax > nmax:
    141141                raise Exception("uniform_uncertain error message: partition vector's values cannot go over the number of vertices or elements")
    142     #}}}
     142    # }}}
    143143
    144144    #virtual functions needed by qmu processing algorithms:
    … …  
    146146
    147147    @staticmethod
    148     def prop_desc(uuv, dstr): #{{{
     148    def prop_desc(uuv, dstr):  # {{{
    149149        desc = ['' for i in range(np.size(uuv))]
    150150        for i in range(np.size(uuv)):
    … …  
    159159
    160160        return desc
    161     #}}}
    162 
    163     @staticmethod
    164     def prop_stddev(uuv): #{{{
     161    # }}}
     162
     163    @staticmethod
     164    def prop_stddev(uuv):  # {{{
    165165        stddev = []
    166166        return stddev
    167     #}}}
    168 
    169     @staticmethod
    170     def prop_mean(uuv): #{{{
     167    # }}}
     168
     169    @staticmethod
     170    def prop_mean(uuv):  # {{{
    171171        mean = []
    172172        return mean
    173     #}}}
    174 
    175     @staticmethod
    176     def prop_lower(uuv): #{{{
     173    # }}}
     174
     175    @staticmethod
     176    def prop_lower(uuv):  # {{{
    177177        lower = np.zeros(np.size(uuv))
    178178        for i in range(np.size(uuv)):
    … …  
    182182
    183183        return lower
    184     #}}}
    185 
    186     @staticmethod
    187     def prop_upper(uuv): #{{{
     184    # }}}
     185
     186    @staticmethod
     187    def prop_upper(uuv):  # {{{
    188188        upper = np.zeros(np.size(uuv))
    189189        for i in range(np.size(uuv)):
    … …  
    193193
    194194        return upper
    195     #}}}
    196 
    197     @staticmethod
    198     def prop_abscissas(hbu): #{{{
     195    # }}}
     196
     197    @staticmethod
     198    def prop_abscissas(hbu):  # {{{
    199199        abscissas = []
    200200        return abscissas
    201     #}}}
    202 
    203     @staticmethod
    204     def prop_pairs_per_variable(hbu): #{{{
     201    # }}}
     202
     203    @staticmethod
     204    def prop_pairs_per_variable(hbu):  # {{{
    205205        pairs_per_variable = []
    206206        return pairs_per_variable
    207     #}}}
    208 
    209     @staticmethod
    210     def prop_counts(hbu): #{{{
     207    # }}}
     208
     209    @staticmethod
     210    def prop_counts(hbu):  # {{{
    211211        counts = []
    212212        return counts
    213     #}}}
    214 
    215     @staticmethod
    216     def prop_initpt(uuv): #{{{
     213    # }}}
     214
     215    @staticmethod
     216    def prop_initpt(uuv):  # {{{
    217217        initpt = []
    218218        return initpt
    219     #}}}
    220 
    221     @staticmethod
    222     def prop_initst(uuv): #{{{
     219    # }}}
     220
     221    @staticmethod
     222    def prop_initst(uuv):  # {{{
    223223        initst = []
    224224        return initst
    225     #}}}
    226 
    227     @staticmethod
    228     def prop_stype(uuv): #{{{
     225    # }}}
     226
     227    @staticmethod
     228    def prop_stype(uuv):  # {{{
    229229        stype = []
    230230        return stype
    231     #}}}
    232 
    233     @staticmethod
    234     def prop_scale(uuv): #{{{
     231    # }}}
     232
     233    @staticmethod
     234    def prop_scale(uuv):  # {{{
    235235        scale = []
    236236        return scale
    237     #}}}
     237    # }}}
    238238
    239239    #new methods:
    240     def isscaled(self): #{{{
     240    def isscaled(self):  # {{{
    241241        if strncmp(self.descriptor, 'scaled_', 7):
    242242            return True
    243243        else:
    244244            return False
    245     #}}}
    246 
    247     @staticmethod
    248     def dakota_write(fidi, dvar): #{{{
     245    # }}}
     246
     247    @staticmethod
     248    def dakota_write(fidi, dvar):  # {{{
    249249        # possible namespace pollution, the above import seems not to work
    250250        from vlist_write import vlist_write
    … …  
    257257        if len(uuv) > 0:
    258258            vlist_write(fidi, 'uniform_uncertain', 'uuv', uuv)
    259     #}}}
     259    # }}}

  • issm/trunk-jpl/src/m/classes/qmustatistics.py

    r25817 r27458  
    4444        else:
    4545            raise Exception('constructor not supported')
    46     #}}}
     46    # }}}
    4747
    4848    def __repr__(self):  # {{{
    … …  
    5656            s += '{}\n'.format(self.method[i])
    5757        return s
    58     #}}}
     58    # }}}
    5959
    6060    def setdefaultparameters(self):  # {{{
    … …  
    6363        self.ndirectories = 50  # Number of output directories; should be < numcpus
    6464        return self
    65     #}}}
     65    # }}}
    6666
    6767    @staticmethod
    … …  
    9191                if m['steps'][s] > md.mesh.numberofvertices:
    9292                    raise Exception('qmustatistics consistency check error: qmu.statistics.method[{}][\'steps\'][{}] should be < md.mesh.numberofvertices!'.format(i, s))
    93     #}}}
     93    # }}}
    9494
    95     def defaultoutputs(self, md): #{{{
     95    def defaultoutputs(self, md):  # {{{
    9696        outputs = []
    9797        return outputs
    98     #}}}
     98    # }}}
    9999
    100     def marshall(self, prefix, md, fid): #{{{
     100    def marshall(self, prefix, md, fid):  # {{{
    101101        if self.method[0]['name'] == 'None':
    102102            WriteData(fid, prefix, 'name', 'md.qmu.statistics', 'data', 0, 'format', 'Boolean')
    … …  
    124124                else:
    125125                    raise Exception('qmustatistics marshall error message: unknown type ''{}'' for qmu.statistics.method[{}]'.format(m['name'], i))
    126     #}}}
     126    # }}}
    127127
    128     def extrude(self, md): #{{{
     128    def extrude(self, md):  # {{{
    129129        return self
    130     #}}}
     130    # }}}
    131131
    132     def addmethod(self, *args): #{{{
     132    def addmethod(self, *args):  # {{{
    133133        """ADDMETHOD - Add new, empty method or passed dict to self.method
    134134        """
    … …  
    140140        else:
    141141            raise Exception('Number of args should be 0 (appends empty dict to methods member) or 1 (appends passed dict to methods member)')
    142     #}}}
     142    # }}}

  • issm/trunk-jpl/src/m/classes/radaroverlay.py

    r24213 r27458  
    1818        self.setdefaultparameters()
    1919
    20     #}}}
     20    # }}}
    2121
    2222    def __repr__(self):  # {{{
    … …  
    2626        string = "%s\n%s" % (string, fielddisplay(self, 'y', 'corresponding y coordinates [m]'))
    2727        return string
    28     #}}}
     28    # }}}
    2929
    3030    def setdefaultparameters(self):  # {{{
    3131        return self
    32     #}}}
     32    # }}}

  • issm/trunk-jpl/src/m/classes/regionaloutput.py

    r26904 r27458  
    5050        #     raise IOError('regionaloutput error message: ''mask'' field or ''maskexpstring'' and ''model'' fields should be defined!')
    5151
    52     #}}}
     52    # }}}
    5353
    5454    def __repr__(self):  # {{{
    … …  
    6060        string = "%s\n%s" % (string, fielddisplay(self, 'maskexpstring', 'name of Argus file that can be passed in to define the regional mask'))
    6161        return string
    62     #}}}
     62    # }}}
    6363
    6464    def extrude(self, md):  # {{{
    6565        self.mask = project3d(md, 'vector', self.mask, 'type', 'node')
    6666        return self
    67     #}}}
     67    # }}}
    6868
    6969    def setdefaultparameters(self):  # {{{
    7070        return self
    71     #}}}
     71    # }}}
    7272
    7373    def setmaskfromexp(self, md):  # {{{

  • issm/trunk-jpl/src/m/classes/results.py

    r26840 r27458  
    1515    def __init__(self):  #{{{
    1616        pass
    17     #}}}
     17    # }}}
    1818
    1919    def __repr__(self):  #{{{
    … …  
    3030
    3131        return s
    32     #}}}
     32    # }}}
    3333
    3434    def setdefaultparameters(self):  #{{{
    3535        #do nothing
    3636        return self
    37     #}}}
    38 
    39     def checkconsistency(self, md, solution, analyses):  #{{{
    40         return md
    41     #}}}
    42 
    43     def marshall(self, prefix, md, fid):  #{{{
    44         pass
    45     #}}}
    46 #}}}
     37    # }}}
     38
     39    def checkconsistency(self, md, solution, analyses):  #{{{
     40        return md
     41    # }}}
     42
     43    def marshall(self, prefix, md, fid):  #{{{
     44        pass
     45    # }}}
     46# }}}
    4747
    4848
    … …  
    5959    def __init__(self):  #{{{
    6060        pass
    61     #}}}
     61    # }}}
    6262
    6363    def __repr__(self):  #{{{
    … …  
    7171            s += '\n'
    7272        return s
    73     #}}}
     73    # }}}
    7474
    7575    def __len__(self):  #{{{
    7676        return len(self.__dict__.keys())
    77     #}}}
     77    # }}}
    7878
    7979    def setdefaultparameters(self):  #{{{
    8080        #do nothing
    8181        return self
    82     #}}}
    83 
    84     def checkconsistency(self, md, solution, analyses):  #{{{
    85         return md
    86     #}}}
    87 
    88     def marshall(self, prefix, md, fid):  #{{{
    89         pass
    90     #}}}
    91 #}}}
     82    # }}}
     83
     84    def checkconsistency(self, md, solution, analyses):  #{{{
     85        return md
     86    # }}}
     87
     88    def marshall(self, prefix, md, fid):  #{{{
     89        pass
     90    # }}}
     91# }}}
    9292
    9393
    … …  
    117117        else:
    118118            self.steps = [solutionstep()]
    119     #}}}
     119    # }}}
    120120
    121121    def __deepcopy__(self, memo):  #{{{
    122122        return solution(deepcopy(self.steps, memo))
    123     #}}}
     123    # }}}
    124124
    125125    def __repr__(self):  #{{{
    … …  
    136136
    137137        return s
    138     #}}}
     138    # }}}
    139139
    140140    def __len__(self):  #{{{
    141141        return len(self.steps)
    142     #}}}
     142    # }}}
    143143
    144144    def __getattr__(self, key):  #{{{
    … …  
    151151        # else:
    152152        #     raise Exception('<results>.<solution> error: Currently, can only get a field if we are not working with a transient solution.')
    153     #}}}
     153    # }}}
    154154
    155155    def __getitem__(self, index):  #{{{
    … …  
    161161        else:
    162162            raise Exception('<results>.<solution>: either request a specific result by index or make sure that there is only a single result for this solution (cannot be a transient solution)')
    163     #}}}
    164 
    165     def setdefaultparameters(self):  #{{{
    166         return self
    167     #}}}
    168 
    169     def checkconsistency(self, md, solution, analyses):  #{{{
    170         return md
    171     #}}}
    172 
    173     def marshall(self, prefix, md, fid):  #{{{
    174         pass
    175     #}}}
    176 #}}}
     163    # }}}
     164
     165    def setdefaultparameters(self):  #{{{
     166        return self
     167    # }}}
     168
     169    def checkconsistency(self, md, solution, analyses):  #{{{
     170        return md
     171    # }}}
     172
     173    def marshall(self, prefix, md, fid):  #{{{
     174        pass
     175    # }}}
     176# }}}
    177177
    178178
    … …  
    186186    def __init__(self, *args):  #{{{
    187187        pass
    188     #}}}
     188    # }}}
    189189
    190190    def __repr__(self):  #{{{
    … …  
    195195
    196196        return s
    197     #}}}
     197    # }}}
    198198
    199199    def getfieldnames(self):  #{{{
    200200        return self.__dict__.keys()
    201     #}}}
     201    # }}}
    202202
    203203    def getlongestfieldname(self):  #{{{
    … …  
    209209
    210210        return maxlength
    211     #}}}
    212 
    213     def setdefaultparameters(self):  #{{{
    214         return self
    215     #}}}
    216 
    217     def checkconsistency(self, md, solution, analyses):  #{{{
    218         return md
    219     #}}}
    220 
    221     def marshall(self, prefix, md, fid):  #{{{
    222         pass
    223     #}}}
    224 #}}}
     211    # }}}
     212
     213    def setdefaultparameters(self):  #{{{
     214        return self
     215    # }}}
     216
     217    def checkconsistency(self, md, solution, analyses):  #{{{
     218        return md
     219    # }}}
     220
     221    def marshall(self, prefix, md, fid):  #{{{
     222        pass
     223    # }}}
     224# }}}

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

    r26759 r27458  
    2222        self.setdefaultparameters()
    2323
    24     #}}}
     24    # }}}
    2525
    2626    def __repr__(self):  # {{{
    … …  
    3030        string = "%s\n%s" % (string, fielddisplay(self, 'riftproperties', ''))
    3131        return string
    32     #}}}
     32    # }}}
    3333
    3434    def setdefaultparameters(self):  # {{{
    3535        return self
    36     #}}}
     36    # }}}
    3737
    3838    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/rotational.py

    r26358 r27458  
    2121        else:
    2222            raise Exception('constructor not supported')
    23     #}}}
     23    # }}}
    2424
    2525    def __repr__(self):  # {{{
    … …  
    2929        s += '{}\n'.format(fielddisplay(self, 'angularvelocity', 'mean rotational velocity of earth [per second]'))
    3030        return s
    31     #}}}
     31    # }}}
    3232
    3333    def setdefaultparameters(self):  # {{{
    … …  
    3939        self.angularvelocity = 7.2921 * pow(10, -5) # [s^-1]
    4040        return self
    41     #}}}
     41    # }}}
    4242
    4343    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    4848        md = checkfield(md, 'fieldname', 'solidearth.rotational.angularvelocity', 'NaN', 1, 'Inf', 1)
    4949        return md
    50     #}}}
     50    # }}}
    5151
    5252    def defaultoutputs(self, md):  #{{{
    5353        return []
    54     #}}}
     54    # }}}
    5555
    5656    def marshall(self, prefix, md, fid):  #{{{
    … …  
    5858        WriteData(fid, prefix, 'object', self, 'fieldname', 'polarmoi', 'name', 'md.solidearth.rotational.polarmoi', 'format', 'Double')
    5959        WriteData(fid, prefix, 'object', self, 'fieldname', 'angularvelocity', 'name', 'md.solidearth.rotational.angularvelocity', 'format', 'Double')
    60     #}}}
     60    # }}}
    6161
    6262    def extrude(self, md):  #{{{
    6363        return self
    64     #}}}
     64    # }}}

  • issm/trunk-jpl/src/m/classes/sampling.py

    r27453 r27458  
    1616    """
    1717
    18     def __init__(self, *args): #{{{
     18    def __init__(self, *args):  # {{{
    1919        self.kappa = np.nan
    2020        self.tau = 0
    … …  
    3030        else:
    3131            raise RuntimeError('constructor not supported')
    32     #}}}
     32    # }}}
    3333
    34     def __repr__(self): #{{{
     34    def __repr__(self):  # {{{
    3535        s = '   Sampling parameters::\n'
    3636        s += '      Parameters of PDE operator (kappa^2 I-Laplacian)^(alpha/2)(tau):\n'
    … …  
    5151
    5252        return s
    53     #}}}
     53    # }}}
    5454
    55     def setdefaultparameters(self): #{{{
     55    def setdefaultparameters(self):  # {{{
    5656
    5757        # Apply Robin boundary conditions
    … …  
    6868
    6969        return self
    70     #}}}
     70    # }}}
    7171
    72     def defaultoutputs(self, md): #{{{
     72    def defaultoutputs(self, md):  # {{{
    7373        return []
    74     #}}}
     74    # }}}
    7575
    76     def checkconsistency(self, md, solution, analyses): #{{{
     76    def checkconsistency(self, md, solution, analyses):  # {{{
    7777        if ('SamplingAnalysis' not in analyses):
    7878            return md
    … …  
    8989
    9090        return md
    91     #}}}
     91    # }}}
    9292
    93     def marshall(self, prefix, md, fid): #{{{
     93    def marshall(self, prefix, md, fid):  # {{{
    9494        WriteData(fid, prefix, 'object', self, 'fieldname', 'kappa', 'format', 'DoubleMat', 'mattype', 1)
    9595        WriteData(fid, prefix, 'object', self, 'fieldname', 'tau', 'format', 'DoubleMat', 'mattype', 1)
    … …  
    107107            outputs = outputscopy
    108108        WriteData(fid, prefix, 'data', outputs, 'name', 'md.sampling.requested_outputs', 'format', 'StringArray')
    109     #}}}
     109    # }}}
    110110
    111     def setparameters(self, md, lc, sigma): #{{{
     111    def setparameters(self, md, lc, sigma):  # {{{
    112112        nu = self.alpha - 1
    113113        KAPPA = pow((8 * nu), 0.5) / lc
    … …  
    117117
    118118        return md
    119     #}}}
     119    # }}}

  • issm/trunk-jpl/src/m/classes/sealevelmodel.py

    r27327 r27458  
    163163    # }}}
    164164
    165     def ncaps(self): #{{{
     165    def ncaps(self):  # {{{
    166166        return len(self.icecaps)
    167167    # }}}
    … …  
    188188    # }}}
    189189
    190     def intersections2d(self, *args): #{{{
     190    def intersections2d(self, *args):  # {{{
    191191        options = pairoptions(*args)
    192192        force = options.getfieldvalue('force', 0)

  • issm/trunk-jpl/src/m/classes/slr.py

    r26352 r27458  
    4747        #set defaults
    4848        self.setdefaultparameters()
    49     #}}}
     49    # }}}
    5050
    5151    def __repr__(self):  # {{{
    … …  
    116116        self.planetradius = planetradius('earth')
    117117        return self
    118     #}}}
     118    # }}}
    119119
    120120    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/spatiallinearbasalforcings.py

    r26789 r27458  
    1515    """
    1616
    17     def __init__(self, *args): #{{{
     17    def __init__(self, *args):  # {{{
    1818        nargs = len(args)
    1919        if nargs == 0:
    … …  
    4343        else:
    4444            raise Exception('constructor not supported')
    45     #}}}
     45    # }}}
    4646
    47     def __repr__(self): #{{{
     47    def __repr__(self):  # {{{
    4848        s = '   spatial linear basal forcings parameters:\n'
    4949        s += '{}\n'.format(fielddisplay(self, 'groundedice_melting_rate', 'basal melting rate (positive if melting) [m/yr]'))
    … …  
    5555        s += '{}\n'.format(fielddisplay(self, 'geothermalflux', 'geothermal heat flux [W/m^2]'))
    5656        return s
    57     #}}}
     57    # }}}
    5858
    59     def extrude(self, md): #{{{
     59    def extrude(self, md):  # {{{
    6060        self.groundedice_melting_rate = project3d(md, 'vector', self.groundedice_melting_rate, 'type', 'node', 'layer', 1)
    6161        self.deepwater_melting_rate = project3d(md, 'vector', self.deepwater_melting_rate, 'type', 'node', 'layer', 1)
    … …  
    6666        self.perturbation_melting_rate = project3d(md, 'vector', self.upperwater_melting_rate, 'type', 'node', 'layer', 1)
    6767        return self
    68     #}}}
     68    # }}}
    6969
    70     def initialize(self, md): #{{{
     70    def initialize(self, md):  # {{{
    7171        if np.all(np.isnan(self.groundedice_melting_rate)):
    7272            self.groundedice_melting_rate = np.zeros((md.mesh.numberofvertices))
    7373            print('      no basalforcings.groundedice_melting_rate specified: values set as zero')
    7474        return self
    75     #}}}
     75    # }}}
    7676
    77     def setdefaultparameters(self): #{{{
     77    def setdefaultparameters(self):  # {{{
    7878        return self
    79     #}}}
     79    # }}}
    8080
    81     def checkconsistency(self, md, solution, analyses): #{{{
     81    def checkconsistency(self, md, solution, analyses):  # {{{
    8282        if not np.all(np.isnan(self.perturbation_melting_rate)):
    8383            md = checkfield(md, 'fieldname', 'basalforcings.perturbation_melting_rate', 'NaN', 1, 'Inf', 1, 'timeseries', 1)
    … …  
    106106    # }}}
    107107
    108     def marshall(self, prefix, md, fid): #{{{
     108    def marshall(self, prefix, md, fid):  # {{{
    109109        yts = md.constants.yts
    110110
    … …  
    117117        WriteData(fid, prefix, 'object', self, 'fieldname', 'upperwater_elevation', 'format', 'DoubleMat', 'name', 'md.basalforcings.upperwater_elevation', 'mattype', 1)
    118118        WriteData(fid, prefix, 'object', self, 'fieldname', 'perturbation_melting_rate', 'format', 'DoubleMat', 'name', 'md.basalforcings.perturbation_melting_rate', 'scale', 1. / yts, 'mattype', 1)
    119     #}}}
     119    # }}}

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

    r24213 r27458  
    2121        self.setdefaultparameters()
    2222
    23     #}}}
     23    # }}}
    2424    def __repr__(self):  # {{{
    2525        string = '   steadystate solution parameters:'
    … …  
    2828        string = "%s\n%s" % (string, fielddisplay(self, 'requested_outputs', 'additional requested outputs'))
    2929        return string
    30     #}}}
     30    # }}}
    3131
    3232    def defaultoutputs(self, md):  # {{{
    3333        return md.stressbalance.defaultoutputs(md) + md.thermal.defaultoutputs(md)
    3434
    35     #}}}
     35    # }}}
    3636    def setdefaultparameters(self):  # {{{
    3737        #maximum of steady state iterations
    … …  
    4242        self.requested_outputs = ['default']
    4343        return self
    44     #}}}
     44    # }}}
    4545
    4646    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/stochasticforcing.py

    r27450 r27458  
    4949        s += '   SMBforcing\n'
    5050        return s
    51     #}}}
     51    # }}}
    5252
    5353    def setdefaultparameters(self):  # {{{
    … …  
    5757        self.randomflag = 1  # true randomness is implemented by default
    5858        return self
    59     #}}}
     59    # }}}
    6060
    6161    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    256256        list1 = list1.keys()
    257257        return list(list1)
    258     #}}}
     258    # }}}
    259259
    260260    def structstochforcing(self):  # {{{

  • issm/trunk-jpl/src/m/classes/surfaceload.py

    r26358 r27458  
    2424        else:
    2525            raise Exception('constructor not supported')
    26     #}}}
     26    # }}}
    2727
    2828    def __repr__(self):  #{{{
    … …  
    3232        s += '{}\n'.format(fielddisplay(self, 'other', 'other loads (sediments) [kg/m^2/yr]'))
    3333        return s
    34     #}}}
     34    # }}}
    3535
    3636    def setdefaultparameters(self):  # {{{
    3737        return self
    38     #}}}
     38    # }}}
    3939
    4040    def checkconsistency(self, md, solution, analyses):  # {{{
    … …  
    4848            md = checkfield(md, 'fieldname', 'solidearth.surfaceload.other', 'timeseries', 1, 'NaN', 1, 'Inf', 1)
    4949        return md
    50     #}}}
     50    # }}}
    5151
    5252    def marshall(self, prefix, md, fid):  #{{{
    … …  
    7575
    7676        WriteData(fid, prefix, 'object', self, 'fieldname', 'otherchange', 'name', 'md.solidearth.surfaceload.otherchange', 'format', 'MatArray', 'timeserieslength', md.mesh.numberofelements + 1, 'yts', yts, 'scale', 1 / yts)
    77     #}}}
     77    # }}}
    7878
    7979    def extrude(self, md):  #{{{
    8080        return self
    81     #}}}
     81    # }}}

  • issm/trunk-jpl/src/m/classes/taoinversion.py

    r26903 r27458  
    1010
    1111
    12 class taoinversion(object): #{{{
     12class taoinversion(object):  # {{{
    1313    """TAOINVERSION class definition
    1414
    … …  
    4141
    4242        self.setdefaultparameters()
    43     #}}}
     43    # }}}
    4444
    4545    def __repr__(self):

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

    r25688 r27458  
    2929        self.requested_outputs = []
    3030        self.setdefaultparameters()
    31     #}}}
     31    # }}}
    3232
    3333    def __repr__(self):  # {{{
    … …  
    4545        s += '{}\n'.format(fielddisplay(self, 'requested_outputs', 'additional outputs requested'))
    4646        return s
    47     #}}}
     47    # }}}
    4848
    4949    def extrude(self, md):  # {{{
    … …  
    5454            self.spctemperature[pos] = md.initialization.temperature[pos]  #impose observed temperature on surface
    5555        return self
    56     #}}}
     56    # }}}
    5757
    5858    def defaultoutputs(self, md):  # {{{
    … …  
    6161        else:
    6262            return ['Temperature', 'BasalforcingsGroundediceMeltingRate']
    63     #}}}
     63    # }}}
    6464
    6565    def setdefaultparameters(self):  # {{{
    … …  
    8787        self.requested_outputs = ['default']
    8888        return self
    89     #}}}
     89    # }}}
    9090
    9191    def checkconsistency(self, md, solution, analyses):  # {{{

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

    r27178 r27458  
    2424        else:
    2525            raise RuntimeError('constructor not supported')
    26     #}}}
     26    # }}}
    2727
    2828    def __repr__(self):  #{{{
    … …  
    3737        s += '{}\n'.format(fielddisplay(self, 'coupling_time', 'length of coupling time steps with ocean model [' + unit + ']'))
    3838        return s
    39     #}}}
     39    # }}}
    4040
    4141    def setdefaultparameters(self):  #{{{
    … …  
    5252
    5353        return self
    54     #}}}
     54    # }}}
    5555
    5656    def checkconsistency(self, md, solution, analyses):  #{{{
    … …  
    6767
    6868        return md
    69     #}}}
     69    # }}}
    7070
    7171    def marshall(self, prefix, md, fid):  #{{{
    … …  
    7979        WriteData(fid, prefix, 'object', self, 'fieldname', 'cycle_forcing', 'format', 'Boolean')
    8080        WriteData(fid, prefix, 'object', self, 'fieldname', 'coupling_time', 'format', 'Double', 'scale', scale)
    81     #}}}
     81    # }}}

  • issm/trunk-jpl/src/m/classes/timesteppingadaptive.py

    r27178 r27458  
    4040        else:
    4141            raise Exception('constructor not supported')
    42     #}}}
     42    # }}}
    4343
    4444    def __repr__(self):  # {{{
    … …  
    6969        self.cycle_forcing   = 0
    7070        return self
    71     #}}}
     71    # }}}
    7272
    7373    def checkconsistency(self, md, solution, analyses):  # {{{

  • issm/trunk-jpl/src/m/classes/toolkits.m

    r27420 r27458  
    6868                                        self.DefaultAnalysis           = issmgslsolver();
    6969                                else
    70                                         disp('WARNING: Need at least Mumps or Gsl to define an issm solver type, no default solver assigned');
     70                                        disp('WARNING: Need at least MUMPS or GSL to define an ISSM solver type, no default solver assigned');
    7171                                end
    7272                        end
    … …  
    124124                        %TOOLKITSFILE - build toolkits file
    125125                        %
    126                         %   Build a Petsc compatible options file, from the toolkits model field  + return options string.
    127                         %   This file will also be used when the toolkit used is 'issm' instead of 'petsc'
     126                        %   Build a Petsc compatible options file, from the toolkits model field and return options string.
     127                        %   This file will also be used when the toolkit used is 'issm' instead of 'petsc'.
    128128                        %
    129129                        %   Usage:     ToolkitsFile(toolkits,filename);

  • issm/trunk-jpl/src/m/classes/toolkits.py

    r27427 r27458  
     1from fielddisplay import fielddisplay
     2from iluasmoptions import iluasmoptions
    13from IssmConfig import IssmConfig
    2 from mumpsoptions import mumpsoptions
    3 from iluasmoptions import iluasmoptions
    4 from fielddisplay import fielddisplay
    54from issmgslsolver import issmgslsolver
    65from issmmumpssolver import issmmumpssolver
     6from mumpsoptions import mumpsoptions
    77
    88
    99class toolkits(object):
    10     """TOOLKITS class definition
     10    """toolkits class definition
    1111
    1212    Usage:
    … …  
    1414    """
    1515
    16     def __init__(self): #{{{
     16    def __init__(self, *args):  # {{{
     17        self.DefaultAnalysis = None
     18        self.RecoveryAnalysis = None
     19
     20        nargs = len(args)
     21        if nargs == 0:
     22            self.setdefaultparameters()
     23        elif nargs == 1:
     24            # TODO: Replace the following with constructor
     25            self.setdefaultparameters()
     26        else:
     27            raise Exception('constructor not supported')
     28    # }}}
     29
     30    def __repr__(self):  # {{{
     31        s = "List of toolkits options per analysis:\n\n"
     32        for analysis in list(vars(self).keys()):
     33            s += "{}\n".format(fielddisplay(self, analysis, ''))
     34
     35        return s
     36    # }}}
     37
     38    def addoptions(self, analysis, *args):  # {{{
     39        """addoptions - add analysis to md.toolkits.analysis
     40
     41        Optional third parameter adds toolkits options to analysis.
     42       
     43        Usage:
     44            md.toolkits = addoptions(md.toolkits, 'StressbalanceAnalysis', FSoptions())
     45            md.toolkits = addoptions(md.toolkits, 'StressbalanceAnalysis')
     46        """
     47
     48        # Create dynamic property if property does not exist yet
     49        if not hasattr(self, analysis):
     50            setattr(self, analysis, None)
     51
     52        # Add toolkits options to analysis
     53        if len(args) == 1:
     54            setattr(self, analysis, args[0])
     55
     56        return self
     57    # }}}
     58
     59    def setdefaultparameters(self):  # {{{
    1760        # Default toolkits
    1861        if IssmConfig('_HAVE_PETSC_')[0]:
    … …  
    2871                self.DefaultAnalysis = issmgslsolver()
    2972            else:
    30                 raise IOError("ToolkitsFile error: need at least Mumps or Gsl to define issm solver type")
     73                raise IOError('ToolkitsFile error: need at least MUMPS or GSL to define ISSM solver type, no default solver assigned')
    3174
    3275        # Use same solver for Recovery mode
    3376        self.RecoveryAnalysis = self.DefaultAnalysis
    3477
    35         # The other properties are dynamic
    36     #}}}
     78        return self
     79    # }}}
    3780
    38     def __repr__(self): #{{{
    39         s = "List of toolkits options per analysis:\n\n"
    40         for analysis in list(vars(self).keys()):
    41             s += "{}\n".format(fielddisplay(self, analysis, ''))
     81    def checkconsistency(self, md, solution, analyses):  # {{{
     82        supported_analyses = [
     83            'DefaultAnalysis',
     84            'RecoveryAnalysis',
     85            'StressbalanceAnalysis',
     86            'GLheightadvectionAnalysis',
     87            'MasstransportAnalysis',
     88            'ThermalAnalysis',
     89            'EnthalpyAnalysis',
     90            'AdjointBalancethicknessAnalysis',
     91            'BalancethicknessAnalysis',
     92            'Balancethickness2Analysis',
     93            'BalancethicknessSoftAnalysis',
     94            'BalancevelocityAnalysis',
     95            'DamageEvolutionAnalysis',
     96            'LoveAnalysis',
     97            'EsaAnalysis',
     98            'SealevelchangeAnalysis',
     99            'FreeSurfaceBaseAnalysis',
     100            'FreeSurfaceTopAnalysis',
     101            'LevelsetAnalysis',
     102            'DebrisAnalysis',
     103            'L2ProjectionBaseAnalysis',
     104            'ExtrudeFromBaseAnalysis',
     105            'ExtrudeFromTopAnalysis'
     106        ]
     107        analyses = list(vars(self).keys())
     108        for analysis in analyses:
     109            if analysis not in supported_analyses:
     110                md.checkmessage('md.toolkits.{} not supported yet'.format(analysis))
    42111
    43         return s
    44     #}}}
    45 
    46     def addoptions(self, analysis, *args): #{{{
    47         # Usage example:
    48         #    md.toolkits = addoptions(md.toolkits, 'StressbalanceAnalysis', FSoptions())
    49         #    md.toolkits = addoptions(md.toolkits, 'StressbalanceAnalysis')
    50 
    51         # Create dynamic property if property does not exist yet
    52         if not hasattr(self, analysis):
    53             setattr(self, analysis, None)
    54 
    55         # Add toolkits options to analysis
    56         if len(args) == 1:
    57             setattr(self, analysis, args[0])
    58 
    59         return self
    60     #}}}
    61 
    62     def checkconsistency(self, md, solution, analyses): #{{{
    63         # TODO:
    64         # - Implement something closer to a switch as in
    65         # src/m/classes/toolkits.m?
    66         #
    67         for analysis in list(vars(self).keys()):
    68112            if not getattr(self, analysis):
    69                 md.checkmessage("md.toolkits.{} is empty".format(analysis))
     113                md.checkmessage('md.toolkits.{} is empty'.format(analysis))
    70114
    71115        return md
    72     #}}}
     116    # }}}
    73117
    74     def ToolkitsFile(self, filename): #{{{
    75         """TOOLKITSFILE - build toolkits file
     118    def ToolkitsFile(self, filename):  # {{{
     119        """ToolkitsFile - build toolkits file
    76120
    77         Build a PETSc compatible options file, from the toolkits model field + return options string.
     121        Build a PETSc compatible options file, from the toolkits model field and return options string.
    78122        This file will also be used when the toolkit used is 'issm' instead of 'petsc'.
    79123
    … …  
    86130            fid = open(filename, 'w')
    87131        except IOError as e:
    88             raise IOError("ToolkitsFile error: could not open {}' for writing due to".format(filename), e)
     132            raise IOError('ToolkitsFile error: could not open {} for writing due to {}'.format(filename), e)
    89133
    90134        # Write header
    91         fid.write("%s%s%s\n" % ('%Toolkits options file: ', filename, ' written from Python toolkits array'))
     135        fid.write('{}{}{}\n'.format('%Toolkits options file: ', filename, ' written from Python toolkits array'))
    92136
    93137        # Start writing options
    … …  
    96140
    97141            # First write analysis
    98             fid.write("\n+{}\n".format(analysis))  # Append a + to recognize it's an analysis enum
     142            fid.write('\n+{}\n'.format(analysis))  # Append a + to recognize it's an analysis enum
     143
    99144            # Now, write options
    100145            for optionname, optionvalue in list(options.items()):
    … …  
    102147                if not optionvalue:
    103148                    # This option has only one argument
    104                     fid.write("-{}\n".format(optionname))
     149                    fid.write('-{}\n'.format(optionname))
    105150                else:
    106151                    # Option with value. Value can be string or scalar.
    107152                    if isinstance(optionvalue, (bool, int, float)):
    108                         fid.write("-{} {}\n".format(optionname, optionvalue))
     153                        fid.write('-{} {}\n'.format(optionname, optionvalue))
    109154                    elif isinstance(optionvalue, str):
    110                         fid.write("-{} {}\n".format(optionname, optionvalue))
     155                        fid.write('-{} {}\n'.format(optionname, optionvalue))
    111156                    else:
    112                         raise TypeError("ToolkitsFile error: option '{}' is not well formatted.".format(optionname))
     157                        raise TypeError('ToolkitsFile error: option {} is not well formatted'.format(optionname))
    113158
    114159        fid.close()
    115     #}}}
     160    # }}}

  • issm/trunk-jpl/src/m/coordsystems/epsg2proj.py

    r27119 r27458  
    3838
    3939    return outs
    40 #}}}
     40# }}}

  • issm/trunk-jpl/src/m/coordsystems/flaglatlongradius.py

    r24902 r27458  
    44
    55
    6 def flaglatlogradius(lat, long, lat0, long0, radius): # {{{
     6def flaglatlogradius(lat, long, lat0, long0, radius):  # {{{
    77    '''
    88    FLAGLATLONGRADIUS - given a vector of lat, long, and a circle of radius

  • issm/trunk-jpl/src/m/coordsystems/flagradiuselements.py

    r24902 r27458  
    66
    77
    8 def flagradiuselements(elements, x, y, z, lat0, long0, radius): # {{{
     8def flagradiuselements(elements, x, y, z, lat0, long0, radius):  # {{{
    99    # get x0,y0,z0:
    1010    R   = planetradius('earth')

  • issm/trunk-jpl/src/m/coordsystems/gdaltransform.py

    r27119 r27458  
    99
    1010
    11 def gdaltransform(x, y, proj_in, proj_out): #{{{
     11def gdaltransform(x, y, proj_in, proj_out):  # {{{
    1212    """GDALTRANSFORM - switch from one projection system to another
    1313
    … …  
    7070
    7171    return [xout, yout]
    72 #}}}
     72# }}}

  • issm/trunk-jpl/src/m/coordsystems/laea.py

    r26661 r27458  
    1 def laea(lat, long): #{{{
     1def laea(lat, long):  # {{{
    22    """LAEA - Lambert Azimuthal Equal Area projection at lat, long projection
    33    center.
    … …  
    1212
    1313    return '+proj=laea +lat_0={} +lon_0={} +x_0=0 +y_0=0 +ellps=WGS84 +units=m +no_defs'.format(lat, long)
    14 #}}}
     14# }}}

  • issm/trunk-jpl/src/m/geometry/AboveGround.py

    r25762 r27458  
    11import numpy as np
    22
    3 def AboveGround(lat, long, r, height): #{{{
     3def AboveGround(lat, long, r, height):  # {{{
    44    r = r + height
    55    x = r * np.cos(np.deg2rad(lat)) * np.cos(np.deg2rad(long))
    66    y = r * np.cos(np.deg2rad(lat)) * np.sin(np.deg2rad(long))
    77    z = r * np.sin(np.deg2rad(lat))
    8 #}}}
     8# }}}

  • issm/trunk-jpl/src/m/geometry/inpolygon.py

    r25455 r27458  
    22import numpy as np
    33
    4 def inpolygon(xq, yq, xv, yv): #{{{
     4def inpolygon(xq, yq, xv, yv):  # {{{
    55    """
    66    INPOLYGON - Returns points located inside polygonal region.
    … …  
    2525
    2626    return in_polygon
    27 #}}}
     27# }}}

  • issm/trunk-jpl/src/m/geometry/planetradius.py

    r25767 r27458  
    1 def planetradius(planet): # {{{
     1def planetradius(planet):  # {{{
    22    '''
    33    PLANETRADIUS - return planet radius according to planetary body name

  • issm/trunk-jpl/src/m/geometry/polyarea.py

    r25685 r27458  
    44
    55
    6 def polyarea(x, y): #{{{
     6def polyarea(x, y):  # {{{
    77    """POLYAREA - returns the area of the 2-D polygon defined by the vertices in
    88    lists x and y
    … …  
    2626
    2727    return 0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
    28 #}}}
     28# }}}

  • issm/trunk-jpl/src/m/interp/interp.py

    r24256 r27458  
    8686
    8787    return interpdata
    88     #}}}
     88    # }}}
    8989
    9090
    … …  
    182182
    183183    return interpdata
    184     #}}}
     184    # }}}
    185185
    186186
    … …  
    247247
    248248    return interpdata
    249     #}}}
     249    # }}}

  • issm/trunk-jpl/src/m/io/loadvars.py

    r27264 r27458  
    144144                                nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]].steps.append(getattr(classtype[mod][1], 'solutionstep')())
    145145                            Tree = nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]][:]
    146                     #}}}
     146                    # }}}
    147147                #elif classtype[mod][0] == 'massfluxatgate.massfluxatgate':  #this is for output definitions {{{
    148148                elif mod.startswith('outputdefinition'):  #this is for output definitions {{{
    … …  
    152152                    nvdict['md'].__dict__[classtree[mod][0]].__dict__[defname].append(getattr(classtype[mod][1], outdeftype)())
    153153                    Tree = nvdict['md'].__dict__[classtree[mod][0]].__dict__[defname][defindex - 1]
    154                 #}}}
     154                # }}}
    155155                elif classtype[mod][0] == 'collections.OrderedDict':  #Treating multiple toolkits {{{
    156156                    nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = getattr(classtype[mod][1], 'OrderedDict')

  • issm/trunk-jpl/src/m/mesh/bamg.py

    r27120 r27458  
    534534        #do nothing...
    535535        pass
    536     #}}}
     536    # }}}
    537537    # Bamg mesh parameters {{{
    538538    if not options.exist('domain') and md.mesh.numberofvertices and md.mesh.elementtype() == 'Tria':
    … …  
    549549        if isinstance(md.rifts.riftstruct, dict):
    550550            raise TypeError("bamg error message: rifts not supported yet. Do meshprocessrift AFTER bamg")
    551     #}}}
     551    # }}}
    552552    # Bamg options {{{
    553553    bamg_options['Crack'] = options.getfieldvalue('Crack', 0)
    … …  
    576576    bamg_options['splitcorners'] = options.getfieldvalue('splitcorners', 1)
    577577    bamg_options['verbose'] = options.getfieldvalue('verbose', 1)
    578     #}}}
     578    # }}}
    579579
    580580    # Call Bamg
    … …  
    781781    """
    782782    return geom
    783     #}}}
     783    # }}}

  • issm/trunk-jpl/src/m/mesh/findsegments.py

    r25499 r27458  
    66from pairoptions import pairoptions
    77
    8 def findsegments(md, *args): #{{{
     8def findsegments(md, *args):  # {{{
    99    """FINDSEGMENTS - build segments model field
    1010
    … …  
    9696
    9797    return segments
    98 #}}}
     98# }}}

  • issm/trunk-jpl/src/m/mesh/meshintersect3d.py

    r25684 r27458  
    66
    77
    8 def meshintersect3d(x, y, z, xs, ys, zs, *args): #{{{
     8def meshintersect3d(x, y, z, xs, ys, zs, *args):  # {{{
    99    """MESHINTERSECT - returns indices (into x, y, and z) of common values
    1010    between (x, y, z) and (xs, ys, zs) (i.e. x(index) = xs; y(index) = ys).
    … …  
    6868
    6969    return indices
    70 #}}}
     70# }}}

  • issm/trunk-jpl/src/m/mesh/planet/gmsh/gmshplanet.py

    r27174 r27458  
    115115    fid.write('Physical Volume(2) = 30;\n')
    116116    fid.close()
    117     #}}}
     117    # }}}
    118118
    119119    if options.exist('refine'):
    … …  
    133133        fid.write('};\n')
    134134        fid.close()
    135         #}}}
     135        # }}}
    136136
    137137    # Call gmsh
    … …  
    192192        raise RuntimeError(['Expecting $EndElements (', A, ')'])
    193193    fid.close()
    194     #}}}
     194    # }}}
    195195
    196196    # A little technicality here. The mesh is not exactly on the sphere. We

  • issm/trunk-jpl/src/m/mesh/rifts/meshprocessoutsiderifts.py

    r25455 r27458  
    101101
    102102    return flag
    103     #}}}
     103    # }}}

  • issm/trunk-jpl/src/m/miscellaneous/MatlabFuncs.py

    r26853 r27458  
    169169
    170170    return np.intersect1d(A, B)
    171 #}}}
     171# }}}
    172172
    173173def isa(A, dataType):  # {{{

  • issm/trunk-jpl/src/m/miscellaneous/PythonFuncs.py

    r26301 r27458  
    22
    33
    4 def logical_and_n(*arg): #{{{
     4def logical_and_n(*arg):  # {{{
    55    if len(arg):
    66        result = arg[0]
    … …  
    1010    else:
    1111        return None
    12 #}}}
     12# }}}
    1313
    14 def logical_or_n(*arg): #{{{
     14def logical_or_n(*arg):  # {{{
    1515    if len(arg):
    1616        result = arg[0]
    … …  
    2020    else:
    2121        return None
    22 #}}}
     22# }}}

  • issm/trunk-jpl/src/m/miscellaneous/fielddisplay.py

    r26856 r27458  
    1919
    2020
    21 def parsedisplay(offset, name, field, comment): #{{{
     21def parsedisplay(offset, name, field, comment):  # {{{
    2222    #string
    2323    if isinstance(field, str):
    … …  
    5858
    5959    return string
    60     #}}}
     60    # }}}
    6161
    6262
    63 def dict_display(offset, name, field, comment): #{{{
     63def dict_display(offset, name, field, comment):  # {{{
    6464    if field:
    6565        string = displayunit(offset, name, '{dictionary}', comment) + '\n'
    … …  
    7676
    7777    return string
    78     #}}}
     78    # }}}
    7979
    8080
    81 def list_display(offset, name, field, comment): #{{{
     81def list_display(offset, name, field, comment):  # {{{
    8282    #initialization
    8383    if isinstance(field, list):
    … …  
    107107    #call displayunit
    108108    return displayunit(offset, name, string, comment)
    109     #}}}
     109    # }}}
    110110
    111111
    … …  
    136136
    137137    return string
    138     #}}}
     138    # }}}

  • issm/trunk-jpl/src/m/miscellaneous/intersect.py

    r25455 r27458  
    22
    33
    4 def intersect(a, b): #{{{
     4def intersect(a, b):  # {{{
    55    """INTERSECT - Python implementation of MATLAB's 'intersect' function
    66
    … …  
    2323
    2424    return c, ia[np.isin(a_unique, c)], ib[np.isin(b_unique, c)]
    25 #}}}
     25# }}}

  • issm/trunk-jpl/src/m/modules/ExpToLevelSet.py

    r26661 r27458  
    44
    55
    6 def ExpToLevelSet(x, y, contourname): #{{{
     6def ExpToLevelSet(x, y, contourname):  # {{{
    77    """EXPTOLEVELSET - Determine levelset distance between a contour and a
    88    cloud of points
    … …  
    3535
    3636    return distance
    37 #}}}
     37# }}}

  • issm/trunk-jpl/src/m/modules/InterpFromMesh2d.py

    r25455 r27458  
    22
    33
    4 def InterpFromMesh2d(*args): #{{{
     4def InterpFromMesh2d(*args):  # {{{
    55    """INTERPFROMMESH2D
    66
    … …  
    3939
    4040    return data_prime[0] # NOTE: Value returned from wrapper function is a tuple, the first element of which being the result we actually want
    41 #}}}
     41# }}}

  • issm/trunk-jpl/src/m/parameterization/setmask.py

    r24861 r27458  
    5353    vertexongroundedice[md.mesh.elements[np.nonzero(elementongroundedice), :] - 1] = True
    5454    vertexonfloatingice[np.nonzero(np.logical_not(vertexongroundedice))] = True
    55     #}}}
     55    # }}}
    5656
    5757    #level sets

  • issm/trunk-jpl/src/m/plot/export_gl.py

    r25011 r27458  
    6565    model.contourz2 = list(map(lambda r, lat: r * math.sin(math.radians(lat)), R2, contour_lat2))
    6666
    67     #}}}
     67    # }}}
    6868    #Deal with mesh and results {{{
    6969    print('getting mesh')
    … …  
    123123    print('writing to file')
    124124    writejsfile(directory + databasename + '.js', model, databasename)
    125     #}}}
     125    # }}}

  • issm/trunk-jpl/src/m/plot/plot_coastlines.py

    r25762 r27458  
    66
    77
    8 def plot_coastlines(mesh, *args): #{{{
     8def plot_coastlines(mesh, *args):  # {{{
    99    # Define coastline #{{{
    1010    coast = np.array([
    … …  
    98899889        coast[:, 1] - 360
    98909890    ])
    9891     #}}}
     9891    # }}}
    98929892
    98939893    if len(args) == 1:
    … …  
    99209920            else:
    99219921                xlim(options.getfieldvalue('xlim', [-180, 180]))
    9922 #}}}
     9922# }}}

  • issm/trunk-jpl/src/m/qmu/helpers.py

    r25726 r27458  
    99    attributes
    1010    """
    11     def __init__(self): #{{{
     11    def __init__(self):  # {{{
    1212        pass
    13     #}}}
    14 
    15     def __repr__(self): #{{{
     13    # }}}
     14
     15    def __repr__(self):  # {{{
    1616        s = ''
    1717        for key, value in self.__dict__.items():
    … …  
    2828            s += '\n'
    2929        return s
    30     #}}}
    31 
    32     def __len__(self): #{{{
     30    # }}}
     31
     32    def __len__(self):  # {{{
    3333        return len(self.__dict__.keys())
    34     #}}}
     34    # }}}
    3535
    3636

  • issm/trunk-jpl/src/m/qmu/preqmu.py

    r25688 r27458  
    8181                    raise RuntimeError('preqmu error message: one of the expanded responses has more values than the number of partitions')
    8282        numresponses = numresponses + np.size(vars(responses)[field_name])
    83     #}}}
     83    # }}}
    8484
    8585    # Create in file for Dakota
    … …  
    114114        else:
    115115            responsedescriptors.append(fieldresponses.descriptor)
    116     #}}}
     116    # }}}
    117117
    118118    # Build a list of variable partitions

  • issm/trunk-jpl/src/m/shp/shpread.py

    r26969 r27458  
    1010
    1111
    12 def shpread(filename, *args): #{{{
     12def shpread(filename, *args):  # {{{
    1313    """SHPREAD - read a shapefile and build a list of shapes
    1414
    … …  
    140140
    141141    return Structs
    142 #}}}
     142# }}}

  • issm/trunk-jpl/src/m/shp/shpwrite.py

    r26969 r27458  
    55
    66
    7 def shpwrite(shp, filename): #{{{
     7def shpwrite(shp, filename):  # {{{
    88    '''
    99    SHPREAD - write a shape file from a contour structure
    … …  
    5959        sf.record(str(i))
    6060    sf.close()
    61 #}}}
     61# }}}

  • issm/trunk-jpl/src/m/solve/parseresultsfromdisk.py

    r26790 r27458  
    1212        #saveres = parseresultsfromdiskioserialsequential(md, filename)
    1313    return saveres
    14 #}}}
     14# }}}
    1515
    1616
    … …  
    345345# }}}
    346346
    347 def addfieldtorecord(a, descr): #{{{
     347def addfieldtorecord(a, descr):  # {{{
    348348    if a.dtype.fields is None:
    349349        raise ValueError('\'a\' must be a structured numpy array')
    … …  
    353353
    354354    return b
    355 #}}}
     355# }}}
Note: See TracChangeset for help on using the changeset viewer.