VBMicrolensing 5.1.1__cp313-cp313-musllinux_1_2_i686.whl → 5.3__cp313-cp313-musllinux_1_2_i686.whl

VBMicrolensing/lib/VBMicrolensingLibrary.h

@@ -1,4 +1,4 @@
-// VBMicrolensing v5.0 (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
@@ -74,7 +74,9 @@ class VBMicrolensing
 		0.3 };
 
 	int* ndatasat;
-	double** tsat, *** possat;
+	double *** possat, * startsat, * stepsat;
+	double** posEar, startEar, stepEar;
+	int ndataEar;
 	double Mag0;
 	double* dist_mp, * q;
 	int nim0, n, n2, nnm1, nroots, nrootsmp, * nrootsmp_mp;
@@ -95,9 +97,10 @@ class VBMicrolensing
 	int iastro;
 	double Obj[3], rad[3], tang[3], t0old;
 	double Eq2000[3], Quad2000[3], North2000[3];
-	double Et0[2], vt0[2], Et[2], Ehel[2];
+	double Et0[2], vt0[2], Et[2], Ehel[2], lighttravel, lighttravel0;
 	double ESPLout[__rsize_ESPL][__zsize_ESPL], ESPLin[__rsize_ESPL][__zsize_ESPL], ESPLoutastro[__rsize_ESPL][__zsize_ESPL], ESPLinastro[__rsize_ESPL][__zsize_ESPL];
-	bool ESPLoff, multidark;
+	bool coordinates_set;
+	bool multidark;
 	double* LDtab, * rCLDtab, * CLDtab;
 	double scr2, sscr2;
 	int npLD;
@@ -146,12 +149,17 @@ public:
 	bool astrometry;
 	bool turn_off_secondary_source;
 	bool turn_off_secondary_lens;
+	bool ESPLoff;
+	bool t_in_HJD;
 
 	static char ESPLtablefile[1024];
 	static void SetESPLtablefile(char* instring) { strcpy(ESPLtablefile, instring); }
-	double Tol, RelTol, a1, a2, t0_par,corrquad, corrquad2, safedist;
+	static char Suntablefile[1024];
+	static void SetSuntablefile(char* instring) { strcpy(Suntablefile, instring); }
+	double Tol, RelTol, a1, a2,corrquad, corrquad2, safedist;
 	double mass_radius_exponent, mass_luminosity_exponent, lens_mass_luminosity_exponent;
-	int satellite, parallaxsystem, t0_par_fixed, nsat;
+	int satellite, parallaxsystem, t0_par, t0_par_fixed, nsat;
+	bool suntable, parallaxephemeris;
 	int minannuli, maxannuli, nannuli, NPS, NPcrit;
 	int newtonstep;
 	double y_1, y_2, av, therr, astrox1, astrox2;
@@ -163,6 +171,7 @@ public:
 	// Initialization for parallax calculation
 	void SetObjectCoordinates(char* Coordinates_file, char* Directory_for_satellite_tables);
 	void SetObjectCoordinates(char* CoordinateString);
+	bool AreCoordinatesSet();
 	// Skowron & Gould root calculation
 	void cmplx_roots_gen(complex*, complex*, int, bool, bool);
 	void cmplx_roots_multigen(complex*, complex**, int, bool, bool);
@@ -202,7 +211,7 @@ public:
 	void SetMethod(Method);
 
 	//ESPL functions
-	void LoadESPLTable(char* tablefilename);
+	void LoadESPLTable(const char* tablefilename);
 	double ESPLMag(double u, double rho);
 	double ESPLMag2(double u, double rho);
 	double ESPLMagDark(double u, double rho);
@@ -211,6 +220,7 @@ public:
 
 	// New (v2) light curve functions, operating on arrays
 
