swe4r 0.0.0

data/ext/swe4r/swehel.c

@@ -0,0 +1,3445 @@
+/* SWISSEPH 
+ $Header: /home/dieter/sweph/RCS/swehel.c,v 1.1 2009/04/21 06:05:59 dieter Exp dieter $
+
+  Heliacal risings and related calculations
+  
+  Author: Victor Reijs
+  This program code is a translation of part of:
+  Victor Reijs' software ARCHAEOCOSMO (archaeoastronomy and
+  geodesy functions), 
+  http://www.iol.ie/~geniet/eng/archaeocosmoprocedures.htm
+
+  Translation from VB into C by Dieter Koch
+
+  Problem reports can be sent to victor.reijs@gmail.com or dieter@astro.ch
+  
+  Copyright (c) Victor Reijs, 2008
+
+  License conditions
+  ------------------
+
+  This file is part of Swiss Ephemeris.
+
+  Swiss Ephemeris is distributed with NO WARRANTY OF ANY KIND.  No author
+  or distributor accepts any responsibility for the consequences of using it,
+  or for whether it serves any particular purpose or works at all, unless he
+  or she says so in writing.  
+
+  Swiss Ephemeris is made available by its authors under a dual licensing
+  system. The software developer, who uses any part of Swiss Ephemeris
+  in his or her software, must choose between one of the two license models,
+  which are
+  a) GNU public license version 2 or later
+  b) Swiss Ephemeris Professional License
+
+  The choice must be made before the software developer distributes software
+  containing parts of Swiss Ephemeris to others, and before any public
+  service using the developed software is activated.
+
+  If the developer choses the GNU GPL software license, he or she must fulfill
+  the conditions of that license, which includes the obligation to place his
+  or her whole software project under the GNU GPL or a compatible license.
+  See http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+
+  If the developer choses the Swiss Ephemeris Professional license,
+  he must follow the instructions as found in http://www.astro.com/swisseph/ 
+  and purchase the Swiss Ephemeris Professional Edition from Astrodienst
+  and sign the corresponding license contract.
+
+  The License grants you the right to use, copy, modify and redistribute
+  Swiss Ephemeris, but only under certain conditions described in the License.
+  Among other things, the License requires that the copyright notices and
+  this notice be preserved on all copies.
+
+  The authors of Swiss Ephemeris have no control or influence over any of
+  the derived works, i.e. over software or services created by other
+  programmers which use Swiss Ephemeris functions.
+
+  The names of the authors or of the copyright holder must not
+  be used for promoting any software, product or service which uses or contains
+  the Swiss Ephemeris. This copyright notice is the ONLY place where the
+  names of the authors can legally appear, except in cases where they have
+  given special permission in writing.
+
+  The trademarks 'Swiss Ephemeris' and 'Swiss Ephemeris inside' may be used
+  for promoting such software, products or services.
+*/
+
+#include "swephexp.h"
+#include "sweph.h"
+#include "swephlib.h"
+#include <sys/stat.h>
+
+#define PLSV   0 /*if Planet, Lunar and Stellar Visibility formula is needed PLSV=1*/
+#define criticalangle   0.0 /*[deg]*/
+#define BNIGHT   	1479.0 /*[nL]*/
+#define BNIGHT_FACTOR   1.0
+#define PI		M_PI
+#define Min2Deg   (1.0 / 60.0)
+#define DEBUG  0
+#define DONE  1
+#define MaxTryHours   4 
+#define TimeStepDefault	1
+#define LocalMinStep	8
+
+/* time constants */
+#define Y2D   365.25 /*[Day]*/
+#define D2Y   (1 / Y2D) /*[Year]*/
+#define D2H   24.0 /*[Hour]*/
+#define H2S   3600.0 /*[sec]*/
+#define D2S   (D2H * H2S) /*[sec]*/
+#define S2H   (1.0 / H2S) /*[Hour]*/
+#define JC2D   36525.0 /*[Day]*/
+#define M2S   60.0 /*[sec]*/
+
+/* Determines which algorimths are used*/
+#define USE_DELTA_T_VR 	 0
+#define REFR_SINCLAIR    0
+#define REFR_BENNETTH    1
+#define FormAstroRefrac   REFR_SINCLAIR /*for Astronomical refraction can be "bennetth" or "sinclair"*/
+#define GravitySource   2 /*0=RGO, 1=Wikipedia,2=Exp. Suppl. 1992,3=van der Werf*/
+#define REarthSource   1 /*0=RGO (constant), 1=WGS84 method*/
+
+#define StartYear   1820 /*[year]*/
+#define Average   1.80546834626888 /*[msec/cy]*/
+#define Periodicy   1443.67123144531 /*[year]*/
+#define Amplitude   3.75606495492684 /*[msec]*/
+#define phase   0 /*[deg]*/
+#define MAX_COUNT_SYNPER           5  /* search within 10 synodic periods */
+#define MAX_COUNT_SYNPER_MAX 1000000  /* high, so there is not max count */
+#define AvgRadiusMoon  (15.541 / 60) /* '[Deg] at 2007 CE or BCE*/
+
+/* WGS84 ellipsoid constants
+ * http://w3sli.wcape.gov.za/Surveys/Mapping/wgs84.htm*/
+#define Ra   6378136.6   /*'[m]*/
+#define Rb   6356752.314 /*'[m]*/
+
+/* choices in Schaefer's model */
+#define nL2erg 	(1.02E-15)
+#define erg2nL 	(1 / nL2erg) /*erg2nL to nLambert*/
+#define MoonDistance 	384410.4978 /*[km]*/
+#define scaleHwater 	3000.0 /*[m] Ricchiazzi [1997] 8200 Schaefer [2000]*/
+#define scaleHrayleigh 	8515.0 /*[m] Su [2003] 8200 Schaefer [2000]*/
+#define scaleHaerosol 	3745.0 /*m Su [2003] 1500 Schaefer [2000]*/
+#define scaleHozone 	20000.0 /*[m] Schaefer [2000]*/
+#define astr2tau 	0.921034037197618  /*LN(10 ^ 0.4)*/
+#define tau2astr 	1 / astr2tau
+
+/* meteorological constants*/
+#define C2K   273.15 /*[K]*/
+#define DELTA   18.36
+#define TempNulDiff   0.000001
+#define PressRef   1000 /*[mbar]*/
+#define MD   28.964 /*[kg] Mol weight of dry air van der Werf*/
+#define MW   18.016 /*[kg] Mol weight of water vapor*/
+#define GCR   8314.472 /*[L/kmol/K] van der Werf*/
+#define LapseSA   0.0065 /*[K/m] standard atmosphere*/
+#define LapseDA   0.0098 /*[K/m] dry adiabatic*/
+
+/* lowest apparent altitude to provide*/
+#define LowestAppAlt   -3.5 /*[Deg]*/
+
+/*optimization delta*/
+#define epsilon   0.001
+/* for Airmass usage*/
+#define staticAirmass   0 /* use staticAirmass=1 instead depending on difference k's*/
+
+/* optic stuff */
+#define GOpticMag   1 /*telescope magnification*/
+#define GOpticTrans   0.8 /*telescope transmission*/
+#define GBinocular   1 /*1-binocular 0=monocular*/
+#define GOpticDia   50 /*telescope diameter [mm]*/
+
+static double mymin(double a, double b)
+{
+  if (a <= b)
+    return a;
+  return b;
+}
+
+static double mymax(double a, double b)
+{
+  if (a >= b)
+    return a;
+  return b;
+}
+
+/*###################################################################*/
+static double Tanh(double x)
+{
+  return (exp(x) - exp(-x)) / (exp(x) + exp(-x));
+}
+
+/*
+' B [nL]
+' SN [-]
+' CVA [deg]
+*/
+static double CVA(double B, double SN)
+{
+  /*Schaefer, Astronomy and the limits of vision, Archaeoastronomy, 1993*/
+  if (B > BNIGHT)
+    return (40.0 / SN) * pow(10, (8.28 * pow(B, (-0.29)))) / 60.0 / 60.0;
+  else
+    return mymin(900, 380 / SN * pow(10, (0.3 * pow(B, (-0.29))))) / 60.0 / 60.0;
+}
+
+/*
+' age [year]
+' B [nL]
+' PupilDia [mm]
+*/
+static double PupilDia(double Age, double B)
+{
+  /* age dependancy from Garstang [2000]*/
+  return (0.534 - 0.00211 * Age - (0.236 - 0.00127 * Age) * Tanh(0.4 * log(B) / log(10) - 2.2)) * 10;
+}
+
+/*
+'Input
+' Bback [nL]
+' kX [-]
+' Binocular [-]
+' OpticMag [-]
+' OpticDia [mm]
+' OpticTrans [-]
+' JDNDaysUT [JDN]
+' Age [Year]
+' SN [-]
+' ObjectName
+' TypeFactor [0=itensity factor 1=background factor]
+'Output
+' OpticFactor [-]
+*/
+static double OpticFactor(double Bback, double kX, double *dobs, double JDNDaysUT, char *ObjectName, int TypeFactor, int helflag)
+{
+  double Pst, CIb, CIi, ObjectSize, Fb, Fe, Fsc, Fci, Fcb, Ft, Fp, Fa, Fr, Fm;
+  double Age = dobs[0];
+  double SN = dobs[1], SNi;
+  double Binocular = dobs[2];
+  double OpticMag = dobs[3];
+  double OpticDia = dobs[4];
+  double OpticTrans = dobs[5];
+  SNi = SN;
+  if (SNi <= 0.00000001) SNi = 0.00000001;
+  /* 23 jaar as standard from Garstang*/
+  Pst = PupilDia(23, Bback);
+  if (OpticMag == 1) { /*OpticMagn=1 means using eye*/
+     OpticTrans = 1;
+     OpticDia = Pst;
+  }
+#if 0 /*is done in default_heliacal_parameters()*/
+  if (OpticMag == 0) { /*OpticMagn=0 (undefined) using eye*/
+    OpticTrans = 1;
+    OpticDia = Pst;
+    Binocular = 1;
+    OpticMag = 1;
+  }
+#endif
+  /* Schaefer, Astronomy and the limits of vision, Archaeoastronomy, 1993*/
+  CIb = 0.7; /* color of background (from Ben Sugerman)*/
+  CIi = 0.5; /* Color index for white (from Ben Sugerman), should be function of ObjectName*/
+  ObjectSize = 0;
+  if (strcmp(ObjectName, "moon") == 0) {
+    /*ObjectSize and CI needs to be determined (depending on JDNDaysUT)*/
+    ;
+  }
+  Fb = 1;
+  if (Binocular == 0) Fb = 1.41;
+  if (Bback < BNIGHT && !(helflag & SE_HELFLAG_VISLIM_PHOTOPIC)) {
+    Fe = pow(10, (0.48 * kX));
+    Fsc = mymin(1, (1 - pow(Pst / 124.4, 4)) / (1 - pow((OpticDia / OpticMag / 124.4), 4)));
+    Fci = pow(10, (-0.4 * (1 - CIi / 2.0)));
+    Fcb = pow(10, (-0.4 * (1 - CIb / 2.0)));
+  } else {
+     Fe = pow(10, (0.4 * kX));
+     Fsc = mymin(1, pow((OpticDia / OpticMag / Pst), 2) * (1 - exp(-pow((Pst / 6.2), 2))) / (1 - exp(-pow((OpticDia / OpticMag / 6.2), 2))));
+     Fci = 1;
+     Fcb = 1;
+  }
+  Ft = 1 / OpticTrans;
+  Fp = mymax(1, pow((Pst / (OpticMag * PupilDia(Age, Bback))), 2));
+  Fa = pow((Pst / OpticDia), 2);
+  Fr = (1 + 0.03 * pow((OpticMag * ObjectSize / CVA(Bback, SNi)), 2)) / pow(SNi, 2);
+  Fm = pow(OpticMag, 2);
+#if DEBUG
+  fprintf(stderr, "Pst=%f\n", Pst);
+  fprintf(stderr, "Fb =%f\n", Fb);
+  fprintf(stderr, "Fe =%f\n", Fe);
+  fprintf(stderr, "Ft =%f\n", Ft);
+  fprintf(stderr, "Fp =%f\n", Fp);
+  fprintf(stderr, "Fa =%f\n", Fa);
+  fprintf(stderr, "Fm =%f\n", Fm);
+  fprintf(stderr, "Fsc=%f\n", Fsc);
+  fprintf(stderr, "Fci=%f\n", Fci);
+  fprintf(stderr, "Fcb=%f\n", Fcb);
+  fprintf(stderr, "Fr =%f\n", Fr );
+#endif
+  if (TypeFactor == 0) 
+    return Fb * Fe * Ft * Fp * Fa * Fr * Fsc * Fci;
+  else
+    return Fb * Ft * Fp * Fa * Fm * Fsc * Fcb;
+}
+
+/*###################################################################
+*/
+static int32 DeterObject(char *ObjectName)
+{
+  char s[AS_MAXCH];
+  char *sp;
+  int32 ipl;
+  strcpy(s, ObjectName);
+  for (sp = s; *sp != '\0'; sp++)
+    *sp = tolower(*sp);
+  if (strncmp(s, "sun", 3) == 0)
+    return SE_SUN;
+  if (strncmp(s, "venus", 5) == 0)
+    return SE_VENUS;
+  if (strncmp(s, "mars", 4) == 0)
+    return SE_MARS;
+  if (strncmp(s, "mercur", 6) == 0)
+    return SE_MERCURY;
+  if (strncmp(s, "jupiter", 7) == 0)
+    return SE_JUPITER;
+  if (strncmp(s, "saturn", 6) == 0)
+    return SE_SATURN;
+  if (strncmp(s, "uranus", 6) == 0)
+    return SE_URANUS;
+  if (strncmp(s, "neptun", 6) == 0)
+    return SE_NEPTUNE;
+  if (strncmp(s, "moon", 4) == 0)
+    return SE_MOON;
+  if ((ipl = atoi(s)) > 0) {
+    ipl += SE_AST_OFFSET;
+    return ipl;
+  }
+  return -1;
+}
+
+#if 0
+int32 call_swe_calc(double tjd, int32 ipl, int32 iflag, double *x, char *serr) 
+{
+  int32 retval = OK, ipli, i;
+  double dtjd;
+  static double tjdsv[3];
+  static double xsv[3][6];
+  static int32 iflagsv[3];
+  ipli = ipl;
+  if (ipli > SE_MOON) 
+    ipli = 2;
+  dtjd = tjd - tjdsv[ipli];
+  if (tjdsv[ipli] != 0 && iflag == iflagsv[ipli] && fabs(dtjd) < 5.0 / 1440.0) {
+    for (i = 0; i < 3; i++) 
+      x[i] = xsv[ipli][i] + dtjd * xsv[ipli][i+3];
+    for (i = 3; i < 6; i++) 
+      x[i] = xsv[ipli][i];
+  } else {
+    retval = swe_calc(tjd, ipl, iflag, x, serr);
+    tjdsv[ipli] = tjd;
+    iflagsv[ipli] = iflag;
+    for (i = 0; i < 6; i++) 
+      xsv[ipli][i] = x[i];
+  }
+  return retval;
+}
+#endif
+
+/* avoids problems with star name string that may be overwritten by 
+   swe_fixstar() */
+int32 call_swe_fixstar(char *star, double tjd, int32 iflag, double *xx, char *serr)
+{
+  int32 retval;
+  char star2[AS_MAXCH];
+  strcpy(star2, star);
+  retval =  swe_fixstar(star2, tjd, iflag, xx, serr);
+  return retval;
+}
+
+/* avoids problems with star name string that may be overwritten by 
+   swe_fixstar_mag() */
+int32 call_swe_fixstar_mag(char *star, double *mag, char *serr)
+{
+  int32 retval;
+  char star2[AS_MAXCH];
+  static double dmag;
+  static char star_save[AS_MAXCH];
+  if (strcmp(star, star_save) == 0) {
+    *mag = dmag;
+    return OK;
+  }
+  strcpy(star_save, star);
+  strcpy(star2, star);
+  retval = swe_fixstar_mag(star2, &dmag, serr);
+  *mag = dmag;
+  return retval;
+}
+
+/* avoids problems with star name string that may be overwritten by 
+   swe_fixstar() */
+int32 call_swe_rise_trans(double tjd, int32 ipl, char *star, int32 helflag, int32 eventtype, double *dgeo, double atpress, double attemp, double *tret, char *serr)
+{
+  int32 retval;
+  int32 iflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  char star2[AS_MAXCH];
+  strcpy(star2, star);
+  retval = swe_rise_trans(tjd, ipl, star2, iflag, eventtype, dgeo, atpress, attemp, tret, serr);
+  return retval;
+}
+
+/* 
+ * Written by Dieter Koch:
+ * Fast function for risings and settings of planets, can be used instead of 
+ * swe_rise_trans(), which is much slower.
+ * For circumpolar and near-circumpolar planets use swe_rise_trans(), or 
+ * generally use it for geographical latitudes higher than 58N/S.
+ * For fixed stars, swe_rise_trans() is fast enough.
+ */
+static int32 calc_rise_and_set(double tjd_start, int32 ipl, double *dgeo, double *datm, int32 eventflag, int32 helflag, double *trise, char *serr)
+{
+  int retc = OK, i;
+  double sda, xs[6], xx[6], xaz[6], xaz2[6], dfac = 1/365.25;
+  double rdi, rh;
+  double tjd0 = tjd_start, tjdrise;
+  double tjdnoon = (int) tjd0 - dgeo[0] / 15.0 / 24.0;
+  int32 iflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  iflag |= SEFLG_EQUATORIAL;
+  if (!(helflag & SE_HELFLAG_HIGH_PRECISION)) 
+    iflag |= SEFLG_NONUT|SEFLG_TRUEPOS;
+  if (swe_calc_ut(tjd0, SE_SUN, iflag, xs, serr) == 0) {
+    if (serr != NULL)
+      strcpy(serr, "error in calc_rise_and_set(): calc(sun) failed ");
+    return ERR;
+  }
+  if (swe_calc_ut(tjd0, ipl, iflag, xx, serr) == 0) {
+    if (serr != NULL)
+      strcpy(serr, "error in calc_rise_and_set(): calc(sun) failed ");
+    return ERR;
+  }
+  tjdnoon -= swe_degnorm(xs[0] - xx[0])/360.0 + 0;
+  /* is planet above horizon or below? */
+  swe_azalt(tjd0, SE_EQU2HOR, dgeo, datm[0], datm[1], xx, xaz);
+if (eventflag & SE_CALC_RISE) {
+  if (xaz[2] > 0) {
+    while (tjdnoon - tjd0 < 0.5) {/*printf("e");*/tjdnoon += 1;}
+    while (tjdnoon - tjd0 > 1.5) {/*printf("f");*/tjdnoon -= 1;}
+  } else {
+    while (tjdnoon - tjd0 < 0.0) {/*printf("g");*/tjdnoon += 1;}
+    while (tjdnoon - tjd0 > 1.0) {/*printf("h");*/tjdnoon -= 1;}
+  }
+} else {
+  if (xaz[2] > 0) {
+    while (tjd0 - tjdnoon > 0.5) {/*printf("a");*/ tjdnoon += 1;}
+    while (tjd0 - tjdnoon < -0.5) {/*printf("b");*/ tjdnoon -= 1;}
+  } else {
+    while (tjd0 - tjdnoon > 0.0) {/*printf("c");*/ tjdnoon += 1;}
+    while (tjd0 - tjdnoon < -1.0) {/*printf("d");*/ tjdnoon -= 1;}
+  }
+}
+  /* position of planet */
+  if (swe_calc_ut(tjdnoon, ipl, iflag, xx, serr) == ERR) {
+    if (serr != NULL)
+      strcpy(serr, "error in calc_rise_and_set(): calc(sun) failed ");
+    return ERR;
+  }
+  /* apparent radius of solar disk (ignoring refraction) */
+  rdi = asin(696000000.0 / 1.49597870691e+11 / xx[2]) / DEGTORAD;
+  if (eventflag & SE_BIT_DISC_CENTER)
+    rdi = 0;
+  /* true altitude of sun, when it appears at the horizon */
+  /* refraction for a body visible at the horizon at 0m above sea,
+   * atmospheric temperature 10 deg C, atmospheric pressure 1013.25 is 34.5 arcmin*/
+  rh = -(34.5 / 60.0 + rdi);
+  /* semidiurnal arc of sun */
+  sda = acos(-tan(dgeo[1] * DEGTORAD) * tan(xx[1] * DEGTORAD)) * RADTODEG;
+  /* rough rising and setting times */
+if (eventflag & SE_CALC_RISE)
+  tjdrise = tjdnoon - sda / 360.0;
+else
+  tjdrise = tjdnoon + sda / 360.0;
+  /*ph->tset = tjd_start + sda / 360.0;*/
+  /* now calculate more accurate rising and setting times.
+   * use vertical speed in order to determine crossing of the horizon  
+   * refraction of 34' and solar disk diameter of 16' = 50' = 0.84 deg */
+  iflag = SEFLG_SPEED|SEFLG_EQUATORIAL;
+  if (ipl == SE_MOON)
+    iflag |= SEFLG_TOPOCTR;
+  if (!(helflag & SE_HELFLAG_HIGH_PRECISION)) 
+    iflag |= SEFLG_NONUT|SEFLG_TRUEPOS;
+  for (i = 0; i < 2; i++) {
+    if (swe_calc_ut(tjdrise, ipl, iflag, xx, serr) == ERR) 
+      return ERR;
+    swe_azalt(tjdrise, SE_EQU2HOR, dgeo, datm[0], datm[1], xx, xaz);
+    xx[0] -= xx[3] * dfac; 
+    xx[1] -= xx[4] * dfac;
+    swe_azalt(tjdrise - dfac, SE_EQU2HOR, dgeo, datm[0], datm[1], xx, xaz2);
+    tjdrise -= (xaz[1] - rh) / (xaz[1] - xaz2[1]) *  dfac;
+    /*fprintf(stderr, "%f\n", ph->trise);*/
+  }
+  *trise = tjdrise;
+  return retc;
+}
+
+static int32 my_rise_trans(double tjd, int32 ipl, char* starname, int32 eventtype, int32 helflag, double *dgeo, double *datm, double *tret, char *serr)
+{
+  int retc = OK;
+  if (starname != NULL && *starname != '\0')
+    ipl = DeterObject(starname);
+  /* for non-circumpolar planets we can use a faster algorithm */
+  /*if (!(helflag & SE_HELFLAG_HIGH_PRECISION) && ipl != -1 && fabs(dgeo[1]) < 58) {*/
+  if (ipl != -1 && fabs(dgeo[1]) < 63) {
+    retc = calc_rise_and_set(tjd, ipl, dgeo, datm, eventtype, helflag, tret, serr);
+  /* for stars and circumpolar planets we use a rigorous algorithm */
+  } else {
+    retc = call_swe_rise_trans(tjd, ipl, starname, helflag, eventtype, dgeo, datm[0], datm[1], tret, serr);
+  }
+/*  printf("%f, %f\n", tjd, *tret);*/
+  return retc;
+}
+
+/*###################################################################
+' JDNDaysUT [Days]
+' dgeo [array: longitude, latitude, eye height above sea m]
+' TempE [C]
+' PresE [mbar]
+' ObjectName (string)
+' RSEvent (1=rise, 2=set,3=up transit,4=down transit)
+' Rim [0=center,1=top]
+' RiseSet [Day]
+*/
+static int32 RiseSet(double JDNDaysUT, double *dgeo, double *datm, char *ObjectName, int32 RSEvent, int32 helflag, int32 Rim, double *tret, char *serr)
+{
+  int32 eventtype = RSEvent, Planet, retval;
+  if (Rim == 0)
+    eventtype |= SE_BIT_DISC_CENTER;
+  Planet = DeterObject(ObjectName);
+  if (Planet != -1)
+    retval = my_rise_trans(JDNDaysUT, Planet, "", eventtype, helflag, dgeo, datm, tret, serr);
+  else
+    retval = my_rise_trans(JDNDaysUT, -1, ObjectName, eventtype, helflag, dgeo, datm, tret, serr);
+  return retval;
+}
+
+/*###################################################################
+' JDNDaysUT [Days]
+' actual [0= approximation, 1=actual]
+' SunRA [deg]
+*/
+static double SunRA(double JDNDaysUT, int32 helflag, char *serr)
+{
+  double tjd_tt;
+  int imon, iday, iyar, calflag = SE_GREG_CAL;
+  double dut;
+  static double tjdlast;
+  static double ralast;
+  tjd_tt = 0; 
+  if (JDNDaysUT == tjdlast)
+    return ralast;
+#ifndef SIMULATE_VICTORVB
+  if (1) { /*helflag & SE_HELFLAG_HIGH_PRECISION) {*/
+    double x[6];
+    int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+    int32 iflag = epheflag | SEFLG_EQUATORIAL;
+    iflag |= SEFLG_NONUT | SEFLG_TRUEPOS;
+    tjd_tt = JDNDaysUT + swe_deltat(JDNDaysUT);
+    if (swe_calc(tjd_tt, SE_SUN, iflag, x, serr) != ERR) {
+      ralast = x[0];
+      tjdlast = JDNDaysUT;
+      return ralast;
+    }
+  }
+#endif
+  swe_revjul(JDNDaysUT, calflag, &iyar, &imon, &iday, &dut); /* this seems to be much faster than calling swe_revjul() ! Note: only because SunRA is called 1000s of times */
+  tjdlast = JDNDaysUT;
+  ralast = swe_degnorm((imon + (iday - 1) / 30.4 - 3.69) * 30);
+  /*ralast = (DatefromJDut(JDNDaysUT, 2) + (DatefromJDut(JDNDaysUT, 3) - 1) / 30.4 - 3.69) * 30;*/
+  return ralast;
+}
+
+/*###################################################################
+' Temp [C]
+' Kelvin [K]
+*/
+static double Kelvin(double Temp)
+{
+  /*' http://en.wikipedia.org/wiki/Kelvin*/
+  return Temp + C2K;
+}
+
+/*###################################################################
+' AppAlt [deg]
+' TempE [C]
+' PresE [mbar]
+' TopoAltitudefromAppAlt [deg]
+*/
+static double TopoAltfromAppAlt(double AppAlt, double TempE, double PresE)
+{
+  double R = 0;
+  double retalt = 0;
+  if (AppAlt >= LowestAppAlt) {
+    if (AppAlt > 17.904104638432)
+      R = 0.97 / tan(AppAlt * DEGTORAD);
+    else
+      R = (34.46 + 4.23 * AppAlt + 0.004 * AppAlt * AppAlt) / (1 + 0.505 * AppAlt + 0.0845 * AppAlt * AppAlt);
+    R = (PresE - 80) / 930 / (1 + 0.00008 * (R + 39) * (TempE - 10)) * R;
+    retalt = AppAlt - R * Min2Deg;
+  } else {
+    retalt = AppAlt;
+  }
+  return retalt;
+}
+
+/*###################################################################
+' TopoAlt [deg]
+' TempE [C]
+' PresE [mbar]
+' AppAltfromTopoAlt [deg]
+' call this instead of swe_azalt(), because it is faster (lower precision
+' is required)
+*/
+static double AppAltfromTopoAlt(double TopoAlt, double TempE, double PresE, int32 helflag)
+{
+  /* using methodology of Newtown derivatives (analogue to what Swiss Emphemeris uses)*/
+  int i, nloop = 2;
+  double newAppAlt = TopoAlt;
+  double newTopoAlt = 0.0;
+  double oudAppAlt = newAppAlt;
+  double oudTopoAlt = newTopoAlt;
+  double verschil, retalt;
+  if (helflag & SE_HELFLAG_HIGH_PRECISION)
+    nloop = 5;
+  for (i = 0; i <= nloop; i++) {
+    newTopoAlt = newAppAlt - TopoAltfromAppAlt(newAppAlt, TempE, PresE);
+    /*newTopoAlt = newAppAlt - swe_refrac(newAppAlt, PresE, TempE, SE_CALC_APP_TO_TRUE);*/
+    verschil = newAppAlt - oudAppAlt;
+    oudAppAlt = newTopoAlt - oudTopoAlt - verschil;
+    if ((verschil != 0) && (oudAppAlt != 0))
+      verschil = newAppAlt - verschil * (TopoAlt + newTopoAlt - newAppAlt) / oudAppAlt;
+    else
+      verschil = TopoAlt + newTopoAlt;
+    oudAppAlt = newAppAlt;
+    oudTopoAlt = newTopoAlt;
+    newAppAlt = verschil;
+  }
+  retalt = TopoAlt + newTopoAlt;
+  if (retalt < LowestAppAlt)
+    retalt = TopoAlt;
+  return retalt;
+}
+
+/*###################################################################
+' TopoAlt [deg]
+' TopoDecl [deg]
+' Lat [deg]
+' HourAngle [hour]
+*/
+static double HourAngle(double TopoAlt, double TopoDecl, double Lat)
+{
+  double Alti = TopoAlt * DEGTORAD;
+  double decli = TopoDecl * DEGTORAD;
+  double Lati = Lat * DEGTORAD;
+  double ha = (sin(Alti) - sin(Lati) * sin(decli)) / cos(Lati) / cos(decli);
+  if (ha < -1) ha = -1; 
+  if (ha > 1) ha = 1;
+  /* from http://star-www.st-and.ac.uk/~fv/webnotes/chapt12.htm*/
+  return acos(ha) / DEGTORAD / 15.0;
+}
+
+/*###################################################################
+' JDNDays [Days]
+' COD [msec/cy]
+' DeltaTSE [Sec]
+*/
+static double DeltaTSE(double JDNDays, int COD)
+{
+  double OffSetYear;
+  int gregflag = SE_GREG_CAL;
+  if (StartYear < 1583)
+    gregflag = SE_JUL_CAL;
+  /* from Swiss Emphemeris */
+  if (COD != 0) {
+    /* Determined by V. Reijs*/
+    OffSetYear = (swe_julday((int) StartYear, 1, 1, 0, gregflag) - JDNDays) / 365.25;
+    return (OffSetYear * OffSetYear / 100.0 / 2.0 * COD * Y2D) / 1000.0;
+  }
+  return swe_deltat(JDNDays) * D2S;
+}
+
+/*###################################################################
+' JDNDays [Day]
+' COD [msec/cy]
+' DeltaTVR [Sec]
+*/
+static double DeltaTVR(double JDNDays, int COD)
+{
+  /* Determined by V. Reijs */
+  double DeltaTVR;
+  int gregflag = SE_GREG_CAL;
+  double OffSetYear;
+  if (StartYear < 1583)
+    gregflag = SE_JUL_CAL;
+  OffSetYear = (swe_julday((int) StartYear, 1, 1, 0, gregflag) - JDNDays) / 365.25;
+  if (COD == 0) {
+    DeltaTVR = (OffSetYear * OffSetYear / 100.0 / 2.0 * Average + Periodicy / 2.0 / PI * Amplitude * (cos((2 * PI * OffSetYear / Periodicy)) - 1)) * Y2D;
+  } else {
+    DeltaTVR = OffSetYear * OffSetYear / 100.0 / 2.0 * COD * Y2D;
+  }
+  return DeltaTVR / 1000.0;
+}
+
+/*###################################################################
+' JDNDays [Days]
+' COD [msec/cy]
+' DeltaT [Sec]
+*/
+static double DeltaT(double JDNDays, int COD)
+{
+  if (USE_DELTA_T_VR)
+    return DeltaTVR(JDNDays, COD);
+  return DeltaTSE(JDNDays, COD);
+}
+
+/*###################################################################
+' JDNDaysUT [Days]
+' dgeo [array: longitude, latitude, eye height above sea m]
+' TempE [C]
+' PresE [mbar]
+' ObjectName [-]
+' Angle (0 = TopoAlt, 1 = Azi, 2=Topo Declination, 3=Topo Rectascension, 4=AppAlt,5=Geo Declination, 6=Geo Rectascension)
+' ObjectLoc [deg]
+ */
+static int32 ObjectLoc(double JDNDaysUT, double *dgeo, double *datm, char *ObjectName, int32 Angle, int32 helflag, double *dret, char *serr)
+{
+  double x[6], xin[3], xaz[3], tjd_tt;
+  int32 Planet;
+  int32 epheflag;
+  int32 iflag = SEFLG_EQUATORIAL;
+  epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  iflag |= epheflag;
+  if (!(helflag & SE_HELFLAG_HIGH_PRECISION))
+    iflag |= SEFLG_NONUT | SEFLG_TRUEPOS;
+  if (Angle < 5) iflag = iflag | SEFLG_TOPOCTR;
+  if (Angle == 7) Angle = 0;
+  tjd_tt = JDNDaysUT + DeltaT(JDNDaysUT, 0) / D2S;
+  Planet = DeterObject(ObjectName);
+  if (Planet != -1) {
+    if (swe_calc(tjd_tt, Planet, iflag, x, serr) == ERR)
+      return ERR;
+  } else {
+    if (call_swe_fixstar(ObjectName, tjd_tt, iflag, x, serr) == ERR)
+      return ERR;
+  }
+  if (Angle == 2 ||  Angle == 5) {
+    *dret = x[1];
+  } else {
+    if (Angle == 3 || Angle == 6) {
+      *dret = x[0];
+    } else {
+      xin[0] = x[0];
+      xin[1] = x[1];
+      swe_azalt(JDNDaysUT, SE_EQU2HOR, dgeo, datm[0], datm[1], xin, xaz);
+      if (Angle == 0)
+	*dret = xaz[1];
+      if (Angle == 4)
+	*dret = AppAltfromTopoAlt(xaz[1], datm[0], datm[1], helflag);
+      if (Angle == 1) {
+	xaz[0] += 180;
+	if (xaz[0] >= 360)
+	  xaz[0] -= 360;
+        *dret = xaz[0];
+      }
+    }
+  }
+  return OK;
+}
+
+/*###################################################################
+' JDNDaysUT [Days]
+' dgeo [array: longitude, latitude, eye height above sea m]
+' TempE [C]
+' PresE [mbar]
+' ObjectName [-]
+' Angle (0 = TopoAlt, 1 = Azi, 2=Topo Declination, 3=Topo Rectascension, 4=AppAlt,5=Geo Declination, 6=Geo Rectascension)
+' ObjectLoc [deg]
+ */
+static int32 azalt_cart(double JDNDaysUT, double *dgeo, double *datm, char *ObjectName, int32 helflag, double *dret, char *serr)
+{
+  double x[6], xin[3], xaz[3], tjd_tt;
+  int32 Planet;
+  int32 epheflag;
+  int32 iflag = SEFLG_EQUATORIAL;
+  epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  iflag |= epheflag;
+  if (!(helflag & SE_HELFLAG_HIGH_PRECISION))
+    iflag |= SEFLG_NONUT | SEFLG_TRUEPOS;
+  iflag = iflag | SEFLG_TOPOCTR;
+  tjd_tt = JDNDaysUT + DeltaT(JDNDaysUT, 0) / D2S;
+  Planet = DeterObject(ObjectName);
+  if (Planet != -1) {
+    if (swe_calc(tjd_tt, Planet, iflag, x, serr) == ERR)
+      return ERR;
+  } else {
+    if (call_swe_fixstar(ObjectName, tjd_tt, iflag, x, serr) == ERR)
+      return ERR;
+  }
+  xin[0] = x[0];
+  xin[1] = x[1];
+  swe_azalt(JDNDaysUT, SE_EQU2HOR, dgeo, datm[0], datm[1], xin, xaz);
+  dret[0] = xaz[0];
+  dret[1] = xaz[1]; /* true altitude */
+  dret[2] = xaz[2]; /* apparent altitude */
+  /* also return cartesian coordinates, for apparent altitude */
+  xaz[1] = xaz[2];
+  xaz[2] = 1;
+  swi_polcart(xaz, xaz);
+  dret[3] = xaz[0];
+  dret[4] = xaz[1];
+  dret[5] = xaz[2];
+  return OK;
+}
+
+/*###################################################################
+' LatA [rad]
+' LongA [rad]
+' LatB [rad]
+' LongB [rad]
+' DistanceAngle [rad]
+*/
+static double DistanceAngle(double LatA, double LongA, double LatB, double LongB)
+{
+  double dlon = LongB - LongA;
+  double dlat = LatB - LatA;
+  /* Haversine formula
+   * http://www.movable-type.co.uk/scripts/GIS-FAQ-5.1.html
+   * R.W. Sinnott, Virtues of the Haversine, Sky and Telescope, vol. 68, no. 2, 1984, p. 159
+   */
+  double sindlat2 = sin(dlat / 2);
+  double sindlon2 = sin(dlon / 2);
+  double corde = sindlat2 * sindlat2 + cos(LatA) * cos(LatB) * sindlon2 *sindlon2;
+  if (corde > 1) corde = 1;
+  return 2 * asin(sqrt(corde));
+}
+
+/*###################################################################
+' heighteye [m]
+' TempS [C]
+' RH [%]
+' kW [-]
+*/
+static double kW(double HeightEye, double TempS, double RH)
+{
+  /* From Schaefer , Archaeoastronomy, XV, 2000, page 128*/
+  double WT = 0.031;
+  WT *= 0.94 * (RH / 100.0) * exp(TempS / 15) * exp(-1 * HeightEye / scaleHwater);
+  return WT;
+}
+
+/*###################################################################
+' JDNDaysUT [-]
+' AltS [deg]
+' lat [deg]
+' kOZ [-]
+*/
+static double kOZ(double AltS, double sunra, double Lat)
+{
+  double CHANGEKO, OZ, LT, kOZret;
+  static double koz_last, alts_last, sunra_last;
+  if (AltS == alts_last && sunra == sunra_last)
+    return koz_last;
+  alts_last = AltS; sunra_last = sunra;
+  OZ = 0.031;
+  LT = Lat * DEGTORAD;
+  /* From Schaefer , Archaeoastronomy, XV, 2000, page 128*/
+  kOZret = OZ * (3.0 + 0.4 * (LT * cos(sunra * DEGTORAD) - cos(3 * LT))) / 3.0;
+  /* depending on day/night vision (altitude of sun < start astronomical twilight), KO changes from 100% to 30%
+   * see extinction section of Vistas in Astronomy page 343*/
+  CHANGEKO = (100 - 11.6 * mymin(6, mymax(-AltS - 12, 0))) / 100;
+  koz_last = kOZret * CHANGEKO;
+  return koz_last;
+}
+
+/*###################################################################
+' AltS [deg]
+' heighteye [m]
+' kR [-]
+*/
+static double kR(double AltS, double HeightEye)
+{
+  /* depending on day/night vision (altitude of sun < start astronomical twilight),
+   * lambda eye sensibility changes
+   * see extinction section of Vistas in Astronomy page 343*/
+  double CHANGEK, LAMBDA;
+  double val = -AltS - 12;
+  if (val < 0) val = 0;
+  if (val > 6) val = 6;
+  /*CHANGEK = (1 - 0.166667 * Min(6, Max(-AltS - 12, 0)));*/
+  CHANGEK = (1 - 0.166667 * val );
+  LAMBDA = 0.55 + (CHANGEK - 1) * 0.04;
+  /* From Schaefer , Archaeoastronomy, XV, 2000, page 128 */
+  return 0.1066 * exp(-1 * HeightEye / scaleHrayleigh) * pow(LAMBDA / 0.55 , -4);
+}
+
+static int Sgn(double x)
+{
+  if (x < 0) 
+    return -1;
+  return 1;
+}
+
+/*###################################################################
+' JDNDaysUT [-]
+' AltS [deg]
+' lat [deg]
+' heighteye [m]
+' TempS [C]
+' RH [%]
+' VR [km]
+' ka [-]
+*/
+static double ka(double AltS, double sunra, double Lat, double HeightEye, double TempS, double RH, double VR, char *serr)
+{
+  double CHANGEKA, LAMBDA, BetaVr, Betaa, kaact;
+  double SL = Sgn(Lat);
+  /* depending on day/night vision (altitude of sun < start astronomical twilight),
+   * lambda eye sensibility changes
+   * see extinction section of Vistas in Astronomy page 343 */
+  static double alts_last, sunra_last, ka_last;
+  if (AltS == alts_last && sunra == sunra_last)
+    return ka_last;
+  alts_last = AltS; sunra_last = sunra;
+  CHANGEKA = (1 - 0.166667 * mymin(6, mymax(-AltS - 12, 0)));
+  LAMBDA = 0.55 + (CHANGEKA - 1) * 0.04;
+  if (VR != 0) {
+    if (VR >= 1) {
+      /* Visbility range from http://www1.cs.columbia.edu/CAVE/publications/pdfs/Narasimhan_CVPR03.pdf
+       * http://www.icao.int/anb/SG/AMOSSG/meetings/amossg3/wp/SN11Rev.pdf where MOR=2.995/ke
+       * factor 1.3 is the relation between "prevailing visibility" and 
+       * meteorological range was derived by Koshmeider in the 1920's */
+      BetaVr = 3.912 / VR;
+      Betaa = BetaVr - (kW(HeightEye, TempS, RH) / scaleHwater + kR(AltS, HeightEye) / scaleHrayleigh) * 1000 * astr2tau;
+      kaact = Betaa * scaleHaerosol / 1000 * tau2astr;
+      if (kaact < 0) {
+	if (serr != NULL)
+	  strcpy(serr, "The provided Meteorological range is too long, when taking into acount other atmospheric parameters"); /* is a warning */
+        /* return 0; * return "#HIGHVR"; */
+      }
+    } else {
+      kaact = VR - kW(HeightEye, TempS, RH) - kR(AltS, HeightEye) - kOZ(AltS, sunra, Lat);
+      if (kaact < 0) {
+	if (serr != NULL)
+	  strcpy(serr, "The provided atmosphic coeefficent (ktot) is too low, when taking into acount other atmospheric parameters"); /* is a warning */
+        /* return 0; * "#LOWktot"; */
+      }
+    }
+  } else {
+    /* From Schaefer , Archaeoastronomy, XV, 2000, page 128 */
+#ifdef SIMULATE_VICTORVB
+    if (RH <= 0.00000001) RH = 0.00000001;
+    if (RH >= 99.99999999) RH = 99.99999999;
+#endif
+    kaact = 0.1 * exp(-1 * HeightEye / scaleHaerosol) * pow(1 - 0.32 / log(RH / 100.0), 1.33) * (1 + 0.33 * SL * sin(sunra * DEGTORAD));
+    kaact = kaact * pow(LAMBDA / 0.55, -1.3);
+  }
+  ka_last = kaact;
+  return kaact;
+}
+
+/*###################################################################
+' JDNDaysUT [-]
+' AltS [deg]
+' lat [deg]
+' heighteye [m]
+' TempS [C]
+' RH [%]
+' VR [km]
+' ExtType [0=ka,1=kW,2=kR,3=kOZ,4=ktot]
+' kt [-]
+*/
+static double kt(double AltS, double sunra, double Lat, double HeightEye, double TempS, double RH, double VR, int32 ExtType, char *serr)
+{
+  double kRact = 0;
+  double kWact = 0;
+  double kOZact = 0;
+  double kaact = 0;
+  if (ExtType == 2 || ExtType == 4)
+    kRact = kR(AltS, HeightEye);
+  if (ExtType == 1 || ExtType == 4)
+    kWact = kW(HeightEye, TempS, RH);
+  if (ExtType == 3 || ExtType == 4)
+    kOZact = kOZ(AltS, sunra, Lat);
+  if (ExtType == 0 || ExtType == 4)
+    kaact = ka(AltS, sunra, Lat, HeightEye, TempS, RH, VR, serr);
+  if (kaact < 0)
+    kaact = 0;
+  return kWact + kRact + kOZact + kaact;
+}
+
+/*###################################################################
+' AppAlt0 [deg]
+' PresS [mbar]
+' Airmass [??]
+*/
+static double Airmass(double AppAltO, double Press)
+{
+  double airm, zend;
+  zend = (90 - AppAltO) * DEGTORAD;
+  if (zend > PI / 2)
+    zend = PI / 2;
+  airm = 1 / (cos(zend) + 0.025 * exp(-11 * cos(zend)));
+  return Press / 1013 * airm;
+}
+
+/*###################################################################
+' scaleH '[m]
+' zend [rad]
+' PresS [mbar]
+' Xext [-]
+*/
+static double Xext(double scaleH, double zend, double Press)
+{
+  return Press / 1013.0 / (cos(zend) + 0.01 * sqrt(scaleH / 1000.0) * exp(-30.0 / sqrt(scaleH / 1000.0) * cos(zend)));
+}
+
+/*###################################################################
+' scaleH '[m]
+' zend [rad]
+' PresS [mbar]
+' Xlay [-]
+*/
+static double Xlay(double scaleH, double zend, double Press)
+{
+  /*return Press / 1013.0 / sqrt(1.0 - pow(sin(zend) / (1.0 + (scaleH / Ra)), 2));*/
+  double a = sin(zend) / (1.0 + (scaleH / Ra));
+  return Press / 1013.0 / sqrt(1.0 - a * a);
+}
+
+/*###################################################################
+' Meteorological formula
+'###################################################################
+' TempS [C]
+' HeightEye [m]
+' TempEfromTempS [C]
+*/
+static double TempEfromTempS(double TempS, double HeightEye, double Lapse)
+{
+  return TempS - Lapse * HeightEye;
+}
+
+/*###################################################################
+' TempS [C]
+' PresS [mbar]
+' HeightEye [m]
+' PresEfromPresS [mbar]
+*/
+static double PresEfromPresS(double TempS, double Press, double HeightEye)
+{
+  return Press * exp(-9.80665 * 0.0289644 / (Kelvin(TempS) + 3.25 * HeightEye / 1000) / 8.31441 * HeightEye);
+}
+
+/*###################################################################
+' AltO [deg]
+' JDNDaysUT [-]
+' AltS [deg]
+' lat [deg]
+' heighteye [m]
+' TempS [C]
+' PresS [mbar]
+' RH [%]
+' VR [km]
+' Deltam [-]
+*/
+static double Deltam(double AltO, double AltS, double sunra, double Lat, double HeightEye, double *datm, int32 helflag, char *serr)
+{
+  double zend, xR, XW, Xa, XOZ;
+  double PresE = PresEfromPresS(datm[1], datm[0], HeightEye);
+  double TempE = TempEfromTempS(datm[1], HeightEye, LapseSA);
+  double AppAltO = AppAltfromTopoAlt(AltO, TempE, PresE, helflag);
+  double deltam;
+  static double alts_last, alto_last, sunra_last, deltam_last;
+  if (AltS == alts_last && AltO == alto_last && sunra == sunra_last)
+    return deltam_last;
+  alts_last = AltS; alto_last = AltO; sunra_last = sunra;
+  if (staticAirmass == 0) {
+    zend = (90 - AppAltO) * DEGTORAD;
+    if (zend > PI / 2)
+      zend = PI / 2;
+    /* From Schaefer , Archaeoastronomy, XV, 2000, page 128*/
+    xR = Xext(scaleHrayleigh, zend, datm[0]);
+    XW = Xext(scaleHwater, zend, datm[0]);
+    Xa = Xext(scaleHaerosol, zend, datm[0]);
+    XOZ = Xlay(scaleHozone, zend, datm[0]);
+    deltam = kR(AltS, HeightEye) * xR + kt(AltS, sunra, Lat, HeightEye, datm[1], datm[2], datm[3], 0, serr) * Xa + kOZ(AltS, sunra, Lat) * XOZ + kW(HeightEye, datm[1], datm[2]) * XW;
+  } else {
+    deltam = kt(AltS, sunra, Lat, HeightEye, datm[1], datm[2], datm[3], 4, serr) * Airmass(AppAltO, datm[0]);
+  }
+  deltam_last = deltam;
+  return deltam;
+}
+
+/*###################################################################
+' AltO [deg]
+' JDNDaysUT [-]
+' AltS [deg]
+' lat [deg]
+' heighteye [m]
+' TempS [C]
+' PresS [mbar]
+' RH [%]
+' VR [km]
+' Bn [nL]
+*/
+static double Bn(double AltO, double JDNDayUT, double AltS, double sunra, double Lat, double HeightEye, double *datm, int32 helflag, char *serr)
+{
+  double PresE = PresEfromPresS(datm[1], datm[0], HeightEye);
+  double TempE = TempEfromTempS(datm[1], HeightEye, LapseSA);
+  double AppAltO = AppAltfromTopoAlt(AltO, TempE, PresE, helflag);
+  double zend, YearB, MonthB, DayB, Bna, kX, Bnb;
+  double B0 = 0.0000000000001, dut;
+  int iyar, imon, iday;
+  /* Below altitude of 10 degrees, the Bn stays the same (see page 343 Vistas in Astronomy) */
+  if (AppAltO < 10)
+    AppAltO = 10;
+  zend = (90 - AppAltO) * DEGTORAD;
+  /* From Schaefer , Archaeoastronomy, XV, 2000, page 128 and adjusted for sunspot period*/
+  /*YearB = DatefromJDut(JDNDayUT, 1);
+    MonthB = DatefromJDut(JDNDayUT, 2);
+    DayB = DatefromJDut(JDNDayUT, 3);*/
+  swe_revjul(JDNDayUT, SE_GREG_CAL, &iyar, &imon, &iday, &dut); 
+  YearB = iyar; MonthB = imon; DayB = iday;
+  Bna = B0 * (1 + 0.3 * cos(6.283 * (YearB + ((DayB - 1) / 30.4 + MonthB - 1) / 12 - 1990.33) / 11.1));
+  kX = Deltam(AltO, AltS, sunra, Lat, HeightEye, datm, helflag, serr);
+  /* From Schaefer , Archaeoastronomy, XV, 2000, page 129 */
+  Bnb = Bna * (0.4 + 0.6 / sqrt(1 - 0.96 * pow(sin(zend), 2))) * pow(10, -0.4 * kX);
+  return mymax(Bnb, 0) * erg2nL;
+}
+
+/*###################################################################
+' JDNDaysUT [-]
+' dgeo [array: longitude, latitude, eye height above sea m]
+' TempE [C]
+' PresE [mbar]
+' ObjectName [-]
+' Magnitude [-]
+*/
+static int32 Magnitude(double JDNDaysUT, double *dgeo, char *ObjectName, int32 helflag, double *dmag, char *serr)
+{
+  double x[20];
+  int32 Planet, iflag, epheflag;
+  epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  *dmag = -99.0;
+  Planet = DeterObject(ObjectName);
+  iflag = SEFLG_TOPOCTR | SEFLG_EQUATORIAL | epheflag;
+  if (!(helflag & SE_HELFLAG_HIGH_PRECISION))
+    iflag |= SEFLG_NONUT|SEFLG_TRUEPOS;
+  if (Planet != -1) {
+    /**dmag = Phenomena(JDNDaysUT, Lat, Longitude, HeightEye, TempE, PresE, ObjectName, 4);*/
+    swe_set_topo(dgeo[0], dgeo[1], dgeo[2]);
+    if (swe_pheno_ut(JDNDaysUT, Planet, iflag, x, serr) == ERR)
+      return ERR;
+    *dmag = x[4];
+  } else {
+    if (call_swe_fixstar_mag(ObjectName, dmag, serr) == ERR)
+      return ERR;
+  }
+  return OK;
+}
+
+#if 0
+static int32 fast_magnitude(double tjd, double *dgeo, char *ObjectName, int32 helflag, double *dmag, char *serr)
+{
+  int32 retval = OK, ipl, ipli;
+  double dtjd;
+  static double tjdsv[3];
+  static double dmagsv[3];
+  static int32 helflagsv[3];
+  ipl = DeterObject(ObjectName);
+  ipli = ipl;
+  if (ipli > SE_MOON) 
+    ipli = 2;
+  dtjd = tjd - tjdsv[ipli];
+  if (tjdsv[ipli] != 0 && helflag == helflagsv[ipli] && fabs(dtjd) < 5.0 / 1440.0) {
+    *dmag = dmagsv[ipli];
+  } else {
+    retval = Magnitude(tjd, dgeo, ObjectName, helflag, dmag, serr);
+    tjdsv[ipli] = tjd;
+    helflagsv[ipli] = helflag;
+    dmagsv[ipli] = *dmag;
+  }
+  return retval;
+}
+#endif
+
+/*###################################################################
+' dist [km]
+' phasemoon [-]
+' MoonsBrightness [-]
+*/
+static double MoonsBrightness(double dist, double phasemoon)
+{
+  double log10 = 2.302585092994;
+  /*Moon's brightness changes with distance: http://hem.passagen.se/pausch/comp/ppcomp.html#15 */
+  return -21.62 + 5 * log(dist / (Ra / 1000)) / log10 + 0.026 * fabs(phasemoon) + 0.000000004 * pow(phasemoon, 4);
+}
+
+/*###################################################################
+' AltM [deg]
+' AziM [deg]
+' AziS [deg]
+' MoonPhase [deg]
+*/
+static double MoonPhase(double AltM, double AziM, double AziS)
+{
+  double AltMi = AltM * DEGTORAD;
+  double AziMi = AziM * DEGTORAD;
+  double AziSi = AziS * DEGTORAD;
+  return 180 - acos(cos(AziSi - AziMi) * cos(AltMi + 0.95 * DEGTORAD)) / DEGTORAD;
+}
+
+/*###################################################################
+' Pressure [mbar]
+*/
+static double Bm(double AltO, double AziO, double AltM, double AziM, double AltS, double AziS, double sunra, double Lat, double HeightEye, double *datm, int32 helflag, char *serr)
+{
+  double M0 = -11.05;
+  double Bm = 0;
+  double RM, kXM, kX, C3, FM, phasemoon, MM;
+  if (AltM > -0.26) {
+  /* moon only adds light when (partly) above horizon
+   * From Schaefer , Archaeoastronomy, XV, 2000, page 129*/
+    RM = DistanceAngle(AltO * DEGTORAD, AziO * DEGTORAD, AltM * DEGTORAD, AziM * DEGTORAD) / DEGTORAD;
+    kXM = Deltam(AltM, AltS, sunra, Lat, HeightEye, datm, helflag, serr);
+    kX = Deltam(AltO, AltS, sunra, Lat, HeightEye, datm, helflag, serr);
+    C3 = pow(10, -0.4 * kXM);
+    FM = (62000000.0) / RM / RM + pow(10, 6.15 - RM / 40) + pow(10, 5.36) * (1.06 + pow(cos(RM * DEGTORAD), 2));
+    Bm = FM * C3 + 440000 * (1 - C3);
+    phasemoon = MoonPhase(AltM, AziM, AziS);
+    MM = MoonsBrightness(MoonDistance, phasemoon);
+    Bm = Bm * pow(10, -0.4 * (MM - M0 + 43.27));
+    Bm = Bm * (1 - pow(10, -0.4 * kX));
+  }
+  Bm = mymax(Bm, 0) * erg2nL;
+  return Bm;
+}
+
+/*###################################################################
+' Pressure [mbar]
+*/
+static double Btwi(double AltO, double AziO, double AltS, double AziS, double sunra, double Lat, double HeightEye, double *datm, int32 helflag, char *serr)
+{
+double M0 = -11.05;
+double MS = -26.74;
+double PresE = PresEfromPresS(datm[1], datm[0], HeightEye);
+double TempE = TempEfromTempS(datm[1], HeightEye, LapseSA);
+double AppAltO = AppAltfromTopoAlt(AltO, TempE, PresE, helflag);
+double ZendO = 90 - AppAltO;
+double RS = DistanceAngle(AltO * DEGTORAD, AziO * DEGTORAD, AltS * DEGTORAD, AziS * DEGTORAD) / DEGTORAD;
+double kX = Deltam(AltO, AltS, sunra, Lat, HeightEye, datm, helflag, serr);
+double k = kt(AltS, sunra, Lat, HeightEye, datm[1], datm[2], datm[3], 4, serr);
+/* From Schaefer , Archaeoastronomy, XV, 2000, page 129*/
+double Btwi = pow(10, -0.4 * (MS - M0 + 32.5 - AltS - (ZendO / (360 * k))));
+Btwi = Btwi * (100 / RS) * (1 - pow(10, -0.4 * kX));
+Btwi = mymax(Btwi, 0) * erg2nL;
+return Btwi;
+}
+
+/*###################################################################
+' Pressure [mbar]
+*/
+static double Bday(double AltO, double AziO, double AltS, double AziS, double sunra, double Lat, double HeightEye, double *datm, int32 helflag, char *serr)
+{
+  double M0 = -11.05;
+  double MS = -26.74;
+  double RS = DistanceAngle(AltO * DEGTORAD, AziO * DEGTORAD, AltS * DEGTORAD, AziS * DEGTORAD) / DEGTORAD;
+  double kXS = Deltam(AltS, AltS, sunra, Lat, HeightEye, datm, helflag, serr);
+  double kX = Deltam(AltO, AltS, sunra, Lat, HeightEye, datm, helflag, serr);
+  /* From Schaefer , Archaeoastronomy, XV, 2000, page 129*/
+  double C4 = pow(10, -0.4 * kXS);
+  double FS = (62000000.0) / RS / RS + pow(10, (6.15 - RS / 40)) + pow(10, 5.36) * (1.06 + pow(cos(RS * DEGTORAD), 2));
+  double Bday = FS * C4 + 440000.0 * (1 - C4);
+  Bday = Bday * pow(10, (-0.4 * (MS - M0 + 43.27)));
+  Bday = Bday * (1 - pow(10, -0.4 * kX));
+  Bday = mymax(Bday, 0) * erg2nL;
+  return Bday;
+}
+
+/*###################################################################
+' Value [nL]
+' PresS [mbar]
+' Bcity [nL]
+*/
+static double Bcity(double Value, double Press)
+{
+  double Bcity = Value;
+  Bcity = mymax(Bcity, 0);
+  return Bcity;
+}
+
+/*###################################################################
+' Pressure [mbar]
+*/
+static double Bsky(double AltO, double AziO, double AltM, double AziM, double JDNDaysUT, double AltS, double AziS, double sunra, double Lat, double HeightEye, double *datm, int32 helflag, char *serr)
+{
+  double Bsky = 0;
+  if (AltS < -3) {
+    Bsky += Btwi(AltO, AziO, AltS, AziS, sunra, Lat, HeightEye, datm, helflag, serr);
+  } else {
+    if (AltS > 4) {
+      Bsky += Bday(AltO, AziO, AltS, AziS, sunra, Lat, HeightEye, datm, helflag, serr);
+    } else {
+      Bsky += mymin(Bday(AltO, AziO, AltS, AziS, sunra, Lat, HeightEye, datm, helflag, serr), Btwi(AltO, AziO, AltS, AziS, sunra, Lat, HeightEye, datm, helflag, serr));
+    }
+  }
+  /* if max. Bm [1E7] <5% of Bsky don't add Bm*/
+  if (Bsky < 200000000.0) 
+    Bsky += Bm(AltO, AziO, AltM, AziM, AltS, AziS, sunra, Lat, HeightEye, datm, helflag, serr);
+  if (AltS <= 0)
+    Bsky += Bcity(0, datm[0]);
+  /* if max. Bn [250] <5% of Bsky don't add Bn*/
+  if (Bsky < 5000)
+    Bsky = Bsky + Bn(AltO, JDNDaysUT, AltS, sunra, Lat, HeightEye, datm, helflag, serr);
+  /* if max. Bm [1E7] <5% of Bsky don't add Bm*/
+  return Bsky;
+}
+
+/* default handling:
+ * 1. datm (atmospheric conditions):
+ * datm consists of 
+ *     [0]  atmospheric pressure
+ *     [1]  temperature
+ *     [2]  relative humidity
+ *     [3]  extinction coefficient
+ * In order to get default values for [0..2], set datm[0] = 0.
+ * Default values for [1-2] are only provided if [0] == 0.
+ * [3] defaults outside this function, depending on [0-2].
+ * 
+ * 2. dobs (observer definition):
+ *     [0]  age (default 36)
+ *     [1]  Snellen ratio or visual acuity of observer (default 1)
+ */
+static void default_heliacal_parameters(double *datm, double *dgeo, double *dobs, int helflag)
+{
+  int i;
+  if (datm[0] <= 0) {
+    /* estimate atmospheric pressure, according to the
+     * International Standard Atmosphere (ISA) */
+    datm[0] = 1013.25 * pow(1 - 0.0065 * dgeo[2] / 288, 5.255);
+    /* temperature */
+    if (datm[1] == 0)
+      datm[1] = 15 - 0.0065 * dgeo[2];
+    /* relative humidity, independent of atmospheric pressure and altitude */
+    if (datm[2] == 0)
+      datm[2] = 40;
+    /* note: datm[3] / VR defaults outside this function */
+  } else {
+#ifndef SIMULATE_VICTORVB
+    if (datm[2] <= 0.00000001) datm[2] = 0.00000001;
+    if (datm[2] >= 99.99999999) datm[2] = 99.99999999;
+#endif
+  }
+  /* age of observer */
+  if (dobs[0] == 0)
+    dobs[0] = 36;
+  /* SN Snellen factor of the visual acuity of the observer */
+  if (dobs[1] == 0)
+    dobs[1] = 1;
+  if (!(helflag & SE_HELFLAG_OPTICAL_PARAMS)) {
+    for (i = 2; i <= 5; i++)
+      dobs[i] = 0;
+  }
+  /* OpticMagn undefined -> use eye */
+  if (dobs[3] == 0) {
+    dobs[2] = 1; /* Binocular = 1 */
+    dobs[3] = 1; /* OpticMagn = 1: use eye */
+    /* dobs[4] and dobs[5] (OpticDia and OpticTrans) will be defaulted in 
+     * OpticFactor() */
+  }
+}
+
+/*###################################################################
+' age [Year]
+' SN [-]
+' AltO [deg]
+' AziO [deg]
+' AltM [deg]
+' AziM [deg]
+' MoonDistance [km]
+' JDNDaysUT [-]
+' AltS [deg]
+' AziS [deg]
+' lat [deg]
+' heighteye [m]
+' TempS [C]
+' PresS [mbar]
+' RH [%]
+' VR [km]
+' VisLimMagn [-]
+*/
+static double VisLimMagn(double *dobs, double AltO, double AziO, double AltM, double AziM, double JDNDaysUT, double AltS, double AziS, double sunra, double Lat, double HeightEye, double *datm, int32 helflag, int32 *scotopic_flag, char *serr)
+{
+  double C1, C2, Th, kX, Bsk, CorrFactor1, CorrFactor2;
+  double log10 = 2.302585092994;
+  /*double Age = dobs[0];*/
+  /*double SN = dobs[1];*/
+  Bsk = Bsky(AltO, AziO, AltM, AziM, JDNDaysUT, AltS, AziS, sunra, Lat, HeightEye, datm, helflag, serr);
+  /* Schaefer, Astronomy and the limits of vision, Archaeoastronomy, 1993 Verder:*/
+  kX = Deltam(AltO, AltS, sunra, Lat, HeightEye, datm, helflag, serr);
+  /* influence of age*/
+  /*Fa = mymax(1, pow(p(23, Bsk) / p(Age, Bsk), 2)); */
+  CorrFactor1 = OpticFactor(Bsk, kX, dobs, JDNDaysUT, "", 1, helflag);
+  CorrFactor2 = OpticFactor(Bsk, kX, dobs, JDNDaysUT, "", 0, helflag);
+  /* From Schaefer , Archaeoastronomy, XV, 2000, page 129*/
+  if (Bsk < BNIGHT && !(helflag & SE_HELFLAG_VISLIM_PHOTOPIC)) {
+    C1 = 1.5848931924611e-10; /*pow(10, -9.8);*/ /* C1 = 10 ^ (-9.8);*/
+    C2 = 0.012589254117942; /*pow(10, -1.9);*/ /* C2 = 10 ^ (-1.9);*/
+    if (scotopic_flag != NULL) 
+      *scotopic_flag = 1;
+  } else {
+    C1 = 4.4668359215096e-9; /*pow(10, -8.35);*/ /* C1 = 10 ^ (-8.35);*/
+    C2 = 1.2589254117942e-6; /*pow(10, -5.9);*/ /* C2 = 10 ^ (-5.9);*/
+    if (scotopic_flag != NULL) 
+      *scotopic_flag = 0;
+  }
+  if (scotopic_flag != NULL) {
+    if (BNIGHT * BNIGHT_FACTOR > Bsk && BNIGHT / BNIGHT_FACTOR < Bsk)
+      *scotopic_flag |= 2;
+  }
+  /*Th = C1 * pow(1 + sqrt(C2 * Bsk), 2) * Fa;*/
+  Bsk = Bsk / CorrFactor1;
+  Th = C1 * pow(1 + sqrt(C2 * Bsk), 2) * CorrFactor2;
+#if DEBUG
+  fprintf(stderr, "Bsk=%f\n", Bsk);
+  fprintf(stderr, "kX =%f\n", kX);
+  fprintf(stderr, "Th =%f\n", Th);
+  fprintf(stderr, "CorrFactor1=%f\n", CorrFactor1);
+  fprintf(stderr, "CorrFactor2=%f\n", CorrFactor2);
+#endif
+  /* Visual limiting magnitude of point source*/
+#if 0
+  if (SN <= 0.00000001)
+    SN = 0.00000001;
+  return -16.57 - 2.5 * (log(Th) / log10) - kX + 5.0 * (log(SN) / log10);*/
+#endif
+  return -16.57 - 2.5 * (log(Th) / log10);
+}
+
+/* Limiting magnitude in dark skies 
+ * function returns:
+ * -1   Error
+ * -2   Object is below horizon
+ *  0   OK, photopic vision
+ *  |1  OK, scotopic vision
+ *  |2  OK, near limit photopic/scotopic
+*/
+int32 FAR PASCAL_CONV swe_vis_limit_mag(double tjdut, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 helflag, double *dret, char *serr)
+{
+  int32 retval = OK, i, scotopic_flag = 0;
+  double AltO, AziO, AltM, AziM, AltS, AziS;
+  double sunra = SunRA(tjdut, helflag, serr);
+  default_heliacal_parameters(datm, dgeo, dobs, helflag);
+  swe_set_topo(dgeo[0], dgeo[1], dgeo[2]);
+  for (i = 0; i < 7; i++)
+    dret[i] = 0;
+  if (ObjectLoc(tjdut, dgeo, datm, ObjectName, 0, helflag, &AltO, serr) == ERR)
+    return ERR;
+  if (AltO < 0 && serr != NULL) {
+    strcpy(serr, "object is below local horizon");
+    *dret = -100;
+    return -2;
+  }
+  if (ObjectLoc(tjdut, dgeo, datm, ObjectName, 1, helflag, &AziO, serr) == ERR)
+    return ERR;
+  if (helflag & SE_HELFLAG_VISLIM_DARK) {
+    AltS = -90;
+    AziS = 0;
+  } else {
+    if (ObjectLoc(tjdut, dgeo, datm, "sun", 0, helflag, &AltS, serr) == ERR)
+      return ERR;
+    if (ObjectLoc(tjdut, dgeo, datm, "sun", 1, helflag, &AziS, serr) == ERR)
+      return ERR;
+  }
+  if (strncmp(ObjectName, "moon", 4) == 0 ||
+      (helflag & SE_HELFLAG_VISLIM_DARK) ||
+      (helflag & SE_HELFLAG_VISLIM_NOMOON)
+     ) {
+    AltM = -90; AziM = 0;
+  } else {
+    if (ObjectLoc(tjdut, dgeo, datm, "moon", 0, helflag, &AltM, serr) == ERR)
+      return ERR;
+    if (ObjectLoc(tjdut, dgeo, datm, "moon", 1, helflag, &AziM, serr) == ERR)
+      return ERR;
+  }
+#if DEBUG
+{
+  int i;
+  for (i = 0; i < 6;i++)
+    printf("dobs[%d] = %f\n", i, dobs[i]);
+  printf("AltO = %.10f, AziO = %.10f\n", AltO, AziO);
+  printf("AltM = %.10f, AziM = %.10f\n", AltM, AziM);
+  printf("AltS = %.10f, AziS = %.10f\n", AltS, AziS);
+  printf("JD = %.10f\n", tjdut);
+  printf("lat = %f, eyeh = %f\n", dgeo[1], dgeo[2]);
+  for (i = 0; i < 4;i++)
+    printf("datm[%d] = %f\n", i, datm[i]);
+  printf("helflag = %d\n", helflag);
+}
+#endif
+  dret[0] = VisLimMagn(dobs, AltO, AziO, AltM, AziM, tjdut, AltS, AziS, sunra, dgeo[1], dgeo[2], datm, helflag, &scotopic_flag, serr);
+  dret[1] = AltO;
+  dret[2] = AziO;
+  dret[3] = AltS;
+  dret[4] = AziS;
+  dret[5] = AltM;
+  dret[6] = AziM;
+  if (Magnitude(tjdut, dgeo, ObjectName, helflag, &(dret[7]), serr) == ERR)
+    return ERR;
+  retval = scotopic_flag;
+  /*dret[8] = (double) is_scotopic;*/
+  /*if (*serr != '\0') * in VisLimMagn(), serr is only a warning *
+    retval = ERR; */
+  return retval;
+}
+
+/*###################################################################
+' Magn [-]
+' age [Year]
+' SN [-]
+' AltO [deg]
+' AziO [deg]
+' AltM [deg]
+' AziM [deg]
+' MoonDistance [km]
+' JDNDaysUT [-]
+' AziS [deg]
+' lat [deg]
+' heighteye [m]
+' Temperature [C]
+' Pressure [mbar]
+' RH [%]
+' VR [km]
+' TopoArcVisionis [deg]
+*/
+static int32 TopoArcVisionis(double Magn, double *dobs, double AltO, double AziO, double AltM, double AziM, double JDNDaysUT, double AziS, double sunra, double Lat, double HeightEye, double *datm, int32 helflag, double *dret, char *serr)
+{
+  double Xm, Ym, AltSi, AziSi;
+  double xR = 0;
+  double Xl = 45;
+  double Yl, Yr;
+  Yl = Magn - VisLimMagn(dobs, AltO, AziO, AltM, AziM, JDNDaysUT, AltO - Xl, AziS, sunra, Lat, HeightEye, datm, helflag, NULL, serr);
+  /* if (*serr != '\0') return ERR; * serr is only a warning */
+  Yr = Magn - VisLimMagn(dobs, AltO, AziO, AltM, AziM, JDNDaysUT, AltO - xR, AziS, sunra, Lat, HeightEye, datm, helflag, NULL, serr);
+  /* if (*serr != '\0') return ERR; * serr is only a warning */
+  /* http://en.wikipedia.org/wiki/Bisection_method*/
+  if ((Yl * Yr) <= 0) {
+    while(fabs(xR - Xl) > epsilon) {
+      /*Calculate midpoint of domain*/
+      Xm = (xR + Xl) / 2.0;
+      AltSi = AltO - Xm;
+      AziSi = AziS;
+      Ym = Magn - VisLimMagn(dobs, AltO, AziO, AltM, AziM, JDNDaysUT, AltSi, AziSi, sunra, Lat, HeightEye, datm, helflag, NULL, serr);
+      /* if (*serr != '\0') return ERR; * serr is only a warning */
+      if ((Yl * Ym) > 0) {
+	/* Throw away left half*/
+	Xl = Xm;
+	Yl = Ym;
+      } else {
+	/* Throw away right half */
+	xR = Xm;
+	Yr = Ym;
+      }
+    }
+    Xm = (xR + Xl) / 2.0;
+  } else {
+    Xm = 99;
+  }
+  if (Xm < AltO) 
+    Xm = AltO;
+  *dret = Xm;
+  return OK;
+}
+
+int32 FAR PASCAL_CONV swe_topo_arcus_visionis(double tjdut, double *dgeo, double *datm, double *dobs, int32 helflag, double mag, double azi_obj, double alt_obj, double azi_sun, double azi_moon, double alt_moon, double *dret, char *serr)
+{
+  double sunra = SunRA(tjdut, helflag, serr);
+  if (serr != NULL && *serr != '\0')
+    return ERR;
+  return TopoArcVisionis(mag, dobs, alt_obj, azi_obj, alt_moon, azi_moon, tjdut, azi_sun, sunra, dgeo[1], dgeo[2], datm, helflag, dret, serr);
+}
+
+/*###################################################################*/
+/*' Magn [-]
+' age [Year]
+' SN Snellen factor of the visual aquity of the observer
+  see: http://www.i-see.org/eyecharts.html#make-your-own
+' AziO [deg]
+' AltM [deg]
+' AziM [deg]
+' MoonDistance [km]
+' JDNDaysUT [-]
+' AziS [deg]
+' Lat [deg]
+' HeightEye [m]
+' Temperature [C]
+' Pressure [mbar]
+' RH [%]   relative humidity
+' VR [km]  Meteorological Range, 
+  see http://www.iol.ie/~geniet/eng/atmoastroextinction.htm
+' TypeAngle 
+'   [0=Object's altitude, 
+'    1=Arcus Visonis (Object's altitude - Sun's altitude), 
+'    2=Sun's altitude]
+' HeliacalAngle [deg]
+*/
+static int32 HeliacalAngle(double Magn, double *dobs, double AziO, double AltM, double AziM, double JDNDaysUT, double AziS, double *dgeo, double *datm, int32 helflag, double *dangret, char *serr)
+{
+  double x, minx, maxx, xmin, ymin, Xl, xR, Yr, Yl, Xm, Ym, xmd, ymd;
+  double Arc, DELTAx;
+  double sunra = SunRA(JDNDaysUT, helflag, serr);
+  double Lat = dgeo[1];
+  double HeightEye = dgeo[2];
+  if (PLSV == 1) {
+    dangret[0] = criticalangle;
+    dangret[1] = criticalangle + Magn * 2.492 + 13.447;
+    dangret[2] = -(Magn * 2.492 + 13.447); /* Magn * 1.1 + 8.9;*/
+    return OK;
+  }
+  minx = 2;
+  maxx = 20;
+  xmin = 0;
+  ymin = 10000;
+  for (x = minx; x <= maxx; x++) {
+    if (TopoArcVisionis(Magn, dobs, x, AziO, AltM, AziM, JDNDaysUT, AziS, sunra, Lat, HeightEye, datm, helflag, &Arc, serr) == ERR)
+      return ERR;
+    if (Arc < ymin) {
+      ymin = Arc;
+      xmin = x;
+    }
+  }
+  Xl = xmin - 1;
+  xR = xmin + 1;
+  if (TopoArcVisionis(Magn, dobs, xR, AziO, AltM, AziM, JDNDaysUT, AziS, sunra, Lat, HeightEye, datm, helflag, &Yr, serr) == ERR)
+    return ERR;
+  if (TopoArcVisionis(Magn, dobs, Xl, AziO, AltM, AziM, JDNDaysUT, AziS, sunra, Lat, HeightEye, datm, helflag, &Yl, serr) == ERR)
+    return ERR;
+  /* http://en.wikipedia.org/wiki/Bisection_method*/
+  while(fabs(xR - Xl) > 0.1) {
+    /* Calculate midpoint of domain */
+    Xm = (xR + Xl) / 2.0;
+    DELTAx = 0.025;
+    xmd = Xm + DELTAx;
+    if (TopoArcVisionis(Magn, dobs, Xm, AziO, AltM, AziM, JDNDaysUT, AziS, sunra, Lat, HeightEye, datm, helflag, &Ym, serr) == ERR)
+      return ERR;
+    if (TopoArcVisionis(Magn, dobs, xmd, AziO, AltM, AziM, JDNDaysUT, AziS, sunra, Lat, HeightEye, datm, helflag, &ymd, serr) == ERR)
+      return ERR;
+    if (Ym >= ymd) {
+      /* Throw away left half */
+      Xl = Xm;
+      Yl = Ym;
+    } else {
+      /*Throw away right half */
+      xR = Xm;
+      Yr = Ym;
+    }
+  }
+  Xm = (xR + Xl) / 2.0;
+  Ym = (Yr + Yl) / 2.0;
+  dangret[1] = Ym;
+  dangret[2] = Xm - Ym;
+  dangret[0] = Xm;
+  return OK;
+}
+
+int32 FAR PASCAL_CONV swe_heliacal_angle(double tjdut, double *dgeo, double *datm, double *dobs, int32 helflag, double mag, double azi_obj, double azi_sun, double azi_moon, double alt_moon, double *dret, char *serr)
+{
+  return HeliacalAngle(mag, dobs, azi_obj, alt_moon, azi_moon, tjdut, azi_sun, dgeo, datm, helflag, dret, serr);
+}
+
+/*###################################################################
+' AltO [deg]
+' AziO [deg]
+' AltS [deg]
+' AziS [deg]
+' parallax [deg]
+' WidthMoon [deg]
+*/
+static double WidthMoon(double AltO, double AziO, double AltS, double AziS, double parallax)
+{
+  /* Yallop 1998, page 3*/
+  double GeoAltO = AltO + parallax;
+  return 0.27245 * parallax * (1 + sin(GeoAltO * DEGTORAD) * sin(parallax * DEGTORAD)) * (1 - cos((AltS - GeoAltO) * DEGTORAD) * cos((AziS - AziO) * DEGTORAD));
+}
+
+/*###################################################################
+' W [deg]
+' LengthMoon [deg]
+*/
+static double LengthMoon(double W, double Diamoon)
+{
+  double Wi, D;
+  if (Diamoon == 0) Diamoon = AvgRadiusMoon * 2;
+  Wi = W * 60;
+  D = Diamoon * 60;
+  /* Crescent length according: http://calendar.ut.ac.ir/Fa/Crescent/Data/Sultan2005.pdf*/
+  return (D - 0.3 * (D + Wi) / 2.0 / Wi) / 60.0;
+}
+
+/*###################################################################
+' W [deg]
+' GeoARCVact [deg]
+' q [-]
+*/
+static double qYallop(double W, double GeoARCVact)
+{
+  double Wi = W * 60;
+  return (GeoARCVact - (11.8371 - 6.3226 * Wi + 0.7319 * Wi * Wi - 0.1018 * Wi * Wi * Wi)) / 10;
+}
+
+/*###################################################################
+'A (0,p)
+'B (1,q)
+'C (0,r)
+'D (1,s)
+*/
+static double crossing(double A, double B, double C, double D)
+{
+return (C - A) / ((B - A) - (D - C));
+}
+
+/*###################################################################*/
+static int32 DeterTAV(double *dobs, double JDNDaysUT, double *dgeo, double *datm, char *ObjectName, int32 helflag, double *dret, char *serr)
+{
+  double Magn, AltO, AziS, AziO, AziM, AltM;
+  double sunra = SunRA(JDNDaysUT, helflag, serr);
+  if (Magnitude(JDNDaysUT, dgeo, ObjectName, helflag, &Magn, serr) == ERR)
+    return ERR;
+  if (ObjectLoc(JDNDaysUT, dgeo, datm, ObjectName, 0, helflag, &AltO, serr) == ERR)
+    return ERR;
+  if (ObjectLoc(JDNDaysUT, dgeo, datm, ObjectName, 1, helflag, &AziO, serr) == ERR)
+    return ERR;
+  if (strncmp(ObjectName, "moon", 4) == 0) {
+    AltM = -90; 
+    AziM = 0;
+  } else {
+    if (ObjectLoc(JDNDaysUT, dgeo, datm, "moon", 0, helflag, &AltM, serr) == ERR)
+      return ERR;
+    if (ObjectLoc(JDNDaysUT, dgeo, datm, "moon", 1, helflag, &AziM, serr) == ERR)
+      return ERR;
+  }
+  if (ObjectLoc(JDNDaysUT, dgeo, datm, "sun", 1, helflag, &AziS, serr) == ERR)
+    return ERR;
+  if (TopoArcVisionis(Magn, dobs, AltO, AziO, AltM, AziM, JDNDaysUT, AziS, sunra, dgeo[1], dgeo[2], datm, helflag, dret, serr) == ERR)
+    return ERR;
+  return OK;
+}
+
+/*###################################################################
+' A y-value at x=1
+' B y-value at x=0
+' C y-value at x=-1
+' x2min minimum for the quadratic function
+*/
+static double x2min(double A, double B, double C)
+{
+  double term = A + C - 2 * B;
+  if (term == 0)
+    return 0;
+  return -(A - C) / 2.0 / term;
+}
+
+
+/*###################################################################
+' A y-value at x=1
+' B y-value at x=0
+' C y-value at x=-1
+' x
+' y is y-value of quadratic function
+*/
+static double funct2(double A, double B, double C, double x)
+{
+  return (A + C - 2 * B) / 2.0 * x * x + (A - C) / 2.0 * x + B;
+}
+
+static void strcpy_VBsafe(char *sout, char *sin)
+{ 
+  char *sp, *sp2; 
+  int iw = 0;
+  sp = sin; 
+  sp2 = sout;
+  while((isalnum(*sp) || *sp == ' ' || *sp == '-') && iw < 30) {
+    *sp2 = *sp;
+    sp++; sp2++; iw++;
+  }
+  *sp2 = '\0';
+}
+
+/*###################################################################
+' JDNDaysUT [JDN]
+' HPheno
+'0=AltO [deg]		topocentric altitude of object (unrefracted)
+'1=AppAltO [deg]        apparent altitude of object (refracted)
+'2=GeoAltO [deg]        geocentric altitude of object
+'3=AziO [deg]           azimuth of object
+'4=AltS [deg]           topocentric altitude of Sun
+'5=AziS [deg]           azimuth of Sun
+'6=TAVact [deg]         actual topocentric arcus visionis
+'7=ARCVact [deg]        actual (geocentric) arcus visionis
+'8=DAZact [deg]         actual difference between object's and sun's azimuth
+'9=ARCLact [deg]        actual longitude difference between object and sun
+'10=kact [-]            extinction coefficient
+'11=minTAV [deg]        smallest topocentric arcus visionis
+'12=TfistVR [JDN]       first time object is visible, according to VR
+'13=TbVR [JDN]          optimum time the object is visible, according to VR
+'14=TlastVR [JDN]       last time object is visible, according to VR
+'15=TbYallop[JDN]       best time the object is visible, according to Yallop
+'16=WMoon [deg]         cresent width of moon
+'17=qYal [-]            q-test value of Yallop 
+'18=qCrit [-]           q-test criterion of Yallop
+'19=ParO [deg]          parallax of object
+'20 Magn [-]            magnitude of object
+'21=RiseO [JDN]         rise/set time of object
+'22=RiseS [JDN]         rise/set time of sun
+'23=Lag [JDN]           rise/set time of object minus rise/set time of sun
+'24=TvisVR [JDN]        visibility duration
+'25=LMoon [deg]         cresent length of moon
+'26=CVAact [deg]
+'27=Illum [%] 'new
+'28=CVAact [deg] 'new
+'29=MSk [-]
+*/
+int32 FAR PASCAL_CONV swe_heliacal_pheno_ut(double JDNDaysUT, double *dgeo, double *datm, double *dobs, char *ObjectNameIn, int32 TypeEvent, int32 helflag, double *darr, char *serr)
+{
+  double AziS, AltS, AltS2, AziO, AltO, AltO2, GeoAltO, AppAltO, DAZact, TAVact, ParO, MagnO;
+  double ARCVact, ARCLact, kact, WMoon, LMoon = 0, qYal, qCrit;
+  double RiseSetO, RiseSetS, Lag, TbYallop, TfirstVR, TlastVR, TbVR;
+  double MinTAV, MinTAVact, Ta, Tc, TimeStep, TimePointer, MinTAVoud = 0, DeltaAltoud = 0, DeltaAlt, TvisVR, crosspoint;
+  double OldestDeltaAlt, OldestMinTAV, extrax, illum;
+  double elong, attr[30];
+  double TimeCheck, LocalminCheck;
+  int32 retval = OK, RS, Planet;
+  AS_BOOL noriseO = FALSE;
+  char ObjectName[AS_MAXCH];
+  double sunra = SunRA(JDNDaysUT, helflag, serr);
+  int32 iflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  /* note, the fixed stars functions rewrite the star name. The input string 
+     may be too short, so we have to make sure we have enough space */
+  strcpy_VBsafe(ObjectName, ObjectNameIn);
+  default_heliacal_parameters(datm, dgeo, dobs, helflag);
+  swe_set_topo(dgeo[0], dgeo[1], dgeo[2]);
+  retval = ObjectLoc(JDNDaysUT, dgeo, datm, "sun", 1, helflag, &AziS, serr);
+  if (retval == OK)
+    retval = ObjectLoc(JDNDaysUT, dgeo, datm, "sun", 0, helflag, &AltS, serr);
+  if (retval == OK)
+    retval = ObjectLoc(JDNDaysUT, dgeo, datm, ObjectName, 1, helflag, &AziO, serr);
+  if (retval == OK)
+    retval = ObjectLoc(JDNDaysUT, dgeo, datm, ObjectName, 0, helflag, &AltO, serr);
+  if (retval == OK)
+    retval = ObjectLoc(JDNDaysUT, dgeo, datm, ObjectName, 7, helflag, &GeoAltO, serr);
+  if (retval == ERR)
+    return ERR;
+  AppAltO = AppAltfromTopoAlt(AltO, datm[1], datm[0], helflag);
+  DAZact = AziS - AziO;
+  TAVact = AltO - AltS;
+  /*this parallax seems to be somewhat smaller then in Yallop and SkyMap! Needs to be studied*/
+  ParO = GeoAltO - AltO;
+  if (Magnitude(JDNDaysUT, dgeo, ObjectName, helflag, &MagnO, serr) == ERR)
+    return ERR;
+  ARCVact = TAVact + ParO;
+  ARCLact = acos(cos(ARCVact * DEGTORAD) * cos(DAZact * DEGTORAD)) / DEGTORAD;
+  Planet = DeterObject(ObjectName);
+  if (Planet == -1) {
+    elong = ARCLact;
+    illum = 100;
+  } else {
+    retval = swe_pheno_ut(JDNDaysUT, Planet, iflag|(SEFLG_TOPOCTR|SEFLG_EQUATORIAL), attr, serr);
+    if (retval == ERR) return ERR;
+    elong = attr[2];
+    illum = attr[1] * 100;
+  }
+  kact = kt(AltS, sunra, dgeo[1], dgeo[2], datm[1], datm[2], datm[3], 4, serr);
+  if (0) {
+darr[26] = kR(AltS, dgeo[2]);
+darr[27] = kW(dgeo[2], datm[1], datm[2]);
+darr[28] = kOZ(AltS, sunra, dgeo[1]);
+darr[29] = ka(AltS, sunra, dgeo[1], dgeo[2], datm[1], datm[2], datm[3], serr);
+darr[30] = darr[26] + darr[27] + darr[28] + darr[29];
+  }
+  WMoon = 0;
+  qYal = 0;
+  qCrit = 0;
+  LMoon = 0;
+  if (Planet == SE_MOON) {
+    WMoon = WidthMoon(AltO, AziO, AltS, AziS, ParO);
+    LMoon = LengthMoon(WMoon, 0);
+    qYal = qYallop(WMoon, ARCVact);
+    if (qYal > 0.216) qCrit = 1; /* A */
+    if (qYal < 0.216 && qYal > -0.014) qCrit = 2; /* B */
+    if (qYal < -0.014 && qYal > -0.16) qCrit = 3; /* C */
+    if (qYal < -0.16 && qYal > -0.232) qCrit = 4; /* D */
+    if (qYal < -0.232 && qYal > -0.293) qCrit = 5; /* E */
+    if (qYal < -0.293) qCrit = 6; /* F */
+  }
+  /*determine if rise or set event*/
+  RS = 2;
+  if (TypeEvent == 1 || TypeEvent == 4) RS = 1;
+  retval = RiseSet(JDNDaysUT - 4.0 / 24.0, dgeo, datm, "sun", RS, helflag, 0, &RiseSetS, serr);
+  if (retval == ERR)
+    return ERR;
+  retval = RiseSet(JDNDaysUT - 4.0 / 24.0, dgeo, datm, ObjectName, RS, helflag, 0, &RiseSetO, serr);
+  if (retval == ERR)
+    return ERR;
+  TbYallop = TJD_INVALID;
+  if (retval == -2) { /* object does not rise or set */
+    Lag = 0;
+    noriseO = TRUE;
+  } else {
+    Lag = RiseSetO - RiseSetS;
+    if (Planet == SE_MOON)
+      TbYallop = (RiseSetO * 4 + RiseSetS * 5) / 9.0;
+  }
+  if ((TypeEvent == 3 || TypeEvent == 4) && (Planet == -1 || Planet >= SE_MARS)) {
+    TfirstVR = TJD_INVALID;
+    TbVR = TJD_INVALID;
+    TlastVR = TJD_INVALID;
+    TvisVR = 0;
+    MinTAV = 0;
+    goto output_heliacal_pheno;
+  }
+  /* If HPheno >= 11 And HPheno <= 14 Or HPheno = 24 Then*/
+  /*te bepalen m.b.v. walkthrough*/
+    MinTAVact = 199;
+    DeltaAlt = 0; 
+    OldestDeltaAlt = 0;
+    OldestMinTAV = 0;
+    Ta = 0;
+    Tc = 0;
+    TbVR = 0;
+    TimeStep = -TimeStepDefault / 24.0 / 60.0;
+    if (RS == 2) TimeStep = -TimeStep;
+    TimePointer = RiseSetS - TimeStep;
+    do {
+      TimePointer = TimePointer + TimeStep;
+      OldestDeltaAlt = DeltaAltoud;
+      OldestMinTAV = MinTAVoud;
+      MinTAVoud = MinTAVact;
+      DeltaAltoud = DeltaAlt;
+      retval = ObjectLoc(TimePointer, dgeo, datm, "sun", 0, helflag, &AltS2, serr);
+      if (retval == OK)
+	retval = ObjectLoc(TimePointer, dgeo, datm, ObjectName, 0, helflag, &AltO2, serr);
+      if (retval != OK)
+        return ERR;
+      DeltaAlt = AltO2 - AltS2;
+      if (DeterTAV(dobs, TimePointer, dgeo, datm, ObjectName, helflag, &MinTAVact, serr) == ERR)
+        return ERR;
+      if (MinTAVoud < MinTAVact && TbVR == 0) {
+        /* determine if this is a local minimum with object still above horizon*/
+	TimeCheck = TimePointer + Sgn(TimeStep) * LocalMinStep / 24.0 / 60.0;
+	if (RiseSetO != 0) {
+	  if (TimeStep > 0)
+	    TimeCheck = mymin(TimeCheck, RiseSetO);
+	  else
+	    TimeCheck = mymax(TimeCheck, RiseSetO);
+	}
+        if (DeterTAV(dobs, TimeCheck, dgeo, datm, ObjectName, helflag, &LocalminCheck, serr) == ERR)
+	  return ERR;
+	if (LocalminCheck > MinTAVact) {
+	  extrax = x2min(MinTAVact, MinTAVoud, OldestMinTAV);
+	  TbVR = TimePointer - (1 - extrax) * TimeStep;
+	  MinTAV = funct2(MinTAVact, MinTAVoud, OldestMinTAV, extrax);
+	}
+      }
+      if (DeltaAlt > MinTAVact && Tc == 0 && TbVR == 0) {
+	crosspoint = crossing(DeltaAltoud, DeltaAlt, MinTAVoud, MinTAVact);
+	Tc = TimePointer - TimeStep * (1 - crosspoint);
+      }
+      if (DeltaAlt < MinTAVact && Ta == 0 && Tc != 0) {
+	crosspoint = crossing(DeltaAltoud, DeltaAlt, MinTAVoud, MinTAVact);
+	Ta = TimePointer - TimeStep * (1 - crosspoint);
+      }
+    } while (fabs(TimePointer - RiseSetS) <= MaxTryHours / 24.0 && Ta == 0 && !((TbVR != 0 && (TypeEvent == 3 || TypeEvent == 4) && (strncmp(ObjectName, "moon", 4) != 0 && strncmp(ObjectName, "venus", 5) != 0 && strncmp(ObjectName, "mercury", 7) != 0))));
+    if (RS == 2) {
+      TfirstVR = Tc;
+      TlastVR = Ta;
+    } else {
+      TfirstVR = Ta;
+      TlastVR = Tc;
+    }
+    if (TfirstVR == 0 && TlastVR == 0) {
+      if (RS == 1)
+        TfirstVR = TbVR - 0.000001;
+      else
+        TlastVR = TbVR + 0.000001;
+    }
+    if (!noriseO) {
+      if (RS == 1)
+        TfirstVR = mymax(TfirstVR, RiseSetO);
+      else
+        TlastVR = mymin(TlastVR, RiseSetO);
+    }
+    TvisVR = TJD_INVALID; /*"#NA!" */
+    if (TlastVR != 0 && TfirstVR != 0)
+      TvisVR = TlastVR - TfirstVR;
+    if (TlastVR == 0) TlastVR = TJD_INVALID; /*"#NA!" */
+    if (TbVR == 0) TbVR = TJD_INVALID; /*"#NA!" */
+    if (TfirstVR == 0) TfirstVR = TJD_INVALID; /*"#NA!" */
+output_heliacal_pheno:
+  /*End If*/
+  darr[0] = AltO;
+  darr[1] = AppAltO;
+  darr[2] = GeoAltO;
+  darr[3] = AziO;
+  darr[4] = AltS;
+  darr[5] = AziS;
+  darr[6] = TAVact;
+  darr[7] = ARCVact;
+  darr[8] = DAZact;
+  darr[9] = ARCLact;
+  darr[10] = kact;
+  darr[11] = MinTAV;
+  darr[12] = TfirstVR;
+  darr[13] = TbVR;
+  darr[14] = TlastVR;
+  darr[15] = TbYallop;
+  darr[16] = WMoon;
+  darr[17] = qYal;
+  darr[18] = qCrit;
+  darr[19] = ParO;
+  darr[20] = MagnO;
+  darr[21] = RiseSetO;
+  darr[22] = RiseSetS;
+  darr[23] = Lag;
+  darr[24] = TvisVR;
+  darr[25] = LMoon;
+  darr[26] = elong;
+  darr[27] = illum;
+  return OK;
+}
+
+#if 0
+int32 FAR PASCAL_CONV HeliacalJDut(double JDNDaysUTStart, double Age, double SN, double Lat, double Longitude, double HeightEye, double Temperature, double Pressure, double RH, double VR, char *ObjectName, int TypeEvent, char *AVkind, double *dret, char *serr)
+{
+  double dgeo[3], datm[4], dobs[6];
+  int32 helflag = SE_HELFLAG_HIGH_PRECISION;
+  helflag |= SE_HELFLAG_AVKIND_VR;
+  dgeo[0] = Longitude;
+  dgeo[1] = Lat;
+  dgeo[2] = HeightEye;
+  datm[0] = Pressure;
+  datm[1] = Temperature;
+  datm[2] = RH;
+  datm[3] = VR;
+  dobs[0] = Age;
+  dobs[1] = SN;
+  return swe_heliacal_ut(JDNDaysUTStart, dgeo, datm, dobs, ObjectName, TypeEvent, helflag, dret, serr);
+}
+#endif
+
+static double get_synodic_period(int Planet) 
+{
+  /* synodic periods from:
+   * Kelley/Milone/Aveni, "Exploring ancient Skies", p. 43. */
+  switch(Planet) {
+    case SE_MOON: return 29.530588853;
+    case SE_MERCURY: return 115.8775;
+    case SE_VENUS: return 583.9214;
+    case SE_MARS: return 779.9361;
+    case SE_JUPITER: return 398.8840;
+    case SE_SATURN: return 378.0919;
+    case SE_URANUS: return 369.6560;
+    case SE_NEPTUNE: return 367.4867;
+    case SE_PLUTO: return 366.7207;
+  }
+  return 366; /* for stars and default for far away planets */
+}
+
+/*###################################################################*/
+static int32 moon_event_arc_vis(double JDNDaysUTStart, double *dgeo, double *datm, double *dobs, int32 TypeEvent, int32 helflag, double *dret, char *serr)
+{
+  double x[20], MinTAV, MinTAVoud, OldestMinTAV;
+  double phase1, phase2, JDNDaysUT, JDNDaysUTi;
+  double tjd_moonevent, tjd_moonevent_start;
+  double DeltaAltoud, TimeCheck, LocalminCheck;
+  double AltS, AltO, DeltaAlt = 90;
+  char ObjectName[30];
+  int32 iflag, Daystep, eventtype, goingup, Planet, i, retval;
+  int32 avkind = helflag & SE_HELFLAG_AVKIND;
+  int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  dret[0] = JDNDaysUTStart; /* will be returned in error case */
+  if (avkind == 0)
+    avkind = SE_HELFLAG_AVKIND_VR;
+  if (avkind != SE_HELFLAG_AVKIND_VR) {
+    if (serr != NULL)
+      strcpy(serr, "error: in valid AV kind for the moon");
+    return ERR;
+  }
+  if (TypeEvent == 1 || TypeEvent == 2) {
+    if (serr != NULL)
+      strcpy(serr, "error: the moon has no morning first or evening last");
+    return ERR;
+  }
+  strcpy(ObjectName, "moon");
+  Planet = SE_MOON;
+  iflag = SEFLG_TOPOCTR | SEFLG_EQUATORIAL | epheflag;
+  if (!(helflag & SE_HELFLAG_HIGH_PRECISION))
+    iflag |= SEFLG_NONUT|SEFLG_TRUEPOS;
+  Daystep = 1;
+  if (TypeEvent == 3) {
+    /*morning last */
+    TypeEvent = 2;
+  } else {
+    /*evening first*/
+    TypeEvent = 1;
+    Daystep = -Daystep;
+  }
+  eventtype = TypeEvent + SE_BIT_DISC_CENTER;
+  /* check Synodic/phase Period */
+  JDNDaysUT = JDNDaysUTStart;
+  /* start 30 days later if TypeEvent=4 (1) */
+  if (TypeEvent == 1) JDNDaysUT = JDNDaysUT + 30;
+  /* determination of new moon date */
+  i = swe_pheno_ut(JDNDaysUT, Planet, iflag, x, serr);
+  phase2 = x[0];
+  goingup = 0;
+  do {
+    JDNDaysUT = JDNDaysUT + Daystep;
+    phase1 = phase2;
+    i = swe_pheno_ut(JDNDaysUT, Planet, iflag, x, serr);
+    phase2 = x[0];
+    if (phase2 > phase1) 
+      goingup = 1;
+  } while (goingup == 0 || (goingup == 1 && (phase2 > phase1)));
+  /* fix the date to get the day with the smallest phase (nwest moon) */
+  JDNDaysUT = JDNDaysUT - Daystep;
+  /* initialize the date to look for set */
+  JDNDaysUTi = JDNDaysUT;
+  JDNDaysUT = JDNDaysUT - Daystep;
+  MinTAVoud = 199;
+  do {
+    JDNDaysUT = JDNDaysUT + Daystep;
+    if ((retval = RiseSet(JDNDaysUT, dgeo, datm, ObjectName, TypeEvent, helflag, 0, &tjd_moonevent, serr)) != OK)
+      return retval;
+    tjd_moonevent_start = tjd_moonevent;
+    MinTAV = 199;
+    OldestMinTAV = MinTAV;
+    do {
+      OldestMinTAV = MinTAVoud;
+      MinTAVoud = MinTAV;
+      DeltaAltoud = DeltaAlt;
+      tjd_moonevent = tjd_moonevent - 1.0 / 60.0 / 24.0 * Sgn(Daystep);
+      if (ObjectLoc(tjd_moonevent, dgeo, datm, "sun", 0, helflag, &AltS, serr) == ERR)
+	return ERR;
+      if (ObjectLoc(tjd_moonevent, dgeo, datm, ObjectName, 0, helflag, &AltO, serr) == ERR)
+	return ERR;
+      DeltaAlt = AltO - AltS;
+      if (DeterTAV(dobs, tjd_moonevent, dgeo, datm, ObjectName, helflag, &MinTAV, serr) == ERR)
+        return ERR;
+      TimeCheck = tjd_moonevent - LocalMinStep / 60.0 / 24.0 * Sgn(Daystep);
+      if (DeterTAV(dobs, TimeCheck, dgeo, datm, ObjectName, helflag, &LocalminCheck, serr) == ERR)
+        return ERR;
+/*printf("%f, %f <= %f\n", tjd_moonevent, MinTAV, MinTAVoud);*/
+    /* while (MinTAV <= MinTAVoud && fabs(tjd_moonevent - tjd_moonevent_start) < 120.0 / 60.0 / 24.0);*/
+    } while ((MinTAV <= MinTAVoud || LocalminCheck < MinTAV) && fabs(tjd_moonevent - tjd_moonevent_start) < 120.0 / 60.0 / 24.0);
+  /* while (DeltaAlt < MinTAVoud && fabs(JDNDaysUT - JDNDaysUTi) < 15);*/
+  } while (DeltaAltoud < MinTAVoud && fabs(JDNDaysUT - JDNDaysUTi) < 15);
+  if (fabs(JDNDaysUT - JDNDaysUTi) < 15) {
+    tjd_moonevent += (1 - x2min(MinTAV, MinTAVoud, OldestMinTAV)) * Sgn(Daystep) / 60.0 / 24.0;
+  } else {
+    strcpy(serr, "no date found for lunar event");
+    return ERR;
+  }
+  dret[0] = tjd_moonevent;
+  return OK;
+}
+
+static int32 heliacal_ut_arc_vis(double JDNDaysUTStart, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 TypeEventIn, int32 helflag, double *dret, char *serr_ret)
+{
+  double x[6];
+  double xin[2];
+  double xaz[2];
+  double dang[3];
+  double objectmagn = 0, maxlength, DayStep, DayStep0;
+  double JDNDaysUT, JDNDaysUTfinal, JDNDaysUTstep, JDNDaysUTstepoud, JDNarcvisUT, tjd_tt, tret, OudeDatum, JDNDaysUTinp = JDNDaysUTStart, JDNDaysUTtijd;
+  double ArcusVis, ArcusVisDelta, ArcusVisPto, ArcusVisDeltaoud;
+  double Trise, sunsangle, Theliacal, Tdelta, Angle;
+  double TimeStep, TimePointer, OldestMinTAV, MinTAVoud, MinTAVact, extrax, TbVR = 0;
+  double AziS, AltS, AziO, AltO, DeltaAlt;
+  double direct, Pressure, Temperature, RH, VR, d;
+  int32 epheflag, retval = OK;
+  int32 iflag, Planet, eventtype;
+  int32 TypeEvent = TypeEventIn;
+  int doneoneday;
+  char serr[AS_MAXCH];
+  *dret = JDNDaysUTStart;
+  *serr = '\0';
+  Planet = DeterObject(ObjectName);
+  Pressure = datm[0];
+  Temperature = datm[1];
+  RH = datm[2];
+  VR = datm[3];
+  /* determine Magnitude of star*/
+  if ((retval = Magnitude(JDNDaysUTStart, dgeo, ObjectName, helflag, &objectmagn, serr)) == ERR)
+    goto swe_heliacal_err;
+  epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  iflag = SEFLG_TOPOCTR | SEFLG_EQUATORIAL | epheflag;
+  if (!(helflag & SE_HELFLAG_HIGH_PRECISION)) 
+    iflag |= SEFLG_NONUT | SEFLG_TRUEPOS;
+  /* start values for search of heliacal rise
+   * maxlength = phase period in days, smaller than minimal synodic period */
+  /* days per step (for heliacal rise) in power of two */
+  switch(Planet) {
+    case SE_MERCURY: 
+      DayStep = 1; maxlength = 100; break;
+    case SE_VENUS: 
+      DayStep = 64; maxlength = 384; break;
+    case SE_MARS: 
+      DayStep = 128; maxlength = 640; break;
+    case SE_JUPITER: 
+      DayStep = 64; maxlength = 384; break;
+    case SE_SATURN: 
+      DayStep = 64; maxlength = 256; break;
+    default:
+      DayStep = 64; maxlength = 256; break;
+  }
+  DayStep0 = DayStep;
+  /* heliacal setting */
+  eventtype = TypeEvent;
+  if (eventtype == 2) DayStep = -DayStep;
+  /* acronychal setting */
+  if (eventtype == 4) {
+      eventtype = 1;
+      DayStep = -DayStep;
+  }
+  /* acronychal rising */
+  if (eventtype == 3) eventtype = 2;
+  eventtype |= SE_BIT_DISC_CENTER;
+  /* normalize the maxlength to the step size */
+  {
+    /* check each Synodic/phase Period */
+    JDNDaysUT = JDNDaysUTStart;
+    /* make sure one can find an event on the just after the JDNDaysUTStart */
+    JDNDaysUTfinal = JDNDaysUT + maxlength;
+    JDNDaysUT = JDNDaysUT - 1;
+    if (DayStep < 0) {
+      JDNDaysUTtijd = JDNDaysUT;
+      JDNDaysUT = JDNDaysUTfinal;
+      JDNDaysUTfinal = JDNDaysUTtijd;
+    }
+    /* prepair the search */
+    JDNDaysUTstep = JDNDaysUT - DayStep;
+    doneoneday = 0;
+    ArcusVisDelta = 199;
+    ArcusVisPto = -5.55;
+    do { /* this is a do {} while() loop */
+      if (fabs(DayStep) == 1) doneoneday = 1;
+      do { /* this is a do {} while() loop */
+	/* init search for heliacal rise */
+	JDNDaysUTstepoud = JDNDaysUTstep;
+	ArcusVisDeltaoud = ArcusVisDelta;
+	JDNDaysUTstep = JDNDaysUTstep + DayStep;
+	/* determine rise/set time */
+	if ((retval = my_rise_trans(JDNDaysUTstep, SE_SUN, "", eventtype, helflag, dgeo, datm, &tret, serr)) == ERR)
+	  goto swe_heliacal_err;
+	/* determine time compensation to get Sun's altitude at heliacal rise */
+	tjd_tt = tret + DeltaT(tret, 0) / D2S;
+	if ((retval = swe_calc(tjd_tt, SE_SUN, iflag, x, serr)) == ERR)
+	  goto swe_heliacal_err;
+	xin[0] = x[0];
+	xin[1] = x[1];
+	swe_azalt(tret, SE_EQU2HOR, dgeo, Pressure, Temperature, xin, xaz);
+	Trise = HourAngle(xaz[1], x[1], dgeo[1]);
+	sunsangle = ArcusVisPto;
+	if (helflag & SE_HELFLAG_AVKIND_MIN7) sunsangle = -7;
+	if (helflag & SE_HELFLAG_AVKIND_MIN9) sunsangle = -9;
+	Theliacal = HourAngle(sunsangle, x[1], dgeo[1]);
+	Tdelta = Theliacal - Trise;
+	if (TypeEvent == 2 || TypeEvent== 3) Tdelta = -Tdelta;
+	/* determine appr.time when sun is at the wanted Sun's altitude */
+	JDNarcvisUT = tret - Tdelta / 24;
+	tjd_tt = JDNarcvisUT + DeltaT(JDNarcvisUT, 0) / D2S;
+	/* determine Sun's position */
+	if ((retval = swe_calc(tjd_tt, SE_SUN, iflag, x, serr)) == ERR)
+	  goto swe_heliacal_err;
+	xin[0] = x[0];
+	xin[1] = x[1];
+	swe_azalt(JDNarcvisUT, SE_EQU2HOR, dgeo, Pressure, Temperature, xin, xaz);
+	AziS = xaz[0] + 180;
+	if (AziS >= 360) AziS = AziS - 360;
+	AltS = xaz[1];
+	/* determine Moon's position */
+#if 0
+  double AltM, AziM;
+	if ((retval = swe_calc(tjd_tt, SE_MOON, iflag, x, serr)) == ERR)
+	  goto swe_heliacal_err;
+	xin[0] = x[0];
+	xin[1] = x[1];
+	swe_azalt(JDNarcvisUT, SE_EQU2HOR, dgeo, Pressure, Temperature, xin, xaz);
+	AziM = xaz[0] + 180;
+	if (AziM >= 360) AziM = AziM - 360;
+	AltM = xaz[1];
+#endif
+	/* determine object's position */
+	if (Planet != -1) {
+	  if ((retval = swe_calc(tjd_tt, Planet, iflag, x, serr)) == ERR)
+	    goto swe_heliacal_err;
+	  /* determine magnitude of Planet */
+	  if ((retval = Magnitude(JDNarcvisUT, dgeo, ObjectName, helflag, &objectmagn, serr)) == ERR)
+	    goto swe_heliacal_err;
+	} else {
+	  if ((retval = call_swe_fixstar(ObjectName, tjd_tt, iflag, x, serr)) == ERR)
+	    goto swe_heliacal_err;
+	}
+	xin[0] = x[0];
+	xin[1] = x[1];
+	swe_azalt(JDNarcvisUT, SE_EQU2HOR, dgeo, Pressure, Temperature, xin, xaz);
+	AziO = xaz[0] + 180;
+	if (AziO >= 360) AziO = AziO - 360;
+	AltO = xaz[1];
+	/* determine arcusvisionis */
+	DeltaAlt = AltO - AltS;
+	/*if ((retval = HeliacalAngle(objectmagn, dobs, AziO, AltM, AziM, JDNarcvisUT, AziS, dgeo, datm, helflag, dang, serr)) == ERR)*/
+	if ((retval = HeliacalAngle(objectmagn, dobs, AziO, -1, 0, JDNarcvisUT, AziS, dgeo, datm, helflag, dang, serr)) == ERR)
+	  goto swe_heliacal_err;
+	ArcusVis = dang[1];
+	ArcusVisPto = dang[2];
+	ArcusVisDelta = DeltaAlt - ArcusVis;
+      /*} while (((ArcusVisDeltaoud > 0 && ArcusVisDelta < 0) || ArcusVisDelta < 0) && (JDNDaysUTfinal - JDNDaysUTstep) * Sgn(DayStep) > 0);*/
+      } while ((ArcusVisDeltaoud > 0 || ArcusVisDelta < 0) && (JDNDaysUTfinal - JDNDaysUTstep) * Sgn(DayStep) > 0);
+      if (doneoneday == 0 && (JDNDaysUTfinal - JDNDaysUTstep) * Sgn(DayStep) > 0) {
+	/* go back to date before heliacal altitude */
+	ArcusVisDelta = ArcusVisDeltaoud;
+	DayStep = ((int) (fabs(DayStep) / 2.0)) * Sgn(DayStep);
+	JDNDaysUTstep = JDNDaysUTstepoud;
+      }
+    } while (doneoneday == 0 && (JDNDaysUTfinal - JDNDaysUTstep) * Sgn(DayStep) > 0);
+  }
+  d = (JDNDaysUTfinal - JDNDaysUTstep) * Sgn(DayStep);
+  if (d <= 0 || d >= maxlength) {
+    dret[0] = JDNDaysUTinp; /* no date found, just return input */
+    retval = -2; /* marks "not found" within synodic period */
+    sprintf(serr, "heliacal event not found within maxlength %f\n", maxlength);
+    goto swe_heliacal_err;
+  } 
+#if 0
+  if (helflag & SE_HELFLAG_AVKIND_VR) {
+    double darr[40];
+    if (swe_heliacal_pheno_ut(JDNarcvisUT, dgeo, datm, dobs, ObjectName, TypeEvent, helflag, darr, serr) != OK)
+      return ERR;
+    JDNarcvisUT = darr[13];
+    }
+  }
+#endif
+  direct = TimeStepDefault / 24.0 / 60.0;
+  if (DayStep < 0) direct = -direct;
+  if (helflag & SE_HELFLAG_AVKIND_VR) {
+    /*te bepalen m.b.v. walkthrough*/
+    TimeStep = direct;
+    TbVR = 0;
+    TimePointer = JDNarcvisUT;
+    if (DeterTAV(dobs, TimePointer, dgeo, datm, ObjectName, helflag, &OldestMinTAV, serr) == ERR)
+      return ERR;
+    TimePointer = TimePointer + TimeStep;
+    if (DeterTAV(dobs, TimePointer, dgeo, datm, ObjectName, helflag, &MinTAVoud, serr) == ERR)
+      return ERR;
+    if (MinTAVoud > OldestMinTAV) {
+      TimePointer = JDNarcvisUT;
+      TimeStep = -TimeStep;
+      MinTAVact = OldestMinTAV;
+    } else {
+      MinTAVact = MinTAVoud;
+      MinTAVoud = OldestMinTAV;
+    }
+    /*TimePointer = TimePointer - Timestep*/
+    do {
+      TimePointer = TimePointer + TimeStep;
+      OldestMinTAV = MinTAVoud;
+      MinTAVoud = MinTAVact;
+      if (DeterTAV(dobs, TimePointer, dgeo, datm, ObjectName, helflag, &MinTAVact, serr) == ERR)
+        return ERR;
+      if (MinTAVoud < MinTAVact) {
+	extrax = x2min(MinTAVact, MinTAVoud, OldestMinTAV);
+	TbVR = TimePointer - (1 - extrax) * TimeStep;
+      }
+    } while (TbVR == 0);
+    JDNarcvisUT = TbVR;
+  }
+  /*if (strncmp(AVkind, "pto", 3) == 0) */
+  if (helflag & SE_HELFLAG_AVKIND_PTO) {
+    do {
+      OudeDatum = JDNarcvisUT;
+      JDNarcvisUT = JDNarcvisUT - direct;
+      tjd_tt = JDNarcvisUT + DeltaT(JDNarcvisUT, 0) / D2S;
+      if (Planet != -1) {
+	if ((retval = swe_calc(tjd_tt, Planet, iflag, x, serr)) == ERR)
+	  goto swe_heliacal_err;
+      } else {
+	if ((retval = call_swe_fixstar(ObjectName, tjd_tt, iflag, x, serr)) == ERR)
+	  goto swe_heliacal_err;
+      }
+      xin[0] = x[0];
+      xin[1] = x[1];
+      swe_azalt(JDNarcvisUT, SE_EQU2HOR, dgeo, Pressure, Temperature, xin, xaz);
+      Angle = xaz[1];
+    } while (Angle > 0);
+    JDNarcvisUT = (JDNarcvisUT + OudeDatum) / 2.0;
+  }
+  if (JDNarcvisUT < -9999999 || JDNarcvisUT > 9999999) {
+    dret[0] = JDNDaysUT; /* no date found, just return input */
+    strcpy(serr, "no heliacal date found");
+    retval = ERR;
+    goto swe_heliacal_err;
+  }
+  dret[0] = JDNarcvisUT;
+swe_heliacal_err:
+  if (serr_ret != NULL && *serr != '\0')
+    strcpy(serr_ret, serr);
+  return retval;
+}
+
+static int32 get_asc_obl(double tjd, int32 ipl, char *star, int32 iflag, double
+ *dgeo, AS_BOOL desc_obl, double *daop, char *serr)
+{
+  int32 retval;
+  int32 epheflag = iflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  double x[6], adp;
+  char s[AS_MAXCH];
+  char star2[AS_MAXCH];
+  strcpy(star2, star);
+  if (ipl == -1) {
+    if ((retval = swe_fixstar(star2, tjd, epheflag | SEFLG_EQUATORIAL, x, serr)) == ERR)
+      return ERR;
+  } else {
+    if ((retval = swe_calc(tjd, ipl, epheflag | SEFLG_EQUATORIAL, x, serr)) == ERR)
+      return ERR;
+  }
+  adp = tan(dgeo[1] * DEGTORAD) * tan(x[1] * DEGTORAD);
+  if (fabs(adp) > 1) {
+    if (star != NULL && *star != '\0')
+      strcpy(s, star);
+    else
+      swe_get_planet_name(ipl, s);
+    sprintf(serr, "%s is circumpolar, cannot calculate heliacal event", s);
+    return -2;
+  }
+  adp = asin(adp) / DEGTORAD;
+  if (desc_obl)
+    *daop = x[0] + adp;
+  else
+    *daop = x[0] - adp;
+  *daop = swe_degnorm(*daop);
+  return OK;
+}
+
+#if 0
+static int32 get_asc_obl_old(double tjd, int32 ipl, char *star, int32 iflag, double *dgeo, AS_BOOL desc_obl, double *daop, char *serr)
+{
+  int32 retval;
+  int32 epheflag = iflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  double x[6], adp;
+  char s[AS_MAXCH];
+  if (star != NULL && *star != '\0') {
+    if ((retval = call_swe_fixstar(star, tjd, epheflag | SEFLG_EQUATORIAL, x, serr)) == ERR)
+      return ERR;
+  } else {
+    if ((retval = swe_calc(tjd, ipl, epheflag | SEFLG_EQUATORIAL, x, serr)) == ERR)
+      return ERR;
+  }
+  adp = tan(dgeo[1] * DEGTORAD) * tan(x[1] * DEGTORAD); 
+  if (fabs(adp) > 1) {
+    if (star != NULL && *star != '\0') 
+      strcpy(s, star);
+    else 
+      swe_get_planet_name(ipl, s);
+    sprintf(serr, "%s is circumpolar, cannot calculate heliacal event", s);
+    return -2;
+  }
+  adp = asin(adp) / DEGTORAD;
+  if (desc_obl)
+    *daop = x[0] + adp;
+  else
+    *daop = x[0] - adp;
+  *daop = swe_degnorm(*daop);
+  return OK;
+}
+#endif
+
+static int32 get_asc_obl_diff(double tjd, int32 ipl, char *star, int32 iflag, double *dgeo, AS_BOOL desc_obl, AS_BOOL is_acronychal, double *dsunpl, char *serr)
+{
+  int32 retval = OK;
+  double aosun, aopl;
+  /* ascensio obliqua of sun */
+  retval = get_asc_obl(tjd, SE_SUN, "", iflag, dgeo, desc_obl, &aosun, serr);
+  if (retval != OK)
+    return retval;
+  if (is_acronychal) {
+    if (desc_obl == TRUE)
+      desc_obl = FALSE;
+    else
+      desc_obl = TRUE;
+  }
+  /* ascensio obliqua of body */
+  retval = get_asc_obl(tjd, ipl, star, iflag, dgeo, desc_obl, &aopl, serr);
+  if (retval != OK)
+    return retval;
+  *dsunpl = swe_degnorm(aosun - aopl);
+  if (is_acronychal)
+    *dsunpl = swe_degnorm(*dsunpl - 180);
+  if (*dsunpl > 180) *dsunpl -= 360;
+  return OK;
+}
+
+#if 0
+static int32 get_asc_obl_diff_old(double tjd, int32 ipl, char *star, int32 iflag, double *dgeo, AS_BOOL desc_obl, double *dsunpl, char *serr)
+{
+  int32 retval = OK;
+  double aosun, aopl;
+  /* ascensio obliqua of sun */
+  retval = get_asc_obl(tjd, SE_SUN, "", iflag, dgeo, desc_obl, &aosun, serr);
+  if (retval != OK)
+    return retval;
+  /* ascensio obliqua of body */
+  retval = get_asc_obl(tjd, ipl, star, iflag, dgeo, desc_obl, &aopl, serr);
+  if (retval != OK)
+    return retval;
+  *dsunpl = swe_degnorm(aosun - aopl);
+  return OK;
+}
+#endif
+
+/* times of 
+ * - superior and inferior conjunction (Mercury and Venus)
+ * - conjunction and opposition (ipl >= Mars)
+ */
+static double tcon[] =
+{
+  0, 0, 
+  2451550, 2451550,  /* Moon */
+  2451604, 2451670,  /* Mercury */
+  2451980, 2452280,  /* Venus */
+  2451727, 2452074,  /* Mars */
+  2451673, 2451877,  /* Jupiter */ 
+  2451675, 2451868,  /* Saturn */
+  2451581, 2451768,  /* Uranus */ 
+  2451568, 2451753,  /* Neptune */
+};
+
+static int32 find_conjunct_sun(double tjd_start, int32 ipl, int32 helflag, int32 TypeEvent, double *tjd, char *serr)
+{
+  int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  int i;
+  double tjdcon, tjd0, ds, dsynperiod, x[6], xs[6], daspect = 0;
+  if (ipl >= SE_MARS && TypeEvent >= 3)
+    daspect = 180;
+  i = (TypeEvent - 1) / 2 + ipl * 2;
+  tjd0 = tcon[i];
+  dsynperiod = get_synodic_period(ipl);
+  tjdcon = tjd0 + ((floor) ((tjd_start - tjd0) / dsynperiod) + 1) * dsynperiod;
+  ds = 100;
+  while (ds > 0.5) {
+    if (swe_calc(tjdcon, ipl, epheflag|SEFLG_SPEED, x, serr) == ERR)
+      return ERR;
+    if (swe_calc(tjdcon, SE_SUN, epheflag|SEFLG_SPEED, xs, serr) == ERR)
+      return ERR;
+    ds = swe_degnorm(x[0] - xs[0] - daspect);
+    if (ds > 180) ds -= 360;
+    tjdcon -= ds / (x[3] - xs[3]);
+  }
+  *tjd = tjdcon;
+  return OK;
+}
+
+static int32 get_asc_obl_with_sun(double tjd_start, int32 ipl, char *star, int32 helflag, int32 evtyp, double dperiod, double *dgeo, double *tjdret, char *serr)
+{
+  int i, retval;
+  int32 is_acronychal = FALSE;
+  int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  double dsunpl = 1, dsunpl_save, dsunpl_test, tjd, daystep;
+  AS_BOOL desc_obl = FALSE, retro = FALSE;
+  if (evtyp == SE_EVENING_LAST || evtyp == SE_EVENING_FIRST)
+    desc_obl = TRUE;
+  if (evtyp == SE_MORNING_FIRST || evtyp == SE_EVENING_LAST)
+    retro = TRUE;
+  if (evtyp == SE_ACRONYCHAL_RISING)
+    desc_obl = TRUE;
+  if (evtyp == SE_ACRONYCHAL_RISING || evtyp ==  SE_ACRONYCHAL_SETTING) {
+    is_acronychal = TRUE;
+    if (ipl != SE_MOON)
+      retro = TRUE;
+  }
+  //  if (evtyp == 3 || evtyp == 4)
+  //    dangsearch = 180;
+  /* find date when sun and object have the same ascensio obliqua */
+  tjd = tjd_start;
+  dsunpl_save = -999999999;
+  retval = get_asc_obl_diff(tjd, ipl, star, epheflag, dgeo, desc_obl, is_acronychal, &dsunpl, serr);
+  if (retval != OK)  /* retval may be ERR or -2 */
+    return retval;
+  daystep = 20;
+  i = 0;
+  while (dsunpl_save == -999999999 ||
+      /*fabs(dsunpl - dsunpl_save) > 180 ||*/
+      fabs(dsunpl) + fabs(dsunpl_save) > 180 ||
+      (retro && !(dsunpl_save < 0 && dsunpl >= 0)) ||
+      (!retro && !(dsunpl_save >= 0 && dsunpl < 0))) {
+    i++;
+    if (i > 5000) {
+      sprintf(serr, "loop in get_asc_obl_with_sun() (1)");
+      return ERR;
+    }
+    dsunpl_save = dsunpl;
+    tjd += 10.0;
+    if (dperiod > 0 && tjd - tjd_start > dperiod)
+      return -2;
+    retval = get_asc_obl_diff(tjd, ipl, star, epheflag, dgeo, desc_obl, is_acronychal, &dsunpl, serr);
+    if (retval != OK)  /* retval may be ERR or -2 */
+      return retval;
+  }
+  tjd_start = tjd - daystep;
+  daystep /= 2.0;
+  tjd = tjd_start + daystep;
+  retval = get_asc_obl_diff(tjd, ipl, star, epheflag, dgeo, desc_obl, is_acronychal, &dsunpl_test, serr);
+  if (retval != OK)  /* retval may be ERR or -2 */
+    return retval;
+  i = 0;
+  while (fabs(dsunpl) > 0.00001) {
+    i++;
+    if (i > 5000) {
+      sprintf(serr, "loop in get_asc_obl_with_sun() (2)");
+      return ERR;
+    }
+    if (dsunpl_save * dsunpl_test >= 0) {
+      dsunpl_save = dsunpl_test;
+      tjd_start = tjd;
+    } else {
+      dsunpl = dsunpl_test;
+    }
+    daystep /= 2.0;
+    tjd = tjd_start + daystep;
+    retval = get_asc_obl_diff(tjd, ipl, star, epheflag, dgeo, desc_obl, is_acronychal, &dsunpl_test, serr);
+    if (retval != OK)  /* retval may be ERR or -2 */
+      return retval;
+  }
+  *tjdret = tjd;
+  return OK;
+}
+
+#if 0
+/* works only for fixed stars */
+static int32 get_asc_obl_with_sun_old(double tjd_start, int32 ipl, char *star, int32 helflag, int32 TypeEvent, double *dgeo, double *tjdret, char *serr)
+{
+  int retval;
+  int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  double dsunpl = 1, tjd, daystep, dsunpl_save;
+  double dsynperiod = 367;
+  double dangsearch = 0;
+  AS_BOOL desc_obl = FALSE;
+  if (TypeEvent == 2 || TypeEvent == 3)
+    desc_obl = TRUE;
+  if (TypeEvent == 3 || TypeEvent == 4)
+    dangsearch = 180;
+  /* find date when sun and object have the same ascensio obliqua */
+  daystep = dsynperiod;
+  tjd = tjd_start;
+  retval = get_asc_obl_diff(tjd, ipl, star, epheflag, dgeo, desc_obl, &dsunpl, serr);
+  if (retval != OK)  /* retval may be ERR or -2 */
+    return retval;
+  while (dsunpl < 359.99999) {
+    dsunpl_save = dsunpl;
+    daystep /= 2.0;
+    retval = get_asc_obl_diff(tjd + daystep, ipl, star, epheflag, dgeo, desc_obl, &dsunpl, serr);
+    if (retval != OK)  /* retval may be ERR or -2 */
+      return retval;
+    if (dsunpl > dsunpl_save)
+      tjd += daystep;
+    else
+      dsunpl = dsunpl_save;
+  }
+  *tjdret = tjd;
+  return OK;
+}
+#endif
+
+#if 0
+/* works only for fixed stars */
+static int32 get_asc_obl_acronychal(double tjd_start, int32 ipl, char *star, int32 helflag, int32 TypeEvent, double *dgeo, double *tjdret, char *serr)
+{
+  int retval;
+  int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  double dsunpl = 1, tjd, daystep, dsunpl_save;
+  double dsynperiod = 367;
+  double aosun, aopl;
+  AS_BOOL sun_desc = TRUE, obj_desc = FALSE;
+  daystep = dsynperiod;
+  tjd = tjd_start;
+  if (TypeEvent == 4) {
+    sun_desc = FALSE; 
+    obj_desc = TRUE;
+  }
+  /* ascensio (descensio) obliqua of sun */
+  retval = get_asc_obl(tjd, SE_SUN, "", epheflag, dgeo, sun_desc, &aosun, serr);
+  if (retval != OK)  /* retval may be ERR or -2 */
+    return retval;
+  /* ascensio (descensio) obliqua of body */
+  retval = get_asc_obl(tjd, ipl, star, epheflag, dgeo, obj_desc, &aopl, serr);
+  if (retval != OK)  /* retval may be ERR or -2 */
+    return retval;
+  dsunpl = swe_degnorm(aosun - aopl + 180);
+  while (dsunpl < 359.99999) {
+    dsunpl_save = dsunpl;
+    daystep /= 2.0;
+    /* ascensio (descensio) obliqua of sun */
+    retval = get_asc_obl(tjd+daystep, SE_SUN, "", epheflag, dgeo, sun_desc, &aosun, serr);
+    if (retval != OK)  /* retval may be ERR or -2 */
+      return retval;
+    /* ascensio (descensio) obliqua of body */
+    retval = get_asc_obl(tjd+daystep, ipl, star, epheflag, dgeo, obj_desc, &aopl, serr);
+    if (retval != OK)  /* retval may be ERR or -2 */
+      return retval;
+    dsunpl = swe_degnorm(aosun - aopl + 180);
+    if (dsunpl > dsunpl_save)
+      tjd += daystep;
+    else
+      dsunpl = dsunpl_save;
+  }
+  *tjdret = tjd;
+  return OK;
+}
+#endif
+
+static int32 get_heliacal_day(double tjd, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 helflag, int32 TypeEvent, double *thel, char *serr)
+{
+  int32 is_rise_or_set, ndays, retval, retval_old;
+  double direct_day, direct_time, tfac, tend, daystep, tday, vdelta, tret;
+  double darr[30], tsave, vd, dmag;
+  int32 ipl = DeterObject(ObjectName);
+  /* 
+   * find the day and minute on which the object becomes visible 
+   */
+  switch (TypeEvent) {
+    /* morning first */
+    case 1: is_rise_or_set = SE_CALC_RISE; 
+      direct_day = 1; direct_time = -1;
+      break;
+    /* evening last */
+    case 2: is_rise_or_set = SE_CALC_SET; 
+      direct_day = -1; direct_time = 1;
+      break;
+    /* evening first */
+    case 3: is_rise_or_set = SE_CALC_SET; 
+      direct_day = 1; direct_time = 1;
+      break;
+    /* morning last */
+    case 4: is_rise_or_set = SE_CALC_RISE; 
+      direct_day = -1; direct_time = -1;
+      break;
+  }
+  tfac = 1;
+  switch (ipl) {
+    case SE_MOON: 
+      ndays = 6; 
+      daystep = 1;
+      break;
+    case SE_MERCURY: 
+      ndays = 60; tjd -= 0 * direct_day; 
+      daystep = 5;
+      tfac = 5;
+      break;
+    case SE_VENUS: 
+      ndays = 300; tjd -= 30 * direct_day; 
+      daystep = 5;
+      if (TypeEvent >= 3) {
+	daystep = 15;
+        tfac = 3;
+      }
+      break;
+    case SE_MARS: 
+      ndays = 400; 
+      daystep = 15;
+      tfac = 5;
+      break; 
+    case SE_SATURN: 
+      ndays = 300; 
+      daystep = 20;
+      tfac = 5;
+      break; 
+    case -1:
+      ndays = 300;
+      if (call_swe_fixstar_mag(ObjectName, &dmag, serr) == ERR)
+	return ERR;
+      daystep = 15;
+      tfac = 10;
+      if (dmag > 2) {
+        daystep = 15;
+      }
+      break;
+    default:
+      ndays = 300; 
+      daystep = 15;
+      tfac = 3;
+      break;
+  }
+  tend = tjd + ndays * direct_day;
+  retval_old = -2;
+  for (tday = tjd;
+       (direct_day > 0 && tday < tend) || (direct_day < 0 && tday > tend);
+       tday += daystep * direct_day) {
+    vdelta = -100; 
+    if ((retval = my_rise_trans(tday, SE_SUN, "", is_rise_or_set, helflag, dgeo, datm, &tret, serr)) == ERR)
+      return ERR;
+    /* sun does not rise: try next day */
+    if (retval == -2) {
+      retval_old = retval;
+      continue;
+    }
+    retval = swe_vis_limit_mag(tret, dgeo, datm, dobs, ObjectName, helflag, darr, serr);
+    if (retval == ERR)
+      return ERR;
+#if 1
+    /*  object has appeared above horizon: reduce daystep */
+    if (retval_old == -2 && retval >= 0 && daystep > 1) {
+      retval_old = retval;
+      tday -= daystep * direct_day;
+      daystep = 1;
+      /* Note: beyond latitude 55N (?), Mars can have a morning last. 
+       * If the period of visibility is less than 5 days, we may miss the
+       * event. I don't know if this happens */
+      if (ipl >= SE_MARS || ipl == -1)
+        daystep = 5;
+      continue;
+    }
+    retval_old = retval;
+#endif
+    /*  object below horizon: try next day */
+    if (retval == -2)
+      continue;
+    vdelta = darr[0] - darr[7];
+    /* find minute of object's becoming visible */
+    tsave = tret;
+    while (retval != -2 && (vd = darr[0] - darr[7]) < 0) {
+      if (vd < -1.0)
+	tret += 5.0 / 1440.0 * direct_time * tfac;
+      else if (vd < -0.5)
+	tret += 2.0 / 1440.0 * direct_time * tfac;
+      else if (vd < -0.1)
+	tret += 1.0 / 1440.0 * direct_time * tfac;
+      else 
+	tret += 1.0 / 1440.0 * direct_time;
+      retval = swe_vis_limit_mag(tret, dgeo, datm, dobs, ObjectName, helflag, darr, serr);
+      if (retval == ERR)
+	return ERR;
+    }
+    vdelta = darr[0] - darr[7];
+    /* object is visible, save time of appearance */
+    if (vdelta > 0) {
+      if ((ipl >= SE_MARS || ipl == -1) && daystep > 1) {
+	tday -= daystep * direct_day;
+	daystep = 1;
+      } else {
+	*thel = tret;
+	return OK;
+      }
+    }
+  }
+  sprintf(serr, "heliacal event does not happen");
+  return -2;
+}
+
+#if 0
+static int32 get_acronychal_day_new(double tjd, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 helflag, int32 TypeEvent, double *thel, char *serr) {
+  double tjdc = tjd, tret, x[6], xaz[6], AltO = -10;
+  int32 retval, is_rise_or_set, iter_day;
+  int32 ipl = DeterObject(ObjectName);
+  int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  int32 iflag = epheflag | SEFLG_EQUATORIAL | SEFLG_TOPOCTR;
+  if ((retval = my_rise_trans(tret, 0, ObjectName, SE_CALC_RISE, helflag, dgeo, datm, &tret, serr)) == ERR) return ERR;
+  trise = tret;
+  tret += 0.01
+  if ((retval = my_rise_trans(tret, 0, ObjectName, SE_CALC_SET, helflag, dgeo, datm, &tret, serr)) == ERR) return ERR;
+  trise = tset;
+
+  *thel = tret;
+  return OK;
+}
+#endif
+
+#if 0
+static int32 get_acronychal_day_old(double tjd, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 helflag, int32 TypeEvent, double *thel, char *serr) {
+  double tjdc = tjd, tret, x[6], xaz[6], AltO = -10;
+  int32 retval, is_rise_or_set, iter_day;
+  int32 ipl = DeterObject(ObjectName);
+  int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  int32 iflag = epheflag | SEFLG_EQUATORIAL | SEFLG_TOPOCTR;
+  if (TypeEvent == 3) {
+    is_rise_or_set = SE_CALC_SET; 
+    tret = tjdc - 3;
+    if (ipl >= SE_MARS)
+      tret = tjdc - 3;
+    iter_day = 1;
+  } else {
+    is_rise_or_set = SE_CALC_RISE; 
+    tret = tjdc + 3;
+    if (ipl >= SE_MARS)
+      tret = tjdc + 3;
+    iter_day = -1;
+  }
+  while (AltO < 0) {
+    tret += 0.3 * iter_day;
+    if (iter_day == -1)
+      tret -= 1;
+    retval = my_rise_trans(tret, SE_SUN, "", is_rise_or_set, helflag, dgeo, datm, &tret, serr);
+    if (retval != OK)
+      return retval;
+    /* determine object's position */
+    if (ipl == -1)
+      retval = call_swe_fixstar(ObjectName, tret+swe_deltat(tret), iflag, x, serr);
+    else 
+      retval = swe_calc(tret+swe_deltat(tret), ipl, iflag, x, serr);
+    if (retval == ERR) return ERR;
+    swe_azalt(tret, SE_EQU2HOR, dgeo, datm[0], datm[1], x, xaz);
+    AltO = xaz[2];
+  }
+  *thel = tret;
+  return OK;
+}
+#endif
+
+static int32 time_optimum_visibility(double tjd, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 helflag, double *tret, char *serr)
+{
+  int32 retval, retval_sv, i;
+  double d, vl, darr[10], phot_scot_opic, phot_scot_opic_sv;
+  *tret = tjd;
+  retval = swe_vis_limit_mag(tjd, dgeo, datm, dobs, ObjectName, helflag, darr, serr);
+  if (retval == ERR) return ERR;
+  retval_sv = retval;
+  vl = darr[0] - darr[7];
+  phot_scot_opic_sv = retval & SE_SCOTOPIC_FLAG;
+  for (i = 0, d = 100.0 / 86400.0; i < 3; i++, d /= 10.0) {
+    while((retval = swe_vis_limit_mag(tjd - d, dgeo, datm, dobs, ObjectName, helflag, darr, serr)) >= 0 
+	&& darr[0] > darr[7] 
+	&& darr[0] - darr[7] > vl) { 
+      tjd -= d; vl = darr[0] - darr[7]; 
+      retval_sv = retval;
+      phot_scot_opic_sv = retval & SE_SCOTOPIC_FLAG;
+    /*  printf("1: %f\n", darr[8]);*/
+    }
+    if (retval == ERR) return ERR;
+    while((retval = swe_vis_limit_mag(tjd + d, dgeo, datm, dobs, ObjectName, helflag, darr, serr)) >= 0 
+        && darr[0] > darr[7] 
+	&& darr[0] - darr[7] > vl) { 
+      tjd += d; vl = darr[0] - darr[7]; 
+      retval_sv = retval;
+      phot_scot_opic_sv = retval & SE_SCOTOPIC_FLAG;
+    /*  printf("2: %f\n", darr[8]);*/
+    }
+    if (retval == ERR) return ERR;
+  }
+    /*  printf("3: %f <-> %f\n", darr[8], phot_scot_opic_sv);*/
+  *tret = tjd;
+  if (retval >= 0) {
+    /* search for optimum came to an end because change scotopic/photopic: */
+    phot_scot_opic = (retval & SE_SCOTOPIC_FLAG);
+    if (phot_scot_opic_sv != phot_scot_opic) {
+      /* calling function writes warning into serr */
+      return -2;
+    }
+    /* valid result found but it is close to the scotopic/photopic limit */
+    if (retval_sv & SE_MIXEDOPIC_FLAG) {
+      return -2;
+    }
+  }
+  return OK;
+}
+
+static int32 time_limit_invisible(double tjd, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 helflag, int32 direct, double *tret, char *serr)
+{
+  int32 retval, retval_sv, i, ncnt = 3;
+  double d = 0, darr[10], phot_scot_opic, phot_scot_opic_sv;
+  double d0 = 100.0 / 86400.0, tjd_save;
+  *tret = tjd;
+  tjd_save = tjd;
+  if (strcmp(ObjectName, "moon") == 0) {
+    d0 *= 10;
+    ncnt = 4;
+  }
+  retval = swe_vis_limit_mag(tjd + d * direct, dgeo, datm, dobs, ObjectName, helflag, darr, serr);
+  if (retval == ERR) return ERR;
+  retval_sv = retval;
+  phot_scot_opic_sv = retval & SE_SCOTOPIC_FLAG;
+  for (i = 0, d = d0; i < ncnt; i++, d /= 10.0) {
+    while((retval = swe_vis_limit_mag(tjd + d * direct, dgeo, datm, dobs, ObjectName, helflag, darr, serr)) >= 0 
+        && darr[0] > darr[7]) { 
+      tjd += d * direct; 
+      retval_sv = retval;
+      phot_scot_opic_sv = retval & SE_SCOTOPIC_FLAG;
+  /*    printf("%d: %f\n", direct, darr[8]); */
+    }
+  }
+   /*   printf("4: %f, %f/%f %f <-> %f\n", darr[8], darr[0], darr[7], tjd, phot_scot_opic_sv); */
+  *tret = tjd;
+  /* if object disappears at setting, retval is -2, but we want it OK, and
+   * also suppress the warning "object is below local horizon" */
+  *serr = '\0'; 
+  if (retval >= 0) {
+    /* search for limit came to an end because change scotopic/photopic: */
+    phot_scot_opic = (retval & SE_SCOTOPIC_FLAG);
+    if (phot_scot_opic_sv != phot_scot_opic) {
+      /* calling function writes warning into serr */
+      return -2;
+    }
+    /* valid result found but it is close to the scotopic/photopic limit */
+    if (retval_sv & SE_MIXEDOPIC_FLAG) {
+      return -2;
+    }
+  }
+  return OK;
+}
+
+static int32 get_acronychal_day(double tjd, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 helflag, int32 TypeEvent, double *thel, char *serr) {
+  double tret, tret_dark, darr[30], dtret, dtret_save;
+  /* x[6], xaz[6], alto, azio, alto_dark, azio_dark;*/
+  int32 retval, is_rise_or_set, direct;
+  int32 ipl = DeterObject(ObjectName);
+  helflag |= SE_HELFLAG_VISLIM_PHOTOPIC;
+  /*int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);*/
+  /* int32 iflag = epheflag | SEFLG_EQUATORIAL | SEFLG_TOPOCTR;*/
+  if (TypeEvent == 3 || TypeEvent == 5) {
+    is_rise_or_set = SE_CALC_RISE; 
+    /* tret = tjdc - 3;
+    if (ipl >= SE_MARS)
+      tret = tjdc - 3;*/
+    direct = -1;
+  } else {
+    is_rise_or_set = SE_CALC_SET; 
+    /*tret = tjdc + 3;
+    if (ipl >= SE_MARS)
+      tret = tjdc + 3;*/
+    direct = 1;
+  }
+  dtret = 999;
+#if 0
+  while (fabs(dtret) > 0.5) {
+#else
+  while (fabs(dtret) > 0.5 / 1440.0) {
+#endif
+    tjd += 0.7 * direct;
+    if (direct < 0) tjd -= 1;
+    retval = my_rise_trans(tjd, ipl, ObjectName, is_rise_or_set, helflag, dgeo, datm, &tjd, serr);
+    if (retval == ERR) return ERR;
+    retval = swe_vis_limit_mag(tjd, dgeo, datm, dobs, ObjectName, helflag, darr, serr);
+    while(darr[0] < darr[7]) {
+      tjd += 10.0 / 1440.0 * -direct;
+      retval = swe_vis_limit_mag(tjd, dgeo, datm, dobs, ObjectName, helflag, darr, serr);
+    }
+    retval = time_limit_invisible(tjd, dgeo, datm, dobs, ObjectName, helflag | SE_HELFLAG_VISLIM_DARK, direct, &tret_dark, serr);
+    if (retval == ERR) return ERR;
+    retval = time_limit_invisible(tjd, dgeo, datm, dobs, ObjectName, helflag | SE_HELFLAG_VISLIM_NOMOON, direct, &tret, serr);
+    if (retval == ERR) return ERR;
+    dtret_save = dtret;
+#if 0
+    if (azalt_cart(tret_dark, dgeo, datm, ObjectName, helflag, darr, serr) == ERR)
+      return ERR;
+    if (azalt_cart(tret, dgeo, datm, ObjectName, helflag, darr+6, serr) == ERR)
+      return ERR;
+    dtret = acos(swi_dot_prod_unit(darr+3, darr+9)) / DEGTORAD;
+#else
+    dtret = fabs(tret - tret_dark);
+#endif
+/*printf("dtret = %f - %f\n", dtret * 1440, fabs(dtret - dtret_save) * 1440);*/
+  }
+  if (azalt_cart(tret, dgeo, datm, "sun", helflag, darr, serr) == ERR)
+    return ERR;
+  *thel = tret;
+  if (darr[1] < -12) {
+    sprintf(serr, "acronychal rising/setting not available, %f", darr[1]);
+    return OK;
+  } else {
+    sprintf(serr, "solar altitude, %f", darr[1]);
+  }
+  return OK;
+}
+
+static int32 get_heliacal_details(double tday, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 TypeEvent, int32 helflag, double *dret, char *serr)
+{
+  int32 i, retval, direct;
+  AS_BOOL optimum_undefined, limit_1_undefined, limit_2_undefined;
+  /* find next optimum visibility */
+  optimum_undefined = FALSE;
+  retval = time_optimum_visibility(tday, dgeo, datm, dobs, ObjectName, helflag, &(dret[1]), serr);
+  if (retval == ERR) return ERR;
+  if (retval == -2) {
+    retval = OK;
+    optimum_undefined = TRUE; /* change photopic <-> scotopic vision */
+  }
+  /* find moment of becoming visible */
+  direct = 1;
+  if (TypeEvent == 1 || TypeEvent == 4)
+    direct = -1;
+  limit_1_undefined = FALSE;
+  retval = time_limit_invisible(tday, dgeo, datm, dobs, ObjectName, helflag, direct, &(dret[0]), serr);
+  if (retval == ERR) return ERR;
+  if (retval == -2) {
+    retval = OK;
+    limit_1_undefined = TRUE; /* change photopic <-> scotopic vision */
+  }
+  /* find moment of end of visibility */
+  direct *= -1;
+  limit_2_undefined = FALSE;
+  retval = time_limit_invisible(dret[1], dgeo, datm, dobs, ObjectName, helflag, direct, &(dret[2]), serr);
+  if (retval == ERR) return ERR;
+  if (retval == -2) {
+    retval = OK;
+    limit_2_undefined = TRUE; /* change photopic <-> scotopic vision */
+  }
+  /* correct sequence of times: 
+   * with event types 2 and 3 swap dret[0] and dret[2] */
+  if (TypeEvent == 2 || TypeEvent == 3) {
+    tday = dret[2];
+    dret[2] = dret[0];
+    dret[0] = tday;
+    i = (int) limit_1_undefined;
+    limit_1_undefined = limit_2_undefined;
+    limit_2_undefined = (AS_BOOL) i;
+  }
+  /*if (retval == OK && dret[0] == dret[1]) */
+  if (optimum_undefined || limit_1_undefined || limit_2_undefined) {
+    sprintf(serr, "return values [");
+    if (limit_1_undefined)
+      strcat(serr, "0,");
+    if (optimum_undefined)
+      strcat(serr, "1,");
+    if (limit_2_undefined)
+      strcat(serr, "2,");
+    strcat(serr, "] are uncertain due to change between photopic and scotopic vision");
+  }
+  return OK;
+}
+
+static int32 heliacal_ut_vis_lim(double tjd_start, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 TypeEventIn, int32 helflag, double *dret, char *serr_ret)
+{
+  int i;
+  double d, darr[10], direct = 1, tjd, tday;
+  int32 epheflag, retval = OK, helflag2;
+  int32 iflag, ipl;
+  int32 TypeEvent = TypeEventIn;
+  char serr[AS_MAXCH];
+  for (i = 0; i < 10; i++)
+    dret[i] = 0;
+  *dret = tjd_start;
+  *serr = '\0';
+  ipl = DeterObject(ObjectName);
+  epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  iflag = SEFLG_TOPOCTR | SEFLG_EQUATORIAL | epheflag;
+  if (!(helflag & SE_HELFLAG_HIGH_PRECISION)) 
+    iflag |= SEFLG_NONUT | SEFLG_TRUEPOS;
+  if (ipl == SE_MERCURY)
+    tjd = tjd_start - 30;
+  else
+    tjd = tjd_start - 50; /* -50 makes sure, that no event is missed, 
+                         * but may return an event before start date */
+  helflag2 = helflag;
+  /*helflag2 &= ~SE_HELFLAG_HIGH_PRECISION;*/
+  /* 
+   * heliacal event
+   */
+  if (ipl == SE_MERCURY || ipl == SE_VENUS || TypeEvent <= 2) {
+    if (ipl == -1) {
+      /* find date when star rises with sun (cosmic rising) */
+    retval = get_asc_obl_with_sun(tjd, ipl, ObjectName, helflag, TypeEvent, 0, dgeo, &tjd, serr);
+      if (retval != OK)
+	goto swe_heliacal_err; /* retval may be -2 or ERR */
+    } else {
+      /* find date of conjunction of object with sun */
+      if ((retval = find_conjunct_sun(tjd, ipl, helflag, TypeEvent, &tjd, serr)) == ERR)
+	goto swe_heliacal_err;
+    }
+    /* find the day and minute on which the object becomes visible */
+    retval = get_heliacal_day(tjd, dgeo, datm, dobs, ObjectName, helflag2, TypeEvent, &tday, serr); 
+    if (retval != OK)
+      goto swe_heliacal_err;
+  /* 
+   * acronychal event
+   */
+  } else {
+    if (1 || ipl == -1) {
+      /*retval = get_asc_obl_acronychal(tjd, ipl, ObjectName, helflag2, TypeEvent, dgeo, &tjd, serr);*/
+      retval = get_asc_obl_with_sun(tjd, ipl, ObjectName, helflag, TypeEvent, 0, dgeo, &tjd, serr);
+      if (retval != OK)
+	goto swe_heliacal_err;
+    } else {
+      /* find date of conjunction of object with sun */
+      if ((retval = find_conjunct_sun(tjd, ipl, helflag, TypeEvent, &tjd, serr)) == ERR)
+	goto swe_heliacal_err;
+    }
+    tday = tjd;
+    retval = get_acronychal_day(tjd, dgeo, datm, dobs, ObjectName, helflag2, TypeEvent, &tday, serr);
+    if (retval != OK)
+      goto swe_heliacal_err;
+  }
+  dret[0] = tday;
+  if (!(helflag & SE_HELFLAG_NO_DETAILS)) {
+    /* more precise event times for 
+     * - morning first, evening last
+     * - venus and mercury's evening first and morning last
+     */
+    if (ipl == SE_MERCURY || ipl == SE_VENUS || TypeEvent <= 2) {
+      retval = get_heliacal_details(tday, dgeo, datm, dobs, ObjectName, TypeEvent, helflag2, dret, serr);
+      if (retval == ERR) goto swe_heliacal_err;
+    } else if (0) {
+      if (TypeEvent == 4 || TypeEvent == 6) direct = -1;
+      for (i = 0, d = 100.0 / 86400.0; i < 3; i++, d /= 10.0) {
+	while((retval = swe_vis_limit_mag(*dret + d * direct, dgeo, datm, dobs, ObjectName, helflag, darr, serr)) == -2 || (retval >= 0 && darr[0] < darr[7])) { 
+	  *dret += d * direct; 
+	}
+      }
+      /* the last time step must be added */
+      if (retval == OK)
+	*dret += 1.0 / 86400.0 * direct;
+    }
+  } /* if (1) */
+swe_heliacal_err:
+  if (serr_ret != NULL && *serr != '\0')
+    strcpy(serr_ret, serr);
+  return retval;
+}
+
+/*###################################################################*/
+static int32 moon_event_vis_lim(double tjdstart, double *dgeo, double *datm, double *dobs, int32 TypeEvent, int32 helflag, double *dret, char *serr_ret)
+{
+  double tjd, trise;
+  char serr[AS_MAXCH];
+  char ObjectName[30];
+  int32 iflag, Daystep, eventtype, ipl, retval, helflag2, direct;
+  int32 epheflag = helflag & (SEFLG_JPLEPH|SEFLG_SWIEPH|SEFLG_MOSEPH);
+  dret[0] = tjdstart; /* will be returned in error case */
+  if (TypeEvent == 1 || TypeEvent == 2) {
+    if (serr != NULL)
+      strcpy(serr, "error: the moon has no morning first or evening last");
+    return ERR;
+  }
+  strcpy(ObjectName, "moon");
+  ipl = SE_MOON;
+  iflag = SEFLG_TOPOCTR | SEFLG_EQUATORIAL | epheflag;
+  if (!(helflag & SE_HELFLAG_HIGH_PRECISION))
+    iflag |= SEFLG_NONUT|SEFLG_TRUEPOS;
+  helflag2 = helflag;
+  helflag2 &= ~SE_HELFLAG_HIGH_PRECISION;
+  Daystep = 1;
+  eventtype = TypeEvent + SE_BIT_DISC_CENTER;
+  /* check Synodic/phase Period */
+  tjd = tjdstart - 30; /* -50 makes sure, that no event is missed, 
+                         * but may return an event before start date */
+  if ((retval = find_conjunct_sun(tjd, ipl, helflag, TypeEvent, &tjd, serr)) == ERR)
+    return ERR;
+  /* find the day and minute on which the object becomes visible */
+  retval = get_heliacal_day(tjd, dgeo, datm, dobs, ObjectName, helflag2, TypeEvent, &tjd, serr); 
+  if (retval != OK)
+    goto moon_event_err;
+  dret[0] = tjd;
+  /* find next optimum visibility */
+  retval = time_optimum_visibility(tjd, dgeo, datm, dobs, ObjectName, helflag, &tjd, serr);
+  if (retval == ERR) goto moon_event_err;
+  dret[1] = tjd;
+  /* find moment of becoming visible */
+  /* Note: The on the day of fist light the moon may become visible 
+   * already during day. It also may appear during day, disappear again
+   * and then reappear after sunset */
+  direct = 1;
+  if (TypeEvent == 4)
+    direct = -1;
+  retval = time_limit_invisible(tjd, dgeo, datm, dobs, ObjectName, helflag, direct, &tjd, serr);
+  if (retval == ERR) goto moon_event_err;
+  dret[2] = tjd;
+  /* find moment of end of visibility */
+  direct *= -1;
+  retval = time_limit_invisible(dret[1], dgeo, datm, dobs, ObjectName, helflag, direct, &tjd, serr);
+  dret[0] = tjd;
+  if (retval == ERR) goto moon_event_err;
+  /* if the moon is visible before sunset, we return sunset as start time */
+  if (TypeEvent == 3) {
+    if ((retval = my_rise_trans(tjd, SE_SUN, "", SE_CALC_SET, helflag, dgeo, datm, &trise, serr)) == ERR)
+      return ERR;
+    if (trise < dret[1]) {
+      dret[0] = trise;
+      /* do not warn, it happens too often */
+      /*strcpy(serr, "start time given is sunset, but moon is observable before that");*/
+    }
+  /* if the moon is visible after sunrise, we return sunrise as end time */
+  } else {
+    if ((retval = my_rise_trans(dret[1], SE_SUN, "", SE_CALC_RISE, helflag, dgeo, datm, &trise, serr)) == ERR)
+      return ERR;
+    if (dret[0] > trise) {
+      dret[0] = trise;
+      /* do not warn, it happens too often */
+      /*strcpy(serr, "end time given is sunrise, but moon is observable after that");*/
+    }
+  }
+  /* correct order of the three times: */
+  if (TypeEvent == 4) {
+    tjd = dret[0];
+    dret[0] = dret[2];
+    dret[2] = tjd;
+  }
+moon_event_err:
+  if (serr_ret != NULL && *serr != '\0')
+    strcpy(serr_ret, serr);
+  return retval;
+}
+
+static int32 MoonEventJDut(double JDNDaysUTStart, double *dgeo, double *datm, double *dobs, int32 TypeEvent, int32 helflag, double *dret, char *serr)
+{
+  int32 avkind = helflag & SE_HELFLAG_AVKIND;
+  if (avkind) 
+    return moon_event_arc_vis(JDNDaysUTStart, dgeo, datm, dobs, TypeEvent, helflag, dret, serr);
+  else
+    return moon_event_vis_lim(JDNDaysUTStart, dgeo, datm, dobs, TypeEvent, helflag, dret, serr);
+}
+
+static int32 heliacal_ut(double JDNDaysUTStart, double *dgeo, double *datm, double *dobs, char *ObjectName, int32 TypeEventIn, int32 helflag, double *dret, char *serr_ret)
+{
+  int32 avkind = helflag & SE_HELFLAG_AVKIND;
+  if (avkind) 
+    return heliacal_ut_arc_vis(JDNDaysUTStart, dgeo, datm, dobs, ObjectName, TypeEventIn, helflag, dret, serr_ret);
+  else
+    return heliacal_ut_vis_lim(JDNDaysUTStart, dgeo, datm, dobs, ObjectName, TypeEventIn, helflag, dret, serr_ret);
+}
+
+/*' Magn [-]
+' tjd_ut            start date (JD) for event search
+' dgeo[3]           geogr. longitude, latitude, eye height (m above sea level)
+' datm[4]           atm. pressure, temperature, RH, and VR
+' - pressure        atmospheric pressure (mbar, =hPa) default 1013.25hPa
+' - temperature      deg C, default 15 deg C (if at
+'                   If both attemp and atpress are 0, a temperature and
+'                   atmospheric pressure are estimated from the above-mentioned
+'                   default values and the height above sea level.
+' - RH              relative humidity in %
+' - VR              VR>=1: the Meteorological range: default 40 km
+'                   1>VR>0: the ktot (so the total atmospheric coefficient): 
+'                   a good default would be 0.25
+'                   VR=-1: the ktot is calculated from the other atmospheric 
+'                   constants.
+' age [Year]        default 36, experienced sky observer in ancient times
+'                   optimum age is 23
+' SN                Snellen factor of the visual aquity of the observer
+'                   default 1
+'                   see: http://www.i-see.org/eyecharts.html#make-your-own
+' TypeEvent         1 morning first
+'                   2 evening last
+'                   3 evening first
+'                   4 morning last
+' dret		    output: time (tjd_ut) of heliacal event
+' see http://www.iol.ie/~geniet/eng/atmoastroextinction.htm
+*/
+int32 FAR PASCAL_CONV swe_heliacal_ut(double JDNDaysUTStart, double *dgeo, double *datm, double *dobs, char *ObjectNameIn, int32 TypeEvent, int32 helflag, double *dret, char *serr_ret)
+{
+  int32 retval, Planet, itry;
+  char ObjectName[AS_MAXCH], serr[AS_MAXCH], s[AS_MAXCH];
+  double tjd0 = JDNDaysUTStart, tjd, dsynperiod, tjdmax, tadd;
+  int32 MaxCountSynodicPeriod = MAX_COUNT_SYNPER;
+  char *sevent[7] = {"", "morning first", "evening last", "evening first", "morning last", "acronychal rising", "acronychal setting"};
+  if (helflag & SE_HELFLAG_LONG_SEARCH)
+    MaxCountSynodicPeriod = MAX_COUNT_SYNPER_MAX;
+/*  if (helflag & SE_HELFLAG_SEARCH_1_PERIOD)
+      MaxCountSynodicPeriod = 1; */
+  *serr = '\0';
+  if (serr_ret != NULL)
+    *serr_ret = '\0';
+  /* note, the fixed stars functions rewrite the star name. The input string 
+     may be too short, so we have to make sure we have enough space */
+  strcpy_VBsafe(ObjectName, ObjectNameIn);
+  default_heliacal_parameters(datm, dgeo, dobs, helflag);
+  swe_set_topo(dgeo[0], dgeo[1], dgeo[2]);
+  Planet = DeterObject(ObjectName);
+  /* 
+   * Moon events
+   */
+  if (Planet == SE_MOON) {
+    if (TypeEvent == 1 || TypeEvent == 2) {
+      if (serr_ret != NULL)
+        sprintf(serr_ret, "%s (event type %d) does not exist for the moon\n", sevent[TypeEvent], TypeEvent);
+      return ERR;
+    }
+    tjd = tjd0;
+    retval = MoonEventJDut(tjd, dgeo, datm, dobs, TypeEvent, helflag, dret, serr);
+    while (retval != -2 && *dret < tjd0) {
+      tjd += 15;
+      *serr = '\0';
+      retval = MoonEventJDut(tjd, dgeo, datm, dobs, TypeEvent, helflag, dret, serr);
+    }
+    if (serr_ret != NULL && *serr != '\0')
+      strcpy(serr_ret, serr);
+    return retval;
+  }
+  /* 
+   * planets and fixed stars 
+   */
+  if (!(helflag & SE_HELFLAG_AVKIND)) {
+    if (Planet == -1 || Planet >= SE_MARS) {
+      if (TypeEvent == 3 || TypeEvent == 4) {
+	if (serr_ret != NULL) {
+	  if (Planet == -1)
+	    strcpy(s, ObjectName);
+	  else
+	    swe_get_planet_name(Planet, s);
+	  sprintf(serr_ret, "%s (event type %d) does not exist for %s\n", sevent[TypeEvent], TypeEvent, s);
+	}
+	return ERR;
+      }
+    }
+  }
+  /* arcus visionis method: set the TypeEvent for acronychal events */
+  if (helflag & SE_HELFLAG_AVKIND) {
+    if (Planet == -1 || Planet >= SE_MARS) {
+      if (TypeEvent == SE_ACRONYCHAL_RISING)
+	TypeEvent = 3;
+      if (TypeEvent == SE_ACRONYCHAL_SETTING)
+	TypeEvent = 4;
+    }
+  /* acronychal rising and setting (cosmic setting) are ill-defined.
+   * We do not calculate them with the "visibility limit method" */
+  } else if (1) {
+    if (TypeEvent == SE_ACRONYCHAL_RISING || TypeEvent == SE_ACRONYCHAL_SETTING) {
+      if (serr_ret != NULL) {
+	if (Planet == -1)
+	  strcpy(s, ObjectName);
+	else
+	  swe_get_planet_name(Planet, s);
+	sprintf(serr_ret, "%s (event type %d) is not provided for %s\n", sevent[TypeEvent], TypeEvent, s);
+      }
+      return ERR;
+    }
+  }
+  dsynperiod = get_synodic_period(Planet);
+  tjdmax = tjd0 + dsynperiod * MaxCountSynodicPeriod;
+  tadd = dsynperiod * 0.6;
+  if (Planet == SE_MERCURY)
+    tadd = 30;
+  /* 
+   * this is the outer loop over n synodic periods 
+   */
+  tjd = tjd0;
+  retval = -2;  /* indicates that another synodic period has to be done */
+  for (itry = 0; 
+       tjd < tjdmax && retval == -2; 
+       itry++, tjd += tadd) {
+    *serr = '\0';
+    retval = heliacal_ut(tjd, dgeo, datm, dobs, ObjectName, TypeEvent, helflag, dret, serr);
+    /* if resulting event date < start date for search (tjd0): retry starting
+     * from half a period later. The event must be found now, unless there
+     * is none, as is often the case with Mercury */
+    while (retval != -2 && *dret < tjd0) {
+      tjd += tadd;
+      *serr = '\0';
+      retval = heliacal_ut(tjd, dgeo, datm, dobs, ObjectName, TypeEvent, helflag, dret, serr);
+    }
+  }
+  /* 
+   * no event was found within MaxCountSynodicPeriod, return error
+   */ 
+  if ((helflag & SE_HELFLAG_SEARCH_1_PERIOD) && (retval == -2 || dret[0] > tjd0 + dsynperiod * 1.5)) {
+    strcpy(serr, "no heliacal date found within this synodic period");
+    retval = -2;
+  } else if (retval == -2) {
+    sprintf(serr, "no heliacal date found within %d synodic periods", MaxCountSynodicPeriod);
+    retval = ERR;
+  }
+  if (serr_ret != NULL && *serr != '\0')
+    strcpy(serr_ret, serr);
+  return retval;
+}