VBMicrolensing 5.1.1__cp312-cp312-musllinux_1_2_i686.whl → 5.3.1__cp312-cp312-musllinux_1_2_i686.whl

VBMicrolensing/lib/VBMicrolensingLibrary.cpp

@@ -1,4 +1,4 @@
-// VBMicrolensing v5.1.1 (2025)
+// VBMicrolensing v5.3 (2025)
 //
 // This code has been developed by Valerio Bozza (University of Salerno) and collaborators.
 // Check the repository at https://github.com/valboz/VBMicrolensing
@@ -252,7 +252,8 @@ public:
 
 #pragma endregion
 
-char VBMicrolensing::ESPLtablefile[1024] = "fatto";
+char VBMicrolensing::ESPLtablefile[1024] = "placeholder";
+char VBMicrolensing::Suntablefile[1024] = "placeholder";
 
 #pragma region Constructor/destructor
 
@@ -277,13 +278,16 @@ VBMicrolensing::VBMicrolensing() {
 	t0old = 0.;
 	Tol = 1.e-2;
 	RelTol = 0;
+	suntable = false;
+	parallaxephemeris = true;
 	tsat = 0;
 	possat = 0;
 	nsat = 0;
 	ndatasat = 0;
 	satellite = 0;
 	parallaxsystem = 1;
-	t0_par_fixed = -1;
+	t0_par_fixed = 0;
+	coordinates_set = false;
 	t0_par = 7000;
 	minannuli = 1;
 	maxannuli = 100;
@@ -328,6 +332,8 @@ VBMicrolensing::VBMicrolensing() {
 	CumulativeFunction = &VBDefaultCumulativeFunction;
 	SelectedMethod = Method::Nopoly;
 	turn_off_secondary_source = turn_off_secondary_lens = false;
+	t_in_HJD = true;
+	parallaxextrapolation = 0;
 	//	testnewcoefs = true;
 }
 
@@ -342,6 +348,10 @@ VBMicrolensing::~VBMicrolensing() {
 		free(possat);
 		free(ndatasat);
 	}
+	if (suntable) {
+		for (int j = 0; j < ndataEar; j++) free(posEar[j]);
+		free(posEar);
+	}
 
 	if (m) {
 		free(m);
@@ -460,7 +470,7 @@ VBMicrolensing::~VBMicrolensing() {
 #pragma region single-source-mag
 
 
-void VBMicrolensing::LoadESPLTable(char* filename) {
+void VBMicrolensing::LoadESPLTable(const char* filename) {
 	FILE* f;
 
 	if ((f = fopen(filename, "rb")) != 0) {
@@ -4845,8 +4855,8 @@ void VBMicrolensing::ComputeCentroids(double* pr, double t, double* c1s, double*
 	c1 = c1prov;            // Now centroid coordinates are in North-East system, but still relative to lens
 
 	// Lens centroid in the sky
-	c1l[0] = muL1 * (t - t0_par) + paiL * (Ehel[0] - Et0[0]); // Note that Ehel is in South-West system
-	c2l[0] = muL2 * (t - t0_par) + paiL * (Ehel[1] - Et0[1]);
+	c1l[0] = muL1 * (t +lighttravel - t0_par - lighttravel0) + paiL * (Ehel[0] - Et0[0]); // Note that Ehel is in South-West system
+	c2l[0] = muL2 * (t +lighttravel - t0_par - lighttravel0) + paiL * (Ehel[1] - Et0[1]);
 	// Image centroid is finally composed with lens centroid
 	c1s[0] = c1 + c1l[0];
 	c2s[0] = c2 + c2l[0];
@@ -4872,10 +4882,11 @@ void VBMicrolensing::PSPLAstroLightCurve(double* pr, double* ts, double* mags, d
 	iastro = 5;
 	dPosAng = 0;
 	t0old = 1.e200;
+	parallaxextrapolation = 0;
 
 	for (int i = 0; i < np; i++) {
 		ComputeParallax(ts[i], t0);
-		tn = (ts[i] - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
+		tn = (ts[i] + lighttravel - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
 		u1 = u0 + pai1 * Et[1] - pai2 * Et[0];
 		u = sqrt(tn * tn + u1 * u1);
 
@@ -4903,10 +4914,11 @@ void VBMicrolensing::ESPLAstroLightCurve(double* pr, double* ts, double* mags, d
 	iastro = 6;
 	dPosAng = 0;
 	t0old = 1.e200;
+	parallaxextrapolation = 0;
 
 	for (int i = 0; i < np; i++) {
 		ComputeParallax(ts[i], t0);
-		tn = (ts[i] - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
+		tn = (ts[i] +lighttravel - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
 		u1 = u0 + pai1 * Et[1] - pai2 * Et[0];
 		u = sqrt(tn * tn + u1 * u1);
 
@@ -4934,10 +4946,11 @@ void VBMicrolensing::BinaryAstroLightCurve(double* pr, double* ts, double* mags,
 	double salpha = sin(pr[3]), calpha = cos(pr[3]);
 	dPosAng = 0;
 	t0old = 1.e200;
+	parallaxextrapolation = 0;
 
 	for (int i = 0; i < np; i++) {
 		ComputeParallax(ts[i], t0);
-		tn = (ts[i] - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
+		tn = (ts[i] + lighttravel - t0_par) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
 		u = u0 + pai1 * Et[1] - pai2 * Et[0];
 
 		y1s[i] = u * salpha - tn * calpha;
@@ -4969,6 +4982,7 @@ void VBMicrolensing::BinaryAstroLightCurveOrbital(double* pr, double* ts, double
 	double w, phi0, inc, phi, Cinc, Sinc, Cphi, Sphi, Cphi0, Sphi0, pphi0, COm, SOm, s_true;
 	double w13, w123, den, den0;
 	t0old = 1.e200;
+	parallaxextrapolation = 0;
 
 	w13 = w1 * w1 + w3 * w3;
 	w123 = sqrt(w13 + w2 * w2);
@@ -4997,14 +5011,14 @@ void VBMicrolensing::BinaryAstroLightCurveOrbital(double* pr, double* ts, double
 	for (int i = 0; i < np; i++) {
 		ComputeParallax(ts[i], t0);
 
-		phi = (ts[i] - t0_par) * w + phi0;
+		phi = (ts[i] + lighttravel - t0_par - lighttravel0) * w + phi0;
 		Cphi = cos(phi);
 		Sphi = sin(phi);
 		den = sqrt(Cphi * Cphi + Cinc * Cinc * Sphi * Sphi);
 		seps[i] = s_true * den; // projected separation at time ts[i]
 
 		u = u0 + pai1 * Et[1] - pai2 * Et[0];
-		tn = (ts[i] - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
+		tn = (ts[i] + lighttravel - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
 		y1s[i] = (Cphi * (u * SOm - tn * COm) + Cinc * Sphi * (u * COm + tn * SOm)) / den;
 		y2s[i] = (-Cphi * (u * COm + tn * SOm) - Cinc * Sphi * (tn * COm - u * SOm)) / den;
 		mags[i] = BinaryMag2(seps[i], q, y1s[i], y2s[i], rho);
@@ -5037,6 +5051,7 @@ void VBMicrolensing::BinaryAstroLightCurveKepler(double* pr, double* ts, double*
 	double arm1, arm2;
 	double X[3], Y[3], Z[3], r[2], x[2];
 	t0old = 1.e200;
+	parallaxextrapolation = 0;
 
 	smix = 1 + szs * szs;
 	sqsmix = sqrt(smix);
@@ -5081,7 +5096,7 @@ void VBMicrolensing::BinaryAstroLightCurveKepler(double* pr, double* ts, double*
 
 	for (int i = 0; i < np; i++) {
 		ComputeParallax(ts[i], t0);
-		M = n * (ts[i] - tperi);
+		M = n * (ts[i] + lighttravel - tperi - lighttravel0);
 		while (M > M_PI) M -= 2 * M_PI;
 		while (M < -M_PI) M += 2 * M_PI;
 		EE = M + e * sin(M);
@@ -5102,7 +5117,7 @@ void VBMicrolensing::BinaryAstroLightCurveKepler(double* pr, double* ts, double*
 		St = sqrt(x[0] * x[0] + x[1] * x[1]);
 		psi = atan2(x[1], x[0]);// +((ar > 1) ? 0 : M_PI);
 		u = u0 + pai1 * Et[1] - pai2 * Et[0];
-		tn = (ts[i] - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
+		tn = (ts[i] + lighttravel - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
 		y1s[i] = -tn * cos(alpha + psi) + u * sin(alpha + psi);
 		y2s[i] = -u * cos(alpha + psi) - tn * sin(alpha + psi);
 		seps[i] = St;
@@ -5137,6 +5152,7 @@ void VBMicrolensing::BinSourceAstroLightCurveXallarap(double* pr, double* ts, do
 	iastro = 12;
 	dPosAng = 0;
 	t0old = 1.e200;
+	parallaxextrapolation = 0;
 
 	s[2] = -(s[0] * w[0] + s[1] * w[1]) / w[2]; // Impose velocity orthogonal to position
 	s3D = sqrt(s[0] * s[0] + s[1] * s[1] + s[2] * s[2]);
@@ -5200,11 +5216,11 @@ void VBMicrolensing::BinSourceAstroLightCurveXallarap(double* pr, double* ts, do
 		paiuB = pai1 * Et[1] - pai2 * Et[0]; // Parallax correction referred to tB
 
 		// Position of barycenter
-		tnB = (ts[i] - t0) * vt0B - t0B + paitB * cos(alpha) - paiuB * sin(alpha);
-		uB = u0B + vuB * (ts[i] - t0) + paitB * sin(alpha) + paiuB * cos(alpha);
+		tnB = (ts[i] + lighttravel - t0) * vt0B - t0B + paitB * cos(alpha) - paiuB * sin(alpha);
+		uB = u0B + vuB * (ts[i]+ lighttravel - t0) + paitB * sin(alpha) + paiuB * cos(alpha);
 
 		// Position of relative particle
-		phi = wtot * (ts[i] - t0) + phi0;
+		phi = wtot * (ts[i] + lighttravel - t0) + phi0;
 		xt = (Om[0] * cos(phi) + Y[0] * sin(phi));
 		xu = (Om[1] * cos(phi) + Y[1] * sin(phi));
 
@@ -5247,6 +5263,183 @@ void VBMicrolensing::BinSourceAstroLightCurveXallarap(double* pr, double* ts, do
 	}
 
 }
+
+
+void VBMicrolensing::BinSourceBinLensAstroLightCurve(double* pr, double* ts, double* mags, double* c1s, double* c2s, double* c1l, double* c2l, double* y1s, double* y2s, double* y1s2, double* y2s2, double *seps, int np) {
+	double tn, u, FRl, s = exp(pr[0]), q = exp(pr[1]), w1 = pr[9], w2 = pr[10], w3 = pr[11];
+	tE_inv = exp(-pr[5]);
+
+	double ws[3] = { pr[15] + 1.01e-15, pr[16] + 1.01e-15, pr[17] + 1.01e-15 };
+	double t01 = pr[6], t02 = pr[13] + ws[0] * (pr[13] - pr[6]) / tE_inv, u1 = pr[2], u2 = pr[12] + ws[1] * (pr[6] - pr[13]), FR = exp(pr[14]), rho2, xt, xu;
+	double ss[3] = { (t01 - t02) * tE_inv,u2 - u1,0 };
+	double L[3], Om[3], Y[3], norm, normOm, s3D, wstot, qs,phis0;
+	double u0B, t0B, vuB, vt0B, s1, s2, uB, tnB, paitB, paiuB, alphas;
+	parallaxextrapolation = 0;
+
+	// Binary lens calculations
+	u0 = pr[2];
+	t0 = pr[6];
+	rho = exp(pr[4]);
+	pai1 = pr[7];
+	pai2 = pr[8];
+	alpha = pr[3];
+	iastro = 18;
+	double salpha = sin(pr[3]), calpha = cos(pr[3]);
+	double w, phi0, inc, phi, Cinc, Sinc, Cphi, Sphi, Cphi0, Sphi0, pphi0, COm, SOm, s_true;
+	double w13, w123, den, den0;
+	t0old = 1.e200;
+
+	w13 = w1 * w1 + w3 * w3;
+	w123 = sqrt(w13 + w2 * w2);
+	w13 = sqrt(w13);
+	if (w13 > 1.e-8) {
+		w3 = (w3 > 1.e-8) ? w3 : 1.e-8;
+		w = w3 * w123 / w13;
+		inc = acos(w2 * w3 / w13 / w123);
+		phi0 = atan2(-w1 * w123, w3 * w13);
+	}
+	else {
+		w = w2;
+		inc = 0.;
+		phi0 = 0.;
+	}
+	Cphi0 = cos(phi0);
+	Sphi0 = sin(phi0);
+	Cinc = cos(inc);
+	Sinc = sin(inc);
+	den0 = sqrt(Cphi0 * Cphi0 + Cinc * Cinc * Sphi0 * Sphi0);
+	s_true = s / den0; // orbital radius
+	COm = (Cphi0 * calpha + Cinc * salpha * Sphi0) / den0;
+	SOm = (Cphi0 * salpha - Cinc * calpha * Sphi0) / den0;
+	pphi0 = atan2(Cinc * Sphi0, Cphi0);
+
+	// Binary source calculations
+
+	ss[2] = -(ss[0] * ws[0] + ss[1] * ws[1]) / ws[2]; // Impose velocity orthogonal to position
+	s3D = sqrt(ss[0] * ss[0] + ss[1] * ss[1] + ss[2] * ss[2]);
+	wstot = sqrt(ws[0] * ws[0] + ws[1] * ws[1] + ws[2] * ws[2]) / s3D; // Angular velocity
+
+	// Angular momentum
+	L[0] = ss[1] * ws[2] - ss[2] * ws[1];
+	L[1] = ss[2] * ws[0] - ss[0] * ws[2];
+	L[2] = ss[0] * ws[1] - ss[1] * ws[0];
+	normOm = L[0] * L[0] + L[1] * L[1];
+	norm = sqrt(normOm + L[2] * L[2]);
+	normOm = sqrt(normOm);
+	// Node line
+	if (normOm > 0) {
+		Om[0] = -L[1] / normOm;
+		Om[1] = L[0] / normOm;
+		Om[2] = 0;
+		for (int i = 0; i < 3; i++) L[i] /= norm;
+	}
+	else {
+		Om[0] = 1;
+		Om[1] = 0 / normOm;
+		Om[2] = 0;
+		L[0] = 0;
+		L[1] = -1;
+		L[2] = 0;
+	}
+
+
+	// Orthogonal axis
+	Y[0] = -L[2] * Om[1];
+	Y[1] = L[2] * Om[0];
+	Y[2] = L[0] * Om[1] - L[1] * Om[0];
+
+	// Phase at time t0
+	norm = (ss[0] * Om[0] + ss[1] * Om[1]) / s3D;
+	if (norm >= 1) norm = 0.99999999999999;
+	if (norm <= -1) norm = -0.99999999999999;
+	phis0 = acos(norm);
+	if (ss[2] < 0) phis0 = -phis0;
+
+	// Mass ratio
+	qs = exp(pr[14] / mass_luminosity_exponent);
+	// Position of barycenter at t0
+	t0B = (t01 + t02 * qs) / (1 + qs);
+	u0B = (u1 + u2 * qs) / (1 + qs);
+	t0B = (t0B - t0) * tE_inv;
+	// Velocity of barycenter
+	vt0B = ws[0] * qs / (1 + qs) + tE_inv;
+	vuB = ws[1] * qs / (1 + qs);
+	alphas = atan2(vuB, vt0B);
+	alpha += alphas;
+	tE_inv = sqrt(vuB * vuB + vt0B * vt0B);
+	// Relative distances from barycenter
+	s2 = s3D / (1 + qs);
+	s1 = s2 * qs;
+
+
+	for (int i = 0; i < np; i++) {
+		ComputeParallax(ts[i], t0);
+
+		// Binary lens calculation
+		phi = (ts[i] + lighttravel - t0) * w + phi0;
+		Cphi = cos(phi);
+		Sphi = sin(phi);
+		den = sqrt(Cphi * Cphi + Cinc * Cinc * Sphi * Sphi);
+		seps[i] = s_true * den; // projected separation at time ts[i]
+
+		// Binary source calculations
+		paitB = pai1 * Et[0] + pai2 * Et[1]; // Parallax correction referred to tB
+		paiuB = pai1 * Et[1] - pai2 * Et[0]; // Parallax correction referred to tB
+
+		// Position of barycenter
+		tnB = (ts[i] + lighttravel - t0) * vt0B - t0B + paitB * cos(alphas) - paiuB * sin(alphas);
+		uB = u0B + vuB * (ts[i] + lighttravel - t0) + paitB * sin(alphas) + paiuB * cos(alphas);
+
+		// Position of relative particle
+		phi = wstot * (ts[i]+lighttravel - t0) + phis0;
+		xt = (Om[0] * cos(phi) + Y[0] * sin(phi));
+		xu = (Om[1] * cos(phi) + Y[1] * sin(phi));
+
+		// Position of source 1
+		tn = tnB - xt * s1;
+		u = uB - xu * s1;
+		//y1s[i] = -tn;
+		//y2s[i] = -u;
+		y1s[i] = (Cphi * (u * SOm - tn * COm) + Cinc * Sphi * (u * COm + tn * SOm)) / den;
+		y2s[i] = (-Cphi * (u * COm + tn * SOm) - Cinc * Sphi * (tn * COm - u * SOm)) / den;
+
+		mags[i] = BinaryMag2(seps[i], q, y1s[i], y2s[i], rho);
+		if (astrometry) {
+			c1s[i] = astrox1;
+			c2s[i] = astrox2;
+		}
+
+		// Position of source 2
+		tn = tnB + xt * s2;
+		u = uB + xu * s2;
+		//y1s2[i] = -tn;
+		//y2s2[i] = -u;
+		y1s2[i] = (Cphi * (u * SOm - tn * COm) + Cinc * Sphi * (u * COm + tn * SOm)) / den;
+		y2s2[i] = (-Cphi * (u * COm + tn * SOm) - Cinc * Sphi * (tn * COm - u * SOm)) / den;
+
+		if (!turn_off_secondary_source) {
+			rho2 = rho * exp(pr[1] * mass_radius_exponent / mass_luminosity_exponent);
+			// Combine magnifications
+			mags[i] += FR * BinaryMag2(seps[i], q, y1s2[i], y2s2[i], rho2);
+			mags[i] /= (1 + FR);
+		}
+		if (astrometry) {
+			if (!turn_off_secondary_source) {
+				c1s[i] += FR * astrox1;
+				c2s[i] += FR * astrox2;
+				c1s[i] /= (1 + FR);
+				c2s[i] /= (1 + FR);
+			}
+			dPosAng = -atan2(Cinc * Sphi, Cphi) + pphi0;
+			ComputeCentroids(pr, ts[i], &c1s[i], &c2s[i], &c1l[i], &c2l[i]);
+			FRl = (turn_off_secondary_lens) ? 0 : pow(q, lens_mass_luminosity_exponent); // Flux ratio between the two lenses
+			c1l[i] += (-q + FRl) * s * thetaE / (1 + q) * cos(PosAng) / (1 + FRl); // Flux center of the two lenses from barycenter
+			c2l[i] += (-q + FRl) * s * thetaE / (1 + q) * sin(PosAng) / (1 + FRl);
+		}
+	}
+}
+
+
 void VBMicrolensing::TripleAstroLightCurve(double* pr, double* ts, double* mags, double* c1s, double* c2s, double* c1l, double* c2l, double* y1s, double* y2s, int np) {
 	double rho = exp(pr[4]), tn, tE_inv = exp(-pr[5]), di, mindi, u, u0 = pr[2], t0 = pr[6], pai1 = pr[10], pai2 = pr[11];
 	double q[3] = { 1, exp(pr[1]),exp(pr[8]) };
@@ -5257,6 +5450,7 @@ void VBMicrolensing::TripleAstroLightCurve(double* pr, double* ts, double* mags,
 	double Et[2];
 	iastro = 12;
 	dPosAng = 0;
+	parallaxextrapolation = 0;
 
 	s[0] = exp(pr[0]) / (q[0] + q[1]);
 	s[1] = s[0] * q[0];
@@ -5274,7 +5468,7 @@ void VBMicrolensing::TripleAstroLightCurve(double* pr, double* ts, double* mags,
 
 	for (int i = 0; i < np; i++) {
 		ComputeParallax(ts[i], t0);
-		tn = (ts[i] - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
+		tn = (ts[i] +lighttravel - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
 		u = u0 + pai1 * Et[1] - pai2 * Et[0];
 		y1s[i] = u * salpha - tn * calpha;
 		y2s[i] = -u * calpha - tn * salpha;
@@ -5436,11 +5630,12 @@ void VBMicrolensing::BinSourceLightCurve(double* pr, double* ts, double* mags, d
 void VBMicrolensing::BinSourceLightCurveParallax(double* pr, double* ts, double* mags, double* y1s, double* y2s, int np) {
 	double u1 = pr[2], u2 = pr[3], t01 = pr[4], t02 = pr[5], tE_inv = exp(-pr[0]), FR = exp(pr[1]), tn, u, u0, pai1 = pr[6], pai2 = pr[7], w1 = pr[8], w2 = pr[9], w3 = pr[10];
 	t0old = 0;
+	parallaxextrapolation = 0;
 
 	for (int i = 0; i < np; i++) {
 		ComputeParallax(ts[i], t0);
 
-		tn = (ts[i] - t01) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
+		tn = (ts[i] + lighttravel - t01) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
 		u0 = u1 + pai1 * Et[1] - pai2 * Et[0];
 		u = tn * tn + u0 * u0;
 
@@ -5448,7 +5643,7 @@ void VBMicrolensing::BinSourceLightCurveParallax(double* pr, double* ts, double*
 		y2s[i] = -u0;
 		mags[i] = (u + 2) / sqrt(u * (u + 4));
 
-		tn = (ts[i] - t02) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
+		tn = (ts[i] + lighttravel - t02) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
 		u0 = u2 + pai1 * Et[1] - pai2 * Et[0];
 		u = tn * tn + u0 * u0;
 
@@ -5466,6 +5661,7 @@ void VBMicrolensing::BinSourceLightCurveXallarap(double* pr, double* ts, double*
 	double s, s_true, w, phi0, inc, phi, Cinc, Sinc, Cphi, Sphi, Cphi0, Sphi0, COm, SOm;
 	double w13, w123, den, den0, du0, dt0;
 	t0old = 0;
+	parallaxextrapolation = 0;
 
 
 	s = sqrt((u1 - u2) * (u1 - u2) + (t01 - t02) * (t01 - t02) * (tE_inv * tE_inv));
@@ -5502,7 +5698,7 @@ void VBMicrolensing::BinSourceLightCurveXallarap(double* pr, double* ts, double*
 	for (int i = 0; i < np; i++) {
 		ComputeParallax(ts[i], t0);
 
-		phi = (ts[i] - t0_par) * w + phi0;
+		phi = (ts[i] + lighttravel - t0_par-lighttravel0) * w + phi0;
 		Cphi = cos(phi);
 		Sphi = sin(phi);
 		den = sqrt(Cphi * Cphi + Cinc * Cinc * Sphi * Sphi);
@@ -5511,7 +5707,7 @@ void VBMicrolensing::BinSourceLightCurveXallarap(double* pr, double* ts, double*
 		dt0 = s_true * (COm * Cphi - Cinc * SOm * Sphi) / (1 + q) * q;  //Position of the primary component with respect to center of mass
 		du0 = s_true * (SOm * Cphi + Cinc * COm * Sphi) / (1 + q) * q;
 
-		tn = -((ts[i] - t0_par) * tE_inv + dt0 + pai1 * Et[0] + pai2 * Et[1]);
+		tn = -((ts[i] + lighttravel - t0_par- lighttravel0) * tE_inv + dt0 + pai1 * Et[0] + pai2 * Et[1]);
 		u = -(u0 + du0 + pai1 * Et[1] - pai2 * Et[0]);
 		y1s[i] = tn;
 		y2s[i] = u;
@@ -5519,7 +5715,7 @@ void VBMicrolensing::BinSourceLightCurveXallarap(double* pr, double* ts, double*
 
 		mags[i] = (u + 2) / sqrt(u * (u + 4));
 
-		tn = -((ts[i] - t0_par) * tE_inv - dt0 / q + pai1 * Et[0] + pai2 * Et[1]); // Position of the secondary component
+		tn = -((ts[i] + lighttravel - t0_par- lighttravel0) * tE_inv - dt0 / q + pai1 * Et[0] + pai2 * Et[1]); // Position of the secondary component
 		u = -(u0 - du0 / q + pai1 * Et[1] - pai2 * Et[0]);
 		u = tn * tn + u * u;
 
@@ -5652,6 +5848,11 @@ void VBMicrolensing::BinSourceSingleLensXallarap(double* pr, double* ts, double*
 }
 
 
+void VBMicrolensing::BinSourceBinLensLightCurve(double* pr, double* ts, double* mags, double* y1s, double* y2s, double* y1s2, double* y2s2, double *seps, int np) {
+	astrometry = false;
+	BinSourceBinLensAstroLightCurve(pr, ts, mags, NULL, NULL, NULL, NULL, y1s, y2s, y1s2, y2s2, seps, np);
+}
+
 
 
 void VBMicrolensing::TripleLightCurve(double* pr, double* ts, double* mags, double* y1s, double* y2s, int np) {
@@ -5842,91 +6043,14 @@ double VBMicrolensing::BinSourceSingleLensXallarap(double* pr, double t) {
 	return mag;
 }
 
-
-double VBMicrolensing::BinSourceBinLensPOX(double* pr, double t) {
-	double s = exp(pr[0]), q = exp(pr[1]), u0 = pr[2], rho = exp(pr[4]), tE_inv = exp(-pr[5]), t0 = pr[6];
-	double pai1 = pr[7], pai2 = pr[8], w1 = pr[9], w2 = pr[10], w3 = pr[11];
-	double salpha = sin(pr[3]), calpha = cos(pr[3]);
-	double tn, w, phi0, phil, incl, Cinc, Sinc, Cphi, Sphi, Cphi0, Sphi0, COm, SOm, s_true;
-	double w13, w123, den, den0, u;
-
-	double xi1 = pr[12], xi2 = pr[13], omega = pr[14], inc = pr[15], phi = pr[16], qs = exp(pr[17]);
-	double Xal[2], phit, disp[2], Xal2[2], disp2[2];
-	double Mag, Mag2, u01, u02, rho2, tn1, tn2, mags, qs4;
-
-	w13 = w1 * w1 + w3 * w3;
-	w123 = sqrt(w13 + w2 * w2);
-	w13 = sqrt(w13);
-	if (w13 > 1.e-8) {
-		w3 = (w3 > 1.e-8) ? w3 : 1.e-8;
-		w = w3 * w123 / w13;
-		incl = acos(w2 * w3 / w13 / w123);
-		phi0 = atan2(-w1 * w123, w3 * w13);
-	}
-	else {
-		w = w2;
-		incl = 0.;
-		phi0 = 0.;
-	}
-
-	Cphi0 = cos(phi0);
-	Sphi0 = sin(phi0);
-	Cinc = cos(incl);
-	Sinc = sin(incl);
-	den0 = sqrt(Cphi0 * Cphi0 + Cinc * Cinc * Sphi0 * Sphi0);
-	s_true = s / den0;
-	COm = (Cphi0 * calpha + Cinc * salpha * Sphi0) / den0;
-	SOm = (Cphi0 * salpha - Cinc * calpha * Sphi0) / den0;
-
-	ComputeParallax(t, t0);
-
-	phil = (t - t0_par) * w + phi0;
-	Cphi = cos(phil);
-	Sphi = sin(phil);
-	den = sqrt(Cphi * Cphi + Cinc * Cinc * Sphi * Sphi);
-	av = s_true * den;
-	u = u0 + pai1 * Et[1] - pai2 * Et[0];
-	tn = (t - t0) * tE_inv + pai1 * Et[0] + pai2 * Et[1];
-
-	phit = omega * (t - t0_par);
-
-	disp[0] = sin(inc) * (-cos(phi) + cos(phi + phit) + phit * sin(phi));
-	disp[1] = -phit * cos(phi) - sin(phi) + sin(phi + phit);
-	disp2[0] = -sin(inc) * (cos(phi) + cos(phi + phit) / qs - phit * sin(phi));
-	disp2[1] = phit * cos(phi) + sin(phi) + sin(phi + phit) / qs;
-
-	Xal[0] = xi1 * disp[0] + xi2 * disp[1];
-	Xal[1] = xi2 * disp[0] - xi1 * disp[1];
-	Xal2[0] = xi1 * disp2[0] - xi2 * disp2[1];
-	Xal2[1] = xi2 * disp2[0] + xi1 * disp2[1];
-
-	tn1 = tn + Xal[0];
-	u01 = u + Xal[1];
-	tn2 = tn + Xal2[0];
-	u02 = u + Xal2[1];
-	rho2 = rho * pow(qs, mass_radius_exponent);
-	qs4 = pow(qs, mass_luminosity_exponent);
-
-
-	/*	y1s = u01 * salpha - tn1 * calpha;
-		y2s = -u01 * calpha - tn1 * salpha;
-		y1s2 = u02 * salpha - tn2 * calpha;
-		y2s2 = -u02 * calpha - tn2 * salpha;*/
-
-	y_1 = (Cphi * (u02 * SOm - tn2 * COm) + Cinc * Sphi * (u02 * COm + tn2 * SOm)) / den;
-	y_2 = (-Cphi * (u02 * COm + tn2 * SOm) - Cinc * Sphi * (tn2 * COm - u02 * SOm)) / den;
-	Mag2 = BinaryMag2(av, q, y_1, y_2, rho2);
-
-	y_1 = (Cphi * (u01 * SOm - tn1 * COm) + Cinc * Sphi * (u01 * COm + tn1 * SOm)) / den;
-	y_2 = (-Cphi * (u01 * COm + tn1 * SOm) - Cinc * Sphi * (tn1 * COm - u01 * SOm)) / den;
-	Mag = BinaryMag2(av, q, y_1, y_2, rho);
-
-	mags = (Mag + qs4 * Mag2) / (1 + qs4);
-
-	return mags;
+double VBMicrolensing::BinSourceBinLensLightCurve(double* pr, double t) {
+	double mag, y1, y2, y21, y22, sep;
+	BinSourceBinLensLightCurve(pr, &t, &mag, &y1, &y2, &y21, &y22, &sep, 1);
+	return mag;
 }
 
 
+
 double VBMicrolensing::TripleLightCurve(double* pr, double t) {
 	double mag, y1, y2;
 	TripleLightCurve(pr, &t, &mag, &y1, &y2, 1);
@@ -6154,6 +6278,113 @@ void VBMicrolensing::SetLDprofile(LDprofiles LDval) {
 //////////////////////////////
 //////////////////////////////
 
+void VBMicrolensing::LoadSunTable(char* filename) {
+	FILE* f;
+	double RA, Dec, dis, phiprec;
+
+	if ((f = fopen(filename, "r")) != 0) {
+		if (suntable) {
+			// Removing existing table if any
+			for (int j = 0; j < ndataEar; j++) free(posEar[j]);
+			free(posEar);
+			suntable = false;
+		}
+		// Reading Sun table files
+		int flag2 = 0;
+//		long startpos = 0;
+		char teststring[1000];
+		ndataEar = 1;
+
+		// Finding start of data
+		while (!feof(f)) {
+			fscanf(f, "%s", teststring);
+			if (!feof(f)) {
+				fgetc(f); //fseek(f, 1, SEEK_CUR);
+				teststring[5] = 0;
+				if (strcmp(teststring, "$$SOE") == 0) {
+					flag2 = 1;
+					break;
+				}
+			}
+		}
+		// Finding end of data
+		if (flag2) {
+			flag2 = 0;
+//			startpos = ftell(f);
+			while (!feof(f)) {
+				fscanf(f, "%[^\n]s", teststring);
+				if (!feof(f)) {
+					//fseek(f, 1, SEEK_CUR);
+					fgetc(f);
+					teststring[5] = 0;
+					if (strcmp(teststring, "$$EOE") == 0) {
+						flag2 = 1;
+						break;
+					}
+					else {
+						ndataEar++;
+					}
+				}
+			}
+		}
+
+		// Allocating memory according to the length of the table
+		posEar = (double**)malloc(sizeof(double*) * ndataEar);
+
+		for (int j = 0; j < ndataEar; j++) {
+			posEar[j] = (double*)malloc(sizeof(double) * 3);
+		}
+		ndataEar--;
+		fclose(f);
+
+		// Reading data
+		f = fopen(filename, "r");
+		double tcur;
+		startEar = stepEar = -1;
+//		fseek(f, startpos, SEEK_SET);
+		
+		// Finding start of data
+		while (!feof(f)) {
+			fscanf(f, "%s", teststring);
+			if (!feof(f)) {
+				fgetc(f); //fseek(f, 1, SEEK_CUR);
+				teststring[5] = 0;
+				if (strcmp(teststring, "$$SOE") == 0) {
+					flag2 = 1;
+					break;
+				}
+			}
+		}
+		for (int id = 0; id < ndataEar; id++) {
+			if (fscanf(f, "%lf %lf %lf %lf %lf", &tcur, &RA, &Dec, &dis, &phiprec) == 5) {
+				if (stepEar < 0) {
+					if (startEar < 0) {
+						startEar = tcur;
+					}
+					else {
+						stepEar = tcur - startEar;
+						startEar -= 2450000.0;
+					}
+				}
+				RA *= M_PI / 180;
+				Dec *= M_PI / 180;
+				for (int i = 0; i < 3; i++) {
+					posEar[id][i] = -dis * (cos(RA) * cos(Dec) * Eq2000[i] + sin(RA) * cos(Dec) * Quad2000[i] + sin(Dec) * North2000[i]);
+				}
+			}
+			else {
+				ndataEar = id;
+				break;
+			}
+		}
+		fclose(f);
+		suntable = true;
+	}
+	else {
+		printf("\nSun ephemeris table not found !");
+		suntable = false;
+	}
+}
 
 void VBMicrolensing::SetObjectCoordinates(char* modelfile, char* sateltabledir) {
 	double RA, Dec, dis, phiprec;
@@ -6167,7 +6398,18 @@ void VBMicrolensing::SetObjectCoordinates(char* modelfile, char* sateltabledir)
 		fscanf(f, "%[^\n]s", CoordinateString);
 		fclose(f);
 		SetObjectCoordinates(CoordinateString);
-
+		
+		// Removing any preiovusly loaded satellite table files
+		if (nsat) {
+			for (int i = 0; i < nsat; i++) {
+				for (int j = 0; j < ndatasat[i]; j++) free(possat[i][j]);
+				free(tsat[i]);
+				free(possat[i]);
+			}
+			free(tsat);
+			free(possat);
+			free(ndatasat);
+		}
 		// Looking for satellite table files in the specified directory
 		sprintf(filename, "%s%csatellite*.txt", sateltabledir, systemslash);
 		nsat = 0;
@@ -6192,7 +6434,6 @@ void VBMicrolensing::SetObjectCoordinates(char* modelfile, char* sateltabledir)
 			f = fopen(filename, "r");
 			if (f != 0) {
 				int flag2 = 0;
-				long startpos = 0;
 				char teststring[1000];
 				ndatasat[ic] = 1;
 
@@ -6211,7 +6452,6 @@ void VBMicrolensing::SetObjectCoordinates(char* modelfile, char* sateltabledir)
 				// Finding end of data
 				if (flag2) {
 					flag2 = 0;
-					startpos = ftell(f);
 					while (!feof(f)) {
 						fscanf(f, "%[^\n]s", teststring);
 						if (!feof(f)) {
@@ -6228,18 +6468,34 @@ void VBMicrolensing::SetObjectCoordinates(char* modelfile, char* sateltabledir)
 						}
 					}
 				}
+				fclose(f);
 
 				// Allocating memory according to the length of the table
 				tsat[ic] = (double*)malloc(sizeof(double) * ndatasat[ic]);
 				possat[ic] = (double**)malloc(sizeof(double*) * ndatasat[ic]);
+				
 				for (int j = 0; j < ndatasat[ic]; j++) {
 					possat[ic][j] = (double*)malloc(sizeof(double) * 3);
 				}
 				ndatasat[ic]--;
 
+				f = fopen(filename, "r");
+				// Finding start of data
+				while (!feof(f)) {
+					fscanf(f, "%s", teststring);
+					if (!feof(f)) {
+						fgetc(f); //fseek(f, 1, SEEK_CUR);
+						teststring[5] = 0;
+						if (strcmp(teststring, "$$SOE") == 0) {
+							flag2 = 1;
+							break;
+						}
+					}
+				}
+
 				// Reading data
 				if (f) {
-					fseek(f, startpos, SEEK_SET);
+					double tcur;
 					for (int id = 0; id < ndatasat[ic]; id++) {
 
 						if (fscanf(f, "%lf %lf %lf %lf %lf", &(tsat[ic][id]), &RA, &Dec, &dis, &phiprec) == 5) {
@@ -6268,34 +6524,44 @@ void VBMicrolensing::SetObjectCoordinates(char* modelfile, char* sateltabledir)
 }
 
 void VBMicrolensing::SetObjectCoordinates(char* CoordinateString) {
-	double RA, Dec, hr, mn, sc, deg, pr, ssc;
+	double RA, Dec, hr, mn, sc, deg, pr, ssc, sp, r;
 
-	if (nsat) {
-		for (int i = 0; i < nsat; i++) {
-			for (int j = 0; j < ndatasat[i]; j++) free(possat[i][j]);
-			free(tsat[i]);
-			free(possat[i]);
-		}
-		free(tsat);
-		free(possat);
-		free(ndatasat);
-	}
+	hr = mn = sc = deg = pr = ssc = -1.e100;
 	sscanf(CoordinateString, "%lf:%lf:%lf %lf:%lf:%lf", &hr, &mn, &sc, &deg, &pr, &ssc);
-	RA = (hr + mn / 60 + sc / 3600) * M_PI / 12,
+	if (hr >= 0 && hr < 24 && mn >= 0 && mn < 60 && sc >= 0 && sc < 60 && deg >= -90 && deg <= 90 && pr >= 0 && pr < 60 && ssc >= 0 && ssc < 60) {
+		RA = (hr + mn / 60 + sc / 3600) * M_PI / 12;
 		Dec = (fabs(deg) + pr / 60 + ssc / 3600) * M_PI / 180;
-	if (deg < 0) Dec = -Dec;
+		if (deg < 0) Dec = -Dec;
 
-	for (int i = 0; i < 3; i++) {
-		Obj[i] = (cos(RA) * cos(Dec) * Eq2000[i] + sin(RA) * cos(Dec) * Quad2000[i] + sin(Dec) * North2000[i]);
-		rad[i] = Eq2000[i];
-		tang[i] = North2000[i];
-	}
+		for (int i = 0; i < 3; i++) {
+			Obj[i] = (cos(RA) * cos(Dec) * Eq2000[i] + sin(RA) * cos(Dec) * Quad2000[i] + sin(Dec) * North2000[i]);
+			//rad[i] = Eq2000[i];
+			//tang[i] = North2000[i];
+		}
+		sp = 0;
+		for (int i = 0; i < 3; i++) sp += North2000[i] * Obj[i];
+		for (int i = 0; i < 3; i++) rad[i] = -North2000[i] + sp * Obj[i];
+
+		r = sqrt(rad[0] * rad[0] + rad[1] * rad[1] + rad[2] * rad[2]); // Celestial South projected orthogonal to LOS
+		rad[0] /= r;
+		rad[1] /= r;
+		rad[2] /= r;
+		tang[0] = rad[1] * Obj[2] - rad[2] * Obj[1]; // Celestial West projected orthogonal to LOS
+		tang[1] = rad[2] * Obj[0] - rad[0] * Obj[2];
+		tang[2] = rad[0] * Obj[1] - rad[1] * Obj[0];
 
-	if (t0_par_fixed == -1) t0_par_fixed = 0;
+		coordinates_set = true;
+	}
+	else coordinates_set = false;
+}
 
+bool VBMicrolensing::AreCoordinatesSet() {
+	return coordinates_set;
 }
 
 void VBMicrolensing::ComputeParallax(double t, double t0) {
+	static double dtflight = 0.0000993512; // = angle covered by Earth as light covers 1 au.
+	static double au_c = 0.005775518331436995; // au/c in days.
 	static double a0 = 1.00000261, adot = 0.00000562; // Ephemeris from JPL website 
 	static double e0 = 0.01671123, edot = -0.00004392;
 	static double inc0 = -0.00001531, incdot = -0.01294668;
@@ -6304,15 +6570,120 @@ void VBMicrolensing::ComputeParallax(double t, double t0) {
 	static double deg = M_PI / 180;
 	static double a, e, inc, L, om, M, EE, dE, dM;
 	static double x1, y1, vx, vy, Ear[3], vEar[3];
-	static double r, sp, ty, Spit;
+	static double r, sp, ty, Spit, dLtof;
 	int c = 0, ic;
+	
+	if (!coordinates_set) {
+		printf("\nUse SetObjectCoordinates to input target coordinates");
+		return;
+	}
+	if (satellite > nsat) {
+		printf("\nSatellite %d not available", satellite);
+		return;
+	}
 
 	if (t0_par_fixed == 0) t0_par = t0;
-	if (t0_par_fixed == -1) {
-		printf("\nUse SetObjectCoordinates to input target coordinates");
+
+	if (parallaxephemeris) {
+		// Calculation with lookup ephemeris table 
+		if (!suntable) {
+			LoadSunTable(Suntablefile);
+		}
+		if (t0_par != t0old) {
+			t0old = t0_par;
+			ty = (t0_par - startEar) / stepEar;
+			ic = (int)floor(ty);
+			ty -= ic;
+			for (int i = 0; i < 3; i++) Ear[i] = posEar[ic][i] * (1 - ty) + posEar[ic + 1][i] * ty;
+			if (t_in_HJD) {
+				double told = t, tnew;
+				lighttravel0 = 0;
+				for (int i = 0; i < 3; i++) lighttravel0 += Ear[i] * Obj[i];
+				lighttravel0 *= au_c;
+				tnew = t0_par - lighttravel0;
+				while (fabs(told - tnew) > 1.e-8) {
+					told = tnew;
+					ty = (told - startEar) / stepEar;
+					ic = (int)floor(ty);
+					ty -= ic;
+					for (int i = 0; i < 3; i++) Ear[i] = posEar[ic][i] * (1 - ty) + posEar[ic + 1][i] * ty;
+					lighttravel0 = 0;
+					for (int i = 0; i < 3; i++) lighttravel0 += Ear[i] * Obj[i];
+					lighttravel0 *= au_c;
+					tnew = t0_par - lighttravel0;
+				}
+			}
+			for (int i = 0; i < 3; i++) {
+				if (ty > 0.5) {
+					vEar[i] = ((posEar[ic+2][i]- posEar[ic+1][i]) * (ty-0.5) + (posEar[ic+1][i] - posEar[ic][i]) * (1.5-ty)) / stepEar;
+				}
+				else {
+					vEar[i] = ((posEar[ic][i] - posEar[ic-1][i]) * (0.5 - ty) + (posEar[ic+1][i] - posEar[ic][i]) * (ty+0.5)) / stepEar;
+				}
+			}
+			if (parallaxsystem != 1) {
+				sp = 0;
+				for (int i = 0; i < 3; i++) sp += Ear[i] * Obj[i];
+				for (int i = 0; i < 3; i++) rad[i] = Ear[i] - sp * Obj[i];
+				r = sqrt(rad[0] * rad[0] + rad[1] * rad[1] + rad[2] * rad[2]); // Celestial South projected orthogonal to LOS
+				rad[0] /= r;
+				rad[1] /= r;
+				rad[2] /= r;
+				tang[0] = rad[1] * Obj[2] - rad[2] * Obj[1]; // Celestial West projected orthogonal to LOS
+				tang[1] = rad[2] * Obj[0] - rad[0] * Obj[2];
+				tang[2] = rad[0] * Obj[1] - rad[1] * Obj[0];
+			}
+
+
+			Et0[0] = Et0[1] = vt0[0] = vt0[1] = 0;
+			lighttravel0 = 0;
+			for (int i = 0; i < 3; i++) {
+				Et0[0] += Ear[i] * rad[i];           // Earth position projected along South at time t0_par
+				Et0[1] += Ear[i] * tang[i];          // Earth position projected along West at time t0_par
+				lighttravel0 += Ear[i] * Obj[i];
+				vt0[0] += vEar[i] * rad[i];          // Earth velocity projected along South at time t0_par
+				vt0[1] += vEar[i] * tang[i];		// Earth velocity projected along West at time t0_par
+			}
+			lighttravel0 *= (t_in_HJD) ? 0 : au_c; // Light travel time from Earth projection to Sun: HJD = JD + lighttravel.
+		}
+		ty = (t - startEar) / stepEar;
+		ic = (int)floor(ty);
+		ty -= ic;
+		if (ic < 0) { parallaxextrapolation = 1; ic = 0; ty = 0; }
+		if (ic >= ndataEar) { parallaxextrapolation = 1; ic = ndataEar - 1; ty = 1; }
+		for (int i = 0; i < 3; i++) Ear[i] = posEar[ic][i] * (1 - ty) + posEar[ic + 1][i] * ty;
+		lighttravel = 0;
+		for (int i = 0; i < 3; i++) lighttravel += Ear[i] * Obj[i];
+		lighttravel *= au_c;
+		if (t_in_HJD) {
+			double told = t, tnew;
+			tnew = t - lighttravel;
+			while (fabs(told - tnew) > 1.e-8) {
+				told = tnew;
+				ty = (told - startEar) / stepEar;
+				ic = (int)floor(ty);
+				ty -= ic;
+				if (ic < 0) { parallaxextrapolation = 1; ic = 0; ty = 0; }
+				if (ic >= ndataEar) { parallaxextrapolation = 1; ic = ndataEar - 1; ty = 1; }
+				for (int i = 0; i < 3; i++) Ear[i] = posEar[ic][i] * (1 - ty) + posEar[ic + 1][i] * ty;
+				lighttravel = 0;
+				for (int i = 0; i < 3; i++) lighttravel += Ear[i] * Obj[i];
+				lighttravel *= au_c;
+				tnew = t - lighttravel;
+			}
+			lighttravel = 0;
+		}
+		Ehel[0] = Ehel[1] = 0;
+		for (int i = 0; i < 3; i++) {
+			Ehel[0] += Ear[i] * rad[i]; // Ehel is the heliocentric position of Earth along South and West at time t
+			Ehel[1] += Ear[i] * tang[i];
+		}
+		Et[0] = Ehel[0] - Et0[0] - vt0[0] * (t+lighttravel - t0_par-lighttravel0); // Earth shift along South wrt extrapolation from t0_par
+		Et[1] = Ehel[1] - Et0[1] - vt0[1] * (t+lighttravel - t0_par-lighttravel0); // Earth shift along West wrt extrapolation from t0_par
+
 	}
 	else {
-
+		// Calculation with Kepler equation
 		if (t0_par != t0old) {
 			t0old = t0_par;
 			ty = (t0_par - 1545) / 36525.0;
@@ -6328,8 +6699,20 @@ void VBMicrolensing::ComputeParallax(double t, double t0) {
 
 			EE = M + e * sin(M);
 			dE = 1;
+			dLtof = 0;
 			while (fabs(dE) > 1.e-8) {
-				dM = M - (EE - e * sin(EE));
+				if (t_in_HJD) {
+					// Correction to calculate Earth position at JD not HJD
+					x1 = a * (cos(EE) - e);
+					y1 = a * sqrt(1 - e * e) * sin(EE);
+					Ear[0] = x1 * cos(om) - y1 * sin(om);
+					Ear[1] = x1 * sin(om) * cos(inc) + y1 * cos(om) * cos(inc);
+					Ear[2] = x1 * sin(om) * sin(inc) + y1 * cos(om) * sin(inc);
+					dLtof = 0;
+					for (int i = 0; i < 3; i++) dLtof -= Ear[i] * Obj[i];
+					dLtof *= dtflight;
+				}
+				dM = M + dLtof - (EE - e * sin(EE));
 				dE = dM / (1 - e * cos(EE));
 				EE += dE;
 			}
@@ -6348,33 +6731,30 @@ void VBMicrolensing::ComputeParallax(double t, double t0) {
 			// Ear is the Earth position in AU in ecliptic coordinates  at time t0_par
 			// vEar is the Earth velocity vector in AU/day in ecliptic coordinates at time t0_par
 
-			sp = 0;
-			switch (parallaxsystem) {
-			case 1:
-				for (int i = 0; i < 3; i++) sp += North2000[i] * Obj[i];
-				for (int i = 0; i < 3; i++) rad[i] = -North2000[i] + sp * Obj[i];
-				break;
-			default:
+			if (parallaxsystem != 1) {
+				sp = 0;
 				for (int i = 0; i < 3; i++) sp += Ear[i] * Obj[i];
 				for (int i = 0; i < 3; i++) rad[i] = Ear[i] - sp * Obj[i];
-				break;
+				r = sqrt(rad[0] * rad[0] + rad[1] * rad[1] + rad[2] * rad[2]); // Celestial South projected orthogonal to LOS
+				rad[0] /= r;
+				rad[1] /= r;
+				rad[2] /= r;
+				tang[0] = rad[1] * Obj[2] - rad[2] * Obj[1]; // Celestial West projected orthogonal to LOS
+				tang[1] = rad[2] * Obj[0] - rad[0] * Obj[2];
+				tang[2] = rad[0] * Obj[1] - rad[1] * Obj[0];
 			}
 
-			r = sqrt(rad[0] * rad[0] + rad[1] * rad[1] + rad[2] * rad[2]); // Celestial South projected orthogonal to LOS
-			rad[0] /= r;
-			rad[1] /= r;
-			rad[2] /= r;
-			tang[0] = rad[1] * Obj[2] - rad[2] * Obj[1]; // Celestial West projected orthogonal to LOS
-			tang[1] = rad[2] * Obj[0] - rad[0] * Obj[2];
-			tang[2] = rad[0] * Obj[1] - rad[1] * Obj[0];
 
 			Et0[0] = Et0[1] = vt0[0] = vt0[1] = 0;
+			lighttravel0 = 0;
 			for (int i = 0; i < 3; i++) {
 				Et0[0] += Ear[i] * rad[i];           // Earth position projected along South at time t0_par
 				Et0[1] += Ear[i] * tang[i];          // Earth position projected along West at time t0_par
+				lighttravel0 += Ear[i] * Obj[i];
 				vt0[0] += vEar[i] * rad[i];          // Earth velocity projected along South at time t0_par
 				vt0[1] += vEar[i] * tang[i];		// Earth velocity projected along West at time t0_par
 			}
+			lighttravel0 *= (t_in_HJD) ? 0 : au_c; // Light travel time from Earth projection to Sun: HJD = JD + lighttravel.
 		}
 
 		ty = (t - 1545) / 36525.0;
@@ -6390,8 +6770,21 @@ void VBMicrolensing::ComputeParallax(double t, double t0) {
 
 		EE = M + e * sin(M);
 		dE = 1;
-		while (dE > 1.e-8) {
-			dM = M - (EE - e * sin(EE));
+		dLtof = 0;
+		while (fabs(dE) > 1.e-8) {
+			if (t_in_HJD) {
+				// Correction to calculate Earth position at JD not HJD
+				x1 = a * (cos(EE) - e);
+				y1 = a * sqrt(1 - e * e) * sin(EE);
+				Ear[0] = x1 * cos(om) - y1 * sin(om);
+				Ear[1] = x1 * sin(om) * cos(inc) + y1 * cos(om) * cos(inc);
+				Ear[2] = x1 * sin(om) * sin(inc) + y1 * cos(om) * sin(inc);
+				dLtof = 0;
+				for (int i = 0; i < 3; i++) dLtof -= Ear[i] * Obj[i];
+				dLtof *= dtflight;
+			}
+
+			dM = M + dLtof - (EE - e * sin(EE));
 			dE = dM / (1 - e * cos(EE));
 			EE += dE;
 		}
@@ -6406,45 +6799,68 @@ void VBMicrolensing::ComputeParallax(double t, double t0) {
 		Ear[2] = x1 * sin(om) * sin(inc) + y1 * cos(om) * sin(inc);
 		// Ear is the Earth position in AU in ecliptic coordinates  at time t
 
-		Ehel[0] = Ehel[1] = 0;
+		Ehel[0] = Ehel[1] = lighttravel = 0;
 		for (int i = 0; i < 3; i++) {
 			Ehel[0] += Ear[i] * rad[i]; // Ehel is the heliocentric position of Earth along South and West at time t
 			Ehel[1] += Ear[i] * tang[i];
+			lighttravel += Ear[i] * Obj[i];
 		}
-		Et[0] = Ehel[0] - Et0[0] - vt0[0] * (t - t0_par); // Earth shift along South wrt extrapolation from t0_par
-		Et[1] = Ehel[1] - Et0[1] - vt0[1] * (t - t0_par); // Earth shift along West wrt extrapolation from t0_par
+		lighttravel *= (t_in_HJD) ? 0 : au_c; // Light travel time from Earth projection to Sun: HJD = JD + lighttravel.
+		Et[0] = Ehel[0] - Et0[0] - vt0[0] * (t + lighttravel - t0_par - lighttravel0); // Earth shift along South wrt extrapolation from t0_par
+		Et[1] = Ehel[1] - Et0[1] - vt0[1] * (t + lighttravel - t0_par - lighttravel0); // Earth shift along West wrt extrapolation from t0_par
 
-		if (satellite > 0 && satellite <= nsat) {
-			if (ndatasat[satellite - 1] > 2) {
-				int left, right;
-				if (t < tsat[satellite - 1][0]) {
-					ic = 0;
+	}
+
+
+	//// For debugging: writes Sun coordinates from Earth to file for comparison with exact ephemerides.
+	//{
+	//	FILE* f = fopen("C:\\Users\\valboz\\Personali\\MicroModels\\test-dev\\ephemeris_test\\outapp.txt", "a");
+	//	double RA, Dec, ran,x,y,z;
+	//	ran = a * (1 - e * cos(EE));
+	//	z = x = y = 0;
+	//	for (int i = 0; i < 3; i++) z += Ear[i] * North2000[i];
+	//	for (int i = 0; i < 3; i++) x += Ear[i] * Eq2000[i];
+	//	for (int i = 0; i < 3; i++) y += Ear[i] * Quad2000[i];
+	//	Dec = -asin(z / ran)/deg;
+	//	RA = 180 + atan2(y, x)/deg;
+	//	if (RA < 0) RA += 360;
+	//	fprintf(f,"%lf %lf %lf %lf\n", t, RA, Dec, ran);
+	//	fclose(f);
+	//}
+
+
+	if (satellite > 0 && satellite <= nsat) {
+		if (ndatasat[satellite - 1] > 2) {
+			int left, right;
+			if (t < tsat[satellite - 1][0]) {
+				ic = 0;
+				parallaxextrapolation = 2;
+			}
+			else {
+				if (t > tsat[satellite - 1][ndatasat[satellite - 1] - 1]) {
+					ic = ndatasat[satellite - 1] - 2;
+					parallaxextrapolation = 2;
 				}
 				else {
-					if (t > tsat[satellite - 1][ndatasat[satellite - 1] - 1]) {
-						ic = ndatasat[satellite - 1] - 2;
-					}
-					else {
-						left = 0;
-						right = ndatasat[satellite - 1] - 1;
-						while (right - left > 1) {
-							ic = (right + left) / 2;
-							if (tsat[satellite - 1][ic] > t) {
-								right = ic;
-							}
-							else {
-								left = ic;
-							}
+					left = 0;
+					right = ndatasat[satellite - 1] - 1;
+					while (right - left > 1) {
+						ic = (right + left) / 2;
+						if (tsat[satellite - 1][ic] > t) {
+							right = ic;
+						}
+						else {
+							left = ic;
 						}
-						ic = left;
 					}
+					ic = left;
 				}
-				ty = (t - tsat[satellite - 1][ic])/(tsat[satellite - 1][ic+1]- tsat[satellite - 1][ic]);
-				for (int i = 0; i < 3; i++) {
-					Spit = possat[satellite - 1][ic][i] * (1 - ty) + possat[satellite - 1][ic + 1][i] * ty;
-					Et[0] += Spit * rad[i];
-					Et[1] += Spit * tang[i];
-				}
+			}
+			ty = t - tsat[satellite - 1][ic];
+			for (int i = 0; i < 3; i++) {
+				Spit = possat[satellite - 1][ic][i] * (1 - ty) + possat[satellite - 1][ic + 1][i] * ty;
+				Et[0] += Spit * rad[i];
+				Et[1] += Spit * tang[i];
 			}
 		}
 	}