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
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