+	void LoadSunTable(char* tablefilename);
 	void PSPLLightCurve(double* parameters, double* t_array, double* mag_array, double* y1_array, double* y2_array, int np);
 	void PSPLLightCurveParallax(double* parameters, double* t_array, double* mag_array, double* y1_array, double* y2_array, int np);
 	void ESPLLightCurve(double* parameters, double* t_array, double* mag_array, double* y1_array, double* y2_array, int np);
@@ -229,6 +239,7 @@ public:
 	void BinSourceExtLightCurveXallarap(double* parameters, double* t_array, double* mag_array, double* y1_array, double* y2_array, double* y1_array2, double* y2_array2, int np);
 	void BinSourceSingleLensXallarap(double* parameters, double* t_array, double* mag_array, double* y1_array, double* y2_array, double* y1_array2, double* y2_array2, int np);
 	void BinSourceBinLensXallarap(double* parameters, double* t_array, double* mag_array, double* y1_array, double* y2_array, int np);
+	void BinSourceBinLensLightCurve(double* parameters, double* t_array, double* mag_array, double* y1_array, double* y2_array, double* y1_array2, double* y2_array2, double* seps_array, int np);
 
 	void TripleLightCurve(double* parameters, double* t_array, double* mag_array, double* y1_array, double* y2_array, int np);
 	void TripleLightCurveParallax(double* parameters, double* t_array, double* mag_array, double* y1_array, double* y2_array, int np);
@@ -253,7 +264,8 @@ public:
 	double BinSourceExtLightCurveXallarap(double* parameters, double t);
 	double BinSourceBinLensXallarap(double* parameters, double t);
 	double BinSourceSingleLensXallarap(double* parameters, double t);
-	double BinSourceBinLensPOX(double* parameters, double t);
+	double BinSourceBinLensLightCurve(double* parameters, double t);
+
 
 	double TripleLightCurve(double* parameters, double t);
 	double TripleLightCurveParallax(double* parameters, double t);
@@ -266,6 +278,7 @@ public:
 	void BinaryAstroLightCurveOrbital(double* parameters, double* t_array, double* mag_array, double* centroid_s1_array, double* centroid_s2_array, double* centroid_l1_array, double* centroid_l2_array, double* y1_array, double* y2_array, double* seps_array, int np);
 	void BinaryAstroLightCurveKepler(double* parameters, double* t_array, double* mag_array, double* centroid_s1_array, double* centroid_s2_array, double* centroid_l1_array, double* centroid_l2_array, double* y1_array, double* y2_array, double* seps_array, int np);
 	void BinSourceAstroLightCurveXallarap(double* parameters, double* t_array, double* mag_array, double* centroid_s1_array, double* centroid_s2_array, double* centroid_l1_array, double* centroid_l2_array, double* y1_array, double* y2_array, double* y1_array2, double* y2_array2, int np);
+	void BinSourceBinLensAstroLightCurve(double* parameters, double* t_array, double* mag_array, double* centroid_s1_array, double* centroid_s2_array, double* centroid_l1_array, double* centroid_l2_array, double* y1_array, double* y2_array, double* y1_array2, double* y2_array2, double* seps_array, int np);
 	void TripleAstroLightCurve(double* parameters, double* t_array, double* mag_array, double* centroid_s1_array, double* centroid_s2_array, double* centroid_l1_array, double* centroid_l2_array, double* y1_array, double* y2_array, int np);
 
 	// Constructor and destructor

VBMicrolensing/lib/python_bindings.cpp

@@ -2,6 +2,7 @@
 #include <pybind11/stl.h>
 #include "VBMicrolensingLibrary.h"
 #include <string>
+#include <filesystem>
 #include <pybind11/functional.h>
 
 
@@ -32,6 +33,8 @@ PYBIND11_MODULE(VBMicrolensing, m) {
         "Minimum number of annuli to calculate for limb darkening.");
     vbm.def_readwrite("NPcrit", &VBMicrolensing::NPcrit,
         "Number of points in critical curves.");
