示例#1
0
    def updateCoeffs(self):
        try:
           if self.updated():
              return

           from Foam.OpenFOAM import IOdictionary
           rheology = IOdictionary.ext_lookupObject( self.db(), self.rheologyName_ )
           from Foam.OpenFOAM import scalarField
           
           # Python does not wait for evaluation of the closure expression, it destroys return values if it is no more in use
           a_rheology_mu = rheology.mu()
           a_rheology_mu_boundaryField = a_rheology_mu.ext_boundaryField()
           mu = scalarField( a_rheology_mu_boundaryField[self.patch().index()] )
           
           a_rheology_lambda = rheology._lambda()
           a_rheology_lambda_boundaryField = a_rheology_lambda.ext_boundaryField()
           lambda_ = scalarField( a_rheology_lambda_boundaryField[ self.patch().index() ] )

           n = self.patch().nf()
           from Foam.finiteVolume import volTensorField
           from Foam.OpenFOAM import word
           gradU =volTensorField.ext_lookupPatchField( self.patch(), word( "grad(" +str( self.UName_ ) + ")" ) )
           
           from Foam.OpenFOAM import ext_Info
           self.gradient().ext_assign( ( ( self.traction_ -  self.pressure_ * n ) - ( n & ( mu * gradU.ext_T() - ( mu + lambda_ ) * gradU ) ) \
                                          - n * lambda_ * gradU.tr() ) / ( 2.0 * mu + lambda_) )
           
           from Foam.finiteVolume import fixedGradientFvPatchVectorField
           fixedGradientFvPatchVectorField.updateCoeffs( self )
        except Exception, exc:
            import sys, traceback
            traceback.print_exc( file = sys.stdout )
            raise exc   
示例#2
0
    def _init__fvPatch__DimensionedField_scalar_volMesh__dictionary(
            self, *args):
        if len(args) != 3:
            raise AssertionError("len( args ) != 3")
        argc = 0

        from Foam.finiteVolume import fvPatch
        try:
            fvPatch.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != fvPatch")
        p = args[argc]
        argc += 1

        from Foam.finiteVolume import DimensionedField_scalar_volMesh
        try:
            DimensionedField_scalar_volMesh.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError(
                "args[ argc ].__class__ != DimensionedField_scalar_volMesh")
        iF = args[argc]
        argc += 1

        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != dictionary")
        dict_ = args[argc]
        argc += 1

        mixedFvPatchScalarField.__init__(self, p, iF)
        from Foam.OpenFOAM import word
        self.neighbourFieldName_ = word(
            dict_.lookup(word("neighbourFieldName")))
        self.KName_ = word(dict_.lookup(word("K")))

        from Foam.finiteVolume import fvPatchScalarField
        from Foam.OpenFOAM import word, scalarField, readBool
        fvPatchScalarField.ext_assign(
            self, scalarField(word("value"), dict_, p.size()))

        if dict_.found(word("refValue")):
            #Full restart
            self.refValue().ext_assign(
                scalarField(word("refValue"), dict_, p.size()))
            self.refGrad().ext_assign(
                scalarField(word("refGradient"), dict_, p.size()))
            self.valueFraction().ext_assign(
                scalarField(word("valueFraction"), dict_, p.size()))
        else:
            # Start from user entered data. Assume fixedValue.
            self.refValue().ext_assign(self)
            self.refGrad().ext_assign(0.0)
            self.valueFraction().ext_assign(1.0)
            pass

        return self
