def __init__( self, name, sigma, dict_ ):
     
     from Foam.OpenFOAM import word, dictionary
     from Foam.finiteVolume import volSymmTensorField
     try:
         name = word( str( name ) )
     except ValueError:
        raise AttributeError("The second arg is not string")
    
     try:
         volSymmTensorField.ext_isinstance( sigma )
     except TypeError:
         raise AssertionError( "sigma != volSymmTensorField" )
        
     from Foam.OpenFOAM import dictionary
     try:
         dictionary.ext_isinstance( dict_ )
     except TypeError:
         raise AssertionError( "dict_ != dictionary" )
                 
     rheologyLaw.__init__( self, name, sigma, dict_ )
     
     from Foam.OpenFOAM import dimensionedScalar
     self.rho_ = dimensionedScalar( dict_.lookup(word( "rho" ) ) )
     self.E_ = dimensionedScalar( dict_.lookup( word( "E" ) ) )
     self.nu_ = dimensionedScalar( dict_.lookup( word( "nu" ) ) )
     pass
    def __init__(self, name, sigma, dict_):

        from Foam.OpenFOAM import word, dictionary
        from Foam.finiteVolume import volSymmTensorField
        try:
            name = word(str(name))
        except ValueError:
            raise AttributeError("The second arg is not string")

        try:
            volSymmTensorField.ext_isinstance(sigma)
        except TypeError:
            raise AssertionError("sigma != volSymmTensorField")

        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance(dict_)
        except TypeError:
            raise AssertionError("dict_ != dictionary")

        rheologyLaw.__init__(self, name, sigma, dict_)

        from Foam.OpenFOAM import dimensionedScalar
        self.rho_ = dimensionedScalar(dict_.lookup(word("rho")))
        self.E_ = dimensionedScalar(dict_.lookup(word("E")))
        self.nu_ = dimensionedScalar(dict_.lookup(word("nu")))
        pass
    def __init__(self, name, sigma, dict_):
        from Foam.OpenFOAM import word, dictionary
        from Foam.finiteVolume import volSymmTensorField
        try:
            name = word(str(name))
        except ValueError:
            raise AttributeError("The second arg is not string")

        try:
            volSymmTensorField.ext_isinstance(sigma)
        except TypeError:
            raise AssertionError("sigma != volSymmTensorField")

        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance(dict_)
        except TypeError:
            raise AssertionError("dict_ != dictionary")

        rheologyLaw.__init__(self, name, sigma, dict_)

        from Foam.OpenFOAM import IOobject, fileName
        from Foam.finiteVolume import volScalarField
        self.materials_ = volScalarField(
            IOobject(word("materials"),
                     fileName(self.mesh().time().timeName()), self.mesh(),
                     IOobject.MUST_READ, IOobject.AUTO_WRITE), self.mesh())

        from Foam.OpenFOAM import PtrList_entry
        lawEntries = PtrList_entry(dict_.lookup(word("laws")))

        for lawI in range(lawEntries.size()):
            self.append(
                rheologyLaw.New(lawEntries[lawI].keyword(), sigma,
                                lawEntries[lawI].dict()))

        from Foam.OpenFOAM import SMALL
        if self.materials_.ext_min().value() < 0 or self.materials_.ext_max(
        ).value() > (len(self) + SMALL):
            raise IOError(" Invalid definition of material indicator field.")

        pass
    def __init__( self, name, sigma, dict_ ):
        from Foam.OpenFOAM import word, dictionary
        from Foam.finiteVolume import volSymmTensorField
        try:
            name = word( str( name ) )
        except ValueError:
           raise AttributeError("The second arg is not string")
       
        try:
            volSymmTensorField.ext_isinstance( sigma )
        except TypeError:
            raise AssertionError( "sigma != volSymmTensorField" )
           
        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance( dict_ )
        except TypeError:
            raise AssertionError( "dict_ != dictionary" )

        rheologyLaw.__init__(self, name, sigma, dict_ )
      
        from Foam.OpenFOAM import IOobject, fileName
        from Foam.finiteVolume import volScalarField
        self.materials_ = volScalarField( IOobject( word( "materials" ),
                                                    fileName( self.mesh().time().timeName() ),
                                                    self.mesh(),
                                                    IOobject.MUST_READ,
                                                    IOobject.AUTO_WRITE ),
                                          self.mesh() )
           
        from Foam.OpenFOAM import PtrList_entry
        lawEntries = PtrList_entry( dict_.lookup( word("laws") ) )
                
        for lawI in range( lawEntries.size() ):
            self.append( rheologyLaw.New( lawEntries[lawI].keyword(), sigma, lawEntries[lawI].dict() ) )
            
        from Foam.OpenFOAM import SMALL
        if self.materials_.ext_min().value() < 0 or self.materials_.ext_max().value() > (len(self) + SMALL):
           raise IOError(" Invalid definition of material indicator field.")
        
        pass