Güneş'in Doğma ve Batma Zamanı Hesabı

SYavuz

Bir proje için güneş'in, enlem ve boylamlara göre doğma ve batma zamanını hesaplamam gerek, fakat internetten yaptığım kaynak araştırmalarında;

f : gözlem yerinin derece biriminde enlemi,
b : gözlem yerinin derece biriminde boylamı,
a , d : Güneşin ekvatoral koordinatları
q : yerel yıldız zamanı
q0 : Greenwich yıldız zamanı

olmak üzere bir gök cisminin, atmosferik kırılma etkisini de dikkate alınarak , doğma-batma

anındaki saat açısı H0 aşağıdaki formülden hesaplanabilir ;

cos H0 = (( sin( 50’ ) - sinj * sind ) / cos j*cos d )

böylece hesaplanan H0 değeri, (-180°< H0 <0°) aralığı içinde doğma (0°< H0 <180°)aralığı içinde batmayı temsil edecek şekilde seçilir. Bu her iki saat açısı değeri

q = H0 + a veya q = q0 + b + a

bağıntısı kullanılarak doğma ve batma anlarındaki Yerel yıldız zamanı elde edilebilir.

bu kadar bilgiye ulaşabildim...bu formülün açılımlarını bilen veya farklı bir hesaplama yöntemini bilen arkadaşlar var ise ve bu bilgilerini bizimle paylaşırlarsa çok sevinirim.

EKLEME:
İnternette araştırmalarım sonucu aşağıda Linkini verdiğim "C" ile yazılmış bir dökümana ulaştım fakat bana sadece gün doğumu ve batımı süreleri gerektiği için konuyu ayrıştırmak bir hayli zor gibi gözüküyor..Dökümanda "prayer time" yani "ibadet zamanı" süreleri hesaplanıyor...Konu hakkında bilgisi olan arkadaşlar var ise sadece formül benin işimi görecektir.

http://www.hemenpaylas.com/download/166...mer.c.html

ta2mc · Tarih: 11.08.2008, 19:32 Mesaj konusu:

Tam da buna benzer bir konu açıyordum. (Önce arama yapmanın faydası)

İnternette bulunabilen dokümanlar fazlasıyla teori ağırlıklı.

Konuyu açtığınız tarihe bakılırsa, epey ilerlemiş olmalısınız ve umarım paylaşırsınız..

Yoksa, Amerika'yı bir kez daha keşfetmeye devam. :)

Selâmlar.

fuzzy · Tarih: 12.08.2008, 00:19 Mesaj konusu:

Bu çalışmalar astronomik röle için mi,merak ettimde.....

ta2mc · Tarih: 13.08.2008, 20:49 Mesaj konusu:

tesadüfen bir forumda, aşağıdaki kodu buldum.

henüz deneme fırsatım olmadı. umarım işe yarar.

Alıntı: 1-2 dk hassasiyetle çalışan güneş doğuş-batış algoritması mevcuttur. ilgilenen arkadaşların işine yaraması ümidi ile...

struct ctime { //güneş doğuş batış süreleri bu değişkenlerde tutulacaktır.
int sunraise_hour;
int sunraise_minute;
int sunset_hour;
int sunset_minute;
};

