Esempio n. 1
0
def comp_axis_time(self, p, per_t=None, is_antiper_t=None, Time_in=None):
    """Compute time axis, with or without periodicities and including normalizations

    Parameters
    ----------
    self : Input
        an Input object
    p: int
        Number of pole pairs
    per_t : int
        time periodicity
    is_antiper_t : bool
        if the time axis is antiperiodic
    Time_in: Data
        Input time axis

    Returns
    -------
    Time: Data
        Requested Time axis
    """

    f_elec = self.OP.get_felec(p=p)
    N0 = self.OP.get_N0(p=p)
    A0 = self.angle_rotor_initial

    # Setup normalizations for time and angle axes
    norm_time = {
        "elec_order":
        Norm_ref(ref=f_elec),
        "mech_order":
        Norm_ref(ref=N0 / 60),
        "angle_elec":
        Norm_ref(ref=self.current_dir / (2 * pi * f_elec)),
        "angle_rotor":
        Norm_affine(slope=self.rot_dir * N0 * 360 / 60, offset=A0 * 180 / pi),
    }

    # Compute Time axis based on input one
    if Time_in is not None:
        if per_t is None or is_antiper_t is None:
            # Get periodicity from input Time axis
            per_t, is_antiper_t = Time_in.get_periodicity()
            per_t = int(per_t / 2) if is_antiper_t else per_t
        # Get axis on given periodicities
        Time = Time_in.get_axis_periodic(Nper=per_t, is_aper=is_antiper_t)
        Time.normalizations = norm_time

    # Create time axis
    elif self.time is None:
        # Create time axis as a DataLinspace
        if self.t_final is not None:
            # Enforce final time
            t_final = self.t_final
        elif self.Nrev is not None:
            # Set final time depending on rotor speed and number of revolutions
            t_final = 60 / self.OP.N0 * self.Nrev
        else:
            # Set final time to p times the number of electrical periods
            t_final = p / f_elec
        # Create time axis as a DataLinspace
        Time = DataLinspace(
            name="time",
            unit="s",
            initial=0,
            final=t_final,
            number=self.Nt_tot,
            include_endpoint=False,
            normalizations=norm_time,
        )
        # Add time (anti-)periodicity
        if per_t > 1 or is_antiper_t:
            Time = Time.get_axis_periodic(per_t, is_antiper_t)
    else:
        # Load time data
        time = self.time.get_data()
        self.Nt_tot = time.size
        Time = Data1D(name="time",
                      unit="s",
                      values=time,
                      normalizations=norm_time)
        # Add time (anti-)periodicity
        sym_t = dict()
        if is_antiper_t:
            sym_t["antiperiod"] = per_t
        elif per_t > 1:
            sym_t["period"] = per_t
        Time.symmetries = sym_t
        Time = Time.to_linspace()

    return Time
Esempio n. 2
0
def comp_axis_angle(self,
                    p,
                    Rag,
                    per_a=None,
                    is_antiper_a=None,
                    Angle_in=None):
    """Compute angle axis with or without periodicities and including normalizations

    Parameters
    ----------
    self : Input
        an Input object
    p : int
        Machine pole pair number
    Rag: float
        Airgap mean radius [m]
    per_a : int
        angle periodicity
    is_antiper_a : bool
        if the angle axis is antiperiodic
    Angle_in: Data
        Input axis angle

    Returns
    -------
    Timee_in: Data
        Requested axis angle

    """

    norm_angle = {
        "space_order": Norm_ref(ref=p),
        "distance": Norm_ref(ref=1 / Rag)
    }

    # Compute angle axis based on input one
    if Angle_in is not None:
        if per_a is None or is_antiper_a is None:
            # Get periodicity from input Angle axis
            per_a, is_antiper_a = Angle_in.get_periodicity()
            per_a = int(per_a / 2) if is_antiper_a else per_a
        # Get Angle axis on requested periodicities
        Angle = Angle_in.get_axis_periodic(Nper=per_a, is_aper=is_antiper_a)
        Angle.normalizations = norm_angle

    # Create angle axis
    elif self.angle is None:

        # Create angle axis as a DataLinspace
        Angle = DataLinspace(
            name="angle",
            unit="rad",
            initial=0,
            final=2 * pi,
            number=self.Na_tot,
            include_endpoint=False,
            normalizations=norm_angle,
        )
        # Add angle (anti-)periodicity
        if per_a > 1 or is_antiper_a:
            Angle = Angle.get_axis_periodic(per_a, is_antiper_a)

    else:
        # Load angle data
        angle = self.angle.get_data()
        self.Na_tot = angle.size
        Angle = Data1D(name="angle",
                       unit="rad",
                       values=angle,
                       normalizations=norm_angle)
        # Add angle (anti-)periodicity
        sym_a = dict()
        if is_antiper_a:
            sym_a["antiperiod"] = per_a
        elif per_a > 1:
            sym_a["period"] = per_a
        Angle.symmetries = sym_a
        Angle = Angle.to_linspace()

    return Angle