text: # -*- coding: utf-8 -*-
  """File generated according to Generator/ClassesRef/Machine/MagnetFlat.csv
  WARNING! All changes made in this file will be lost!
  """
  
  from os import linesep
  from logging import getLogger
  from ._check import check_var, raise_
  from ..Functions.get_logger import get_logger
  from ..Functions.save import save
  from .Magnet import Magnet
  
  from ._check import InitUnKnowClassError
  from .Material import Material
  
  
  class MagnetFlat(Magnet):
      """abstract class of magnets with rectangular base"""
  
      VERSION = 1
  
      # save method is available in all object
      save = save
  
      # get_logger method is available in all object
      get_logger = get_logger
  
      def __init__(self, mat_type=-1, type_magnetization=0, Lmag=0.95, init_dict=None):
          """Constructor of the class. Can be use in two ways :
          - __init__ (arg1 = 1, arg3 = 5) every parameters have name and default values
              for Matrix, None will initialise the property with an empty Matrix
              for pyleecan type, None will call the default constructor
          - __init__ (init_dict = d) d must be a dictionnary wiht every properties as keys
  
          ndarray or list can be given for Vector and Matrix
          object or dict can be given for pyleecan Object"""
  
          if mat_type == -1:
              mat_type = Material()
          if init_dict is not None:  # Initialisation by dict
              assert type(init_dict) is dict
              # Overwrite default value with init_dict content
              if "mat_type" in list(init_dict.keys()):
                  mat_type = init_dict["mat_type"]
              if "type_magnetization" in list(init_dict.keys()):
                  type_magnetization = init_dict["type_magnetization"]
              if "Lmag" in list(init_dict.keys()):
                  Lmag = init_dict["Lmag"]
          # Initialisation by argument
          # Call Magnet init
          super(MagnetFlat, self).__init__(
              mat_type=mat_type, type_magnetization=type_magnetization, Lmag=Lmag
          )
          # The class is frozen (in Magnet init), for now it's impossible to
          # add new properties
  
      def __str__(self):
          """Convert this objet in a readeable string (for print)"""
  
          MagnetFlat_str = ""
          # Get the properties inherited from Magnet
          MagnetFlat_str += super(MagnetFlat, self).__str__()
          return MagnetFlat_str
  
      def __eq__(self, other):
          """Compare two objects (skip parent)"""
  
          if type(other) != type(self):
              return False
  
          # Check the properties inherited from Magnet
          if not super(MagnetFlat, self).__eq__(other):
              return False
          return True
  
      def as_dict(self):
          """Convert this objet in a json seriable dict (can be use in __init__)
          """
  
          # Get the properties inherited from Magnet
          MagnetFlat_dict = super(MagnetFlat, self).as_dict()
          # The class name is added to the dict fordeserialisation purpose
          # Overwrite the mother class name
          MagnetFlat_dict["__class__"] = "MagnetFlat"
          return MagnetFlat_dict
  
      def _set_None(self):
          """Set all the properties to None (except pyleecan object)"""
  
          # Set to None the properties inherited from Magnet
          super(MagnetFlat, self)._set_None()
  