1744 lines
34 KiB
C
1744 lines
34 KiB
C
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
#include <time.h>
|
|
#include <getopt.h>
|
|
#include "cpgplot.h"
|
|
#include "sgdp4h.h"
|
|
|
|
#define LIM 128
|
|
#define NMAX 1024
|
|
#define MMAX 28368
|
|
#define D2R M_PI/180.0
|
|
#define R2D 180.0/M_PI
|
|
#define XKMPER 6378.135 // Earth radius in km
|
|
#define FLAT (1.0/298.257)
|
|
#define XKMPAU 149597879.691 // AU in km
|
|
|
|
long Isat=0;
|
|
long Isatsel=0;
|
|
extern double SGDP4_jd0;
|
|
|
|
struct coeff_lr {
|
|
int nd,nm,nm1,nf;
|
|
double sa,ca;
|
|
} clr[60];
|
|
struct coeff_b {
|
|
int nd,nm,nm1,nf;
|
|
double sa;
|
|
} cb[60];
|
|
|
|
struct map {
|
|
long satno;
|
|
double l0,b0,h0;
|
|
double lat,lng;
|
|
double mjd;
|
|
float alt,timezone;
|
|
int length;
|
|
char orientation[LIM];
|
|
char nfd[LIM],tlefile[LIM],observer[32];
|
|
char datadir[LIM],tledir[LIM],notamfile[LIM],xyzfile[LIM];
|
|
int site_id,notamflag,xyzflag,moonflag,launchsitesflag;
|
|
int plotfootprint;
|
|
float w;
|
|
} m;
|
|
struct globe {
|
|
int n;
|
|
float l[MMAX],b[MMAX],x[MMAX],y[MMAX],z[MMAX];
|
|
} glb;
|
|
struct sat {
|
|
long Isat;
|
|
double jd;
|
|
double dx,dy,dz;
|
|
double x,y,z,vx,vy,vz;
|
|
double rsun,rearth;
|
|
double psun,pearth,p;
|
|
double r,ra,de;
|
|
double azi,alt;
|
|
double rx,ry;
|
|
double lng,lat;
|
|
};
|
|
void read_globe(void);
|
|
void plot_globe(void);
|
|
double nfd2mjd(char *date);
|
|
double date2mjd(int year,int month,double day);
|
|
void mjd2date(double mjd,char *date,int length);
|
|
void usage();
|
|
void interactive_usage();
|
|
void nfd_now(char *s);
|
|
void rotate(int axis,float angle,float *x,float *y,float *z);
|
|
void sunpos_xyz(double mjd,xyz_t *pos,double *ra,double *de);
|
|
void lunpos_xyz(double mjd,xyz_t *pos,double *ra,double *de);
|
|
double gmst(double);
|
|
double dgmst(double);
|
|
double modulo(double,double);
|
|
void get_site(int site_id);
|
|
void ecliptical2equatorial(double l,double b,double *ra,double *de);
|
|
void plot_launch_sites(void);
|
|
int fgetline(FILE *file,char *s,int lim);
|
|
|
|
int giza_open_device_size_float (const char *, const char *, float, float, int);
|
|
void giza_set_colour_palette (int palette) ;
|
|
|
|
// Initialize setup
|
|
void initialize_setup(void)
|
|
{
|
|
int i;
|
|
FILE *file;
|
|
char *env,filename[128];
|
|
|
|
// Default parameters
|
|
m.satno=0;
|
|
m.timezone=0.0;
|
|
m.length=60;
|
|
strcpy(m.orientation,"terrestial");
|
|
nfd_now(m.nfd);
|
|
m.mjd=nfd2mjd(m.nfd);
|
|
m.w=1.2;
|
|
m.h0=gmst(m.mjd);
|
|
m.notamflag=0;
|
|
m.xyzflag=0;
|
|
m.moonflag=0;
|
|
m.launchsitesflag=0;
|
|
m.plotfootprint=1;
|
|
|
|
// Default settings
|
|
strcpy(m.observer,"Unknown");
|
|
m.site_id=0;
|
|
|
|
// Get environment variables
|
|
env=getenv("ST_DATADIR");
|
|
if (env!=NULL) {
|
|
strcpy(m.datadir,env);
|
|
} else {
|
|
printf("ST_DATADIR environment variable not found.\n");
|
|
}
|
|
env=getenv("ST_COSPAR");
|
|
if (env!=NULL) {
|
|
get_site(atoi(env));
|
|
} else {
|
|
printf("ST_COSPAR environment variable not found.\n");
|
|
}
|
|
env=getenv("ST_TLEDIR");
|
|
if (env!=NULL) {
|
|
strcpy(m.tledir,env);
|
|
} else {
|
|
printf("ST_TLEDIR environment variable not found.\n");
|
|
}
|
|
// sprintf(m.tlefile,"%s/classfd.tle",m.tledir);
|
|
strcpy(m.tlefile,"");
|
|
|
|
// Read LR coefficients
|
|
sprintf(filename,"%s/data/moonLR.dat",m.datadir);
|
|
file=fopen(filename,"r");
|
|
for (i=0;i<60;i++)
|
|
fscanf(file,"%d %d %d %d %lf %lf",&clr[i].nd,&clr[i].nm,&clr[i].nm1,&clr[i].nf,&clr[i].sa,&clr[i].ca);
|
|
fclose(file);
|
|
|
|
// Read B coefficients
|
|
sprintf(filename,"%s/data/moonB.dat",m.datadir);
|
|
file=fopen(filename,"r");
|
|
for (i=0;i<60;i++)
|
|
fscanf(file,"%d %d %d %d %lf",&cb[i].nd,&cb[i].nm,&cb[i].nm1,&cb[i].nf,&cb[i].sa);
|
|
fclose(file);
|
|
|
|
return;
|
|
}
|
|
|
|
// Convert ecliptical into equatorial coordinates
|
|
void ecliptical2equatorial(double l,double b,double *ra,double *de)
|
|
{
|
|
double eps=23.4392911;
|
|
|
|
*ra=modulo(atan2(sin(l*D2R)*cos(eps*D2R)-tan(b*D2R)*sin(eps*D2R),cos(l*D2R))*R2D,360.0);
|
|
*de=asin(sin(b*D2R)*cos(eps*D2R)+cos(b*D2R)*sin(eps*D2R)*sin(l*D2R))*R2D;
|
|
|
|
return;
|
|
}
|
|
|
|
void plot_footprint(struct sat s)
|
|
{
|
|
int i,j,flag;
|
|
float range,alpha,dist,zz,theta,rr;
|
|
float x,y,z,x0,y0,z0,r0,r;
|
|
|
|
// Foot print size
|
|
range=sqrt(s.x*s.x+s.y*s.y+s.z*s.z);
|
|
dist=sqrt(range*range-XKMPER*XKMPER);
|
|
alpha=acos(XKMPER/range);
|
|
zz=range-dist*sin(alpha);
|
|
rr=sqrt(XKMPER*XKMPER-zz*zz);
|
|
|
|
// Sub satellite point
|
|
z=cos(s.lng*D2R)*cos(s.lat*D2R)*XKMPER;
|
|
x=sin(s.lng*D2R)*cos(s.lat*D2R)*XKMPER;
|
|
y=sin(s.lat*D2R)*XKMPER;
|
|
rotate(1,m.l0,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
r=sqrt(x*x+y*y);
|
|
z0=cos(s.lng*D2R)*cos(s.lat*D2R)*range;
|
|
x0=sin(s.lng*D2R)*cos(s.lat*D2R)*range;
|
|
y0=sin(s.lat*D2R)*range;
|
|
rotate(1,m.l0,&x0,&y0,&z0);
|
|
rotate(0,m.b0,&x0,&y0,&z0);
|
|
r0=sqrt(x0*x0+y0*y0);
|
|
|
|
if (r<XKMPER && z<0.0) {
|
|
x*=XKMPER/r;
|
|
y*=XKMPER/r;
|
|
}
|
|
if (r0>XKMPER || (r0<XKMPER && z0>0.0)) {
|
|
cpgmove(x0,y0);
|
|
cpgdraw(x,y);
|
|
cpgmove(x,y);
|
|
}
|
|
if (z>0.0)
|
|
cpgpt1(x,y,4);
|
|
|
|
for (i=0,j=0,flag=0;i<NMAX;i++,j++) {
|
|
theta=2.0*M_PI*(float) i/(float) (NMAX-1);
|
|
|
|
x=rr*sin(theta);
|
|
y=rr*cos(theta);
|
|
z=zz;
|
|
|
|
rotate(0,-s.lat,&x,&y,&z);
|
|
rotate(1,-s.lng,&x,&y,&z);
|
|
rotate(1,m.l0,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
|
|
if (flag==0)
|
|
cpgmove(x,y);
|
|
else {
|
|
cpgdraw(x,y);
|
|
cpgmove(x,y);
|
|
}
|
|
if (z>0.0)
|
|
flag=1;
|
|
else
|
|
flag=0;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Computes apparent position
|
|
struct sat apparent_position(double mjd)
|
|
{
|
|
struct sat s;
|
|
double jd,rsun,rearth;
|
|
double dx,dy,dz;
|
|
xyz_t satpos,obspos,satvel,sunpos;
|
|
double sra,sde;
|
|
|
|
// Sat ID
|
|
s.Isat=Isat;
|
|
|
|
// Get Julian Date
|
|
jd=mjd+2400000.5;
|
|
|
|
// Get positions
|
|
satpos_xyz(jd,&satpos,&satvel);
|
|
sunpos_xyz(mjd,&sunpos,&sra,&sde);
|
|
|
|
// Sat positions
|
|
s.x=satpos.x;
|
|
s.y=satpos.y;
|
|
s.z=satpos.z;
|
|
s.vx=satvel.x;
|
|
s.vy=satvel.y;
|
|
s.vz=satvel.y;
|
|
|
|
// Sun position from satellite
|
|
dx=-satpos.x+sunpos.x;
|
|
dy=-satpos.y+sunpos.y;
|
|
dz=-satpos.z+sunpos.z;
|
|
|
|
// Distances
|
|
rsun=sqrt(dx*dx+dy*dy+dz*dz);
|
|
rearth=sqrt(satpos.x*satpos.x+satpos.y*satpos.y+satpos.z*satpos.z);
|
|
// Angles
|
|
s.psun=asin(696.0e3/rsun)*R2D;
|
|
s.pearth=asin(6378.135/rearth)*R2D;
|
|
s.p=acos((-dx*satpos.x-dy*satpos.y-dz*satpos.z)/(rsun*rearth))*R2D;
|
|
// s.p=acos(((sunpos.x+satpos.x)*satpos.x+(sunpos.y+satpos.y)*satpos.y+(sunpos.z+satpos.z)*satpos.z)/(rsun*rearth))*R2D;
|
|
|
|
s.p-=s.pearth;
|
|
|
|
// Celestial position
|
|
s.r=sqrt(satpos.x*satpos.x+satpos.y*satpos.y+satpos.z*satpos.z);
|
|
s.ra=atan2(satpos.y,satpos.x)*R2D;
|
|
s.de=asin(satpos.z/s.r)*R2D;
|
|
|
|
// Latitude and longitude
|
|
s.lng=s.ra-gmst(m.mjd);;
|
|
s.lat=s.de;
|
|
|
|
return s;
|
|
}
|
|
|
|
// plot satellite track
|
|
void plot_track(void)
|
|
{
|
|
int i=0,nstep=500;
|
|
orbit_t orb;
|
|
xyz_t pos,vel;
|
|
double jd,dt,h,mjd;
|
|
FILE *fp=NULL;
|
|
float x,y,z,r,v;
|
|
long imode;
|
|
int isci;
|
|
float isch;
|
|
char norad[7];
|
|
struct sat s;
|
|
float rmin,rmax;
|
|
float xmin,ymin,zmin,xmax,ymax,zmax;
|
|
|
|
if (strcmp(m.tlefile,"")==0)
|
|
return;
|
|
|
|
cpgqci(&isci);
|
|
cpgqch(&isch);
|
|
cpgsci(7);
|
|
|
|
fp=fopen(m.tlefile,"rb");
|
|
if (fp==NULL) {
|
|
fatal_error("File open failed for reading \"%s\"",m.tlefile);
|
|
}
|
|
|
|
while (read_twoline(fp,m.satno,&orb) == 0) {
|
|
// print_orb(&orb);
|
|
|
|
Isat=orb.satno;
|
|
imode=init_sgdp4(&orb);
|
|
|
|
if(imode == SGDP4_ERROR) continue;
|
|
|
|
jd=m.mjd+2400000.5;
|
|
h=gmst(m.mjd);
|
|
|
|
for (i=0,dt=0.0;;i++) {
|
|
//if(satpos_xyz(jd, &pos, &vel) == SGDP4_ERROR) break;
|
|
mjd=jd-2400000.5;
|
|
s=apparent_position(mjd);
|
|
|
|
x=s.x;
|
|
y=s.y;
|
|
z=s.z;
|
|
|
|
rotate(0,-90.0,&x,&y,&z);
|
|
rotate(1,90.0,&x,&y,&z);
|
|
rotate(1,m.l0+h,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
|
|
// Visibility
|
|
if (s.p<-s.psun)
|
|
cpgsci(14);
|
|
else if (s.p>-s.psun && s.p<s.psun)
|
|
cpgsci(15);
|
|
else if (s.p>s.psun)
|
|
cpgsci(7);
|
|
|
|
// Find perigee and apogee
|
|
if (i==0) {
|
|
rmin=s.r;
|
|
rmax=s.r;
|
|
} else {
|
|
if (s.r<rmin) {
|
|
rmin=s.r;
|
|
xmin=x;
|
|
ymin=y;
|
|
zmin=z;
|
|
}
|
|
if (s.r>rmax) {
|
|
rmax=s.r;
|
|
xmax=x;
|
|
ymax=y;
|
|
zmax=z;
|
|
}
|
|
}
|
|
|
|
// Plot
|
|
if (i==0) {
|
|
if (m.plotfootprint==1)
|
|
plot_footprint(s);
|
|
if (!(sqrt(x*x+y*y)<XKMPER && z<0.0)) {
|
|
sprintf(norad," %ld",Isat);
|
|
cpgsch(0.6);
|
|
cpgtext(x,y,norad);
|
|
cpgsch(isch);
|
|
cpgpt1(x,y,17);
|
|
}
|
|
cpgmove(x,y);
|
|
} else if (s.r>XKMPER) {
|
|
if (sqrt(x*x+y*y)<XKMPER && z<0.0)
|
|
cpgmove(x,y);
|
|
else
|
|
cpgdraw(x,y);
|
|
cpgmove(x,y);
|
|
}
|
|
|
|
// Do timestep
|
|
r=sqrt(s.x*s.x+s.y*s.y+s.z*s.z);
|
|
v=sqrt(s.vx*s.vx+s.vy*s.vy+s.vz*s.vz);
|
|
dt=2.0*M_PI*r/(0.75*v*nstep);
|
|
jd+=dt/86400.0;
|
|
|
|
if (i==nstep)
|
|
break;
|
|
}
|
|
if (!(sqrt(xmin*xmin+ymin*ymin)<XKMPER && zmin<0.0))
|
|
cpgpt1(xmin,ymin,4);
|
|
if (!(sqrt(xmax*xmax+ymax*ymax)<XKMPER && zmax<0.0))
|
|
cpgpt1(xmax,ymax,6);
|
|
}
|
|
cpgsls(1);
|
|
cpgsci(isci);
|
|
cpgsch(isch);
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
// plot satellite track
|
|
void plot_xyz(void)
|
|
{
|
|
int i=0,nstep=500,flag=0;
|
|
orbit_t orb;
|
|
xyz_t pos,vel;
|
|
double jd,dt,h,mjd,mjd0;
|
|
FILE *fp=NULL;
|
|
float x,y,z,r,v;
|
|
long imode;
|
|
int isci;
|
|
float isch;
|
|
char norad[7],line[LIM],nfd[32];
|
|
struct sat s;
|
|
double rsun,rearth;
|
|
double dx,dy,dz,sra,sde;
|
|
xyz_t sunpos,satpos;
|
|
|
|
cpgqci(&isci);
|
|
cpgqch(&isch);
|
|
cpgsci(8);
|
|
|
|
fp=fopen(m.xyzfile,"rb");
|
|
if (fp==NULL) {
|
|
fatal_error("File open failed for reading \"%s\"",m.xyzfile);
|
|
}
|
|
h=gmst(m.mjd);
|
|
|
|
while (fgetline(fp,line,LIM)>0) {
|
|
// Get satellite position
|
|
if (line[10]=='T') {
|
|
sscanf(line,"%s %lf %lf %lf",nfd,&satpos.x,&satpos.y,&satpos.z);
|
|
mjd=nfd2mjd(nfd);
|
|
} else {
|
|
sscanf(line,"%lf %lf %lf %lf",&mjd,&satpos.x,&satpos.y,&satpos.z);
|
|
}
|
|
|
|
// Mark point to plot
|
|
if (mjd>m.mjd && mjd0<=m.mjd && flag==0 && i>0)
|
|
flag=1;
|
|
|
|
// Get positions
|
|
sunpos_xyz(m.mjd,&sunpos,&sra,&sde);
|
|
// Sun position from satellite
|
|
dx=-satpos.x+sunpos.x;
|
|
dy=-satpos.y+sunpos.y;
|
|
dz=-satpos.z+sunpos.z;
|
|
|
|
// Distances
|
|
rsun=sqrt(dx*dx+dy*dy+dz*dz);
|
|
rearth=sqrt(satpos.x*satpos.x+satpos.y*satpos.y+satpos.z*satpos.z);
|
|
// Angles
|
|
s.psun=asin(696.0e3/rsun)*R2D;
|
|
s.pearth=asin(6378.135/rearth)*R2D;
|
|
s.p=acos((-dx*satpos.x-dy*satpos.y-dz*satpos.z)/(rsun*rearth))*R2D;
|
|
// s.p=acos(((sunpos.x+satpos.x)*satpos.x+(sunpos.y+satpos.y)*satpos.y+(sunpos.z+satpos.z)*satpos.z)/(rsun*rearth))*R2D;
|
|
|
|
s.p-=s.pearth;
|
|
|
|
// Celestial position
|
|
s.r=sqrt(satpos.x*satpos.x+satpos.y*satpos.y+satpos.z*satpos.z);
|
|
s.ra=atan2(satpos.y,satpos.x)*R2D;
|
|
s.de=asin(satpos.z/s.r)*R2D;
|
|
|
|
// Latitude and longitude
|
|
s.lng=s.ra-gmst(m.mjd);;
|
|
s.lat=s.de;
|
|
|
|
s.x=satpos.x;
|
|
s.y=satpos.y;
|
|
s.z=satpos.z;
|
|
|
|
x=satpos.x;
|
|
y=satpos.y;
|
|
z=satpos.z;
|
|
|
|
rotate(0,-90.0,&x,&y,&z);
|
|
rotate(1,90.0,&x,&y,&z);
|
|
rotate(1,m.l0+h,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
|
|
// Visibility
|
|
if (s.p<-s.psun)
|
|
cpgsci(14);
|
|
else if (s.p>-s.psun && s.p<s.psun)
|
|
cpgsci(15);
|
|
else if (s.p>s.psun)
|
|
cpgsci(7);
|
|
|
|
// Plot
|
|
if (flag==1) {
|
|
flag=2;
|
|
if (m.plotfootprint==1)
|
|
plot_footprint(s);
|
|
if (!(sqrt(x*x+y*y)<XKMPER && z<0.0)) {
|
|
sprintf(norad," xyz");
|
|
cpgsch(0.6);
|
|
cpgtext(x,y,norad);
|
|
cpgsch(isch);
|
|
cpgpt1(x,y,17);
|
|
}
|
|
}
|
|
if (i==0) {
|
|
cpgmove(x,y);
|
|
i++;
|
|
} else if (s.r>XKMPER) {
|
|
if (sqrt(x*x+y*y)<XKMPER && z<0.0)
|
|
cpgmove(x,y);
|
|
else
|
|
cpgdraw(x,y);
|
|
cpgmove(x,y);
|
|
}
|
|
mjd0=mjd;
|
|
}
|
|
cpgsls(1);
|
|
cpgsci(isci);
|
|
cpgsch(isch);
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
void read_globe(void)
|
|
{
|
|
int i,status;
|
|
FILE *file;
|
|
float l,b;
|
|
char filename[LIM];
|
|
|
|
sprintf(filename,"%s/data/globe.dat",m.datadir);
|
|
file=fopen(filename,"r");
|
|
|
|
for (i=0;i<MMAX;i++) {
|
|
status=fscanf(file,"%f %f",&glb.b[i],&glb.l[i]);
|
|
|
|
l=glb.l[i]*D2R;
|
|
b=glb.b[i]*D2R;
|
|
|
|
glb.z[i]=XKMPER*cos(l)*cos(b);
|
|
glb.x[i]=XKMPER*sin(l)*cos(b);
|
|
glb.y[i]=XKMPER*sin(b);
|
|
}
|
|
fclose(file);
|
|
glb.n=MMAX;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void plot_globe(void)
|
|
{
|
|
int i,flag;
|
|
float x,y,z;
|
|
|
|
for (i=0,flag=0;i<glb.n;i++) {
|
|
if (glb.b[i]==9999.0) {
|
|
flag=0;
|
|
continue;
|
|
}
|
|
x=glb.x[i];
|
|
y=glb.y[i];
|
|
z=glb.z[i];
|
|
|
|
rotate(1,m.l0,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
|
|
if (z>0.0) {
|
|
if (flag==0) {
|
|
cpgmove(x,y);
|
|
flag=1;
|
|
} else {
|
|
cpgdraw(x,y);
|
|
cpgmove(x,y);
|
|
}
|
|
} else {
|
|
flag=0;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// plot grid
|
|
void plot_grid(void)
|
|
{
|
|
int i,j,flag;
|
|
float l,b;
|
|
float x,y,z;
|
|
|
|
for (l=0.0;l<=360.0;l+=30.0) {
|
|
for (b=-90.0,flag=0;b<=90.0;b+=1.0) {
|
|
z=cos(l*D2R)*cos(b*D2R)*XKMPER;
|
|
x=sin(l*D2R)*cos(b*D2R)*XKMPER;
|
|
y=sin(b*D2R)*XKMPER;
|
|
|
|
rotate(1,m.l0,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
|
|
if (flag==0)
|
|
cpgmove(x,y);
|
|
else {
|
|
cpgdraw(x,y);
|
|
cpgmove(x,y);
|
|
}
|
|
if (z>0.0)
|
|
flag=1;
|
|
else
|
|
flag=0;
|
|
}
|
|
}
|
|
|
|
for (b=-90.0;b<=90.0;b+=30.0) {
|
|
for (l=0.0,flag=0;l<=360.0;l+=1.0) {
|
|
z=cos(l*D2R)*cos(b*D2R)*XKMPER;
|
|
x=sin(l*D2R)*cos(b*D2R)*XKMPER;
|
|
y=sin(b*D2R)*XKMPER;
|
|
|
|
rotate(1,m.l0,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
|
|
if (flag==0)
|
|
cpgmove(x,y);
|
|
else {
|
|
cpgdraw(x,y);
|
|
cpgmove(x,y);
|
|
}
|
|
if (z>0.0)
|
|
flag=1;
|
|
else
|
|
flag=0;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Plot terminator
|
|
void plot_moon(void)
|
|
{
|
|
xyz_t s;
|
|
float r,h;
|
|
float l,b,l0,b0;
|
|
float x0,y0,z0,x,y,z;
|
|
double lra,lde,dmjd;
|
|
int isci;
|
|
char text[8];
|
|
|
|
cpgqci(&isci);
|
|
cpgsci(3);
|
|
|
|
// Get positions
|
|
lunpos_xyz(m.mjd,&s,&lra,&lde);
|
|
|
|
// GMST
|
|
h=gmst(m.mjd);
|
|
|
|
// Lunar subpoint
|
|
l0=modulo(lra-h,360.0);
|
|
b0=lde;
|
|
if (l0>180.0)
|
|
l0-=360.0;
|
|
|
|
// Convert
|
|
z0=cos(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
x0=sin(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
y0=sin(b0*D2R)*XKMPER;
|
|
|
|
rotate(1,m.l0,&x0,&y0,&z0);
|
|
rotate(0,m.b0,&x0,&y0,&z0);
|
|
|
|
// Plot sub lunar point
|
|
if (z0>0.0)
|
|
cpgpt1(x0,y0,17);
|
|
|
|
// Lunar antipode
|
|
l0=modulo(lra-h-180,360.0);
|
|
b0=-lde;
|
|
if (l0>180.0)
|
|
l0-=360.0;
|
|
|
|
// Convert
|
|
z0=cos(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
x0=sin(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
y0=sin(b0*D2R)*XKMPER;
|
|
|
|
rotate(1,m.l0,&x0,&y0,&z0);
|
|
rotate(0,m.b0,&x0,&y0,&z0);
|
|
|
|
// Plot antipode
|
|
if (z0>0.0)
|
|
cpgpt1(x0,y0,6);
|
|
|
|
// Plot moon
|
|
z=s.z;
|
|
x=s.x;
|
|
y=s.y;
|
|
|
|
rotate(0,-90.0,&x,&y,&z);
|
|
rotate(1,90.0,&x,&y,&z);
|
|
rotate(1,m.l0+h,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
|
|
cpgcirc(x,y,1737.5);
|
|
|
|
// Plot antipode travel
|
|
for (dmjd=1.0;dmjd<7.0;dmjd+=1.0) {
|
|
// Get positions
|
|
lunpos_xyz(m.mjd+dmjd,&s,&lra,&lde);
|
|
|
|
// GMST
|
|
h=gmst(m.mjd);
|
|
|
|
// Lunar antipode
|
|
l0=modulo(lra-h-180,360.0);
|
|
b0=-lde;
|
|
if (l0>180.0)
|
|
l0-=360.0;
|
|
|
|
// Convert
|
|
z0=cos(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
x0=sin(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
y0=sin(b0*D2R)*XKMPER;
|
|
|
|
rotate(1,m.l0,&x0,&y0,&z0);
|
|
rotate(0,m.b0,&x0,&y0,&z0);
|
|
|
|
// Plot antipode
|
|
if (z0>0.0) {
|
|
sprintf(text," %.0f",dmjd);
|
|
cpgpt1(x0,y0,2);
|
|
cpgtext(x0,y0,text);
|
|
}
|
|
}
|
|
for (dmjd=-6.0;dmjd<0.0;dmjd+=1.0) {
|
|
// Get positions
|
|
lunpos_xyz(m.mjd+dmjd,&s,&lra,&lde);
|
|
|
|
// GMST
|
|
h=gmst(m.mjd);
|
|
|
|
// Lunar antipode
|
|
l0=modulo(lra-h-180,360.0);
|
|
b0=-lde;
|
|
if (l0>180.0)
|
|
l0-=360.0;
|
|
|
|
// Convert
|
|
z0=cos(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
x0=sin(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
y0=sin(b0*D2R)*XKMPER;
|
|
|
|
rotate(1,m.l0,&x0,&y0,&z0);
|
|
rotate(0,m.b0,&x0,&y0,&z0);
|
|
|
|
// Plot antipode
|
|
if (z0>0.0) {
|
|
sprintf(text," %.0f",dmjd);
|
|
cpgpt1(x0,y0,2);
|
|
cpgtext(x0,y0,text);
|
|
}
|
|
}
|
|
|
|
|
|
cpgsci(isci);
|
|
|
|
return;
|
|
}
|
|
|
|
// Plot terminator
|
|
void plot_terminator(void)
|
|
{
|
|
int i,j,k,flag,j1,j2;
|
|
double jd;
|
|
xyz_t s;
|
|
float r,h;
|
|
float l,b,l0,b0;
|
|
float x0,y0,z0;
|
|
float x,y,z,t0,t1,t2,t;
|
|
float xx[NMAX],yy[NMAX],zz[NMAX];
|
|
float xt[NMAX],yt[NMAX],zt[NMAX];
|
|
int isci;
|
|
double sra,sde;
|
|
float theta;
|
|
float ang[]={0.0,-6.0,-12.0,-18.0};
|
|
|
|
cpgqci(&isci);
|
|
|
|
// Get positions
|
|
sunpos_xyz(m.mjd,&s,&sra,&sde);
|
|
|
|
// GMST
|
|
h=gmst(m.mjd);
|
|
|
|
// Solar subpoint
|
|
l0=modulo(sra-h,360.0);
|
|
b0=sde;
|
|
if (l0>180.0)
|
|
l0-=360.0;
|
|
|
|
// Convert
|
|
z0=cos(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
x0=sin(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
y0=sin(b0*D2R)*XKMPER;
|
|
|
|
rotate(1,m.l0,&x0,&y0,&z0);
|
|
rotate(0,m.b0,&x0,&y0,&z0);
|
|
|
|
t0=atan2(y0,x0)*R2D;
|
|
|
|
// Loop over terminator boundaries
|
|
for (i=0,j=0,flag=0;i<NMAX;i++,j++) {
|
|
theta=2.0*M_PI*(float) i/(float) (NMAX-1);
|
|
|
|
x=XKMPER*sin(theta);
|
|
y=XKMPER*cos(theta);
|
|
z=0.0;
|
|
|
|
rotate(0,-b0,&x,&y,&z);
|
|
rotate(1,-l0,&x,&y,&z);
|
|
rotate(1,m.l0,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
xx[i]=x;
|
|
yy[i]=y;
|
|
zz[i]=z;
|
|
}
|
|
for (i=0,j=0;i<NMAX;i++) {
|
|
if (i>0 && zz[i]*zz[i-1]<0.0) {
|
|
if (zz[i]>0.0 && zz[i-1]<0.0) {
|
|
t1=atan2(yy[i],xx[i])*R2D;
|
|
j1=i;
|
|
} else {
|
|
t2=atan2(yy[i],xx[i])*R2D;
|
|
j2=i;
|
|
}
|
|
}
|
|
}
|
|
// angles
|
|
t0=modulo(t0,360);
|
|
t1=modulo(t1,360);
|
|
t2=modulo(t2,360);
|
|
if (t1<t2)
|
|
t1+=360.0;
|
|
if (abs(j2-j1)>512)
|
|
j2++;
|
|
if (abs(j2-j1)<512)
|
|
j2--;
|
|
if (j1>j2) {
|
|
for (i=0,j=0;i<j2;i++,j++) {
|
|
xt[j]=xx[i];
|
|
yt[j]=yy[i];
|
|
}
|
|
for (i=0;i<NMAX-abs(j2-j1);i++,j++) {
|
|
t=t2-(t2-t1)*(float) i/(float) (NMAX-abs(j2-j1));
|
|
|
|
xt[j]=XKMPER*cos(t*D2R);
|
|
yt[j]=XKMPER*sin(t*D2R);
|
|
}
|
|
for (i=j1;i<NMAX;i++,j++) {
|
|
xt[j]=xx[i];
|
|
yt[j]=yy[i];
|
|
}
|
|
} else {
|
|
for (i=j1,j=0;i<j2;i++,j++) {
|
|
xt[j]=xx[i];
|
|
yt[j]=yy[i];
|
|
}
|
|
for (i=0;i<NMAX-abs(j2-j1);i++,j++) {
|
|
t=t2-(t2-t1)*(float) i/(float) (NMAX-abs(j2-j1));
|
|
|
|
xt[j]=XKMPER*cos(t*D2R);
|
|
yt[j]=XKMPER*sin(t*D2R);
|
|
}
|
|
}
|
|
|
|
// Plot day side
|
|
cpgscr(17,0.0,0.0,0.7);
|
|
cpgsci(17);
|
|
cpgsfs(1);
|
|
cpgcirc(0.0,0.0,XKMPER);
|
|
|
|
// Plot night side
|
|
cpgscr(16,0.0,0.0,0.2);
|
|
cpgsci(16);
|
|
cpgpoly(NMAX,xt,yt);
|
|
|
|
// Plot
|
|
if (z0>0.0) {
|
|
cpgsci(7);
|
|
cpgpt1(x0,y0,17);
|
|
}
|
|
|
|
// Loop over terminator boundaries
|
|
for (k=0;k<4;k++) {
|
|
if (k==0)
|
|
cpgsci(2);
|
|
else
|
|
cpgsci(4);
|
|
for (i=0,j=0,flag=0;i<NMAX;i++,j++) {
|
|
theta=2.0*M_PI*(float) i/(float) (NMAX-1);
|
|
|
|
x=XKMPER*sin(theta)*cos(ang[k]*D2R);
|
|
y=XKMPER*cos(theta)*cos(ang[k]*D2R);
|
|
z=XKMPER*sin(ang[k]*D2R);
|
|
|
|
rotate(0,-b0,&x,&y,&z);
|
|
rotate(1,-l0,&x,&y,&z);
|
|
rotate(1,m.l0,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
|
|
if (flag==0)
|
|
cpgmove(x,y);
|
|
else {
|
|
cpgdraw(x,y);
|
|
cpgmove(x,y);
|
|
}
|
|
if (z>0.0)
|
|
flag=1;
|
|
else
|
|
flag=0;
|
|
}
|
|
}
|
|
cpgsci(isci);
|
|
return;
|
|
}
|
|
|
|
// Read a line of maximum length int lim from file FILE into string s
|
|
int fgetline(FILE *file,char *s,int lim)
|
|
{
|
|
int c,i=0;
|
|
|
|
while (--lim > 0 && (c=fgetc(file)) != EOF && c != '\n')
|
|
s[i++] = c;
|
|
if (c == '\t')
|
|
c=' ';
|
|
if (c == '\n')
|
|
s[i++] = c;
|
|
s[i] = '\0';
|
|
return i;
|
|
}
|
|
|
|
void plot_notam(char *filename)
|
|
{
|
|
int i,flag=0;
|
|
float x,y,z;
|
|
float l,b,r;
|
|
char line[LIM];
|
|
FILE *file;
|
|
|
|
file=fopen(filename,"r");
|
|
while (fgetline(file,line,LIM)>0) {
|
|
r=0.0;
|
|
sscanf(line,"%f %f %f",&b,&l,&r);
|
|
if (strlen(line)<2) {
|
|
flag=0;
|
|
continue;
|
|
}
|
|
|
|
z=cos(l*D2R)*cos(b*D2R)*XKMPER;
|
|
x=sin(l*D2R)*cos(b*D2R)*XKMPER;
|
|
y=sin(b*D2R)*XKMPER;
|
|
|
|
rotate(1,m.l0,&x,&y,&z);
|
|
rotate(0,m.b0,&x,&y,&z);
|
|
|
|
if (z>0.0) {
|
|
if (flag==0) {
|
|
cpgmove(x,y);
|
|
flag=1;
|
|
} else {
|
|
cpgdraw(x,y);
|
|
cpgmove(x,y);
|
|
}
|
|
} else {
|
|
flag=0;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void plot_map(int plotflag)
|
|
{
|
|
int redraw=1,status;
|
|
char text[256];
|
|
float x,y,z;
|
|
char c;
|
|
|
|
for (;;) {
|
|
if (redraw>0) {
|
|
// Get present mjd
|
|
if (m.mjd<0.0) {
|
|
nfd_now(m.nfd);
|
|
m.mjd=nfd2mjd(m.nfd);
|
|
m.h0=gmst(m.mjd);
|
|
}
|
|
|
|
// Update position
|
|
if (strcmp(m.orientation,"terrestial")==0) {
|
|
m.l0=m.lng;
|
|
m.b0=m.lat;
|
|
} else if (strcmp(m.orientation,"sidereal")==0) {
|
|
m.l0=m.lng-gmst(m.mjd)+m.h0;
|
|
m.b0=m.lat;
|
|
}
|
|
|
|
cpgscr(0,0.0,0.0,0.0);
|
|
cpgeras();
|
|
|
|
// Create window
|
|
cpgsvp(0.05,0.95,0.05,0.95);
|
|
cpgwnad(-m.w*XKMPER,m.w*XKMPER,-m.w*XKMPER,m.w*XKMPER);
|
|
|
|
// Set background
|
|
cpgscr(0,0.0,0.0,0.5);
|
|
cpgsci(0);
|
|
cpgwnad(-m.w*XKMPER,m.w*XKMPER,-m.w*XKMPER,m.w*XKMPER);
|
|
cpgsci(1);
|
|
cpgscr(0,0.0,0.0,0.0);
|
|
|
|
// Top left string
|
|
cpgsch(0.8);
|
|
mjd2date(m.mjd,m.nfd,0);
|
|
sprintf(text,"%s UTC",m.nfd);
|
|
cpgmtxt("T",0.6,0.0,0.0,text);
|
|
|
|
// Bottom string
|
|
sprintf(text,"l: %d s",m.length);
|
|
cpgmtxt("B",1.0,0.0,0.0,text);
|
|
cpgsch(1.0);
|
|
|
|
// Plot terminator
|
|
plot_terminator();
|
|
|
|
// Plot Grid
|
|
cpgsls(2);
|
|
cpgsci(14);
|
|
plot_grid();
|
|
cpgsls(1);
|
|
cpgsci(1);
|
|
|
|
// Plot globe
|
|
plot_globe();
|
|
cpgsfs(2);
|
|
cpgcirc(0.0,0.0,XKMPER);
|
|
cpgpt1(0.0,0.0,2);
|
|
cpgsci(1);
|
|
cpgbox("BC",0.,0,"BC",0.,0);
|
|
|
|
// Plot notam
|
|
if (m.notamflag==1) {
|
|
cpgsci(3);
|
|
plot_notam(m.notamfile);
|
|
cpgsci(1);
|
|
}
|
|
|
|
// Plot moon
|
|
if (m.moonflag==1)
|
|
plot_moon();
|
|
|
|
// Plot launch sites
|
|
if (m.launchsitesflag==1)
|
|
plot_launch_sites();
|
|
|
|
// Plot track
|
|
if (m.xyzflag==1)
|
|
plot_xyz();
|
|
else
|
|
plot_track();
|
|
}
|
|
|
|
// Reset redraw
|
|
redraw=0;
|
|
|
|
if (plotflag==1) {
|
|
cpgend();
|
|
exit(0);
|
|
}
|
|
|
|
// Get cursor
|
|
cpgcurs(&x,&y,&c);
|
|
|
|
// Help
|
|
if (c=='h') {
|
|
interactive_usage();
|
|
|
|
continue;
|
|
}
|
|
|
|
// Redraw
|
|
if (c=='r') {
|
|
m.mjd=-1.0;
|
|
m.length=60;
|
|
redraw=1;
|
|
}
|
|
|
|
// Footprint toggle
|
|
if (c=='f') {
|
|
if (m.plotfootprint==1)
|
|
m.plotfootprint=0;
|
|
else
|
|
m.plotfootprint=1;
|
|
redraw=1;
|
|
}
|
|
|
|
// Moon toggle
|
|
if (c=='m') {
|
|
if (m.moonflag==1)
|
|
m.moonflag=0;
|
|
else
|
|
m.moonflag=1;
|
|
redraw=1;
|
|
}
|
|
|
|
// Launchsites toggle
|
|
if (c=='L') {
|
|
if (m.launchsitesflag==1)
|
|
m.launchsitesflag=0;
|
|
else
|
|
m.launchsitesflag=1;
|
|
redraw=1;
|
|
}
|
|
|
|
// Orientation
|
|
if (c=='o') {
|
|
if (strcmp(m.orientation,"terrestial")==0)
|
|
strcpy(m.orientation,"sidereal");
|
|
else if (strcmp(m.orientation,"sidereal")==0)
|
|
strcpy(m.orientation,"terrestial");
|
|
redraw=1;
|
|
}
|
|
|
|
// Recenter
|
|
if (sqrt(x*x+y*y)<XKMPER && c=='c') {
|
|
z=sqrt(XKMPER*XKMPER-x*x-y*y);
|
|
rotate(0,-m.lat,&x,&y,&z);
|
|
rotate(1,-m.l0,&x,&y,&z);
|
|
rotate(1,-90.0,&x,&y,&z);
|
|
rotate(0,90.0,&x,&y,&z);
|
|
|
|
m.lng=atan2(y,x)*R2D;
|
|
m.lat=asin(z/XKMPER)*R2D;
|
|
printf("%8.3f %8.3f\n",m.lng,m.lat);
|
|
m.l0=m.lng;
|
|
m.b0=m.lat;
|
|
redraw=1;
|
|
}
|
|
|
|
// Zoom
|
|
if (c=='-') {
|
|
m.w*=1.2;
|
|
redraw=1;
|
|
}
|
|
if (c=='+' || c=='=') {
|
|
m.w/=1.2;
|
|
redraw=1;
|
|
}
|
|
|
|
// Pan
|
|
if (c=='{') {
|
|
m.lat-=2.0;
|
|
redraw=1;
|
|
}
|
|
if (c=='}') {
|
|
m.lat+=2.0;
|
|
redraw=1;
|
|
}
|
|
if (c=='[') {
|
|
m.lng-=2.0;
|
|
redraw=1;
|
|
}
|
|
if (c==']') {
|
|
m.lng+=2.0;
|
|
redraw=1;
|
|
}
|
|
|
|
if (c=='>') {
|
|
m.length*=2.0;
|
|
redraw=1;
|
|
}
|
|
if (c=='<') {
|
|
m.length/=2.0;
|
|
redraw=1;
|
|
}
|
|
if (c==',') {
|
|
m.mjd-=m.length/86400.0;
|
|
redraw=1;
|
|
}
|
|
if (c=='.') {
|
|
m.mjd+=m.length/86400.0;
|
|
redraw=1;
|
|
}
|
|
|
|
// Integration length
|
|
if (c=='l') {
|
|
printf("Enter integration length (s): ");
|
|
status=scanf("%d",&m.length);
|
|
redraw=1;
|
|
}
|
|
|
|
// Exit
|
|
if (c=='q' || c=='Q') {
|
|
cpgend();
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
int main(int argc,char *argv[])
|
|
{
|
|
int arg=0,plotflag=0;
|
|
char plottype[128]="/xs";
|
|
|
|
// Initialize setup
|
|
initialize_setup();
|
|
|
|
// Decode options
|
|
while ((arg=getopt(argc,argv,"t:c:i:s:l:hN:p:mL:B:R:Sqg:"))!=-1) {
|
|
switch (arg) {
|
|
|
|
case 'g':
|
|
strcpy(plottype,optarg);
|
|
plotflag=1;
|
|
break;
|
|
|
|
case 't':
|
|
strcpy(m.nfd,optarg);
|
|
m.mjd=nfd2mjd(m.nfd);
|
|
break;
|
|
|
|
case 'c':
|
|
strcpy(m.tlefile,optarg);
|
|
break;
|
|
|
|
case 's':
|
|
get_site(atoi(optarg));
|
|
break;
|
|
|
|
case 'i':
|
|
m.satno=atoi(optarg);
|
|
break;
|
|
|
|
case 'q':
|
|
m.launchsitesflag=1;
|
|
break;
|
|
|
|
case 'l':
|
|
m.length=atoi(optarg);
|
|
break;
|
|
|
|
case 'N':
|
|
strcpy(m.notamfile,optarg);
|
|
m.notamflag=1;
|
|
break;
|
|
|
|
case 'L':
|
|
m.lng=atof(optarg);
|
|
break;
|
|
|
|
case 'B':
|
|
m.lat=atof(optarg);
|
|
break;
|
|
|
|
case 'R':
|
|
m.w=atof(optarg);
|
|
break;
|
|
|
|
case 'S':
|
|
strcpy(m.orientation,"sidereal");
|
|
break;
|
|
|
|
case 'p':
|
|
strcpy(m.xyzfile,optarg);
|
|
m.xyzflag=1;
|
|
break;
|
|
|
|
case 'm':
|
|
m.moonflag=1;
|
|
break;
|
|
|
|
case 'h':
|
|
usage();
|
|
return 0;
|
|
break;
|
|
|
|
default:
|
|
usage();
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
read_globe();
|
|
|
|
giza_open_device_size_float("/xs", "satorbit", 1920, 1020, 3);
|
|
giza_set_colour_palette(1);
|
|
|
|
plot_map(plotflag);
|
|
|
|
cpgend();
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Present nfd
|
|
void nfd_now(char *s)
|
|
{
|
|
time_t rawtime;
|
|
struct tm *ptm;
|
|
|
|
// Get UTC time
|
|
time(&rawtime);
|
|
ptm=gmtime(&rawtime);
|
|
|
|
sprintf(s,"%04d-%02d-%02dT%02d:%02d:%02d",ptm->tm_year+1900,ptm->tm_mon+1,ptm->tm_mday,ptm->tm_hour,ptm->tm_min,ptm->tm_sec);
|
|
|
|
return;
|
|
}
|
|
|
|
// nfd2mjd
|
|
double nfd2mjd(char *date)
|
|
{
|
|
int year,month,day,hour,min,sec;
|
|
double mjd,dday;
|
|
|
|
sscanf(date,"%04d-%02d-%02dT%02d:%02d:%02d",&year,&month,&day,&hour,&min,&sec);
|
|
dday=day+hour/24.0+min/1440.0+sec/86400.0;
|
|
|
|
mjd=date2mjd(year,month,dday);
|
|
|
|
return mjd;
|
|
}
|
|
|
|
void usage()
|
|
{
|
|
printf("usage: satorbit -c TLEFILE [-g DEVICE] [-t TIMESTAMP] [-s COSPARID] [-i SATNO]\n");
|
|
printf(" [-q] [-p XYZFILE] [-m] [-N NOTAMFILE] [-l LENGTH]\n");
|
|
printf(" [-L LNG] [-B LAT] [-R ZOOMSIZE] [-S ORIENTATION] [-h]\n\n");
|
|
|
|
printf("-c TLEFILE The file containing orbital elements in the form of TLEs, 3 lines per object\n");
|
|
printf("-g DEVICE PGPlot device (default: \"/xs\" --> interactive).\n");
|
|
printf(" If set exit the program when everything was drawn.\n");
|
|
printf(" default: stay in interactive mode\n");
|
|
printf("-t TIMESTAMP Timestamp of the map, formatted as YYYY-mm-ddTHH:MM:SS, default: now\n");
|
|
printf("-s COSPARID observation site, COSPAR ID of the observation site on which the map is centered optionally\n");
|
|
printf("-i SATNO satno of the selected satellite, default: 0 (all satellites in the TLE file)\n");
|
|
printf("-q launchsitesflag: If value=1 plot the launch sites as well, default: 0\n");
|
|
printf("-p XYZFILE If given, plot xyz instead of track\n");
|
|
printf("-m moonflag: If value=1 plot the moon as well\n");
|
|
printf("-N NOTAMFILE If given, plot the NOTAM as well\n");
|
|
printf("-l LENGTH Integration length in seconds, default: 60\n");
|
|
printf("-L LNG map longitude\n");
|
|
printf("-B LAT map latitude\n");
|
|
printf("-R ZOOMSIZE Initial window size in earth radii, default: 1.2\n");
|
|
printf("-S ORIENTATION map orientation: sidereal, default: terrestial\n");
|
|
printf("-h Print usage\n");
|
|
}
|
|
|
|
void interactive_usage()
|
|
{
|
|
printf("r Redraw\n");
|
|
printf("f Toggle footprint visibility\n");
|
|
printf("m Toggle moon visibility\n");
|
|
printf("L Toggle launchsite visibility\n");
|
|
printf("o Switch between terrestial and sidereal orientation\n");
|
|
printf("c Center map on cursor position\n");
|
|
printf("- Zoom out by a factor of 1.2\n");
|
|
printf("+/= Zoom in\n");
|
|
printf("{ decrease latitude -2\n");
|
|
printf("} increase latitude +2\n");
|
|
printf("[ decrease longitude -2\n");
|
|
printf("] increase longitude +2\n");
|
|
printf("< Divide the integration length by a facor of 2\n");
|
|
printf("> Multiply the integration length by a facor of 2\n");
|
|
printf(", Increase time (+integration_length in seconds /(1 day))\n");
|
|
printf(". Roll back the time\n");
|
|
printf("l Enter the integration length in seconds\n");
|
|
printf("h this interactive help\n");
|
|
printf("q/Q Exit\n");
|
|
}
|
|
|
|
// Compute Date from Julian Day
|
|
void mjd2date(double mjd,char *date,int length)
|
|
{
|
|
double f,jd,dday;
|
|
int z,alpha,a,b,c,d,e;
|
|
int year,month,day,hour,min;
|
|
float sec,x;
|
|
|
|
jd=mjd+2400000.5;
|
|
jd+=0.5;
|
|
|
|
z=floor(jd);
|
|
f=fmod(jd,1.);
|
|
|
|
if (z<2299161)
|
|
a=z;
|
|
else {
|
|
alpha=floor((z-1867216.25)/36524.25);
|
|
a=z+1+alpha-floor(alpha/4.);
|
|
}
|
|
b=a+1524;
|
|
c=floor((b-122.1)/365.25);
|
|
d=floor(365.25*c);
|
|
e=floor((b-d)/30.6001);
|
|
|
|
dday=b-d-floor(30.6001*e)+f;
|
|
if (e<14)
|
|
month=e-1;
|
|
else
|
|
month=e-13;
|
|
|
|
if (month>2)
|
|
year=c-4716;
|
|
else
|
|
year=c-4715;
|
|
|
|
day=(int) floor(dday);
|
|
x=24.0*(dday-day);
|
|
x=3600.*fabs(x);
|
|
sec=fmod(x,60.);
|
|
x=(x-sec)/60.;
|
|
min=fmod(x,60.);
|
|
x=(x-min)/60.;
|
|
hour=x;
|
|
sec=floor(1000.0*sec)/1000.0;
|
|
|
|
if (length==3)
|
|
sprintf(date,"%04d-%02d-%02dT%02d:%02d:%06.3f",year,month,day,hour,min,sec);
|
|
else if (length==0)
|
|
sprintf(date,"%04d-%02d-%02dT%02d:%02d:%02.0f",year,month,day,hour,min,sec);
|
|
return;
|
|
}
|
|
|
|
// Compute Julian Day from Date
|
|
double date2mjd(int year,int month,double day)
|
|
{
|
|
int a,b;
|
|
double jd;
|
|
|
|
if (month<3) {
|
|
year--;
|
|
month+=12;
|
|
}
|
|
|
|
a=floor(year/100.);
|
|
b=2.-a+floor(a/4.);
|
|
|
|
if (year<1582) b=0;
|
|
if (year==1582 && month<10) b=0;
|
|
if (year==1582 && month==10 && day<=4) b=0;
|
|
|
|
jd=floor(365.25*(year+4716))+floor(30.6001*(month+1))+day+b-1524.5;
|
|
|
|
return jd-2400000.5;
|
|
}
|
|
|
|
// rotate vector
|
|
void rotate(int axis,float angle,float *x,float *y,float *z)
|
|
{
|
|
float xx,yy,zz;
|
|
float ca,sa;
|
|
|
|
ca=cos(angle*D2R);
|
|
sa=sin(angle*D2R);
|
|
|
|
if (axis==0) {
|
|
xx= *x;
|
|
yy= *y*ca- *z*sa;
|
|
zz= *z*ca+ *y*sa;
|
|
}
|
|
if (axis==1) {
|
|
xx= *x*ca- *z*sa;
|
|
yy= *y;
|
|
zz= *z*ca+ *x*sa;
|
|
}
|
|
if (axis==2) {
|
|
xx= *x*ca- *y*sa;
|
|
yy= *y*ca+ *x*sa;
|
|
zz= *z;
|
|
}
|
|
|
|
*x=xx;
|
|
*y=yy;
|
|
*z=zz;
|
|
|
|
return;
|
|
}
|
|
|
|
// Moon position
|
|
void lunpos_xyz(double mjd,xyz_t *pos,double *ra,double *de)
|
|
{
|
|
int i;
|
|
double t,t2,t3,t4;
|
|
double l1,d,m,m1,f,a1,a2,a3,e,ef;
|
|
double suml,sumb,sumr,arglr,argb;
|
|
double l,b,r;
|
|
|
|
// Julian Centuries
|
|
t=(mjd-51544.5)/36525.0;
|
|
|
|
// Powers of t
|
|
t2=t*t;
|
|
t3=t2*t;
|
|
t4=t3*t;
|
|
|
|
// angles
|
|
l1=modulo(218.3164477+481267.88123421*t-0.0015786*t2+t3/538841.0-t4/65194000.0,360.0)*D2R;
|
|
d=modulo(297.8501921+445267.1114034*t-0.0018819*t2+t3/545868.0-t4/113065000.0,360.0)*D2R;
|
|
m=modulo(357.5291092+35999.0502909*t-0.0001536*t2+t3/24490000.0,360.0)*D2R;
|
|
m1=modulo(134.9633964+477198.8675055*t+0.0087417*t2+t3/69699.0-t4/14712000.0,360.0)*D2R;
|
|
f=modulo(93.2720950+483202.0175233*t-0.0036539*t2-t3/3526000.0+t4/86331000.0,360.0)*D2R;
|
|
a1=modulo(119.75+131.849*t,360.0)*D2R;
|
|
a2=modulo(53.09+479264.290*t,360.0)*D2R;
|
|
a3=modulo(313.45+481266.484*t,360.0)*D2R;
|
|
e=1.0-0.002516*t-0.0000074*t2;
|
|
|
|
// Compute sums
|
|
for (i=0,suml=sumb=sumr=0.0;i<60;i++) {
|
|
// Arguments
|
|
arglr=clr[i].nd*d+clr[i].nm*m+clr[i].nm1*m1+clr[i].nf*f;
|
|
argb=cb[i].nd*d+cb[i].nm*m+cb[i].nm1*m1+cb[i].nf*f;
|
|
|
|
// E multiplication factor
|
|
if (abs(clr[i].nm)==1)
|
|
ef=e;
|
|
else if (abs(clr[i].nm)==2)
|
|
ef=e*e;
|
|
else
|
|
ef=1.0;
|
|
|
|
// Sums
|
|
suml+=clr[i].sa*sin(arglr)*ef;
|
|
sumr+=clr[i].ca*cos(arglr)*ef;
|
|
|
|
// E multiplication factor
|
|
if (abs(cb[i].nm)==1)
|
|
ef=e;
|
|
else if (abs(cb[i].nm)==2)
|
|
ef=e*e;
|
|
else
|
|
ef=1.0;
|
|
|
|
// Sums
|
|
sumb+=cb[i].sa*sin(argb)*ef;
|
|
}
|
|
|
|
// Additives
|
|
suml+=3958*sin(a1)+1962*sin(l1-f)+318*sin(a2);
|
|
sumb+=-2235*sin(l1)+382*sin(a3)+175*sin(a1-f)+175*sin(a1+f)+127*sin(l1-m1)-115*sin(l1+m1);
|
|
|
|
// Ecliptic longitude, latitude and distance
|
|
l=modulo(l1*R2D+suml/1000000.0,360.0);
|
|
b=sumb/1000000.0;
|
|
r=385000.56+sumr/1000.0;
|
|
|
|
// Equatorial
|
|
ecliptical2equatorial(l,b,ra,de);
|
|
|
|
// Position
|
|
pos->x=r*cos(*de*D2R)*cos(*ra*D2R);
|
|
pos->y=r*cos(*de*D2R)*sin(*ra*D2R);
|
|
pos->z=r*sin(*de*D2R);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
// Solar position
|
|
void sunpos_xyz(double mjd,xyz_t *pos,double *ra,double *de)
|
|
{
|
|
double jd,t,l0,m,e,c,r;
|
|
double n,s,ecl;
|
|
|
|
jd=mjd+2400000.5;
|
|
t=(jd-2451545.0)/36525.0;
|
|
l0=modulo(280.46646+t*(36000.76983+t*0.0003032),360.0)*D2R;
|
|
m=modulo(357.52911+t*(35999.05029-t*0.0001537),360.0)*D2R;
|
|
e=0.016708634+t*(-0.000042037-t*0.0000001267);
|
|
c=(1.914602+t*(-0.004817-t*0.000014))*sin(m)*D2R;
|
|
c+=(0.019993-0.000101*t)*sin(2.0*m)*D2R;
|
|
c+=0.000289*sin(3.0*m)*D2R;
|
|
|
|
r=1.000001018*(1.0-e*e)/(1.0+e*cos(m+c));
|
|
n=modulo(125.04-1934.136*t,360.0)*D2R;
|
|
s=l0+c+(-0.00569-0.00478*sin(n))*D2R;
|
|
ecl=(23.43929111+(-46.8150*t-0.00059*t*t+0.001813*t*t*t)/3600.0+0.00256*cos(n))*D2R;
|
|
|
|
*ra=atan2(cos(ecl)*sin(s),cos(s))*R2D;
|
|
*de=asin(sin(ecl)*sin(s))*R2D;
|
|
|
|
pos->x=r*cos(*de*D2R)*cos(*ra*D2R)*XKMPAU;
|
|
pos->y=r*cos(*de*D2R)*sin(*ra*D2R)*XKMPAU;
|
|
pos->z=r*sin(*de*D2R)*XKMPAU;
|
|
|
|
return;
|
|
}
|
|
|
|
// Return x modulo y [0,y)
|
|
double modulo(double x,double y)
|
|
{
|
|
x=fmod(x,y);
|
|
if (x<0.0) x+=y;
|
|
|
|
return x;
|
|
}
|
|
|
|
// Greenwich Mean Sidereal Time
|
|
double gmst(double mjd)
|
|
{
|
|
double t,gmst;
|
|
|
|
t=(mjd-51544.5)/36525.0;
|
|
|
|
gmst=modulo(280.46061837+360.98564736629*(mjd-51544.5)+t*t*(0.000387933-t/38710000),360.0);
|
|
|
|
return gmst;
|
|
}
|
|
|
|
// Greenwich Mean Sidereal Time
|
|
double dgmst(double mjd)
|
|
{
|
|
double t,dgmst;
|
|
|
|
t=(mjd-51544.5)/36525.0;
|
|
|
|
dgmst=360.98564736629+t*(0.000387933-t/38710000);
|
|
|
|
return dgmst;
|
|
}
|
|
|
|
// Get observing site
|
|
void get_site(int site_id)
|
|
{
|
|
int i=0;
|
|
char line[LIM];
|
|
FILE *file;
|
|
int id;
|
|
double lat,lng;
|
|
float alt;
|
|
char abbrev[3],observer[64];
|
|
char filename[LIM];
|
|
|
|
sprintf(filename,"%s/data/sites.txt",m.datadir);
|
|
file=fopen(filename,"r");
|
|
if (file==NULL) {
|
|
printf("File with site information not found!\n");
|
|
return;
|
|
}
|
|
while (fgets(line,LIM,file)!=NULL) {
|
|
// Skip
|
|
if (strstr(line,"#")!=NULL)
|
|
continue;
|
|
|
|
// Strip newline
|
|
line[strlen(line)-1]='\0';
|
|
|
|
// Read data
|
|
sscanf(line,"%4d %2s %lf %lf %f",
|
|
&id,abbrev,&lat,&lng,&alt);
|
|
strcpy(observer,line+38);
|
|
|
|
// Change to km
|
|
alt/=1000.0;
|
|
|
|
if (id==site_id) {
|
|
m.lat=lat;
|
|
m.lng=lng;
|
|
m.alt=alt;
|
|
m.site_id=id;
|
|
strcpy(m.observer,observer);
|
|
}
|
|
|
|
}
|
|
fclose(file);
|
|
|
|
return;
|
|
}
|
|
|
|
// Plot launch sites
|
|
void plot_launch_sites(void)
|
|
{
|
|
int i=0;
|
|
char line[LIM];
|
|
FILE *file;
|
|
double lat,lng;
|
|
char site[64],text[8],filename[LIM];
|
|
float isch;
|
|
float x0,y0,z0,l0,b0;
|
|
|
|
|
|
cpgqch(&isch);
|
|
|
|
sprintf(filename,"%s/data/launchsites.txt",m.datadir);
|
|
file=fopen(filename,"r");
|
|
if (file==NULL) {
|
|
printf("File with site information not found!\n");
|
|
return;
|
|
}
|
|
while (fgets(line,LIM,file)!=NULL) {
|
|
// Skip
|
|
if (strstr(line,"#")!=NULL)
|
|
continue;
|
|
|
|
// Strip newline
|
|
line[strlen(line)-1]='\0';
|
|
|
|
// Read data
|
|
sscanf(line,"%lf %lf",
|
|
&lat,&lng);
|
|
strcpy(site,line+21);
|
|
|
|
l0=modulo(lng,360.0);
|
|
b0=lat;
|
|
if (l0>180.0)
|
|
l0-=360.0;
|
|
|
|
// Convert
|
|
z0=cos(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
x0=sin(l0*D2R)*cos(b0*D2R)*XKMPER;
|
|
y0=sin(b0*D2R)*XKMPER;
|
|
|
|
rotate(1,m.l0,&x0,&y0,&z0);
|
|
rotate(0,m.b0,&x0,&y0,&z0);
|
|
|
|
// Plot location
|
|
if (z0>0.0) {
|
|
cpgsci(2);
|
|
cpgsch(0.5);
|
|
cpgpt1(x0,y0,4);
|
|
cpgtext(x0,y0,site);
|
|
cpgsci(1);
|
|
}
|
|
}
|
|
fclose(file);
|
|
cpgsch(isch);
|
|
|
|
return;
|
|
}
|