docs: def _Plot_HorProj_Ves(V, ax=None, Elt='PI', Nstep=_def.TorNTheta,
                        Pdict=_def.TorPd, Idict=_def.TorITord,
                        Bsdict=_def.TorBsTord, Bvdict=_def.TorBvTord,
                        LegDict=_def.TorLegd, indices=False,
                        draw=True, fs=None, wintit=_wintit, Test=True):
      """ Plotting the toroidal projection of a Ves instance
  
      Parameters
      ----------
          V           A Ves instance
          Nstep      An int (the number of points for evaluation of theta by np.linspace)
          ax          A plt.Axes instance (if given) on which to plot, otherwise ('None') a new figure/axes is created
          Tdict       A dictionnary specifying the style of the polygon plot
          LegDict     A dictionnary specifying the style of the legend box (if None => no legend)
  
      Returns
      -------
          ax          The plt.Axes instance on which the plot was performed
      """
      if Test:
          assert type(Nstep) is int
          ax, C0, C1, C2 = _check_Lax(ax,n=1)
          assert type(Pdict) is dict, 'Arg Pdict should be a dictionary !'
          assert type(Idict) is dict, 'Arg Idict should be a dictionary !'
          assert type(LegDict) is dict or LegDict is None, 'Arg LegDict should be a dictionary !'
  
      if ax is None:
          ax = _def.Plot_LOSProj_DefAxes('Hor', Type=V.Id.Type,
                                         fs=fs, wintit=wintit)
      P1Min = V.dgeom['P1Min']
      P1Max = V.dgeom['P1Max']
      if 'P' in Elt:
          if V._InOut=='in':
              if V.Id.Type=='Tor':
                  Theta = np.linspace(0, 2*np.pi, num=Nstep,
                                      endpoint=True, retstep=False)
                  lx = np.concatenate((P1Min[0]*np.cos(Theta),np.array([np.nan]),
                                       P1Max[0]*np.cos(Theta)))
                  ly = np.concatenate((P1Min[0]*np.sin(Theta),np.array([np.nan]),
                                       P1Max[0]*np.sin(Theta)))
              elif V.Id.Type=='Lin':
                  lx = np.array([V.Lim[0,0],V.Lim[0,1],V.Lim[0,1],
                                 V.Lim[0,0],V.Lim[0,0]])
                  ly = np.array([P1Min[0],P1Min[0],P1Max[0],P1Max[0],P1Min[0]])
              ax.plot(lx,ly,label=V.Id.NameLTX,**Pdict)
          elif V._InOut=='out':
              if V.Id.Type=='Tor':
                  Theta = np.linspace(0, 2*np.pi, num=Nstep,
                                      endpoint=True, retstep=False)
                  if V.noccur==0:
                      lx = np.concatenate((P1Min[0]*np.cos(Theta),
                                           P1Max[0]*np.cos(Theta[::-1])))
                      ly = np.concatenate((P1Min[0]*np.sin(Theta),
                                           P1Max[0]*np.sin(Theta[::-1])))
                      Lp = [mPolygon(np.array([lx,ly]).T, closed=True,
                                     label=V.Id.NameLTX, **Pdict)]
                  else:
                      Lp = [mWedge((0,0), P1Max[0],
                                   V.Lim[ii][0]*180./np.pi,
                                   V.Lim[ii][1]*180./np.pi,
                                   width=P1Max[0]-P1Min[0],
                                   label=V.Id.NameLTX, **Pdict)
                            for ii in range(0,len(V.Lim))]
              elif V.Id.Type=='Lin':
                      ly = np.array([P1Min[0],P1Min[0],
                                     P1Max[0],P1Max[0],P1Min[0]])
                      Lp = []
                      for ii in range(0,len(V.Lim)):
                          lx = np.array([V.Lim[ii][0],V.Lim[ii][1],
                                         V.Lim[ii][1],V.Lim[ii][0],
                                         V.Lim[ii][0]])
                          Lp.append(mPolygon(np.array([lx,ly]).T,
                                             closed=True, label=V.Id.NameLTX,
                                             **Pdict))
              for pp in Lp:
                  ax.add_patch(pp)
          else:
              msg = "Unknown self._InOut !"
              raise Exception(msg)
  
      if 'I' in Elt:
          if V.Id.Type=='Tor':
              lx = V.dsino['RefPt'][0]*np.cos(Theta)
              ly = V.dsino['RefPt'][0]*np.sin(Theta)
          elif V.Id.Type=='Lin':
              lx = np.array([np.min(V.Lim),np.max(V.Lim)])
              ly = V.dsino['RefPt'][0]*np.ones((2,))
          ax.plot(lx,ly,label=V.Id.NameLTX+" Imp",**Idict)
      if 'Bs' in Elt:
          if V.Id.Type=='Tor':
              lx = V.dgeom['BaryS'][0]*np.cos(Theta)
              ly = V.dgeom['BaryS'][0]*np.sin(Theta)
          elif V.Id.Type=='Lin':
              lx = np.array([np.min(V.Lim),np.max(V.Lim)])
              ly = V.dgeom['BaryS'][0]*np.ones((2,))
          ax.plot(lx,ly,label=V.Id.NameLTX+" Bs", **Bsdict)
      if 'Bv' in Elt and V.Type=='Tor':
          lx = V.dgeom['BaryV'][0]*np.cos(Theta)
          ly = V.dgeom['BaryV'][0]*np.sin(Theta)
          ax.plot(lx,ly,label=V.Id.NameLTX+" Bv", **Bvdict)
  
      if indices and V.noccur>1:
          if V.Id.Type=='Tor':
              for ii in range(0,V.noccur):
                  R, theta = V.dgeom['P1Max'][0], np.mean(V.Lim[ii])
                  X, Y = R*np.cos(theta), R*np.sin(theta)
                  ax.annotate(r"{0}".format(ii), size=10,
                              xy = (X,Y),
                              xytext = (X+0.02*np.cos(theta),
                                        Y+0.02*np.sin(theta)),
                              horizontalalignment='center',
                              verticalalignment='center')
          elif V.Id.Type=='Lin':
              for ii in range(0,V.noccur):
                  X, Y = np.mean(V.Lim[ii]), V.dgeom['P1Max'][0]
                  ax.annotate(r"{0}".format(ii), size=10,
                              xy = (X,Y),
                              xytext = (X, Y+0.02),
                              horizontalalignment='center',
                              verticalalignment='center')
  
      if not LegDict is None:
          ax.legend(**LegDict)
      if draw:
          ax.relim()
          ax.autoscale_view()
          ax.figure.canvas.draw()
      return ax