示例#3
0
    def _init__fvPatch__DimensionedField_scalar_volMesh__dictionary( self, *args ) :
        if len( args ) != 3 :
            raise AssertionError( "len( args ) != 3" )
        argc = 0
        
        from Foam.finiteVolume import fvPatch        
        try:
            fvPatch.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != fvPatch" )
        p = args[ argc ]; argc += 1
        
        from Foam.finiteVolume import DimensionedField_scalar_volMesh
        try:
            DimensionedField_scalar_volMesh.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != DimensionedField_scalar_volMesh" )
        iF = args[ argc ]; argc += 1
        
        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != dictionary" )
        dict_ = args[ argc ]; argc += 1
        
        mixedFvPatchScalarField.__init__( self, p, iF )
        from Foam.OpenFOAM import word
        self.neighbourFieldName_ = word( dict_.lookup( word( "neighbourFieldName" ) ) )
        self.KName_ = word( dict_.lookup( word( "K" ) ) )
       
        from Foam.finiteVolume import fvPatchScalarField
        from Foam.OpenFOAM import word, scalarField, readBool
        fvPatchScalarField.ext_assign( self, scalarField( word( "value" ), dict_, p.size() ) )
        
        if dict_.found( word( "refValue" ) ) :
            #Full restart
            self.refValue().ext_assign( scalarField( word( "refValue" ), dict_, p.size() ) )
            self.refGrad().ext_assign( scalarField( word( "refGradient" ), dict_, p.size() ) )
            self.valueFraction().ext_assign( scalarField( word( "valueFraction" ), dict_, p.size() ) )
            self.fixesValue_ = readBool( dict_.lookup( word( "fixesValue" ) ) )
        else:
            # Start from user entered data. Assume fixedValue.
            self.refValue().ext_assign( self )
            self.refGrad().ext_assign( 0.0 )
            self.valueFraction().ext_assign( 1.0 )
            self.fixesValue_ = True
            pass

        return self
示例#4
0
    def _init__fvPatch__DimensionedField_vector_volMesh(self, *args):
        if len(args) != 2:
            raise AssertionError("len( args ) != 2")
        argc = 0

        from Foam.finiteVolume import fvPatch
        try:
            fvPatch.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != fvPatch")
        p = args[argc]
        argc += 1

        from Foam.finiteVolume import DimensionedField_vector_volMesh
        try:
            DimensionedField_vector_volMesh.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError(
                "args[ argc ].__class__ != DimensionedField_Vector_volMesh")
        iF = args[argc]
        argc += 1

        fixedGradientFvPatchVectorField.__init__(self, p, iF)

        from Foam.OpenFOAM import word
        from Foam.OpenFOAM import vectorField, vector, scalarField
        self.UName_ = word("undefined")
        self.rheologyName_ = word("undefined")
        self.traction_ = vectorField(p.size(), vector.zero)
        self.pressure_ = scalarField(p.size(), 0.0)

        return self
示例#5
0
    def _init__fvPatch__DimensionedField_vector_volMesh( self, *args ) :
        if len( args ) != 2 :
            raise AssertionError( "len( args ) != 2" )
        argc = 0

        from Foam.finiteVolume import fvPatch
        try:
            fvPatch.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != fvPatch" )
        p = args[ argc ]; argc += 1
        
        from Foam.finiteVolume import DimensionedField_vector_volMesh
        try:
            DimensionedField_vector_volMesh.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != DimensionedField_Vector_volMesh" )
        iF = args[ argc ]; argc += 1
        
        fixedGradientFvPatchVectorField.__init__( self, p, iF )
        
        from Foam.OpenFOAM import word
        from Foam.OpenFOAM import vectorField, vector, scalarField
        self.UName_ = word( "undefined" )
        self.rheologyName_ = word( "undefined" )
        self.traction_ = vectorField( p.size(), vector.zero)
        self.pressure_ = scalarField(p.size(), 0.0)
                
        return self
示例#6
0
    def updateCoeffs(self):
        try:
            if self.updated():
                return

            from Foam.OpenFOAM import IOdictionary
            rheology = IOdictionary.ext_lookupObject(self.db(),
                                                     self.rheologyName_)
            from Foam.OpenFOAM import scalarField

            # Python does not wait for evaluation of the closure expression, it destroys return values if it is no more in use
            a_rheology_mu = rheology.mu()
            a_rheology_mu_boundaryField = a_rheology_mu.ext_boundaryField()
            mu = scalarField(a_rheology_mu_boundaryField[self.patch().index()])

            a_rheology_lambda = rheology._lambda()
            a_rheology_lambda_boundaryField = a_rheology_lambda.ext_boundaryField(
            )
            lambda_ = scalarField(
                a_rheology_lambda_boundaryField[self.patch().index()])

            n = self.patch().nf()
            from Foam.finiteVolume import volTensorField
            from Foam.OpenFOAM import word
            gradU = volTensorField.ext_lookupPatchField(
                self.patch(), word("grad(" + str(self.UName_) + ")"))

            from Foam.OpenFOAM import ext_Info
            self.gradient().ext_assign( ( ( self.traction_ -  self.pressure_ * n ) - ( n & ( mu * gradU.ext_T() - ( mu + lambda_ ) * gradU ) ) \
                                           - n * lambda_ * gradU.tr() ) / ( 2.0 * mu + lambda_) )

            from Foam.finiteVolume import fixedGradientFvPatchVectorField
            fixedGradientFvPatchVectorField.updateCoeffs(self)
        except Exception, exc:
            import sys, traceback
            traceback.print_exc(file=sys.stdout)
            raise exc
