VBMicrolensing 5.1.1__cp311-cp311-musllinux_1_2_i686.whl → 5.3.1__cp311-cp311-musllinux_1_2_i686.whl

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,10 @@ 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("parallaxextrapolation", &VBMicrolensing::parallaxextrapolation,
+        "If non-zero, extrapolation has been used because the input time is outside the lookup tables");
     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 +46,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 +64,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 +76,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 +400,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 +427,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,12 +484,23 @@ 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());
             self.PSPLLightCurveParallax(params.data(), times.data(), mags.data(),
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s,y2s };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -492,15 +547,27 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             results: list[list[float],list[float],list[float]] 
                 [Magnification array, source position y1 array, source position y2 array]
             )mydelimiter");
+
     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());
             self.ESPLLightCurveParallax(params.data(), times.data(), mags.data(),
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s,y2s };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -576,16 +643,29 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             results: list[list[float],list[float],list[float]] 
                 [Magnification array, source position y1 array, source position y2 array]
             )mydelimiter");
+
     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());
             self.BinaryLightCurveParallax(params.data(), times.data(), mags.data(),
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s,y2s };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
+
         },
         R"mydelimiter(
             Static binary lens light curve for a given set of parameters including parallax.
@@ -609,6 +689,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());
@@ -616,6 +706,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.BinaryLightCurveOrbital(params.data(), times.data(), mags.data(),
                 y1s.data(), y2s.data(), separations.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s,y2s, separations };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -642,6 +733,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());
@@ -649,6 +750,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.BinaryLightCurveKepler(params.data(), times.data(), mags.data(),
                 y1s.data(), y2s.data(), separations.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s,y2s, separations };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -703,12 +805,23 @@ 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());
             self.BinSourceLightCurveParallax(params.data(), times.data(), mags.data(),
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s,y2s };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -792,6 +905,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());
@@ -800,6 +923,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.BinSourceExtLightCurveXallarap(params.data(), times.data(), mags.data(),
                 y1s1.data(), y2s1.data(), y1s2.data(), y2s2.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s1,y2s1,y1s2,y2s2 };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -823,6 +947,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 +1033,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());
@@ -864,6 +1050,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.BinSourceLightCurveXallarap(params.data(), times.data(), mags.data(),
                 y1s.data(), y2s.data(), separations.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s,y2s, separations };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -923,12 +1110,23 @@ 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());
             self.TripleLightCurveParallax(params.data(), times.data(), mags.data(),
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags,y1s,y2s };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -1006,6 +1204,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());
@@ -1017,6 +1225,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.PSPLAstroLightCurve(params.data(), times.data(), mags.data(), c1s.data(), c2s.data(), c1l.data(), c2l.data(),
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags, c1s, c2s, c1l, c2l,y1s,y2s };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -1045,6 +1254,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());
@@ -1057,6 +1276,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.ESPLAstroLightCurve(params.data(), times.data(), mags.data(), c1s.data(), c2s.data(), c1l.data(), c2l.data(),
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags, c1s, c2s, c1l, c2l,y1s,y2s };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -1087,6 +1307,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());
@@ -1099,6 +1329,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.BinaryAstroLightCurve(params.data(), times.data(), mags.data(), c1s.data(), c2s.data(), c1l.data(), c2l.data(),
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags, c1s, c2s, c1l, c2l,y1s,y2s };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -1128,6 +1359,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());
@@ -1141,6 +1382,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.BinaryAstroLightCurveOrbital(params.data(), times.data(), mags.data(), c1s.data(), c2s.data(), c1l.data(), c2l.data(),
                 y1s.data(), y2s.data(), seps.data(), times.size());
             std::vector< std::vector<double> > results{ mags, c1s, c2s, c1l, c2l,y1s,y2s, seps };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -1171,6 +1413,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());
@@ -1184,6 +1436,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.BinaryAstroLightCurveKepler(params.data(), times.data(), mags.data(), c1s.data(), c2s.data(), c1l.data(), c2l.data(),
                 y1s.data(), y2s.data(), seps.data(), times.size());
             std::vector< std::vector<double> > results{ mags, c1s, c2s, c1l, c2l,y1s,y2s, seps };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -1216,6 +1469,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());
@@ -1230,6 +1493,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.BinSourceAstroLightCurveXallarap(params.data(), times.data(), mags.data(), c1s.data(), c2s.data(), c1l.data(), c2l.data(),
                 y1s1.data(), y2s1.data(), y1s2.data(), y2s2.data(), times.size());
             std::vector< std::vector<double> > results{ mags, c1s, c2s, c1l, c2l,y1s1,y2s1,y1s2,y2s2 };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(
@@ -1259,9 +1523,81 @@ 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 };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
+            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());
@@ -1274,6 +1610,7 @@ PYBIND11_MODULE(VBMicrolensing, m) {
             self.TripleAstroLightCurve(params.data(), times.data(), mags.data(), c1s.data(), c2s.data(), c1l.data(), c2l.data(),
                 y1s.data(), y2s.data(), times.size());
             std::vector< std::vector<double> > results{ mags, c1s, c2s, c1l, c2l,y1s,y2s };
+            if (self.parallaxextrapolation > 0) py::print("Input time is outside range of lookup tables: extrapolation is used.");
             return results;
         },
         R"mydelimiter(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VBMicrolensing
-Version: 5.1.1
+Version: 5.3.1
 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)