Refactor radar configuration to use Configure method

Replaces direct Radar object construction with a new Configure method for radar setup. Updates Cython interface and usage in simulator_radar.pyx to improve clarity and separation of configuration logic.

Author: zpeng

src/radarsimpy/includes/radarsimc.pxd

@@ -260,6 +260,14 @@ cdef extern from "radar.hpp":
               Vec3[L] speed_array,                               # Platform velocity
               vector[Vec3[L]] & rotation_array,                  # Platform orientations
               Vec3[L] rotrate_array) except +                    # Platform rotation rates
+
+        void Configure(Transmitter[H, L] & tx,                            # Transmitter configuration
+                       Receiver[L] & rx,                                  # Receiver configuration
+                       vector[H] & frame_start_time,                      # Frame timing array (s)
+                       vector[Vec3[L]] & location_array,                  # Platform locations
+                       Vec3[L] speed_array,                               # Platform velocity
+                       vector[Vec3[L]] & rotation_array,                  # Platform orientations
+                       Vec3[L] rotrate_array) except +                    # Platform rotation rates
 
         # Memory management for baseband data
         void InitBaseband(H *bb_real,                            # Real baseband buffer

src/radarsimpy/lib/cp_radarsimc.pxd

@@ -48,7 +48,7 @@ cdef void cp_AddPoint(location, speed, rcs, phase, shape, PointsManager[float_t]
 # Create a Radar system object for simulation 
 # Converts Python radar config to C++ with complete transmitter/receiver setup
 # Raises ValueError for invalid config, RuntimeError for setup failures
-cdef Radar[double, float_t] cp_Radar(radar, frame_start_time) except *
+cdef void cp_ConfigureRadar(radar, frame_start_time, Radar[double, float_t] * cptr_radar) except *
 
 # Create a Target object specifically optimized for RCS calculations
 # Simplified target object without full dynamic simulation requirements

src/radarsimpy/lib/cp_radarsimc.pyx

@@ -530,7 +530,7 @@ cdef RxChannel[float_t] cp_RxChannel(rx,
 @cython.cdivision(True)
 @cython.boundscheck(False)
 @cython.wraparound(False)
-cdef Radar[double, float_t] cp_Radar(radar, frame_start_time):
+cdef void cp_ConfigureRadar(radar, frame_start_time, Radar[double, float_t] * cptr_radar):
     """
     cp_Radar(radar, frame_start_time)
 
@@ -583,7 +583,6 @@ cdef Radar[double, float_t] cp_Radar(radar, frame_start_time):
     """
     cdef Transmitter[double, float_t] tx_c
     cdef Receiver[float_t] rx_c
-    cdef Radar[double, float_t] radar_c
 
     # Extract key system dimensions from radar configuration
     cdef int_t txsize_c = radar.radar_prop["transmitter"].txchannel_prop["size"]
@@ -667,15 +666,13 @@ cdef Radar[double, float_t] cp_Radar(radar, frame_start_time):
     spd_vt = Vec3[float_t](<float_t>radar.radar_prop["speed"][0], <float_t>radar.radar_prop["speed"][1], <float_t>radar.radar_prop["speed"][2])
     rrt_vt = Vec3[float_t](<float_t>radar.radar_prop["rotation_rate"][0], <float_t>radar.radar_prop["rotation_rate"][1], <float_t>radar.radar_prop["rotation_rate"][2])
 
-    radar_c = Radar[double, float_t](tx_c,
-                             rx_c,
-                             t_frame_vt,
-                             loc_vt,
-                             spd_vt,
-                             rot_vt,
-                             rrt_vt)
-    
-    return radar_c
+    cptr_radar[0].Configure(tx_c,
+                            rx_c,
+                            t_frame_vt,
+                            loc_vt,
+                            spd_vt,
+                            rot_vt,
+                            rrt_vt)
 
 @cython.cdivision(True)
 @cython.boundscheck(False)

src/radarsimpy/simulator_radar.pyx

@@ -57,7 +57,7 @@ from radarsimpy.includes.radarsimc cimport (
 
 # RadarSimX library components
 from radarsimpy.lib.cp_radarsimc cimport (
-    cp_Radar,
+    cp_ConfigureRadar,
     cp_AddTarget,
     cp_AddPoint
 )
@@ -248,8 +248,8 @@ cpdef sim_radar(radar, targets, frame_time=None, density=1, level=None, interf=N
     #----------------------
     # Core simulation objects
     cdef:
-        shared_ptr[Radar[double, float_t]] radar_c
-        shared_ptr[Radar[double, float_t]] interf_radar_c
+        shared_ptr[Radar[double, float_t]] radar_c = make_shared[Radar[double, float_t]]()
+        shared_ptr[Radar[double, float_t]] interf_radar_c = make_shared[Radar[double, float_t]]()
         Vec2[int_t] ray_filter_c
 
     cdef shared_ptr[TargetsManager[float_t]] targets_manager = make_shared[TargetsManager[float_t]]()
@@ -339,7 +339,7 @@ cpdef sim_radar(radar, targets, frame_time=None, density=1, level=None, interf=N
 
             cp_AddPoint(loc, spd, rcs, phs, ts_shape, points_manager.get())
 
-    radar_c = make_shared[Radar[double, float_t]](cp_Radar(radar, frame_start_time))
+    cp_ConfigureRadar(radar, frame_start_time, radar_c.get())
 
     cdef double[:,:,::1] bb_real = np.empty(ts_shape, order='C', dtype=np.float64)
     cdef double[:,:,::1] bb_imag = np.empty(ts_shape, order='C', dtype=np.float64)
@@ -446,7 +446,7 @@ cpdef sim_radar(radar, targets, frame_time=None, density=1, level=None, interf=N
     if interf is not None:
         # Use main radar frame time if interference frame time not specified
         interf_frame_start_time = np.array(interf.time_prop["frame_start_time"], dtype=np.float64)
-        interf_radar_c = make_shared[Radar[double, float_t]](cp_Radar(interf, interf_frame_start_time))
+        cp_ConfigureRadar(interf, interf_frame_start_time, interf_radar_c.get())
 
         # Initialize baseband for interference calculation
         radar_c.get()[0].InitBaseband(&bb_real[0][0][0], &bb_imag[0][0][0])