示例#7
0
 def indicator( self, i ):
     try:
         arg = int( i )
     except ValueError:
         raise AttributeError ("The i is not int")
     
     mat = self.materials_.internalField()
     
     from Foam.OpenFOAM import scalarField, SMALL
     result = scalarField( mat.size(), 0.0 )
     for matI in range(mat.size()):
         if mat[ matI ] > (i- SMALL) and mat[matI] < (i + 1 - SMALL):
            result[ matI ] = 1.0
     
     return result
示例#8
0
    def indicator(self, i):
        try:
            arg = int(i)
        except ValueError:
            raise AttributeError("The i is not int")

        mat = self.materials_.internalField()

        from Foam.OpenFOAM import scalarField, SMALL
        result = scalarField(mat.size(), 0.0)
        for matI in range(mat.size()):
            if mat[matI] > (i - SMALL) and mat[matI] < (i + 1 - SMALL):
                result[matI] = 1.0

        return result
示例#9
0
    def _init__self__fvPatch__DimensionedField_vector_volMesh__mapper(
            self, *args):
        if len(args) != 4:
            raise AssertionError("len( args ) != 4")
        argc = 0

        if args[argc].__class__ != self.__class__:
            raise AssertionError("args[ argc ].__class__ != self.__class__")
        tdpvf = args[argc]
        argc += 1

        from Foam.finiteVolume import fvPatch
        try:
            fvPatch.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != fvPatch")
        p = args[argc]
        argc += 1

        from Foam.finiteVolume import DimensionedField_vector_volMesh
        try:
            DimensionedField_vector_volMesh.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError(
                "args[ argc ].__class__ != DimensionedField_Vector_volMesh")
        iF = args[argc]
        argc += 1

        from Foam.finiteVolume import fvPatchFieldMapper
        try:
            fvPatchFieldMapper.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError(
                "args[ argc ].__class__ != fvPatchFieldMapper")
        mapper = args[argc]
        argc += 1

        fixedGradientFvPatchVectorField.__init__(self, tdpvf, p, iF, mapper)

        from Foam.OpenFOAM import word
        from Foam.OpenFOAM import vectorField, scalarField
        self.UName_ = tdpvf.UName_
        self.rheologyName_ = tdpvf.rheologyName_
        self.traction_ = vectorField(tdpvf.traction_, mapper)
        self.pressure_ = scalarField(tdpvf.pressure_, mapper)

        return self
    def _init__fvPatch__DimensionedField_scalar_volMesh__dictionary(
            self, *args):
        if len(args) != 3:
            raise AssertionError("len( args ) != 3")
        argc = 0

        from Foam.finiteVolume import fvPatch
        try:
            fvPatch.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != fvPatch")
        p = args[argc]
        argc += 1

        from Foam.finiteVolume import DimensionedField_scalar_volMesh
        try:
            DimensionedField_scalar_volMesh.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError(
                "args[ argc ].__class__ != DimensionedField_scalar_volMesh")
        iF = args[argc]
        argc += 1

        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != dictionary")
        dict_ = args[argc]

        fixedGradientFvPatchScalarField.__init__(self, p, iF)
        from chtMultiRegionFlux.r1_5.coupleManager import coupleManager
        self.coupleManager_ = coupleManager(p, dict_)
        from Foam.OpenFOAM import word
        self.KName_ = word(dict_.lookup(word("K")))

        if dict_.found(word("value")):
            from Foam.finiteVolume import fvPatchScalarField
            from Foam.OpenFOAM import scalarField
            fvPatchScalarField.ext_assign(
                self, scalarField(word("value"), dict_, p.size()))
            pass
        else:
            self.evaluate()
            pass

        return self
