/* NIGHTFALL Light Curve Synthesis Program */ /* Copyright (C) 1998 Rainer Wichmann */ /* */ /* This program is free software; you can redistribute it */ /* and/or modify */ /* it under the terms of the GNU General Public License as */ /* published by */ /* the Free Software Foundation; either version 2 of the License, or */ /* (at your option) any later version. */ /* */ /* This program is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ /* GNU General Public License for more details. */ /* */ /* You should have received a copy of the GNU General Public License */ /* along with this program; if not, write to the Free Software */ /* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "config.h" /* This is actually nowhere used, but causes a 'redefined' */ /* error due to a bug in the JPEG lib headers. */ #undef HAVE_STDLIB_H /* Fourth LD law is currently for experimental purposes only */ #define LD_LAW_MAX 2 /* --------------------------------------------------------- */ /* */ /* Default values that may be changed */ /* */ /* --------------------------------------------------------- */ /* default number of steps per pi (in Eta) */ /* pi = 3.14 = 180 degree */ /* steps in Phi are calculated as 10+2*STEPS_PER_PI/sin(Eta) */ /* -- and corresponding maximum number of surface elements */ /* */ #ifdef HIGH_PRECISION #define STEPS_PER_PI 196 #define MAXELEMENTS 65536 #else #define STEPS_PER_PI 64 #ifdef HAVE_DISK #define MAXELEMENTS 65536 #else #define MAXELEMENTS 8192 #endif #endif /* window size if Gnuplot */ /* for pgplot, width will be used to scale display */ /* unless environment variable PGPLOT_XW_WIDTH is set */ /* */ #define GNU_GEOMETRY "550x424+300+20" /* maximum number of steps for a full orbit */ /* */ #define PHASESTEPS 2048 /* maximum number of observations in each passband/filter */ /* */ #define MAXOBS 8192 /* maximum number of spots per component */ /* */ #define N_SPOT 10 /* output file for lightcurve */ /* */ #define OUT_FILE "NightfallCurve.dat" /* output file for fit results */ /* */ #define OUT_SIMPLEX "NightfallFitted.dat" /* output file for chi square map */ /* */ #define OUT_CHIMAP "NightfallChiMap.dat" /* Grid size (square) for Chi Square Map */ /* */ #define _CHI_SCANS_ 16 /* default wavelength for line profile (V band) */ /* */ #define LAMDAZERO_DEFAULT 550.0 /* array for line profile (multiple of two) */ #define PROFILE_ARRAY 128 /* resolution of profile (delta_lambda/lambda) */ #define PROFILE_RES 20000.0 /* switch model atmospheres PHOENIX -> ATLAS */ #define SWITCH_TEMP 9000.0 /* --------------------------------------------------------- */ /* */ /* nothing to change below this line */ /* (unless you know what you do ... ) */ /* */ /* --------------------------------------------------------- */ /* Maximum Number of Iterations for RootFind/MinFind */ #define MAXITER 100 /* Maximum linesize for config file */ #define MAX_CFG_INLINE 255 /* Floating-Point precision */ #define EPS 3.0e-8 /* number of passbands */ #define NUM_MAG 12 /* maximum iteration for downhill simplex */ #define MAX_ITER_SIMPLEX 200 /* default tolerance for downhill simplex */ #define SIMPLEX_FIT_TOLERANCE 0.01 /* the maximum dimension of the parameter space */ /* -- Careful: some calls to array indices are */ /* hardcoded (LightSimplex.c), decreasing SDIM */ /* can lead to disaster */ #define SDIM 49 /************************************************************************/ /* */ /* TYPEDEFS */ /* */ /************************************************************************/ #define WARN 0 #define BUSY 1 #define VERBOSE 2 #define GEO 3 #define OPTIMIZE 4 #define MINFIND 5 #define CHISQR 6 #define INFILE 7 #define SURFACE 8 #define MAX_FVAL 9 #define NF_NATIVE_FILE 0 /* ----------------- A 2D Point ------------------------------- */ typedef struct Point2Struct { /* 2D Point */ double x, y; } Point2; typedef Point2 Vector2; /* ----------------- Output Table ------------------------------- */ typedef struct PhotoOutStruct { float Phase; /* phase of output datum */ double Mag[NUM_MAG]; /* magnitudes of output data */ float RV[3]; /* radial velocities */ /* 2->3 components 2002/04/09, MPR */ float D_RV[3]; /* disturbance of Kepler RV */ /* 2->3 components 2002/04/09, MPR */ } PhotoOut; /* ----------------- Data Point ------------------------------- */ typedef struct PhotoStruct { double time; /* time of observation */ float mag; /* value of observation */ float weight; /* weight of observation */ float phi; /* phase of observation */ float residual; /* residual of observation */ } Photo3; /* ----------------- Spot Parameters ------------------------------- */ typedef struct SpotStruct { double nowlongitude; /* actual value */ double longitude; /* latitude of spot */ double latitude; /* longitude of spot */ double radius; /* angular radius */ double dimfactor; /* dimming (= T.new/T.old) */ } SpotLight; /* ----------------- Surface Element ------------------------------- */ typedef struct SurfaceStruct { float rad; /* radius */ float eta; /* angle to x-axis */ float phi; /* angle in y-z-plane */ float lambda; /* holds rad*cos(eta) = x */ float mu; /* holds rad*sin(eta)cos(phi) = y */ float nu; /* holds rad*sin(eta)sin(phi) = z */ float l; /* surface normal x */ float m; /* surface normal y */ float n; /* surface normal z */ float rho; /* distance to other stars centre */ #ifdef HIGH_PRECISION double area; /* area of element */ #else float area; /* area of element */ #endif float grav; /* dimensionless gravity at element*/ double temp; /* temperature of element */ double orig_temp; /* temperature of element */ double f_[NUM_MAG]; /* intensity in various passbands */ long MyNum; /* number */ int ring; /* ring this element lives in */ struct SurfaceStruct *phi_ptr; /* pointer to last in phi */ struct SurfaceStruct *phi1_ptr; /* pointer to next in phi */ struct SurfaceStruct *next_ptr; /* pointer to next in eta */ struct SurfaceStruct *last_ptr; /* pointer to last in eta */ float LOS_Pot; /* Potential min. on LOS */ float visibility; /* (fractional) visibility */ float CosGamma; /* angle LOS-surface normal */ int EclipseFlag; /* eclipsed = ON/OFF */ int SpotNum; /* number of overlapping spots */ double SumDimFactor; /* average dimming factor */ float Velocity; /* projected velocity */ /* Parameter needed for eclipse testing */ int AreaType; /* AreaType: (TOP_SEGMENT/BOTTOM_SEGMENT/ OUT_RECTANGLE/IN_RECTANGLE) */ double RadiusIn; /* Inner radius of area element PR */ double RadiusOut; /* Outer radius of area element PR */ double AreaAngle; /* Angle of area element between x-axis and middle of the element*/ double AreaHeight; double AreaWidth; double VecE1[3]; /* Element vector 1 of test layer */ double VecE2[3]; /* Element vector 2 of test layer */ } SurfaceElement; /* ----------------- Disk Component -------------------------------- */ /* disk parameters MK 14.03.2001 */ /* typedef struct DiskStruct { */ /* double Incl; */ /* disk inclination */ /* */ /* in degrees */ /* double Warp; */ /* warp angle of the disk */ /* */ /* in degrees */ /* double Thick; */ /* thickness of disk */ /* */ /* in units of R */ /* double HR; */ /* H over R for the disk */ /* double Rout; */ /* outer radius of the disk */ /* */ /* in units of seperation */ /* double Rin; */ /* inner radius of the disk */ /* */ /* in units of seperation */ /* } DiskComponent; */ /* ----------------- Binary Component ----------------------------- */ typedef struct ComponentStruct { double Mq; /* mass ratio */ double RocheFill; /* Roche Lobe filling Factor */ double RocheStore; /* Roche Lobe filling Factor */ double RLag1; /* Lagrange One */ double RLag2; /* Lagrange Two */ double RLag3; /* Lagrange Three */ double RCLag1; /* Lagrange One Potential */ double RCLag2; /* Lagrange Two Potential */ double RCLag3; /* Lagrange Three Potential */ double CosPhiLagrange; /* Lim. angle for eclipse */ double RZatL1; /* Throat Rad perpend. L1 */ double RYatL1; /* Throat Rad perpend. L1 */ double LimRad; /* Radius at Throat */ double LimEta; /* Eta at Throat */ double Fratio; /* Nonsync Rotation */ double RXCrit; /* Max. Radius on X axis */ double RochePotCrit; /* Potential for Max Lobe */ double RochePot; /* Roche Potential-Star */ double RCrit; /* Radius for Max Lobe */ double Radius; /* Polar Radius Star */ double Surface; /* Surface Area */ double Gravity; /* MeanGravity */ double Temperature; /* Effective Temperature */ double Albedo; /* Bolometric Albedo */ double GravDarkCoeff; /* Gravitational Darkening */ double DarkeningGrav; /* Denominator for dark. law */ long NumElem; /* Number of Surface Elements */ long NumPlus; /* plus the Throat ... */ long N_PhiStep[STEPS_PER_PI+10]; /* steps in phi at eta */ int N_Rings; /* number of rings (in eta) */ /* steps in phi at eta */ double Xp; /* Smallest enclosing radius */ double Volume; /* volume of star */ double ScaledVolume; /* scaled volume */ double RadMean; /* mean radius */ double TempMean; /* mean temperature */ double K; /* half-amplitude of radial v */ double log_g; /* log_g for model atmosphere */ /* -------------------- disk parameters -------------------------- */ double Tilt; /* disk inclination */ /* in degrees */ double Warp; /* warp angle of the disk */ /* in degrees */ double Thick; /* thickness of disk */ /* in units of R */ double HR; /* H over R for the disk */ double Rout; /* outer radius of the disk */ /* in units of seperation */ double Rin; /* inner radius of the disk */ /* in units of seperation */ int RingsOut; /* Number of rings on the outer side of the disk */ int RingsIn; /* Number of Rings on the * inner side of the disk */ int Segments; /* Number of Segments in Phi direction */ /* -------------------- hot spot parameters ---------------------- */ double tempHS; /* Hot Spot temperature */ double longitudeHS; /* Hot Spot longitude */ double extentHS; /* Hot Spot extent */ double depthHS; /* Hot Spot depth */ } BinaryComponent; /* ----------------- Flags --------------------------------------- */ /* added disk related flags MK 13.05.01 */ typedef struct FlagsStruct { unsigned long debug[MAX_FVAL]; /* debug flags */ int disk; /* want disk geometry (ON/OFF) */ int warp; /* warped disk (ON/OFF) */ int plot; /* want lightcurve (ON/OFF) */ int visualize; /* want visualize (ON/OFF) */ int animate; /* want animated (ON/OFF) */ #ifdef _WITH_OPENGL int axes; /* want x-,y-, z-axis (ON/OFF) */ int movie; /* want jpeg movie (ON/OFF) */ int texture; /* want textures (ON/OFF) */ int textype; /* what kind of textures (IMAGE,TEMP)*/ int frame; /* number of jpeg frame */ int wireframe; /* want wire frame or solid rendering*/ int points; /* use POINTS instead of QUAD_STRIP */ int labels; /* want labels (ON/OFF) */ float GLdistancez; /* distance of observer in */ /* z-direction */ float GLdistancey; /* distance of observer in */ /* y-direction */ float GLdistancex; /* distance of observer in */ /* x-direction */ int use_opengl; /* really use it ? (ON/OFF) */ #endif int interactive; /* want interactive (ON/OFF) */ int fill; /* overfill roche lobe (ON/OFF) */ int lineprofile; /* want line profile (ON/OFF) */ int smap; /* want surface map (ON/OFF) */ int monochrome; /* want monochrome wavelen (ON/OFF) */ int limb; /* limb darkening method */ int reflect; /* reflection treatment */ int fractional; /* fractional visibility (ON/OFF) */ int blackbody; /* blackbody approximation (ON/OFF) */ int InEclipse1; /* we are in eclipse w/ Primary */ int InEclipse2; /* we are in eclipse w/ Secondary */ int asynchron1; /* Primary rotates asynchron */ int asynchron2; /* Secondary rotates asynchron */ int Spots1; /* num. of spots on primary */ int Spots2; /* num. of spots on secondary */ int elliptic; /* is eccentric orbit */ int first_pass; /* first pass in main_loop() */ long Passbands[NUM_MAG+2]; /* number of data read in passband N */ int PlotBand; /* which passband to plot ? */ int simplex[64]; /* parameter set to fit */ int WantFit; /* want to fit something (ON/OFF) */ float SimplexTol; /* how good is the fit ? */ float Step[2]; /* Stepsizes for Map */ int WantMap; /* we want to map chi square */ int anneal; /* do simulated annealing */ int eps; /* EPS plot */ int IsComputed; /* Lightcurve is computed */ int ProComputed; /* Profile is computed */ int parseCL; /* do we parse the command line */ int plotOpened; /* Gnuplot window opened */ int GN_exitconfirm; /* whether confirm exit */ int GN_rempos; /* whether remember position */ int GN_tooltips; /* whether have tooltips */ int GL; /* does the display support OpenGL */ char ConfFile[256]; /* configuration file */ int tdisk; /* disk temperature distribution */ } FlagsHandle; /* ----------------- The Orbit ------------------------------------- */ typedef struct OrbitStruct { char Name[MAX_CFG_INLINE+1]; /* system name */ double Inclination; /* orbit inclination */ double Omega; /* length of periastron */ double OmegaZero; /* passage of periastron */ double MQuad; /* start (quadrature) */ double Excentricity; /* excentricity of orbit */ double Nu; /* true anomaly */ double M; /* mean anomaly */ double E; /* excentric anomaly */ double MinDist; /* distance at periastron */ double Phase; /* the phase angle */ double Dist; /* the distance */ double TruePeriod; /* Period in seconds */ double TrueMass; /* Total mass in kg */ double TrueDistance; /* Periastron Dist in meter */ double LambdaZero; /* Wavelength for Profile */ int PhaseIndex; /* Where do we stand ? */ double Third[NUM_MAG]; /* Third Light */ } OrbitType; /* ----------------- Data Files ------------------------------------ */ typedef struct FileStruct { char DataFile[1024+MAX_CFG_INLINE+1]; int DataFormat; /*@null@*/ struct FileStruct *nextFile; } FileType; /*********************************/ /* one-argument macros */ /*********************************/ /* round a to nearest integer */ #define ROUND(a) (((a) >= FLT_EPSILON) ? (int)((a)+0.5) : -(int)(0.5-(a))) /* square a */ extern double GArgSquare; # define SQR(a) \ ( fabs(GArgSquare = (a)) <= FLT_EPSILON ? 0.0 : (GArgSquare*GArgSquare) ) /*********************************/ /* error handling */ /*********************************/ /* shout if something goes wrong */ #define WARNING(msg) \ {if (Flags.debug[VERBOSE] == ON || Flags.debug[WARN] == ON) \ fprintf(stderr, "**Warning**: %s \n", msg);} /* input error */ #define INERR(msg, input) \ {fprintf(stderr,"** Input Error **: %s \n (offending item: %s)\n .. exit to system\n",\ msg,input);\ exit(EXIT_FAILURE);} /* input error */ #define WARNERR(msg, input) \ {fprintf(stderr, "** Input Warning **: %s \n (offending item: %s)\n", msg, input);} /*********************************/ /* two-argument macros */ /*********************************/ /* find minimum of a and b */ #undef MIN #define MIN(a,b) ( ( (a)-(b) <= FLT_EPSILON ) ? (a) : (b)) /* find minimum of a and b */ #undef IMIN #define IMIN(a,b) ( ( (a)<(b) ) ? (a) : (b)) /* find maximum of a and b */ #undef MAX #define MAX(a,b) ( ( (a)-(b) >= FLT_EPSILON ) ? (a) : (b)) /* find maximum of a and b */ #undef IMAX #define IMAX(a,b) ( ( (a)>(b) ) ? (a) : (b)) /* Ensures that x is between the limits set by low and high */ #undef CLAMP #define CLAMP(x, low, high) \ (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x))) /*********************************/ /* useful constants */ /*********************************/ #ifndef PI #define PI 3.14159265358979323846 #endif #ifndef LN10 #define LN10 2.30258509299404568402 /* ln 10; 10eX = exp(ln10*X) */ #endif #ifndef DTOR #define DTOR 0.01745329251994329547 /* radian = degree * DTOR */ #endif #ifndef RTOD #define RTOD 57.2957795130823228646 /* degree = radian * RTOD */ #endif #define ON 1 #define OFF 0 /* Surface identifier for the disk */ #define TOP_SEGMENT 1 #define OUT_RECTANGLE 2 #define BOTTOM_SEGMENT 3 #define IN_RECTANGLE 4 #define EclipsedByPrimary 1 #define EclipsedBySecondary 2 #define EclipsedByDisk 3 /* illuminated/non-illuminated part of stellar surface */ #define BACKSIDE 1 #define FRONTSIDE (-1) /*****************************************************/ /* */ /* PROTOTYPES */ /* */ /*****************************************************/ /* ---------------- the gui --------------- */ #ifdef _WITH_GTK /* main GTK program */ int the_gui(int argc, char *argv[]); #endif /* ------- temperature distribution --------------- */ /* compute detailed reflection */ void LightReflect(); /* simple reflection treatment */ void SimpleReflect(int Comp); /* Compute Gravitation Darkening, Albedo */ void ComputeGravDark(); /* put spots on surface */ void MakeSpots(int Component, int phasestep); /* ------- flux computation ----------------------- */ /* Get a set of monochromatic wavelenghts from the */ /* environment */ int DefineMonoWavelengths (); /* compute temperature-dependent effective */ /* wavelengths for blackbody */ void EffectiveWavelength(int Comp); /* Compute limb darkening coeff - filter dependedent */ void LightLimbDark(int Comp); /* flux in blackbody approximation */ void BlackbodyFlux(int Comp); /* flux with atmospheric model */ void ModelFlux(int Comp); /* limits for Kurucz models */ float ModelLimits(float log_g); /* flux computing - filter dependent */ void LightFlux(int Comp, int Phase_index); /* normalize the output flux */ void NormalizeFlux(); /* Initialize Output flux tables - filter dependent */ void InitOutFlux(); /* normalize the output flux */ void SetNormalPhase (int band, float phase); /* reset normalization point */ void ResetNormalPhaseOne (int band); /* reset all normalization points */ void ResetNormalPhase (); /* copy flux to L90 array */ void LightLuminosity(int component, int phaseindex); /* ------ simplex fit algorithm ------------------- */ /* the downhill simplex code */ int Simplex(); /* morph Simplex */ double SimplexFlow(double Factor, double M[][SDIM], double Y[], double M_Sum[], int Worst, int FitDim, int *ErrCode); /* Initialize the ranges */ void SimplexInitRanges(); /* Initialize the Simplex */ int SimplexInit(double Y[], double M[][SDIM]); /* set the global variables */ void SimplexSetVariables(double x[]); /* check the Vertex */ int SimplexCheckVertex(double X[]); /* print fit result the global variables */ void SimplexPrintVariables(double Chi, double VarChiSquare); /* simulated annealing */ float SaAnneal(double tscale, double t0, double X[], double *Y_Best, double BestEver[], double *BestChi); /* Map Chi Square */ int ChiMap(); /* ------ main ----------------------------------- */ /* initialize flags and variables */ void InitFlags(); /* Print Usage Info */ void UsageInfo(); /* Get The Command Line Arguments */ void GetArguments(int *argc, char *argv[]); /* Here we set up the Stars, do the Lightcurve, */ /* and return the Merit */ int MainLoop(/*@out@*/ double *Merit); /* radial velocity curve */ void RadVel(int Phase_Index); /* ------ statistics ----------------------------- */ /* compute the merit function - we use ChiSquare */ /* globally over all input data */ double MeritFunction (); /* perform runs test on fit residuals, return number */ /* of runs, upper and lower 5 percent limit */ void Runs(Photo3 *data, long NumData, int *Runs, int *UpLim, int *LowLim); /* -------- Input/Output --------------------------- */ /* wrapper function to do printing */ void my_cpgend(); /* Get data file path */ char * data_data_fls(); /* Get cfg file path */ char * data_cfg_fls(); /* Get doc file path */ char * data_doc_fls(); /* Get pixmap file path */ char * data_pix_fls(); /* parse the config file */ void ParseConfig(const char *InputFile, int *numarg); /* write header of output file */ void OutfileHeader(FILE *file_out); /* read a single line from an open file */ int LireLigne(char *s, int lim, FILE *fpe); /* read from input data file */ void Read(const char InputFile[]); /* visualize geometry */ void PlotGeometry(); /* Write Output flux tables - filter dependent */ void WriteOutput(); /* Plot Output flux tables - filter dependent */ void PlotOutput(); /* animated plot */ void Animate(int j); /* set PGPLOT window size */ void SetPgplotWindow(); /* --------- Eclipse verification, Visibility ----- */ /* attach the throat of star a to star b */ void LightCopyThroat(); /* copy the throat back */ void LightCopyThroatBack(); /* Calculate various quantities for simple */ /* geometric tests */ int LightSetupTests(); /* Eclipse Verification for stars */ void LightCurve(int Phase_index); /* Eclipse Verification for disk */ void LightCurveDisk(int j); void eclipsedbydisk(double lzero2, double mzero2, double nzero2, long Diskelements, int Comp, SurfaceElement *SurfPtrD, int *eclipsed); /* Fractional Visibility */ void LightFractionalPot(int Component); /* -------- Functions ----------------------------- */ /* find minimum of potential along LOS */ int MinFinder(double *q, double *f, double *t1, double *t3, double *l0, double *m0, double *n0, double *x0, double *y0, double *z0, double *tmin, /*@out@*/ double *Cmin); /* find root of Function in [low,high] w/ tolerance */ double RootFind(double (*Function)(double), const double Low, const double Up, const double Tolerance, const char *caller, int *Err); /* Zero at LagrangeOne */ double LagrangeOne(double x); /* Zero at LagrangeTwo */ double LagrangeTwo(double x); /* Zero at LagrangeThree */ double LagrangeThree(double x); /* Potential in X-Y Plane */ double RocheXYPrimary(double x, double y, double q, double f); /* Potential */ double RocheSurface(double x); /* Potential */ double RocheYPerpendL1(double y); /* Potential */ double RocheZPerpendL1(double z); /* Potential */ double RochePerpendSecond(double z); /* find the phase of periastron */ void FindPeriastron(); /* solve kepler equation */ void SolveKepler(int j); /* shift phase to correct interval */ void PhaseShift(); /* analytic polar radius */ double PolRad(double q, double r); /* returns (volume-scaledvolume) as function of r */ /* zero if r = RadMean(ScaledVolume) */ double VolOfR(double r); /* copies PhotoPoint b to a */ void V2CopyPhoto(/*@out@*/ Photo3 *a, Photo3 *b); /* Sort in ascending order in phi w/ */ /* Heapsort Algorithm */ /* D.E. Knuth, Sorting and Searching, 1973 */ /* contrary to Quicksort, this is guaranteed to be */ /* always of order NlogN, even in worst case */ void SortPhotoPoints(long n, Photo3 *seq); /* --------- Surface Definition ------------------- */ /* Define Dimensionless System Parameters */ /* -- Overcontact */ int DefineParamOver(); /* Define Dimensionless System Parameters */ int DefineParam(int n); /* Define Dimensionless System Parameters for disk */ int DefineParamDisk(); /* Surface Division - filter dependent */ int DivideSurface(int Comp); /* Disk Surface Division - filter dependent */ /* MK 14.03.01 */ int DivideDisk(int Comp); /* update radius and potential */ int UpdateGeometry(int n); /* --------- Surface Map ------------------- */ /* set base path */ int SetMapPath (); /* set passband */ void SetMapBand (); /* print map */ void PrintSurfaceMap (int thisPhaseStep); /* --------- Utilities ------------------- */ /* error handler */ void /*@exits@*/ nf_error(char error_text[]); /* allocate a matrix */ /*@only@*/ /*@null@*/ /*@out@*/ float **matrix(long nrh, long nch); /* convert to lowercase */ void nf_strlwr(char * instring); /* clear data file list */ void ClearList(); /* add to data file list */ void AddToList(const char * item, int Format); /* determine the locale */ const char *guess_the_locale (); /* Set user-defined albedo value(s) */ void SetAlbedo (int Comp, const char * str); /**************************************************************************/ /* */ /* GLOBAL VARIABLES */ /* */ /**************************************************************************/ #if 0 extern char * program_invocation_name; #endif /* ----------- Error Messages ---------------------------------------- */ extern char *errmsg[23]; /* ----------- Flags ------------------------------------------------- */ extern FlagsHandle Flags; /* ----------- Flux ------------------------------------------------- */ extern /*@out@*/ PhotoOut *FluxOut; extern double L90[3][NUM_MAG]; /* Luminosities */ extern double F90[NUM_MAG]; /* Normalization Variable */ extern double P90[NUM_MAG]; /* Normalization Phase */ extern int Umag, Bmag, Vmag; extern int umag, bmag, vmag, ymag; extern int Rmag, Imag; extern int Jmag, Hmag, Kmag; extern int mag1, mag2; extern char Filters[NUM_MAG+2][24]; /* the names */ /* -----------limb darkening coefficients ------------------------------ */ extern double Limb[3][NUM_MAG][2]; /* component, passband, number */ extern double WaveL[3][NUM_MAG]; /* wavelengths */ extern float mono_zero[NUM_MAG]; /* monochromatic wavelengths */ /* ----------- Input File(s) -------------------------------------------- */ extern Photo3 *Observed[NUM_MAG+2]; extern /*@null@*/ FileType *FileList; /* ----------- Components ----------------------------------------------- */ extern const int Primary; /* literal definition */ extern const int Secondary; /* literal definition */ extern const int Disk; /* literal definition */ #ifdef HAVE_DISK #define NUM_COMP 3 #else #define NUM_COMP 2 #endif extern BinaryComponent Binary[NUM_COMP]; extern SurfaceElement *Surface[NUM_COMP]; /* stars+disk */ extern SpotLight *Spot[2]; /* surface spots */ extern OrbitType Orbit; /* orbit details */ /* ---------- line profile --------------------------------------------- */ extern /*@out@*/ float /* **ProData; */ ProData[PHASESTEPS][PROFILE_ARRAY+1]; /* ---------- misc ---------------------------------------------------- */ extern char Out_Plot_File[256]; /* output plot file */ extern int StepsPerPi; /* No of steps per Pi */ extern double MaximumElements; /* max. no of surface elements*/ extern int PhaseSteps; /* phasesteps for lightcurve */ /* --- These are Global Variables that are used (mainly) to pass ------- */ /* --- Arguments to Functions that are called by RootFind/MinFind ------ */ extern double Mq; /* mass ratio */ extern double F; /* nonsync rotation */ extern double RochePot; /* Roche Potential */ extern double PhaseScaledVolume; /* scaled volume */ extern double lambda, mu, nu; /* Coordinates */ /**************************************************************************/ /* */ /* INCLUDES */ /* */ /**************************************************************************/ #ifndef HAVE_MKFIFO #ifdef _WITH_GNUPLOT #undef _WITH_GNUPLOT #undef _WITH_PGPLOT #endif #endif #ifndef HAVE_UNISTD_H #ifdef _WITH_GNUPLOT #undef _WITH_GNUPLOT #undef _WITH_PGPLOT #endif #endif /* include limits for parameters */ #include "LightLimits.h" /* ---------- MPI ---------------------------------------------------- */ /* include header for MPI */ #if defined(_WITH_MPI_COARSE) void NF_Mpi_distribute (); void NF_Mpi_collect (); #endif #if defined(_WITH_MPI) || defined(_WITH_MPI_COARSE) #include "mpi.h" #define NF_MPI_DEBUG #define NF_MSG_TAG 42 #else #define MPI_MAX_PROCESSOR_NAME 256 #define MPI_MAX_ERROR_STRING 512 #define MPI_COMM_WORLD 0 /* dummy functions */ #define MPI_Abort(a, b) #define MPI_Finalize() #endif #define NF_TAG_END 1 #define NF_TAG_MAINLOOP 4 extern int myrank; extern int numprocs; extern char processor_name[MPI_MAX_PROCESSOR_NAME]; extern char error_name[MPI_MAX_ERROR_STRING]; void NF_Mpi_call(int tag); void NF_Mpi_endcall(); void NF_MPI_Abort(); /* ---------- MPI END ------------------------------------------------- */ /* include header for PGPLOT emulation */ #ifdef _WITH_GNUPLOT #include "LightPGemulate.h" #endif /* include header for GUI, also included by gnome.h */ #ifdef _WITH_GTK #ifdef HAVE_GNOME #include #else #include #endif #include "LightGtk.h" #ifdef _WITH_OPENGL /* need to #undef this because /usr/include/jconfig.h * defines HAVE_STDDEF_H (which is plain stupid IMHO) */ #undef HAVE_STDDEF_H #include "LightGL.h" #endif #endif /* end include header for GUI */ /* i18n, this stuff is already included by gnome.h */ #ifndef HAVE_GNOME #include "gettext.h" #ifdef ENABLE_NLS /* #include */ #define _(string) gettext (string) #ifdef gettext_noop #define N_(string) gettext_noop (string) #else #define N_(String) (String) #endif #else #define _(string) string #define N_(string) string #endif /* #ifndef HAVE_GNOME */ #endif /* end i18n */