:py:mod:`wolfhece.mesh2d.gpu_2d`
================================

.. py:module:: wolfhece.mesh2d.gpu_2d


Module Contents
---------------

.. py:class:: infiltration_GPU(parent: Sim_2D_GPU)


   .. py:property:: infiltrations_chronology
      :type: list[float]


   .. py:property:: nb_steps
      :type: int


   .. py:property:: nb_zones
      :type: wolfhece.PyVertexvectors.Zones


   .. py:method:: plot_plt(figax=None, show=True)

      Plot the infiltration data



.. py:class:: Sim_2D_GPU(directory: Union[str, pathlib.Path] = '')


   Simulation 2D GPU -- Interface

   .. py:property:: boundary_condition


   .. py:property:: is_loaded
      :type: bool


   .. py:property:: sim


   .. py:property:: nullvalues
      :type: dict[str, int]

      Define null values for the arrays

   .. py:method:: unload() -> None

      Unload the simulation


   .. py:method:: _get_name_arrays() -> list[str]

      Get the name of the arrays


   .. py:method:: _get_description_arrays() -> list[str]

      Get the description of the arrays


   .. py:method:: get_header() -> wolfhece.wolf_array.header_wolf

      Get the header of the simulation


   .. py:method:: get_arraysasdict() -> dict[str, wolfhece.wolf_array.WolfArray]

      Get all the arrays from the simulation


   .. py:method:: mimic_mask(source: wolfhece.wolf_array.WolfArray, dest: list[wolfhece.wolf_array.WolfArray])

      Mimic the mask


   .. py:method:: create_arrays_from(source: wolfhece.wolf_array.WolfArray)

      Create arrays from a source


   .. py:method:: create_from_vector(vector: Sim_2D_GPU.create_from_vector.vector, dx: float, dy: float)

      Create a simulation from a vector


   .. py:method:: create_from_array(array: wolfhece.wolf_array.WolfArray)

      Create a simulation from an array


   .. py:method:: create_from_header(header: wolfhece.wolf_array.header_wolf) -> Sim_2D_GPU

      Create a simulation from a header


   .. py:method:: set_mesh_size(dx, dy)

      Set the mesh size


   .. py:method:: set_magnetic_grid(dx: float, dy: float, origx: float, origy: float)

      Définition de la grille magnétique

      :param dx: taille de maille selon X
      :type dx: float
      :param dy: taille de maille selon Y
      :type dy: float
      :param origx: origine selon X (coordonnée du noeud d'intersection)
      :type origx: float
      :param origy: origine selon Y (coordonnée du noeud d'intersection)
      :type origy: float


   .. py:method:: align2grid(x: float, y: float)

      Alignement sur la grille magnétique


   .. py:method:: verify_files()

      Verify the files


   .. py:method:: get_wizard_text(lang: str = 'en') -> str

      Get the wizard text


   .. py:method:: bc2txt() -> str

      " Get the text for the boundary conditions Manager


   .. py:method:: check_infiltration() -> str

      Informations sur les zones d'infiltration :
        - nombre de zones dans la simulation
        - nombre de cellules de chaque zone
        - première maille de chaque zone
        - nombre de temps énumérés dans le fichier .fil
        - Warning si le nombre de zones est différent entre les fichiers .inf et .fil



   .. py:method:: check_environment() -> list[str]


   .. py:method:: run(limit_dryuploops: int = -1)

      run the simulation in a subprocess


   .. py:method:: write_initial_condition_from_record(recpath: pathlib.Path = None, id_rec: int = None, destpath: pathlib.Path = None)

      Write the initial condition from a record

      :param recpath: the path to the records. if None, the default path is used and 'simul_gpu_results' as result directory.
      :param id_rec: the index of the record you want to start from.
      :param destpath: the path where to save the initial condition. If None, the current path is used.



   .. py:method:: copy2dir(destpath: pathlib.Path)

      Copy the simulation to a directory


   .. py:method:: reload_ic()

      Reload the initial conditions from the disk and store ir in the same memory space.


   .. py:method:: reload_all()

      Reload all the data from the disk and store them in the same memory space.