struct ctime rtime;
//***************************************************************************************************
bool ısleapyear(int32 nyear ) { // dört yılda bir şubat ayı 29 gün olur biliyorsunuz işte burada artık yılı hesaplıyoruz..
if (((nyear % 4 == 0) && (nyear % 100 != 0)) || (nyear % 400 == 0))
return (true);
else
return (false);
}
//***************************************************************************************************
float radtodeg(float anglerad) { // radyanı dereceye çeviriyoruz
return (180 * anglerad / 3.1415926535);
}
//***************************************************************************************************
float degtorad(float angledeg) { // dereceyi radyana çeviriyoruz
return (3.1415926535 * angledeg / 180);
}
//***************************************************************************************************
int32 calcdayofyear(int32 nmn, int32 ndy, bool bleapyear) { // yılın hangi günündeyiz bunu hesaplıyoruz

return ((int16)((275 * nmn) / 9) - (bleapyear ? 1 : 2) * (int16)((nmn + 9) / 12) + ndy - 30);
}
//***************************************************************************************************
int32 calcjulianday(int32 nmonth, int32 nday, bool bleapyear) { //referans olarak aldığımız yıla göre hangi gündeyiz bunu hesaplıyoruz.
//julian takviminin hesaplama mantığı bilinen bir yıl,ay,gün ve saatinde
//güneşin bilinen açısını hesaplıyoruz daha sonra bunu gelecek gün,ay ve yıllara göre ilerletiyoruz.
int i;
int32 njulianday=0;

ıf (bleapyear) {
for (i=0;i<(nmonth-1);i++) {
njulianday = njulianday + m_monthleap[i];
}
}
else {
for (i=0;i<(nmonth-1);i++) {
njulianday = njulianday + m_monthlist[i];
}
}

njulianday += nday;

return (njulianday);
}
//***************************************************************************************************
int dayofweek(int d, int m, int y) { //haftanın gününü hesaplıyoruz.
static int t[] = { 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 };
int result;
y -= m < 3;
result = ( y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
result++;
return (result);
}
//***************************************************************************************************
//=========================================================================
#define radeg 180 / pı
#define degrad pı / 180
//=========================================================================

float x_atan2(float ys, float xs){
float theta;
if(xs != 0) {
theta = atan(ys / xs);
ıf(xs < 0){
theta = theta + pı;
}
}
else {
ıf(ys < 0) {
theta = 3 * pı / 2; //90
}
else {
theta = pı / 2; //270
}
}
return(theta);
}
//**********************************************************************************************************
float x_sqrt(float x){
//if(x > 0)
return(sqrt(x));
//else
// return(0);
}
//**********************************************************************************************************
float x_acos(float x) {
return (atan(-x / x_sqrt(-x * x + 1)) + 2 * atan(1));
}
//**********************************************************************************************************
float sind(float qqq) {
return(sin(qqq * degrad));
}
//**********************************************************************************************************
float cosd(float qqq) {
return(cos((qqq) * degrad));
}
//**********************************************************************************************************
float tand(float qqq){
return(tan((qqq) * degrad));
}
//**********************************************************************************************************
float atand(float qqq) {
return(radeg * atan(qqq));
}
//**********************************************************************************************************
float asind(float qqq) {
return(radeg * asin(qqq));
}
//**********************************************************************************************************
float acosd(float qqq) {
return(radeg * x_acos(qqq));
}
//**********************************************************************************************************
float atan2d(float qqq, float qqq1) {
return(radeg * x_atan2(qqq, qqq1));
}
//**********************************************************************************************************
float rev(float qqq){
float x;
x = (qqq - (int16)(qqq / 360.0) * 360.0);
ıf(x <= 0){ x += 360; }
return x;
}
//**********************************************************************************************************
void calcsuntimes(float stryear, float strmonth, float strday, float longitude, float latitude, float tz) {
// örnek olarak fonksiyonu şu şekilde çağıracaksınız;
// calcsuntimes(<yıl>,<ay>,<gün>,<ilgili yerin boylamı>,<ilgili yerin enlemi>,<yerel saat farkı>)
// calcsuntimes(2008,08,06,29,41,2) türkiye için istanbul'un koordinatlarını girdim.yerel saat farkı türkiye için +2 'dir.

float d, n, i, w, m, l, e, e1, a, xv, yv, v, xs, ys, xe, ecl, lonsun, ye, ze, ra, dec, h,r;
float gmst0, ut_sun_in_south, lha, hour_rise, hour_set, min_rise, min_set;
int32 njulianday=0;

njulianday = calcjulianday((int32)strmonth, (int32)strday, ısleapyear((int32)stryear));
dayofyear = njulianday;

// 1 ocak 2000 yılını referans alarak julian hesaplamasını yapıyoruz.
d = (367 * (stryear) - (int16)((7 * ((stryear) + (((strmonth) + 9) / 12))) / 4) + (int16)((275 * (strmonth)) / 9) + (strday) - 730530);

//güneşin orbital elementlerinin bulunduğu bölgeyi hesaplyoruz.
//(orbital-> elektronların bulunma olasılığının en fazla olduğu hacimsel bölgedir. güneşten gelen ışık yığınlarının hesabı için burada kullanılmıştır)
n = 0.0;
i = 0.0;
w = 282.9404 + 0.0000470935 * d;

a = 1.0;
e = 0.016709 - 0.000000001151 * d;

m = 356.047 + 0.9856002585 * d;
m = rev(m);

ecl = 23.4393 - 0.0000003563 * d;
l = w + m;
if((l < 0) || (l > 360)) {
l = rev(l);
}

//güneşin pozisyonunu hesaplıyoruz.
e1 = m + e * (180 / pı) * sind(m) * (1.0 + e * cosd(m));
xv = cosd(e1) - e;
yv = x_sqrt(1.0 - e * e) * sind(e1);
v = atan2d(yv, xv);
r = x_sqrt(xv * xv + yv * yv);
lonsun = v + w;
ıf((lonsun < 0) || (lonsun > 360)) {
lonsun = rev(lonsun);
}
xs = r * cosd(lonsun);
ys = r * sind(lonsun);
xe = xs;
ye = ys * cosd(ecl);
ze = ys * sind(ecl);
ra = atan2d(ye, xe);
dec = atan2d(ze, (x_sqrt((xe * xe) + (ye * ye))));
h = -0.833;

gmst0 = l + 180;
if((gmst0 < 0) || (gmst0 > 360)) {
gmst0 = rev(gmst0);
}

ut_sun_in_south = (ra - gmst0 - longitude) / 15.0;
ıf (ut_sun_in_south < 0) {
ut_sun_in_south = ut_sun_in_south + 24;
}

lha = sind(h) - (sind(latitude) * sind(dec)) / (cosd(latitude) * cosd(dec));
ıf ((lha > -1) && (lha < 1)) {
lha = acosd(lha) / 15;
}
else {
return;
}

hour_rise = (ut_sun_in_south - lha);
hour_set = (ut_sun_in_south + lha);

min_rise = (int)((hour_rise - (int)(hour_rise)) * 60);
min_set = (int)((hour_set - (int)(hour_set)) * 60);

hour_rise = ((int)(hour_rise) + tz);
hour_set = ((int)(hour_set) + tz);

rtime.sunraise_hour = hour_rise;
rtime.sunraise_minute = min_rise;
rtime.sunset_hour = hour_set;
rtime.sunset_minute = min_set;
}