# PLaSK User Manual

#### Page Contents

- Static2D Class
  - `Static2D`
  - Methods
  - Attributes
    - Receivers
    - Providers
    - Other
  - Descriptions
    - Method Details
      - `Static2D.compute()`
      - `Static2D.initialize()`
      - `Static2D.invalidate()`
    - Receiver Details
      - `Static2D.inHeat`
    - Provider Details
      - `Static2D.outHeatFlux`
      - `Static2D.outTemperature`
      - `Static2D.outThermalConductivity`
    - Attribute Details
      - `Static2D.algorithm`
      - `Static2D.convection_boundary`
      - `Static2D.Convection`
      - `Static2D.empty_elements`
      - `Static2D.err`
      - `Static2D.geometry`
      - `Static2D.heatflux_boundary`
      - `Static2D.id`
      - `Static2D.initialized`
      - `Static2D.inittemp`
      - `Static2D.iterative`
      - `Static2D.maxerr`
      - `Static2D.mesh`
      - `Static2D.radiation_boundary`
      - `Static2D.Radiation`
      - `Static2D.temperature_boundary`

# Static2D Class

class thermal.static.Static2D(name='')

  Finite element thermal solver for 2D Cartesian Geometry.

## Methods

`compute`([loops]) | Run thermal calculations
`initialize`() | Initialize solver.
`invalidate`() | Set the solver back to uninitialized state.

## Attributes

### Receivers

`inHeat` | Receiver of the heat sources density required for computations [W/m³].

### Providers

`outHeatFlux` | Provider of the computed heat flux [W/m²].
`outTemperature` | Provider of the computed temperature [K].
`outThermalConductivity` | Provider of the computed thermal conductivity [W/(m×K)].

### Other

`algorithm` | Chosen matrix factorization algorithm
`convection_boundary` | Convective boundary conditions
`empty_elements` | Should empty regions (e.g. air) be included into computation domain?.
`err` | Maximum estimated error
`geometry` | Geometry provided to the solver
`heatflux_boundary` | Boundary conditions for the constant heat flux
`id` | Id of the solver object.
`initialized` | True if the solver has been initialized.
`inittemp` | Initial temperature
`iterative` | Iterative matrix parameters (see `IterativeParams`)
`maxerr` | Limit for the temperature updates
`mesh` | Mesh provided to the solver
`radiation_boundary` | Radiative boundary conditions
`temperature_boundary` | Boundary conditions for the constant temperature

## Descriptions

### Method Details

Static2D.compute(loops=0)

  Run thermal calculations

Static2D.initialize()

  Initialize solver.

  This method manually initialized the solver and sets `initialized` to True. Normally calling it is not necessary, as each solver automatically initializes itself when needed.

  Returns:

    solver `initialized` state prior to this method call.

  Return type:

    bool

Static2D.invalidate()

  Set the solver back to uninitialized state.

  This method frees the memory allocated by the solver and sets `initialized` to False.

### Receiver Details

Static2D.inHeat = <property object>

  Receiver of the heat sources density required for computations [W/m³].

  You will find usage details in the documentation of the receiver class `HeatReceiver2D`.

  Example

  Connect the receiver to a provider from some other solver:

      >>> solver.inHeat = other_solver.outHeat

  See also

  Receciver class: `plask.flow.HeatReceiver2D`

  Provider class: `plask.flow.HeatProvider2D`

  Data filter: `plask.filter.HeatFilter2D`

### Provider Details

Static2D.outHeatFlux(mesh, interpolation='default') = <property object>

  Provider of the computed heat flux [W/m²].

  Parameters:

    - mesh (mesh) – Target mesh to get the field at.

    - interpolation (str) – Requested interpolation method.

  Returns:

    Data with the heat flux on the specified mesh [W/m²].

  Example

  Connect the provider to a receiver in some other solver:

      >>> other_solver.inHeatFlux = solver.outHeatFlux

  Obtain the provided field:

      >>> solver.outHeatFlux(mesh)
      <plask.Data at 0x1234567>

  See also

  Provider class: `plask.flow.HeatFluxProvider2D`

  Receciver class: `plask.flow.HeatFluxReceiver2D`

Static2D.outTemperature(mesh, interpolation='default') = <property object>

  Provider of the computed temperature [K].

  Parameters:

    - mesh (mesh) – Target mesh to get the field at.

    - interpolation (str) – Requested interpolation method.

  Returns:

    Data with the temperature on the specified mesh [K].

  Example

  Connect the provider to a receiver in some other solver:

      >>> other_solver.inTemperature = solver.outTemperature

  Obtain the provided field:

      >>> solver.outTemperature(mesh)
      <plask.Data at 0x1234567>

  See also

  Provider class: `plask.flow.TemperatureProvider2D`

  Receciver class: `plask.flow.TemperatureReceiver2D`