+    vbm.def_readwrite("parallaxephemeris", &VBMicrolensing::parallaxephemeris,
+        "True for parallax calculation with ephemeris, False for parallax calculation with Kepler equation");
     vbm.def_readwrite("parallaxsystem", &VBMicrolensing::parallaxsystem,
         "0 for parallel-perpendicular, 1 for North-Eeast.");
     vbm.def_readwrite("t0_par_fixed", &VBMicrolensing::t0_par_fixed,
@@ -41,6 +44,8 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def_readwrite("satellite", &VBMicrolensing::satellite,
         "Specifies the satellite number for the next calculation \
                 (0 for observations from the ground);.");
+    vbm.def_readwrite("nsat", &VBMicrolensing::nsat,
+        "Number of satellite tables found in satellite table directory.");
     vbm.def_readwrite("astrometry", &VBMicrolensing::astrometry,
         "Unlock astrometry centroid calculation.");
     vbm.def_readwrite("astrox1", &VBMicrolensing::astrox1,
@@ -57,6 +62,8 @@ PYBIND11_MODULE(VBMicrolensing, m) {
         "Flux of secondary source is set to zero.");
     vbm.def_readwrite("turn_off_secondary_lens", &VBMicrolensing::turn_off_secondary_lens,
         "Flux of secondary lens is set to zero.");
+    vbm.def_readwrite("t_in_HJD", &VBMicrolensing::t_in_HJD,
+        "Set if t is given in HJD");
     vbm.def_readwrite("corrquad", &VBMicrolensing::corrquad,
         "Quadrupole test.");
     vbm.def_readwrite("corrquad2", &VBMicrolensing::corrquad2,
@@ -67,10 +74,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
 
     vbm.def("LoadESPLTable", &VBMicrolensing::LoadESPLTable,
         """Loads a pre calculated binary table for extended source calculation.""");
+    vbm.def("LoadSunTable", &VBMicrolensing::LoadSunTable,
+        """Loads a Sun ephemeris table for parallax calculation.""");
     vbm.def("SetESPLtablefile", [](char* s) {
         VBMicrolensing::SetESPLtablefile(s);
         },
         """Sets the path to a pre calculated binary table for extended source calculation.""");
+    vbm.def("SetSuntablefile", [](char* s) {
+        VBMicrolensing::SetSuntablefile(s);
+        },
+        """Sets the path to a pre calculated Sun ephemeris table to be used in parallax calculations.""");
     // Maginfication calculations
     vbm.def("PSPLMag", &VBMicrolensing::PSPLMag,
         py::return_value_policy::reference,
@@ -385,7 +398,24 @@ PYBIND11_MODULE(VBMicrolensing, m) {
                 .
             )mydelimiter");
 
-    vbm.def("SetObjectCoordinates", (void (VBMicrolensing::*)(char*)) & VBMicrolensing::SetObjectCoordinates,
+    //vbm.def("SetObjectCoordinates", (void (VBMicrolensing::*)(char*)) & VBMicrolensing::SetObjectCoordinates,
+    //    R"mydelimiter(
+    //        Sets the astronomical coordinates of the microlensing target.            
+    //        
+    //        Parameters
+    //        ----------
+    //        CoordinateString : string 
+    //            Format \"hr:mn:sc +deg:pr:sc\".
+    //        )mydelimiter");
+
+    vbm.def("SetObjectCoordinates", 
+        [](VBMicrolensing& self, char* coordinatestring) 
+        {
+            self.SetObjectCoordinates(coordinatestring);
+            if (!self.AreCoordinatesSet()) {
+                py::print("! Invalid coordinates format !");
+            }
+        },
         R"mydelimiter(
             Sets the astronomical coordinates of the microlensing target.            
             
@@ -395,7 +425,19 @@ PYBIND11_MODULE(VBMicrolensing, m) {
                 Format \"hr:mn:sc +deg:pr:sc\".
             )mydelimiter");
 
-    vbm.def("SetObjectCoordinates", (void (VBMicrolensing::*)(char*, char*)) & VBMicrolensing::SetObjectCoordinates,
+    vbm.def("SetObjectCoordinates", 
+        [](VBMicrolensing& self, char* coordinatefile, char* sattabledir)
+        {
+            if (std::filesystem::exists(sattabledir)) {
+                self.SetObjectCoordinates(coordinatefile, sattabledir);
+                if (!self.AreCoordinatesSet()) {
+                    py::print("! Invalid coordinates format !");
+                }
+            }
+            else {
+                py::print("! Invalid satellite table directory !");
+            }
+        },
         R"mydelimiter(
             Sets the astronomical coordinates of the microlensing target and 
             specifies the path where to look for the position tables 
@@ -440,6 +482,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("PSPLLightCurveParallax",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> y1s(times.size());
             std::vector<double> y2s(times.size());
@@ -495,6 +547,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("ESPLLightCurveParallax",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> y1s(times.size());
             std::vector<double> y2s(times.size());
@@ -579,6 +641,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinaryLightCurveParallax",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> y1s(times.size());
             std::vector<double> y2s(times.size());
@@ -586,6 +658,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s,y2s };
             return results;
+
         },
         R"mydelimiter(
             Static binary lens light curve for a given set of parameters including parallax.
@@ -609,6 +682,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinaryLightCurveOrbital",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> y1s(times.size());
             std::vector<double> y2s(times.size());
@@ -642,6 +725,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinaryLightCurveKepler",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> y1s(times.size());
             std::vector<double> y2s(times.size());
@@ -703,6 +796,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinSourceLightCurveParallax",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> y1s(times.size());
             std::vector<double> y2s(times.size());
@@ -792,6 +895,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinSourceExtLightCurveXallarap",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> y1s1(times.size());
             std::vector<double> y2s1(times.size());
@@ -823,6 +936,58 @@ PYBIND11_MODULE(VBMicrolensing, m) {
                     source2 position y1 array, source2 position y2 array]
             )mydelimiter");
 
+
+    vbm.def("BinSourceBinLensLightCurve",
+        [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
+        {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            std::vector<double> mags(times.size());
+            std::vector<double> y1s1(times.size());
+            std::vector<double> y2s1(times.size());
+            std::vector<double> y1s2(times.size());
+            std::vector<double> y2s2(times.size());
+            std::vector<double> seps(times.size());
+            self.astrometry = true;
+            self.parallaxsystem = 1;
+            self.BinSourceBinLensLightCurve(params.data(), times.data(), mags.data(),
+                y1s1.data(), y2s1.data(), y1s2.data(), y2s2.data(), seps.data(), times.size());
+            std::vector< std::vector<double> > results{ mags, y1s1,y2s1,y1s2,y2s2,seps };
+            return results;
+        },
+        R"mydelimiter(
+            Binary source - Binary lens light curve including xallarap and orbital motion for a full array of observations.
+
+            Parameters
+            ----------
+            params : list[float]
+                List of parameters [log_s, log_q, u0, alpha, log_rho, log_tE, t0, 
+                                    paiN, paiE,     # components of the parallax vector
+                                    w1, w2, w3,     # relative angular orbital velocity components (Einstein angle/day)
+                                    u02, t02,       # impact parameter, time of closest approach of the seconf source
+                                    log_FR,         # log of flux ratio of the two sources
+                                    ws1, ws2, ws3,  # relative angular orbital velocity components of the sources (Einstein angle/day)
+                                    ] 
+            times : list[float] 
+                Array of times at which the magnification is calculated.
+ 
+            Returns
+            -------
+            results: list[list[float],list[float],list[float],list[float],list[float],list[float]] 
+                [Magnification array,
+                    source1 position y1 array, source1 position y2 array, 
+                    source2 position y1 array, source2 position y2 array,
+                    projected separations of the two lenses]
+            )mydelimiter");
+
     vbm.def("BinSourceBinLensXallarap",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
@@ -857,6 +1022,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinSourceLightCurveXallarap",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> y1s(times.size());
             std::vector<double> y2s(times.size());
@@ -923,6 +1098,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("TripleLightCurveParallax",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> y1s(times.size());
             std::vector<double> y2s(times.size());
@@ -1006,6 +1191,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("PSPLAstroLightCurve",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> c1s(times.size());
             std::vector<double> c2s(times.size());
@@ -1045,6 +1240,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("ESPLAstroLightCurve",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> c1s(times.size());
             std::vector<double> c2s(times.size());
@@ -1087,6 +1292,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinaryAstroLightCurve",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> c1s(times.size());
             std::vector<double> c2s(times.size());
@@ -1128,6 +1343,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinaryAstroLightCurveOrbital",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> c1s(times.size());
             std::vector<double> c2s(times.size());
@@ -1171,6 +1396,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinaryAstroLightCurveKepler",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> c1s(times.size());
             std::vector<double> c2s(times.size());
@@ -1216,6 +1451,16 @@ PYBIND11_MODULE(VBMicrolensing, m) {
     vbm.def("BinSourceAstroLightCurveXallarap",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> c1s(times.size());
             std::vector<double> c2s(times.size());
@@ -1259,9 +1504,80 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             )mydelimiter");
 
 
+    vbm.def("BinSourceBinLensAstroLightCurve",
+        [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
+        {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            std::vector<double> mags(times.size());
+            std::vector<double> c1s(times.size());
+            std::vector<double> c2s(times.size());
+            std::vector<double> c1l(times.size());
+            std::vector<double> c2l(times.size());
+            std::vector<double> y1s1(times.size());
+            std::vector<double> y2s1(times.size());
+            std::vector<double> y1s2(times.size());
+            std::vector<double> y2s2(times.size());
+            std::vector<double> seps(times.size());
+            self.astrometry = true;
+            self.parallaxsystem = 1;
+            self.BinSourceBinLensAstroLightCurve(params.data(), times.data(), mags.data(), c1s.data(), c2s.data(), c1l.data(), c2l.data(),
+                y1s1.data(), y2s1.data(), y1s2.data(), y2s2.data(), seps.data(), times.size());
+            std::vector< std::vector<double> > results{ mags, c1s, c2s, c1l, c2l,y1s1,y2s1,y1s2,y2s2,seps };
+            return results;
+        },
+        R"mydelimiter(
+            Binary source - Binary lens light curve  and astrometry including xallarap and orbital motion for a full array of observations.
+
+            Parameters
+            ----------
+            params : list[float]
+                List of parameters [log_s, log_q, u0, alpha, log_rho, log_tE, t0, 
+                                    paiN, paiE,     # components of the parallax vector
+                                    w1, w2, w3,     # relative angular orbital velocity components (Einstein angle/day)
+                                    u02, t02,       # impact parameter, time of closest approach of the seconf source
+                                    log_FR,         # log of flux ratio of the two sources
+                                    ws1, ws2, ws3,  # relative angular orbital velocity components of the sources (Einstein angle/day)
+                                    muS_N, muS_E,   # proper motion components of the source (mas/yr)
+                                    pai_S,          # parallax of the source (mas)
+                                    thetaE          # Einstein angle (mas) 
+                                    ] 
+            times : list[float] 
+                Array of times at which the magnification is calculated.
+ 
+            Returns
+            -------
+            results: list[list[float],list[float],list[float],list[float],list[float],list[float],list[float],list[float],list[float],list[float]] 
+                [Magnification array,
+                    centroid of images N array, centroid of images E array, 
+                    centroid of lens N array, centroid of lens E array,
+                    source1 position y1 array, source1 position y2 array, 
+                    source2 position y1 array, source2 position y2 array,
+                    projected separations of the two lenses]
+            )mydelimiter");
+
+
     vbm.def("TripleAstroLightCurve",
         [](VBMicrolensing& self, std::vector<double> params, std::vector<double> times)
         {
+            if (!self.AreCoordinatesSet()) {
+                py::print("Use SetObjectCoordinates before any parallax calculation!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
+            if (self.satellite > self.nsat) {
+                py::print("! Ephemerides table not available for this satellite!");
+                std::vector< std::vector<double> > results{  };
+                return results;
+            }
             std::vector<double> mags(times.size());
             std::vector<double> c1s(times.size());
             std::vector<double> c2s(times.size());

{vbmicrolensing-5.1.1.dist-info → vbmicrolensing-5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VBMicrolensing
-Version: 5.1.1
+Version: 5.3
 Summary: VBMicrolensing is a tool for efficient computation in gravitational microlensing events using the advanced contour integration method, supporting single, binary and multiple lenses.
 Keywords: Microlensing magnification and astrometry
 Author-Email: Valerio Bozza <valboz@sa.infn.it>, Vito Saggese <vitosaggese.vs@gmail.com>
@@ -27,12 +27,12 @@ In particular, VBMicrolensing is designed for the following calculations:
 
 `VBMicrolensing` is written as a C++ library and wrapped as a Python package, the user can call the code from either C++ or Python. This new code encompasses the well-known [VBBinaryLensing](https://github.com/valboz/VBBinaryLensing) code, which is at the basis of several platforms for microlensing modeling. `VBBinaryLensing` will still be available as a legacy software, but will no longer be maintained. 
 
-`VBMicrolensing` has been developed by **Valerio Bozza**, University of Salerno, with a substantial contribution by **Vito Saggese**, University of Naples and **Jiyuan Zhang**, Tisnghua University. We also acknowledge a long list of collaborators who contributed to testing and development of particular aspects over the years: Etienne Bachelet, Fran Bartolic, Sebastiano Calchi Novati, Giovanni Covone, Giuseppe D'Ago, Tyler Heintz, Ava Hoag, Markus Hundertmark, Elahe Khalouei, Radek Poleski, Haibin Ren, Paolo Rota, Sedighe Sajadian, Rachel Street, Keto Zhang, Weicheng Zhang, Wei Zhu.
+`VBMicrolensing` has been developed by **Valerio Bozza**, University of Salerno, with a substantial contribution by **Vito Saggese**, University of Naples and **Jiyuan Zhang**, Tisnghua University. We also acknowledge a long list of collaborators who contributed to testing and development of particular aspects over the years: Natasha Abrams, Etienne Bachelet, Fran Bartolic, Dex Bhadra, Sebastiano Calchi Novati, Giovanni Covone, Giuseppe D'Ago, Tyler Heintz, Ava Hoag, Markus Hundertmark, Elahe Khalouei, Jessica Lu, Matthew Penny, Radek Poleski, Haibin Ren, Paolo Rota, Sedighe Sajadian, Rachel Street, Keto Zhang, Weicheng Zhang, Wei Zhu.
 
 ## Attribution
 Any use of this code for scientific publications should be acknowledged by a citation to the works relevant to your study:
 - [V. Bozza, MNRAS 408 (2010) 2188](https://ui.adsabs.harvard.edu/abs/2010MNRAS.408.2188B/abstract): general algorithm for binary lensing;
-- [V. Bozza et al., MNRAS 479 (2018) 5157](https://ui.adsabs.harvard.edu/abs/2018MNRAS.479.5157B/abstract): BinaryMag2 function, Extended-Source-Point-Lens methods; 
+- [V. Bozza, E. Bachelet, F. Bartolic, T. Heintz, A. Hoag, M. Hundertmark, MNRAS 479 (2018) 5157](https://ui.adsabs.harvard.edu/abs/2018MNRAS.479.5157B/abstract): BinaryMag2 function, Extended-Source-Point-Lens methods; 
 - [V. Bozza, E. Khalouei and E. Bachelet, MNRAS 505 (2021) 126](https://ui.adsabs.harvard.edu/abs/2021MNRAS.505..126B/abstract): astrometry, generalized limb darkening, Keplerian orbital motion; 
 - [V. Bozza, v. Saggese, G. Covone, P. Rota & J. Zhang, A&A 694 (2025) 219](https://ui.adsabs.harvard.edu/abs/2025A%26A...694A.219B/abstract): multiple lenses.
 
@@ -59,6 +59,7 @@ If you just want to use the C++ library, clone this repository, all cpp files an
 
 The package also contains the following files:
 - `VBMicrolensing/data/ESPL.tbl`  - Pre-calculated table for Extended-source-point-lens
+- `VBMicrolensing/data/SunEphemeris.txt`  - Sun ephemeris for parallax calculation
 - `VBMicrolensing/data/OB151212coords.txt` - Sample file with event coordinates
 - `VBMicrolensing/data/satellite1.txt` - Sample table for satellite position (Spitzer)
 - `VBMicrolensing/data/satellite2.txt` - Sample table for satellite position (Kepler)

vbmicrolensing-5.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+vbmicrolensing.libs/libgcc_s-1257a076.so.1,sha256=wbXWo2Qh33OuE7spB8-mVbZoEiUkvZu6ZH78pUNr9X8,168321
+vbmicrolensing.libs/libstdc++-0530927c.so.6.0.32,sha256=h2p2et0WB0CYcMcUEViWjYXOe8uir-_tHJJZui-6GRc,3537509
+vbmicrolensing-5.3.dist-info/METADATA,sha256=HzYzW5BnoiFafPOeleHg4fPbbRFJv77W2eUO194B0EY,5252
+vbmicrolensing-5.3.dist-info/RECORD,,
+vbmicrolensing-5.3.dist-info/WHEEL,sha256=Gn71w5XGPEA6oH49qoed5OcYzpzuctX6-QkJzqvkUKs,115
+vbmicrolensing-5.3.dist-info/licenses/LICENSE,sha256=9Mshi9y3rHWswcmBvMd7l39rm2wqMn1ySJ_J_MvpDbo,7651
+VBMicrolensing/__init__.py,sha256=4Vvgfp21A_YOYqJUvBxXgWLOGannprtI4bZG31ELQgY,339
+VBMicrolensing/VBMicrolensing.so,sha256=40y_VXtYIWDpVggsJn8-Zb90FUTMHzIB-4Z_BGjzqRs,951497
+VBMicrolensing/lib/VBMicrolensingLibrary.cpp,sha256=DdN0jqrT4YTH9B2jUpgsO6utA7Yv9iRRZxr-0h4qgxI,281308
+VBMicrolensing/lib/python_bindings.cpp,sha256=ZeD0kqafLExPqgvsITdlFJ4moBoahhgukIGTcqClTlU,86363
+VBMicrolensing/lib/VBMicrolensingLibrary.h,sha256=pW9MKGPGSh2N4nJLI5u-3cz1sfGowbL4jEBWdZCWrKE,23085
+VBMicrolensing/data/SunEphemeris.txt,sha256=6PIPZoa6L38ITLUFDWFcmbREWgQkrGZePtDmgjaa-F8,1591038
+VBMicrolensing/data/satellite2.txt,sha256=wEySAu6SiUc7y5Vmx_B5jUnStpEtUyYp4u-HKlvb4Wk,112560
+VBMicrolensing/data/satellite1.txt,sha256=JzmXrT2aUJxoArVcXyZyGfscwSFIow_0fRh_ZMcxNS0,110290
+VBMicrolensing/data/OB151212coords.txt,sha256=j8i1PA8r1atAO22li0KxM2cVWUDGF9tMaNurX-6Vx0o,18
+VBMicrolensing/data/ESPL.tbl,sha256=Pv6QdMo1hJAlDdh2Znci9YHRej9gyrrASuLaegKiMsQ,488032

{vbmicrolensing-5.1.1.dist-info → vbmicrolensing-5.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.4
+Generator: scikit-build-core 0.11.5
 Root-Is-Purelib: false
 Tag: cp313-cp313-musllinux_1_2_i686