示例#11
0
    def _init__fvPatch__DimensionedField_vector_volMesh__dictionary(
            self, *args):
        if len(args) != 3:
            raise AssertionError("len( args ) != 3")
        argc = 0

        from Foam.finiteVolume import fvPatch
        try:
            fvPatch.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != fvPatch")
        p = args[argc]
        argc += 1

        from Foam.finiteVolume import DimensionedField_vector_volMesh
        try:
            DimensionedField_vector_volMesh.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError(
                "args[ argc ].__class__ != DimensionedField_Vector_volMesh")
        iF = args[argc]
        argc += 1

        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != dictionary")
        dict_ = args[argc]
        argc += 1

        fixedGradientFvPatchVectorField.__init__(self, p, iF)

        from Foam.OpenFOAM import word
        from Foam.OpenFOAM import vectorField, vector, scalarField
        self.UName_ = word(dict_.lookup(word("U")))
        self.rheologyName_ = word(dict_.lookup(word("rheology")))
        self.traction_ = vectorField(word("traction"), dict_, p.size())
        self.pressure_ = scalarField(word("pressure"), dict_, p.size())

        self.ext_assign(self.patchInternalField())
        self.gradient().ext_assign(vector.zero)

        ext_Info() << "rf: " << self.rheologyName_ << nl

        return self
    def _init__fvPatch__DimensionedField_scalar_volMesh__dictionary(self, *args):
        if len(args) != 3:
            raise AssertionError("len( args ) != 3")
        argc = 0

        from Foam.finiteVolume import fvPatch

        try:
            fvPatch.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != fvPatch")
        p = args[argc]
        argc += 1

        from Foam.finiteVolume import DimensionedField_scalar_volMesh

        try:
            DimensionedField_scalar_volMesh.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != DimensionedField_scalar_volMesh")
        iF = args[argc]
        argc += 1

        from Foam.OpenFOAM import dictionary

        try:
            dictionary.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != dictionary")
        dict_ = args[argc]

        fixedGradientFvPatchScalarField.__init__(self, p, iF)

        if dict_.found(word("gradient")):
            from Foam.OpenFOAM import scalarField

            self.gradient().ext_assign(scalarField(word("gradient"), dict_, p.size()))
            fixedGradientFvPatchScalarField.updateCoeffs(self)
            fixedGradientFvPatchScalarField.evaluate()
            pass
        else:
            self.ext_assign(self.patchInternalField())
            self.gradient().ext_assign(0.0)
            pass

        return self
 def _init__fvPatch__DimensionedField_scalar_volMesh__dictionary( self, *args ):
     if len( args ) != 3 :
         raise AssertionError( "len( args ) != 3" )
     argc = 0
     
     from Foam.finiteVolume import fvPatch        
     try:
         fvPatch.ext_isinstance( args[ argc ] )
     except TypeError:
         raise AssertionError( "args[ argc ].__class__ != fvPatch" )
     p = args[ argc ]; argc += 1
     
     from Foam.finiteVolume import DimensionedField_scalar_volMesh
     try:
         DimensionedField_scalar_volMesh.ext_isinstance( args[ argc ] )
     except TypeError:
         raise AssertionError( "args[ argc ].__class__ != DimensionedField_scalar_volMesh" )
     iF = args[ argc ]; argc += 1
     
     from Foam.OpenFOAM import dictionary
     try:
         dictionary.ext_isinstance( args[ argc ] )
     except TypeError:
         raise AssertionError( "args[ argc ].__class__ != dictionary" )
     dict_ = args[ argc ]
     
     fixedValueFvPatchScalarField.__init__( self, p, iF )
     from chtMultiRegionFlux.r1_5.coupleManager import coupleManager
     self.coupleManager_ = coupleManager( p, dict_ )
     from Foam.OpenFOAM import word
     self.KName_ = word( dict_.lookup( word( "K" ) ) )
     
     if dict_.found( word( "value" ) ):
        from Foam.finiteVolume import fvPatchScalarField
        from Foam.OpenFOAM import scalarField
        fvPatchScalarField.ext_assign( self, scalarField( word( "value" ), dict_, p.size() ) )
        pass
     else:
        self.evaluate()
        pass
     
     return self
