SkyMapMod 0.1.33__tar.gz → 0.1.35__tar.gz

{skymapmod-0.1.33 → skymapmod-0.1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SkyMapMod
-Version: 0.1.33
+Version: 0.1.35
 Summary: for modeling
 Project-URL: Homepage, https://istina.msu.ru/profile/aminevann/
 Author-email: Anna Amineva <amineva.2219@physics.msu.ru>

skymapmod-0.1.35/SkyMapMod/airglow.py

@@ -0,0 +1,70 @@
+#для работы с собственным свечением атмосферы. возможно, сюда можно досыпать поправку на радиопоток
+import numpy as np
+import matplotlib.pyplot as plt
+
+from .solar_radio_flux import fluxdate
+from .solar_radio_flux import fluxtime
+from .solar_radio_flux import fluxobsflux
+
+from .airglow_spectrum import wavelenght_kp, intensity_kp
+from .modtran_default_kp_transparency import wavelenght_modtran_kp, trancparency_modtran_kp
+
+#следующая функция для поправки на радиопоток, пока не используется
+def radioflux(date, time): #date -- в формате строки 'дд.мм.гггг', time -- в формате строки 'чч:мм:сс'
+    day, month, year = date.split('.')
+    date = year + month + day
+    hours, minutes, seconds = time.split(':')
+    time = hours + minutes + seconds
+    data_times = fluxtime[np.where(fluxdate==date)[0]]
+    box = []
+    for i in range(data_times.shape[0]):
+        box.append(abs(int(data_times[i]) - int(time)))
+    box = np.array(box)
+    return float(fluxobsflux[np.argmin(box)])
+
+
+def airglow_spectrum(wavelenght_airglow = wavelenght_kp, intensity_airglow = intensity_kp, wavelenght_atmosphere = wavelenght_modtran_kp, transparency_atmosphere = trancparency_modtran_kp):
+    """
+    Возвращает длины волн и спектр собственного свечения за атмосферой.
+
+    Функция корректирует спектр собственного свечения, учитывая прозрачность атмосферы на соответствующих 
+    длинах волн. Затем пересчитывает интенсивность из Рэлей/Ангстрем в фот/(с·м²·бин·нм).
+
+    Параметры:
+        wavelenght_airglow (np.ndarray, optional): Длины волн спектра собственного свечения, нм.
+            По умолчанию — wavelenght_kp.
+        intensity_airglow (np.ndarray, optional): Интенсивность собственного свечения, Рэлей/Ангстрем.
+            По умолчанию — intensity_kp.
+        wavelenght_atmosphere (np.ndarray, optional): Длины волн атмосферных данных, нм.
+            По умолчанию — wavelenght_modtran_kp.
+        transparency_atmosphere (np.ndarray, optional): Прозрачность атмосферы (от 0 до 1).
+            По умолчанию — transparency_modtran_kp.
+
+    Возвращает:
+        wavelength_corrected (np.ndarray): Общие длины волн для спектра и атмосферных данных, нм.
+        intensity_corrected (np.ndarray): Скорректированная интенсивность, 
+            фот/(с·м²·бин·нм).
+    
+    Примечания:
+        - Для совпадающих длин волн значение интенсивности делится на соответствующую прозрачность.
+        - Пересчёт из "Рэлей/Ангстрем" в "фотоны/(с·м²·бин·нм)" производится по формуле:
+          intensity = intensity * 10^11 / (4 * pi) * pi^2 / (1800 * 1800)
+    """
+    wavelenght = []
+    intensity = []
+    for i in range(wavelenght_airglow.shape[0]):
+        for j in range(wavelenght_atmosphere.shape[0]):
+            if wavelenght_airglow[i] == wavelenght_atmosphere[j]:
+                wavelenght.append(wavelenght_airglow[i])
+                intensity.append(intensity_airglow[i] / transparency_atmosphere[j])
+    intensity = np.array(intensity)
+    intensity = intensity * 10**11 / (4 * np.pi) * np.pi**2 / (1800 * 1800)
+    wavelenght = np.array(wavelenght)
+    return(wavelenght, intensity)   #возвращает длину волны в нм и поток в фот / (сек м^2 ср нм) + от стерадиан к сетке
+
+
+#функция написана для спектра взятого от китт пик, прозрачность атмосферы взята из модтрана, параметры -- см. доклад, там прямо скрин. Прозрачность взята для 45 градусов, пересчитана в 30 градусов
+
+from .solar_radio_flux import fluxdate
+
+

skymapmod-0.1.35/SkyMapMod/planets.py

@@ -0,0 +1,372 @@
+from astropy.coordinates import get_body, Galactic
+from astropy.time import Time
+import ephem
+import numpy as np
+
+from .zodiac import convolution, integral
+from .albedo_of_planets import venus_alb_wl, venus_alb_rf, mars_alb_wl, mars_alb_rf, jupiter_alb_wl, jupiter_alb_rf, saturn_alb_wl, saturn_alb_rf
+from .solar_spectrum import wavelenght_newguey2003, flux_newguey2003
+from .band_V_data import wavelenght_band_V, trancparency_band_V
+
+
+def coordinates_of_planet(body, date, time): #'mars', 'venus', 'saturn', 'jupyter'; 2023-11-03; 12:00:00; return galactic coordinates of planet
+    """
+    Вычисляет галактические координаты указанной планеты на заданную дату и время.
+
+    Функция принимает название планеты, дату и время, преобразует их в объект времени,
+    вычисляет положение планеты с использованием эфемерид и возвращает её галактические 
+    координаты (долготу l и широту b).
+
+    Параметры:
+        body (str): Название планеты. Допустимые значения: 'mars', 'venus', 'saturn', 'jupiter'.
+        date (str): Дата в формате 'YYYY-MM-DD' (например, '2023-11-03').
+        time (str): Время в формате 'HH:MM:SS' (например, '12:00:00').
+
+    Возвращает:
+        tuple: Кортеж из двух значений:
+            - l (float): Галактическая долгота планеты (в градусах).
+            - b (float): Галактическая широта планеты (в градусах).
+
+    Примечания:
+        - Для вычисления положения планеты используется библиотека `astropy`:
+            - `get_body`: Получает положение планеты в экваториальной системе координат.
+            - `transform_to(Galactic)`: Преобразует координаты в галактическую систему.
+        - Эфемериды берутся из встроенного набора данных (`ephemeris='builtin'`).
+        - Результат возвращается в градусах, так как метод `.value` извлекает числовое значение углов.
+    """
+    datetime = date + ' ' + time
+    time = Time(datetime)
+    planet = get_body(body, time, ephemeris='builtin').transform_to(Galactic)
+    l = planet.l.value
+    b = planet.b.value
+    return(l, b)
+
+    
+def magnitude_of_planet(body, date, time): #'mars', 'venus', 'saturn', 'jupiter'; 2023-11-03; 12:00:00';
+    """
+    Вычисляет видимую звездную величину указанной планеты на заданную дату и время.
+
+    Функция принимает название планеты, дату и время наблюдения, использует библиотеку `ephem`
+    для расчета положения планеты и возвращает её видимую звездную величину (magnitude).
+
+    Параметры:
+        body (str): Название планеты. Допустимые значения: 'venus', 'mars', 'jupiter', 'saturn'.
+        date (str): Дата наблюдения в формате 'YYYY-MM-DD' (например, '2023-11-03').
+        time (str): Время наблюдения в формате 'HH:MM:SS' (например, '12:00:00'). 
+                    В текущей реализации параметр time не используется, так как библиотека `ephem` 
+                    автоматически учитывает время при вычислениях.
+
+    Возвращает:
+        magnitude (float): Видимая звездная величина планеты (magnitude). Чем меньше значение, тем ярче объект.
+
+    Примечания:
+        - Для расчетов используется библиотека `ephem`, которая моделирует движение небесных тел.
+        - Дата преобразуется из формата 'YYYY-MM-DD' в формат 'YYYY/MM/DD', так как это требование библиотеки `ephem`.
+        - Видимая звездная величина (magnitude) зависит от положения планеты относительно Земли и Солнца.
+        - Если планета не указана в списке допустимых значений ('venus', 'mars', 'jupiter', 'saturn'),
+          функция вызовет ошибку.
+
+
+    Зависимости:
+        - `ephem`: Библиотека для астрономических расчетов.
+          Установка: `pip install ephem`
+    """
+    if body == 'venus':
+        planet = ephem.Venus()
+    elif body == 'mars':
+        planet = ephem.Mars()
+    elif body == 'jupiter':
+        planet = ephem.Jupiter()
+    elif body == 'saturn':
+        planet = ephem.Saturn()
+        
+    # Устанавливаем дату наблюдения
+    date = date.replace('-', '/')
+
+    planet.compute(date)
+    magnitude = planet.mag
+    return magnitude
+
+def mag_to_phot(mag): #в полосе V
+    """
+    Пересчитывает звездную величину (magnitude) в поток фотонов в полосе V, используя эталонную звезду 10-й звездной величины.
+
+    Функция использует формулу Погсона для пересчета звездной величины в поток фотонов.
+    Звезда 10-й звездной величины в полосе V имеет эталонный поток F0 = 10^2 фот / (см^2 сек).
+
+    Параметры:
+        mag (float): Звездная величина (magnitude) объекта в полосе V.
+
+    Возвращает:
+        F1 (float): Поток фотонов в единицах фот / (м^2 сек).
+
+    Примечания:
+        - Формула Погсона: F = F0 * 10^(0.4 * (10 - mag)),
+          где F0 — поток фотонов для звезды 10-й звездной величины.
+        - В данной реализации F0 = 10^2 фот / (см^2 сек).
+        - Результат переводится из фот / (см^2 сек) в фот / (м^2 сек) умножением на 10^4.
+        - Полоса V соответствует видимому диапазону спектра (визуальная звездная величина).
+        - Деление на 4π (для перехода к стерадианам) не выполняется, так как это зависит от контекста использования.
+    """
+    F0 = 10**2
+    F1 = F0 * 10 ** (0.4 * (10 - mag)) # фот / (см^2 сек)
+    F1 = F1 * 10**4 #/ (4 * np.pi) # фот / (м^2 сек ср) -- НАДО ЛИ ДЕЛИТЬ НА 4 ПИ?
+    return F1
+
+
+def venus_spectrum(date, time, Sun_sp_wl = wavelenght_newguey2003, Sun_sp_fx = flux_newguey2003, albedo_wl = venus_alb_wl, albedo_rf = venus_alb_rf, V_wl = wavelenght_band_V, V_tr = trancparency_band_V):
+    """
+    Вычисляет спектр Венеры на основе заданных даты и времени наблюдения.
+
+    Функция использует спектр альбедо Венеры, солнечный спектр и полосу пропускания V 
+    для вычисления нормированного спектра планеты. Нормировка производится так, чтобы 
+    интегральная яркость в полосе V соответствовала видимой звездной величине Венеры на 
+    указанную дату и время.
+
+    Параметры:
+        date (str): Дата наблюдения в формате 'YYYY-MM-DD' (например, '2023-11-03').
+        time (str): Время наблюдения в формате 'HH:MM:SS' (например, '12:00:00').
+        Sun_sp_wl (ndarray, optional): Массив длин волн солнечного спектра (в нм). 
+                                           По умолчанию используется `wavelenght_newguey2003`.
+        Sun_sp_fx (ndarray, optional): Массив значений солнечного спектра (в фот / (сек м^2 нм)).
+                                           По умолчанию используется `flux_newguey2003`.
+        albedo_wl (ndarray, optional): Массив длин волн спектра альбедо Венеры (в нм).
+                                           По умолчанию используется `venus_alb_wl`.
+        albedo_rf (ndarray, optional): Массив значений спектра альбедо Венеры.
+                                           По умолчанию используется `venus_alb_rf`.
+        V_wl (ndarray, optional): Массив длин волн полосы пропускания V (в нм).
+                                     По умолчанию используется `wavelenght_band_V`.
+        V_tr (ndarray, optional): Массив значений прозрачности полосы пропускания V.
+                                     По умолчанию используется `trancparency_band_V`.
+
+    Возвращает:
+        tuple: Кортеж из двух массивов:
+            - planet_wl (ndarray): Массив длин волн спектра планеты (в нм).
+            - planet_sp (ndarray): Массив значений спектра планеты (в фот / (сек ср м^2 нм)).
+
+    Примечания:
+        - Спектр планеты вычисляется как свертка спектра альбедо планеты с солнечным спектром.
+        - Нормировка спектра производится так, чтобы интегральная яркость в полосе V 
+          соответствовала видимой звездной величине планеты, вычисленной с помощью 
+          функции `magnitude_of_planet`.
+        - Пользователь может задать свои спектры вместо стандартных данных.
+
+    Зависимости:
+        - `convolution`: Функция для свертки спектров.
+        - `integral`: Функция для численного интегрирования.
+        - `magnitude_of_planet`: Функция для вычисления видимой звездной величины планеты.
+        - `mag_to_phot`: Функция для пересчета звездной величины в поток фотонов.
+    """
+    body = 'venus'
+    planet_wl, planet_sp = convolution(albedo_wl, albedo_rf, Sun_sp_wl, Sun_sp_fx) #вот тут получили спектр планеты
+    planet_V_wl, planet_V_sp = convolution(planet_wl, planet_sp, V_wl, V_tr) #свернули с полосой V, фот / (сек ср м^2 нм)
+
+    norm = integral(planet_V_wl, planet_V_sp) # фот / (сек ср м^2)
+    
+    #делаем так, чтобы эта норма была равна F1
+    mag = magnitude_of_planet(body, date, time)
+    F1 = mag_to_phot(mag)
+    A = F1 / norm
+    planet_sp = A * planet_sp
+    
+    #########################################################################
+#     planet_V_wl, planet_V_sp = convolution(planet_wl, planet_sp, V_wl, V_tr)
+#     integr = integral(planet_V_wl, planet_V_sp)
+#     print('Техническая проверка на совпадение двух чисел:', integr, F1)
+    #########################################################################
+    
+    return planet_wl, planet_sp
+
+def mars_spectrum(date, time, Sun_sp_wl = wavelenght_newguey2003, Sun_sp_fx = flux_newguey2003, albedo_wl = mars_alb_wl, albedo_rf = mars_alb_rf, V_wl = wavelenght_band_V, V_tr = trancparency_band_V):
+    """
+    Вычисляет спектр Марса на основе заданных даты и времени наблюдения.
+
+    Функция использует спектр альбедо Марса, солнечный спектр и полосу пропускания V 
+    для вычисления нормированного спектра планеты. Нормировка производится так, чтобы 
+    интегральная яркость в полосе V соответствовала видимой звездной величине Марса на 
+    указанную дату и время.
+
+    Параметры:
+        date (str): Дата наблюдения в формате 'YYYY-MM-DD' (например, '2023-11-03').
+        time (str): Время наблюдения в формате 'HH:MM:SS' (например, '12:00:00').
+        Sun_sp_wl (ndarray, optional): Массив длин волн солнечного спектра (в нм). 
+                                           По умолчанию используется `wavelenght_newguey2003`.
+        Sun_sp_fx (ndarray, optional): Массив значений солнечного спектра (в фот / (сек м^2 нм)).
+                                           По умолчанию используется `flux_newguey2003`.
+        albedo_wl (ndarray, optional): Массив длин волн спектра альбедо Марса (в нм).
+                                           По умолчанию используется `mars_alb_wl`.
+        albedo_rf (ndarray, optional): Массив значений спектра альбедо Марса.
+                                           По умолчанию используется `mars_alb_rf`.
+        V_wl (ndarray, optional): Массив длин волн полосы пропускания V (в нм).
+                                     По умолчанию используется `wavelenght_band_V`.
+        V_tr (ndarray, optional): Массив значений прозрачности полосы пропускания V.
+                                     По умолчанию используется `trancparency_band_V`.
+
+    Возвращает:
+        tuple: Кортеж из двух массивов:
+            - planet_wl (ndarray): Массив длин волн спектра планеты (в нм).
+            - planet_sp (ndarray): Массив значений спектра планеты (в фот / (сек ср м^2 нм)).
+
+    Примечания:
+        - Спектр планеты вычисляется как свертка спектра альбедо планеты с солнечным спектром.
+        - Нормировка спектра производится так, чтобы интегральная яркость в полосе V 
+          соответствовала видимой звездной величине планеты, вычисленной с помощью 
+          функции `magnitude_of_planet`.
+        - Пользователь может задать свои спектры вместо стандартных данных.
+
+    Зависимости:
+        - `convolution`: Функция для свертки спектров.
+        - `integral`: Функция для численного интегрирования.
+        - `magnitude_of_planet`: Функция для вычисления видимой звездной величины планеты.
+        - `mag_to_phot`: Функция для пересчета звездной величины в поток фотонов.
+    """
+    body = 'mars'
+    planet_wl, planet_sp = convolution(albedo_wl, albedo_rf, Sun_sp_wl, Sun_sp_fx) #вот тут получили спектр планеты
+    planet_V_wl, planet_V_sp = convolution(planet_wl, planet_sp, V_wl, V_tr) #свернули с полосой V, фот / (сек ср м^2 нм)
+
+    norm = integral(planet_V_wl, planet_V_sp) # фот / (сек ср м^2)
+    
+    #делаем так, чтобы эта норма была равна F1
+    mag = magnitude_of_planet(body, date, time)
+    F1 = mag_to_phot(mag)
+    A = F1 / norm
+    planet_sp = A * planet_sp
+    
+    #########################################################################
+#     planet_V_wl, planet_V_sp = convolution(planet_wl, planet_sp, V_wl, V_tr)
+#     integr = integral(planet_V_wl, planet_V_sp)
+#     print('Техническая проверка на совпадение двух чисел:', integr, F1)
+    #########################################################################
+    
+    return planet_wl, planet_sp
+
+def jupiter_spectrum(date, time, Sun_sp_wl = wavelenght_newguey2003, Sun_sp_fx = flux_newguey2003, albedo_wl = jupiter_alb_wl, albedo_rf = jupiter_alb_rf, V_wl = wavelenght_band_V, V_tr = trancparency_band_V):
+    """
+    Вычисляет спектр Юпитера на основе заданных даты и времени наблюдения.
+
+    Функция использует спектр альбедо Юпитера, солнечный спектр и полосу пропускания V 
+    для вычисления нормированного спектра планеты. Нормировка производится так, чтобы 
+    интегральная яркость в полосе V соответствовала видимой звездной величине Юпитера на 
+    указанную дату и время.
+
+    Параметры:
+        date (str): Дата наблюдения в формате 'YYYY-MM-DD' (например, '2023-11-03').
+        time (str): Время наблюдения в формате 'HH:MM:SS' (например, '12:00:00').
+        Sun_sp_wl (ndarray, optional): Массив длин волн солнечного спектра (в нм). 
+                                           По умолчанию используется `wavelenght_newguey2003`.
+        Sun_sp_fx (ndarray, optional): Массив значений солнечного спектра (в фот / (сек м^2 нм)).
+                                           По умолчанию используется `flux_newguey2003`.
+        albedo_wl (ndarray, optional): Массив длин волн спектра альбедо Юпитера (в нм).
+                                           По умолчанию используется `jupiter_alb_wl`.
+        albedo_rf (ndarray, optional): Массив значений спектра альбедо Юпитера.
+                                           По умолчанию используется `jupiter_alb_rf`.
+        V_wl (ndarray, optional): Массив длин волн полосы пропускания V (в нм).
+                                     По умолчанию используется `wavelenght_band_V`.
+        V_tr (ndarray, optional): Массив значений прозрачности полосы пропускания V.
+                                     По умолчанию используется `trancparency_band_V`.
+
+    Возвращает:
+        tuple: Кортеж из двух массивов:
+            - planet_wl (ndarray): Массив длин волн спектра планеты (в нм).
+            - planet_sp (ndarray): Массив значений спектра планеты (в фот / (сек ср м^2 нм)).
+
+    Примечания:
+        - Спектр планеты вычисляется как свертка спектра альбедо планеты с солнечным спектром.
+        - Нормировка спектра производится так, чтобы интегральная яркость в полосе V 
+          соответствовала видимой звездной величине планеты, вычисленной с помощью 
+          функции `magnitude_of_planet`.
+        - Пользователь может задать свои спектры вместо стандартных данных.
+
+    Зависимости:
+        - `convolution`: Функция для свертки спектров.
+        - `integral`: Функция для численного интегрирования.
+        - `magnitude_of_planet`: Функция для вычисления видимой звездной величины планеты.
+        - `mag_to_phot`: Функция для пересчета звездной величины в поток фотонов.
+    """
+    body = 'jupiter'
+    planet_wl, planet_sp = convolution(albedo_wl, albedo_rf, Sun_sp_wl, Sun_sp_fx) #вот тут получили спектр планеты
+    planet_V_wl, planet_V_sp = convolution(planet_wl, planet_sp, V_wl, V_tr) #свернули с полосой V, фот / (сек ср м^2 нм)
+
+    norm = integral(planet_V_wl, planet_V_sp) # фот / (сек ср м^2)
+    
+    #делаем так, чтобы эта норма была равна F1
+    mag = magnitude_of_planet(body, date, time)
+    F1 = mag_to_phot(mag)
+    A = F1 / norm
+    planet_sp = A * planet_sp
+    
+    #########################################################################
+#     planet_V_wl, planet_V_sp = convolution(planet_wl, planet_sp, V_wl, V_tr)
+#     integr = integral(planet_V_wl, planet_V_sp)
+#     print('Техническая проверка на совпадение двух чисел:', integr, F1)
+    #########################################################################
+    
+    return planet_wl, planet_sp
+
+def saturn_spectrum(date, time, Sun_sp_wl = wavelenght_newguey2003, Sun_sp_fx = flux_newguey2003, albedo_wl = saturn_alb_wl, albedo_rf = saturn_alb_rf, V_wl = wavelenght_band_V, V_tr = trancparency_band_V):
+    """
+    Вычисляет спектр Сатурна на основе заданных даты и времени наблюдения.
+
+    Функция использует спектр альбедо Сатурна, солнечный спектр и полосу пропускания V 
+    для вычисления нормированного спектра планеты. Нормировка производится так, чтобы 
+    интегральная яркость в полосе V соответствовала видимой звездной величине Сатурна на 
+    указанную дату и время.
+
+    Параметры:
+        date (str): Дата наблюдения в формате 'YYYY-MM-DD' (например, '2023-11-03').
+        time (str): Время наблюдения в формате 'HH:MM:SS' (например, '12:00:00').
+        Sun_sp_wl (ndarray, optional): Массив длин волн солнечного спектра (в нм). 
+                                           По умолчанию используется `wavelenght_newguey2003`.
+        Sun_sp_fx (ndarray, optional): Массив значений солнечного спектра (в фот / (сек м^2 нм)).
+                                           По умолчанию используется `flux_newguey2003`.
+        albedo_wl (ndarray, optional): Массив длин волн спектра альбедо Сатурна (в нм).
+                                           По умолчанию используется `saturn_alb_wl`.
+        albedo_rf (ndarray, optional): Массив значений спектра альбедо Сатурна.
+                                           По умолчанию используется `saturn_alb_rf`.
+        V_wl (ndarray, optional): Массив длин волн полосы пропускания V (в нм).
+                                     По умолчанию используется `wavelenght_band_V`.
+        V_tr (ndarray, optional): Массив значений прозрачности полосы пропускания V.
+                                     По умолчанию используется `trancparency_band_V`.
+
+    Возвращает:
+        tuple: Кортеж из двух массивов:
+            - planet_wl (ndarray): Массив длин волн спектра планеты (в нм).
+            - planet_sp (ndarray): Массив значений спектра планеты (в фот / (сек ср м^2 нм)).
+
+    Примечания:
+        - Спектр планеты вычисляется как свертка спектра альбедо планеты с солнечным спектром.
+        - Нормировка спектра производится так, чтобы интегральная яркость в полосе V 
+          соответствовала видимой звездной величине планеты, вычисленной с помощью 
+          функции `magnitude_of_planet`.
+        - Пользователь может задать свои спектры вместо стандартных данных.
+
+    Зависимости:
+        - `convolution`: Функция для свертки спектров.
+        - `integral`: Функция для численного интегрирования.
+        - `magnitude_of_planet`: Функция для вычисления видимой звездной величины планеты.
+        - `mag_to_phot`: Функция для пересчета звездной величины в поток фотонов.
+    """
+    body = 'saturn'
+    planet_wl, planet_sp = convolution(albedo_wl, albedo_rf, Sun_sp_wl, Sun_sp_fx) #вот тут получили спектр планеты
+    planet_V_wl, planet_V_sp = convolution(planet_wl, planet_sp, V_wl, V_tr) #свернули с полосой V, фот / (сек ср м^2 нм)
+
+    norm = integral(planet_V_wl, planet_V_sp) # фот / (сек ср м^2)
+    
+    #делаем так, чтобы эта норма была равна F1
+    mag = magnitude_of_planet(body, date, time)
+    F1 = mag_to_phot(mag)
+    A = F1 / norm
+    planet_sp = A * planet_sp
+    
+    #########################################################################
+#     planet_V_wl, planet_V_sp = convolution(planet_wl, planet_sp, V_wl, V_tr)
+#     integr = integral(planet_V_wl, planet_V_sp)
+#     print('Техническая проверка на совпадение двух чисел:', integr, F1)
+    #########################################################################
+    
+    return planet_wl, planet_sp
+    
+# Внутри основной функции: если планета попадает в поле зрения (через coordinates_of_planet(.....)),
+# ищем ее спектр venus_spectrum(.....)
+    
+    

skymapmod-0.1.35/SkyMapMod/star_catalogues.py

@@ -0,0 +1,59 @@
+import numpy as np
+
+from .data.load_data import load_star_temperatures, load_star_brightness
+
+from.zodiac import black_body_phot
+
+#на вход подаем галактические координаты (l -- долгота, b -- широта) и массив длин волн, по которым строим спектр
+#РАЗОБРАТЬСЯ С КОЭФФИЦИЕНТАМИ А -- НАДО ЛИ НОРМИРОВАТЬ НА C (КАЖЕТСЯ НАДО) А ЕЩЕ ВРОДЕ Я ЕГО ОТНОРМИРОВАЛА И ПОДГРУЗИЛА -- ПРОВЕРИТЬ
+def star_spectrum(l, b, lmbd):
+    """
+    Вычисляет спектр звезды по её галактическим координатам и массиву длин волн.
+
+    Функция принимает галактические координаты (долгота и широта) и массив длин волн,
+    пересчитывает координаты в индексы массива, извлекает температуру и амплитуду 
+    из предварительно рассчитанных массивов данных, и вычисляет спектр звезды 
+    с использованием формулы Планка для абсолютно черного тела.
+
+    Параметры:
+        l (float): Галактическая долгота точки наблюдения (в градусах).
+        b (float): Галактическая широта точки наблюдения (в градусах).
+        lmbd (ndarray): Массив длин волн, для которых рассчитывается спектр (в нм).
+
+    Возвращает:
+        ndarray: Массив значений спектра звезды (в фот / (сек * м^2 * нм)).
+
+    Примечания:
+        - Пересчет галактических координат в индексы массива:
+            - Долгота преобразуется в диапазон от 0 до 3600.
+            - Широта преобразуется в диапазон от 0 до 1800.
+        - Используются два предварительно рассчитанных массива:
+            - `star_brightness`: массив амплитуд яркости звезд.
+            - `star_temperatures`: массив температур звезд (в Кельвинах).
+        - Спектр рассчитывается по формуле Планка для абсолютно черного тела:
+            - spectrum = A * black_body_phot(lmbd, T),
+            где A — амплитуда, T — температура, lmbd — длина волны.
+        - Функция `black_body_phot` определена отдельно.
+
+
+    Зависимости:
+        - `load_star_brightness()`: загружает массив амплитуд яркости звезд.
+        - `load_star_temperatures()`: загружает массив температур звезд.
+        - `black_body_phot(lmbd, T)`: вычисляет спектральную плотность излучения 
+          абсолютно черного тела для заданной длины волны и температуры.
+    """
+    #пересчет из галактических к позиции в массиве, ЕСЛИ ПРОБЛЕМЫ ВОЗНИКЛИ, ПЕРЕПРОВЕРИТЬ
+    if round(l*10) >= 1800:
+        j = int((1800 - round(l*10)) + 3600)
+    elif round(l*10) < 1800:
+        j =  int(1800 - round((l+10)*10))
+     
+    i = int(900 + round(b*10))
+    star_brightness = load_star_brightness()
+    star_temperatures = load_star_temperatures()    
+    A = star_brightness[i][j]
+    T = star_temperatures[i][j]
+    print('Информация по звезде в этом пикселе: T = ', T, ', A = ', A, sep='')
+    print('Техническая строчка: i = ', i, ', j = ', j, sep='')
+    spectrum = A * black_body_phot(lmbd, T)
+    return spectrum

{skymapmod-0.1.33 → skymapmod-0.1.35}/SkyMapMod/total_background.py

@@ -15,6 +15,35 @@ from .albedo_of_planets import *
 from .planets import *
 
 def galactic_to_equatorial(l, b):
+    """
+    Преобразует галактические координаты в эклиптические.
+
+    Функция принимает галактическую долготу и широту объекта, преобразует их 
+    в эклиптические координаты (долготу и широту) с использованием стандартной 
+    эпохи J2000.0 и библиотеки `astropy`.
+
+    Параметры:
+        l (float): Галактическая долгота объекта (в градусах).
+        b (float): Галактическая широта объекта (в градусах).
+
+    Возвращает:
+        tuple: Кортеж из двух значений:
+            - ecl_lon (float): Эклиптическая долгота объекта (в градусах).
+            - ecl_lat (float): Эклиптическая широта объекта (в градусах).
+
+    Примечания:
+        - Для преобразования используется библиотека `astropy`:
+            - `Galactic`: Представляет галактические координаты.
+            - `GeocentricMeanEcliptic`: Представляет эклиптические координаты.
+        - Эпоха расчетов фиксирована как J2000.0.
+        - Результат возвращается в градусах, так как это наиболее распространенный формат для астрономических данных.
+
+    Зависимости:
+        - `astropy.units`: Для работы с единицами измерения (градусы).
+        - `astropy.time.Time`: Для задания эпохи J2000.0.
+        - `astropy.coordinates.Galactic`: Для представления галактических координат.
+        - `astropy.coordinates.GeocentricMeanEcliptic`: Для представления эклиптических координат.
+    """
     import astropy.units as u
 # Входные данные: галактические координаты и эпоха
     galactic_l = l * u.deg  # Галактическая долгота
@@ -31,9 +60,40 @@ def galactic_to_equatorial(l, b):
     print("Техническая проверка")
     print(f"Эклиптическая долгота (λ): {ecliptic_coords.lon.to(u.deg)}")
     print(f"Эклиптическая широта (β): {ecliptic_coords.lat.to(u.deg)}")
-    return(ecliptic_coords.lon.to(u.deg).value, ecliptic_coords.lat.to(u.deg).value)
+    
+    ecl_lon = ecliptic_coords.lon.to(u.deg).value
+    ecl_lat = ecliptic_coords.lat.to(u.deg).value
+    return(ecl_lon, ecl_lat)
 
 def Sun_ecl_lon(date, time):
+    """
+    Вычисляет эклиптическую долготу Солнца по заданным дате и времени.
+
+    Функция принимает дату и время наблюдения, использует библиотеку `astropy` 
+    для расчета положения Солнца в геоцентрической эклиптической системе координат 
+    и возвращает эклиптическую долготу Солнца.
+
+    Параметры:
+        date (str): Дата наблюдения в формате 'YYYY-MM-DD' (например, '2023-11-03').
+        time (str): Время наблюдения в формате 'HH:MM:SS' (например, '12:00:00').
+
+    Возвращает:
+        ecl_lon_of_Sun (float): Эклиптическая долгота Солнца (в градусах).
+
+    Примечания:
+        - Для расчетов используется библиотека `astropy`:
+            - `get_sun`: Получает положение Солнца в геоцентрической системе координат.
+            - `GeocentricMeanEcliptic`: Преобразует координаты в эклиптическую систему.
+        - Результат возвращается в градусах, так как это наиболее распространенный формат 
+          для астрономических данных.
+        - Эклиптическая широта Солнца не возвращается, так как она не используется в дальнейших расчетах.
+
+    Зависимости:
+        - `astropy.time.Time`: Для обработки даты и времени.
+        - `astropy.coordinates.get_sun`: Для получения положения Солнца.
+        - `astropy.coordinates.GeocentricMeanEcliptic`: Для преобразования координат 
+          в эклиптическую систему.
+    """
     datetime = date + ' ' + time
     observation_time = Time(datetime)
 
@@ -51,9 +111,43 @@ def Sun_ecl_lon(date, time):
     print("Техническая проверка:")
     print(f"Эклиптическая долгота Солнца: {ecliptic_longitude}")
     print(f"Эклиптическая широта Солнца: {ecliptic_latitude}")
-    return(ecliptic_longitude.value)
+    ecl_lon_of_Sun = ecliptic_longitude.value
+    return(ecl_lon_of_Sun)
 
 def sum_of_spectrums(wl_1, sp_1, wl_2, sp_2):
+    """
+    Суммирует два спектра, заданных длинами волн и их интенсивностями.
+
+    Функция принимает два спектра, представленных массивами длин волн и соответствующих 
+    интенсивностей, объединяет их по длинам волн и вычисляет сумму интенсивностей 
+    на совпадающих длинах волн. Результатом является общий спектр, содержащий все 
+    уникальные длины волн из обоих входных спектров.
+
+    Параметры:
+        wl_1 (ndarray): Массив длин волн первого спектра (в нм).
+        sp_1 (ndarray): Массив интенсивностей первого спектра.
+        wl_2 (ndarray): Массив длин волн второго спектра (в нм).
+        sp_2 (ndarray): Массив интенсивностей второго спектра.
+
+    Возвращает:
+        tuple: Кортеж из двух массивов:
+            - result_wl (ndarray): Массив уникальных длин волн, объединяющий 
+              длины волн из обоих спектров (в нм).
+            - result_spec (ndarray): Массив суммарных интенсивностей для каждой 
+              длины волны из `result_wl`.
+
+    Примечания:
+        - Если длина волны присутствует только в одном из спектров, её интенсивность 
+          добавляется без изменений.
+        - Если длина волны присутствует в обоих спектрах, её интенсивности суммируются.
+        - Для объединения длин волн используется функция `numpy.union1d`, которая 
+          гарантирует уникальность значений и их сортировку.
+        - Функция предполагает, что входные массивы `wl_1` и `sp_1`, а также `wl_2` 
+          и `sp_2`, имеют одинаковую длину.
+
+    Зависимости:
+        - `numpy`: Для работы с массивами и выполнения операций объединения и поиска.
+    """
     result_wl = np.union1d(wl_1, wl_2) #создали массив совокупности длин волн
     result_spec = np.zeros(result_wl.shape[0]) #создали массив для спектра
     for i in range(result_wl.shape[0]):