Static2D.outThermalConductivity(mesh, interpolation='default') = <property object>

  Provider of the computed thermal conductivity [W/(m×K)].

  Parameters:

    - mesh (mesh) – Target mesh to get the field at.

    - interpolation (str) – Requested interpolation method.

  Returns:

    Data with the thermal conductivity on the specified mesh [W/(m×K)].

  Example

  Connect the provider to a receiver in some other solver:

      >>> other_solver.inThermalConductivity = solver.outThermalConductivity

  Obtain the provided field:

      >>> solver.outThermalConductivity(mesh)
      <plask.Data at 0x1234567>

  See also

  Provider class: `plask.flow.ThermalConductivityProvider2D`

  Receciver class: `plask.flow.ThermalConductivityReceiver2D`

### Attribute Details

Static2D.algorithm = <property object>

  Chosen matrix factorization algorithm

Static2D.convection_boundary = <property object>

  Convective boundary conditions

  This field holds a list of boundary conditions for the solver. You may access and alter its elements a normal Python list. Each element is a special class that has two attributes:

  `place` | Boundary condition location (`plask.mesh.RectangularBase2D.Boundary`).
  `value` | Boundary condition value (`thermal.static.Convection`).

  When you add new boundary condition, you may use two-argument `append`, or `prepend` methods, or three-argument `insert` method, where you separately specify the place and the value. See the below example for clarification.

  Example

      >>> solver.convection_boundary.clear()
      >>> solver.convection_boundary.append(solver.mesh.Bottom(), some_value)
      >>> solver.convection_boundary[0].value = different_value
      >>> solver.convection_boundary.insert(0, solver.mesh.Top(), new_value)
      >>> solver.convection_boundary[1].value == different_value
      True

  class Convection

    Convective boundary condition value.

Static2D.empty_elements = <property object>

  Should empty regions (e.g. air) be included into computation domain?

Static2D.err = <property object>

  Maximum estimated error

Static2D.geometry = <property object>

  Geometry provided to the solver

Static2D.heatflux_boundary = <property object>

  Boundary conditions for the constant heat flux

  This field holds a list of boundary conditions for the solver. You may access and alter its elements a normal Python list. Each element is a special class that has two attributes:

  `place` | Boundary condition location (`plask.mesh.RectangularBase2D.Boundary`).
  `value` | Boundary condition value.

  When you add new boundary condition, you may use two-argument `append`, or `prepend` methods, or three-argument `insert` method, where you separately specify the place and the value. See the below example for clarification.

  Example

      >>> solver.heatflux_boundary.clear()
      >>> solver.heatflux_boundary.append(solver.mesh.Bottom(), some_value)
      >>> solver.heatflux_boundary[0].value = different_value
      >>> solver.heatflux_boundary.insert(0, solver.mesh.Top(), new_value)
      >>> solver.heatflux_boundary[1].value == different_value
      True

Static2D.id = <property object>

  Id of the solver object. (read only)

  Example

      >>> mysolver.id
      mysolver:category.type

Static2D.initialized = <property object>

  True if the solver has been initialized. (read only)

  Solvers usually get initialized at the beginning of the computations. You can clean the initialization state and free the memory by calling the `invalidate()` method.

Static2D.inittemp = <property object>

  Initial temperature

Static2D.iterative = <property object>

  Iterative matrix parameters (see `IterativeParams`)

Static2D.maxerr = <property object>

  Limit for the temperature updates

Static2D.mesh = <property object>

  Mesh provided to the solver

Static2D.radiation_boundary = <property object>

  Radiative boundary conditions

  This field holds a list of boundary conditions for the solver. You may access and alter its elements a normal Python list. Each element is a special class that has two attributes:

  `place` | Boundary condition location (`plask.mesh.RectangularBase2D.Boundary`).
  `value` | Boundary condition value (`thermal.static.Radiation`).

  When you add new boundary condition, you may use two-argument `append`, or `prepend` methods, or three-argument `insert` method, where you separately specify the place and the value. See the below example for clarification.

  Example

      >>> solver.radiation_boundary.clear()
      >>> solver.radiation_boundary.append(solver.mesh.Bottom(), some_value)
      >>> solver.radiation_boundary[0].value = different_value
      >>> solver.radiation_boundary.insert(0, solver.mesh.Top(), new_value)
      >>> solver.radiation_boundary[1].value == different_value
      True

  class Radiation

    Radiative boundary condition value.

Static2D.temperature_boundary = <property object>

  Boundary conditions for the constant temperature

  This field holds a list of boundary conditions for the solver. You may access and alter its elements a normal Python list. Each element is a special class that has two attributes:

  `place` | Boundary condition location (`plask.mesh.RectangularBase2D.Boundary`).
  `value` | Boundary condition value.

  When you add new boundary condition, you may use two-argument `append`, or `prepend` methods, or three-argument `insert` method, where you separately specify the place and the value. See the below example for clarification.

  Example

      >>> solver.temperature_boundary.clear()
      >>> solver.temperature_boundary.append(solver.mesh.Bottom(), some_value)
      >>> solver.temperature_boundary[0].value = different_value
      >>> solver.temperature_boundary.insert(0, solver.mesh.Top(), new_value)
      >>> solver.temperature_boundary[1].value == different_value
      True