mors.cluster

def ActivityLifetime(self,Quantity=None,Threshold=None,AgeMax=None):
    """Takes threshold value, returns ages at which each star last drops below this threshold.

    This function can be used to determine when each star's emission crosses a given threshold value for a few
    activity quantities. These are Lx, Fx, Rx, and FxHZ for X-rays, and similar values for EUV1, EUV2, EUV,
    XUV, and Ly-alpha. If the star crosses the threshold (from above it to below it) multiple times, this
    will find the final time it will cross the threshold. If the user wants to set a maximum age so that the
    code only looks for crossings of the threshold below this age then this can be done using the AgeMax
    keyword argument.

    Parameters
    ----------
    Quantity : str
        Gives which quantity to consider (e.g. 'Lx').
    Threshold : float or str
        Value for threshold in units of quantity or string of 'sat'.
    AgeMax : float , optional
        End age of track to consider in Myr.

    Returns
    ----------
    AgeActive : float
        Activity lifetime in Myr.

    """

    # Make sure Quantity is set
    if Quantity is None:
        raise Exception("Quantity not set in call to function")

    # Make sure Quantity is string
    if not isinstance(Quantity,str):
        raise Exception("Quantity must be string")

    # Make array
    AgeActive = np.zeros(self.nStars)

    # Loop over stars and get each
    for iStar in range(self.nStars):
        AgeActive[iStar] = self.stars[iStar].ActivityLifetime(Quantity=Quantity,Threshold=Threshold,AgeMax=AgeMax)

    return AgeActive

def IntegrateEmission(self,AgeMin=None,AgeMax=None,Band=None,aOrb=None):
    """Takes age range, returns integrated emission in band within that range for each star.

    This code can be used to the luminosities of the stars between two ages. This can be applied to any wavelength band
    and the result is a total energy emitted in this time in erg. If the user also specifies an orbital distance using
    the aOrb keyword argument, the code integrates the flux at this obital distance returns a fluence in erg cm^-2. The
    user can specify aOrb as a string to get the fluences at various habitable zone boundaries (using the HZ calculated
    at the age defined in params when creating this cluster). Options are 'RecentVenus', 'RunawayGreenhouse', 'MoistGreenhouse',
    'MaximumGreenhouse', 'EarlyMars', and 'HZ'.

    Parameters
    ----------
    AgeMin : float
        Start of time period to integrate in Myr.
    AgeMax : float
        End of time period to integrate in Myr.
    Band : str
        Gives which wavelength band to consider (options are 'XUV', 'Xray', 'EUV1', 'EUV2', 'EUV', 'Lyman', 'bol').
    aOrb : float or str, optional
        Orbital distance to get fluence at in AU or string identifying HZ boundary.

    Returns
    ----------
    Energy : numpy.ndarray
        Integrated luminosity or flux in erg or erg cm^-2.

    """

    # Make array
    Energy = np.zeros(self.nStars)

    # Loop over stars and get each
    for iStar in range(self.nStars):
        Energy[iStar] = self.stars[iStar].IntegrateEmission(AgeMin=AgeMin,AgeMax=AgeMax,Band=Band,aOrb=aOrb)

    return Energy

def Percentile(self,Mstar=None,Age=None,Omega=None,Prot=None,percentile=None):
    """Gets rotation rate of percentile or percentile of rotation rate in the rotation distribution at given age.

    This function can be used for two purposes
    1. to determine the percentile in a rotation distribution of a star given its mass, rotation rate, and age
    2. to determine the rotation rate of a star in a rotation distribution given its mass, percentile, and age
    In the first case, the user should specify the rotation rate using either the Omega or Prot keyword arguments (given
    in OmegaSun and days respectively) and the mass. In the second case, the user should specify the percentile using the
    percentile keyword argument (in the range 0 to 100) and the mass. The mass should be specified in Msun using the Mstar
    keyword argument and the age in Myr using the Age keyword argument. These should only be given as floats.

    Parameters
    ----------
    Mstar : float
        Stellar mass in Msun.
    Age : float
        Age of star in Myr.
    Omega : float , optional
        Rotation rate of star in OmegaSun.
    Prot : float , optional
        Rotation period of star in days.
    percentile : float , optional
        percentile in distribution (between 0 and 100).

    Returns
    ----------
    result : float
        Either rotation rate for percentile or percentile for rotation rate.

    """

    # Make sure the age is specified
    if Age is None:
        raise Exception("keyword parameter Age not set in call to function")

    # If percentile was set to a string, get float version
    if isinstance(percentile,str):
        if ( percentile == 'slow' ):
            percentile = 5.0
        elif ( percentile == 'medium' ):
            percentile = 50.0
        elif ( percentile == 'fast' ):
            percentile = 95.0
        else:
            raise Exception( "invalid percentile string (options are 'slow', 'medium', or 'fast')" )

    # Get the rotation distribution at this age
    OmegaDist = self.Values( Age=Age , Quantity='OmegaEnv' )

    # Get the result
    result = star.Percentile( Mstar=Mstar , Omega=Omega , Prot=Prot , percentile=percentile ,
                            MstarDist=self.Mstar , OmegaDist=OmegaDist , params=self.params )

    return result

def PrintStars(self):
    """Prints list of stars in cluster to screen."""

    # Header
    log.info("The following is a list of masses for stars in this cluster.")

    # Loop over each star and print basic parameters
    for iStar in range(0,self.nStars):
        log.info("   "+str(iStar)+". "+str(self.Mstar[iStar])+" Msun")

    # Total number of stars
    log.info("Number of stars in cluster = "+str(self.nStars))

    return

def Save(self,filename='cluster.pickle'):
    """Takes filename (default is 'cluster.pickle'), saves cluster to this file using pickle."""

    with open(filename,'wb') as f:
        pickle.dump(self,f)

    return

def Values(self,Age=None,Quantity=None):
    """Takes age in Myr and a string with name of quantity to output, returns value of that quantity at specified age for all stars.

    Parameters
    ----------
    Age : float
        Age of cluster.
    Quantity : str
        String holding name of parameter to get.

    Returns
    ----------
    values : numpy.ndarray
        Set of extended quantities.

    """

    # Make sure input parameters are set
    if Age is None:
        raise Exception("keyword parameter Age not set in call to function")
    if Quantity is None:
        raise Exception("keyword parameter Quantity not set in call to function")

    # Make array to hold values
    values = np.zeros(self.nStars)

    # Loop over stars and get values for each
    for iStar in range(0,self.nStars):
        values[iStar] = self.stars[iStar].Value(Age=Age,Quantity=Quantity)

    return values

def save(self,filename='cluster.pickle'):
    """Same as Save()."""
    self.Save(filename=filename)
    return