示例#14
0
    def _init__fvPatch__DimensionedField_vector_volMesh__dictionary( self, *args ) :
        if len( args ) != 3 :
            raise AssertionError( "len( args ) != 3" )
        argc = 0
        
        from Foam.finiteVolume import fvPatch
        try:
            fvPatch.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != fvPatch" )
        p = args[ argc ]; argc += 1

        from Foam.finiteVolume import DimensionedField_vector_volMesh
        try:
            DimensionedField_vector_volMesh.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != DimensionedField_Vector_volMesh" )
        iF = args[ argc ]; argc += 1
        
        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != dictionary" )
        dict_ = args[ argc ]; argc += 1

        fixedGradientFvPatchVectorField.__init__( self, p, iF )
       
        from Foam.OpenFOAM import word
        from Foam.OpenFOAM import vectorField, vector, scalarField
        self.UName_ = word( dict_.lookup( word( "U" ) ) )
        self.rheologyName_ = word( dict_.lookup( word( "rheology" ) ) )
        self.traction_ = vectorField( word( "traction" ) , dict_, p.size() )
        self.pressure_ = scalarField( word( "pressure" ), dict_, p.size() )
        
        self.ext_assign( self.patchInternalField() )
        self.gradient().ext_assign( vector.zero )
        
        ext_Info() << "rf: " << self.rheologyName_ << nl
        
        return self
    def _init__fvPatch__DimensionedField_scalar_volMesh__dictionary( self, *args ):
        if len( args ) != 3 :
           raise AssertionError( "len( args ) != 3" )
        argc = 0
        
        from Foam.finiteVolume import fvPatch        
        try:
            fvPatch.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != fvPatch" )
        p = args[ argc ]; argc += 1
        
        from Foam.finiteVolume import DimensionedField_scalar_volMesh
        try:
            DimensionedField_scalar_volMesh.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != DimensionedField_scalar_volMesh" )
        iF = args[ argc ]; argc += 1
        
        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != dictionary" )
        dict_ = args[ argc ]
        
        fixedGradientFvPatchScalarField.__init__( self, p, iF )
        
        if dict_.found( word( "gradient" ) ):
           from Foam.OpenFOAM import scalarField
           self.gradient().ext_assign( scalarField( word( "gradient" ) , dict_, p.size() ) )
           fixedGradientFvPatchScalarField.updateCoeffs( self )
           fixedGradientFvPatchScalarField.evaluate()
           pass
        else:
           self.ext_assign( self.patchInternalField() )
           self.gradient().ext_assign( 0.0 )
           pass

        return self
示例#16
0
    def _init__self__fvPatch__DimensionedField_vector_volMesh__mapper( self, *args ) :
        if len( args ) != 4 :
            raise AssertionError( "len( args ) != 4" )
        argc = 0
        
        if args[ argc ].__class__ != self.__class__ :
            raise AssertionError( "args[ argc ].__class__ != self.__class__" )
        tdpvf = args[ argc ]; argc += 1
        
        from Foam.finiteVolume import fvPatch
        try:
            fvPatch.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != fvPatch" )
        p = args[ argc ]; argc += 1

        from Foam.finiteVolume import DimensionedField_vector_volMesh
        try:
            DimensionedField_vector_volMesh.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != DimensionedField_Vector_volMesh" )
        iF = args[ argc ]; argc += 1
        
        from Foam.finiteVolume import fvPatchFieldMapper
        try:
            fvPatchFieldMapper.ext_isinstance( args[ argc ] )
        except TypeError:
            raise AssertionError( "args[ argc ].__class__ != fvPatchFieldMapper" )
        mapper = args[ argc ]; argc += 1
        
        fixedGradientFvPatchVectorField.__init__( self, tdpvf, p, iF, mapper )
        
        from Foam.OpenFOAM import word
        from Foam.OpenFOAM import vectorField, scalarField
        self.UName_ = tdpvf.UName_
        self.rheologyName_ = tdpvf.rheologyName_
        self.traction_ = vectorField( tdpvf.traction_ , mapper )
        self.pressure_ = scalarField( tdpvf.pressure_ , mapper )
        
        return self