At_Surface.h

Go to the documentation of this file.

/* © 1998 JRM Technologies, Inc.*/



/***********************************
Copyright JRM Enterprises, Inc. 1998
All rights reserved.

This code is the intellectual property of JRM Enterprises, Inc.
It may not be used or released as source or compiled binary form
without the prior written consent of JRM Enterprises, Inc.
***********************************/


#ifndef _At_Surface_
#define _At_Surface_

#include "LOS_Prop.h"

#ifdef __cplusplus
extern "C"
{
#endif  // __cplusplus


    // ---------- State Updates -------------

    // UpdateObjectKinematics() is intended to update the position and FOV for this object by indexing into the proper track record based on the simtime.
    // INPUTS : sens points to object with one or more track records filled in.
    //         E defines the Earth ellipsoid for geodetic to geocentric conversion
    //         simtime is the simulation time in seconds.
    // OUTPUTS: object->{geoc_loc, geod_loc} corresponding to simtime (from track records)
    //         object->{ned_linear_velocity, ned_angular_velocity, ned_linear_acceleration, ned_angular_acceleration} corresponding to simtime (from track records).
    SIGSIM49_API int UpdateObjectKinematics(OBJECT *object, ellipsoid E, double simtime); 

    // ObjectThermalSpinUp() forms nodal mesh for object matl systems and plays a time-step update to initialize them.
    SIGSIM49_API int ObjectThermalSpinUp(OBJECT *object, double spinupPeriod, METIN *metin);

    // UpdateObjectMSPOLYARRAYTemperatures() merely updates the ms_poly_array temperatures (degK) with the mp_table.Tsurf temperatures corresponding to the instantiated material system.
    SIGSIM49_API int UpdateObjectMSPOLYARRAYTemperatures(OBJECT *object);

    // ReturnScatterAspect() gets the most relevant XPatch scatter center table for that target az/el aspect and frequency.
    // Returns FALSE if no appropriate data exists. 
    // Not required if CalcRFReflectedPower is to be called, but useful if one is to pass this info to 3rd party codes.
    // "el" [deg] measured from FR plane toward D, 
    // "az" [deg] measured on FR plane counter-clockwise about D from F
    // "freq" [Hz]
    //SIGSIM49_API jrmbool ReturnScatterAspect(OBJECT *object, double az, double el, double freq, SCATTER_ASPECT *sa);
    SIGSIM49_API jrmbool ReturnScatterAspect(OBJECT *object, double az, double el, double freq, RCS_ASPECT *aspect);

    // ReturnRCSAspect() makes sure that the relavent RCS data is available for this az/el aspect and frequency
    // Returns FALSE if no appropriate data exists.
    // Not required if CalcRFReflectedPower is to be called, but useful if one is to pass this info to 3rd party codes.
    // "el" [deg] measured from FR plane toward D, 
    // "az" [deg] measured on FR plane counter-clockwise about D from F
    // "freq" [Hz]
    SIGSIM49_API jrmbool ReturnRCSAspect(OBJECT *object, double az, double el, double freq, RCS_ASPECT *ra);

    /*
    // CalcObjectRCS() performs coherent ray-sums over all scatter centers to calculate rcs and stores in object->rcs.
    // Internal function.
    SIGSIM49_API int CalcObjectRCS(OBJECT *object); 
    */
   SIGSIM49_API jrmComplex getSigSimTargetRCS(double az_deg, double el_deg, double freq_Hz, RCS_TABLE *rcs_table, enum Polarization pol);
   SIGSIM49_API void getSigSimTargetRCSAllPol (double az_deg, double el_deg, double freq_Hz, RCS_TABLE *rcs_table, jrmComplex *HH, jrmComplex *HV, jrmComplex *VH, jrmComplex *VV);


    // GetProjectedRCS inputs an object, along with the hitpoint at that object, and desired frequency in [Hz],
    // and calculates (based on the object->mp_table) the effective single-value projected RCS [dBm2] and STDDEV [dBm2] at the hitpoint
    SIGSIM49_API double GetProjectedRCS(OBJECT *object, double freq_Hz, LOS_DB_INTERSECT *intersect);

    // GetProjectedRCS_Terrain inputs a terrain object, along with the hitpoint at that object, and desired frequency in [Hz],
    // and calculates (based on the object->mp_table) the effective single-value projected Sigma0Mean [dBm2] and Sigma0StDev [dBm2] at the hitpoint
    SIGSIM49_API int GetProjectedRCS_Terrain(OBJECT *terrain, double freq_Hz, LOS_DB_INTERSECT intersect, double *Sigma0Mean, double *Sigma0StDev);

    // Get2DProjectedRCS_Terrain inputs a terrain object, along with the desired spectral domain [um] and hitpoint information, 
    // and calculates (based on the object->mp_table) the effective single-value projected RCS [dBm2] and STDDEV [dBm2] at each hitpoint in the FOV.
    // INPUTS: E defines the eath ellipsoid.
    //         fov gives the resolution and angular extents of the FOV
    //         spectrum gives the desired spectral domain and resolution
    //         terrain = pointer to the terrain object (can be NULL)
    //         object_id_of_interest : If >=0, only those pixels which fall on this object_id will be calculated (all the rest will return -1E-28 dBsm for Sigma0Mean and Sigma0StDev). If object_id_of_interest<0, all pixels will be calculated.
    //         object_id_map = an FOV array of object IDs for the corresponding view, indexed as object_id_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE : object_id_map = -1 for no intersect.
    //         ms_index_map = an FOV array of indices into the mp_table array for the corresponding terrain or object, indexed as ms_index_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE : ms_index = -1 for no intersect.
    //         range_map = an FOV array of ranges to the corresponding hitpoint, indexed as range_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE: range for no-intersect can be taken to be any large number, or use IntersectEllipsoid(sens.geoc_loc, NED2XYZ(metin.fm.E,sens.fov.ned_view,sens.fov.geoc_loc), metin.fm.E, &hitpoint_geoC, &range); to find range to TOA in that direction.
    //         normal_map = an FOV array of surface normals (local NED) at the corresponding hitpoint, indexed as normal_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE: Take advantage of XYZ2NED or FRD2NED functions in ellipsoid.h to translate to NED.
    // OUTPUTS: Sigma0Mean is a pointer to a spectral array of terrain RCS values [dBm2] of size fov.hsamples*fov.vsamples*spectrum.nlambda.
    //         Sigma0StDev is a pointer to a spectral array of standard deviations [dBm2] in the terrain RCS, of size fov.hsamples*fov.vsamples*spectrum.nlambda.
    SIGSIM49_API int Get2DProjectedRCS_Terrain(ellipsoid E, FOV fov, SPECTRAL_DOMAIN spectrum, OBJECT *terrain, int object_id_of_interest, int *object_id_map, int *ms_index_map, double *range_map, VECTOR *normal_map, double **Sigma0Mean, double **Sigma0StDev);


    // ----------- Signature Prediction ------------------------
    // GetAtSurfaceRadiance3D() calculates the 2D spectral at-surface radiance field corresponding 
    //  to the sensor's FOV using a filled in los_map that defines the intersection at each pixel.
    // INPUTS : sens = the transmitter/receiver
    //         los_map is a pointer to a 2D LOS_DB_INTERSECT array containing the hitpoint info (object_id, material, range, location, etc).
    //         terrain = pointer to the terrain object (can be NULL)
    //         voiobject = an array of entities/non-entities (can be NULL)
    //         num_voiobjects = number of entities/non-entities in the voiobject array
    //         metin = meteorological & atmospheric conditions to be passed to the LOS atmospherics routine for each pixel LOS.
    //         eimap = the environmental influence map to be used.
    //         brdf_model = the brdf model to use.
    //         light_enable = the brdf model to use.
    // OUTPUTS: radiance3D is a pointer to a 2D spectral radiance array [W/cm2/sr/um] at-surface, indexed as radiance3D[horiz_index*sens.fov.vsamples+vert_index].
    //         HDR_map is a pointer to an FOV reflectivity array at-surface, indexed as HDR_map[horiz_index*sens.fov.vsamples+vert_index].
    SIGSIM49_API int GetAtSurfaceRadiance3D(SENSOR sens, double **radiance3D, double **HDR_map, 
        LOS_2D_MAP *los_map, METIN metin, OBJECT *terrain, int num_voiobjects, 
        OBJECT *voiobject, ENVIRONMENTAL_INFLUENCE_MAP eimap, BRDF_MODEL brdf_model, jrmbool emission_enable, jrmbool light_enable);


    // GetAtSurfaceRadiance3D_GPU() calculates the 2D spectral at-surface radiance field corresponding to the sensor's FOV.  
    // INPUTS : sens = the transmitter/receiver
    //         terrain = pointer to the terrain object (can be NULL)
    //         voi_object = an array of entities/non-entities (can be NULL)
    //         num_voiobjects = number of entities/non-entities in the voiobject array
    //         object_index_map = an FOV array of indices into the voiobject array, indexed as object_index_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE: object_index = -1 for terrain, = -2 for no intersect.
    //         ms_index_map = an FOV array of indices into the mp_table array for the corresponding terrain or object, indexed as ms_index_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE : ms_index = -1 for no intersect.
    //         range_map = an FOV array of ranges to the corresponding hitpoint, indexed as range_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE: range for no-intersect can be taken to be any large number, or use IntersectEllipsoid(sens.geoc_loc, NED2XYZ(metin.fm.E,sens.fov.ned_view,sens.fov.geoc_loc), metin.fm.E, &hitpoint_geoC, &range); to find range to TOA in that direction.
    //         normal_map = an FOV array of surface normals (local NED) at the corresponding hitpoint, indexed as normal_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE: Take advantage of XYZ2NED or FRD2NED functions in ellipsoid.h to translate to NED.
    //         metin = meteorological & atmospheric conditions to be passed to the LOS atmospherics routine for each pixel LOS.
    // OUTPUTS: radiance3D is a pointer to a 2D spectral radiance array [W/cm2/sr/um] at-surface, indexed as radiance3D[horiz_index*sens.fov.vsamples+vert_index].
    //         HDR_map is a pointer to an FOV reflectivity array at-surface, indexed as HDR_map[horiz_index*sens.fov.vsamples+vert_index].
    //         rdot_map is a pointer to an FOV range rate map, indexed as rdot_map[horiz_index*sens.fov.vsamples+vert_index].
    SIGSIM49_API int GetAtSurfaceRadiance3D_GPU(SENSOR sens, double **radiance3D, double **HDR_map, double **rdot_map, int *object_index_map, int *ms_index_map, double *range_map, VECTOR *normal_map, METIN metin, OBJECT *terrain, int num_voiobjects, OBJECT *voiobject, ENVIRONMENTAL_INFLUENCE_MAP eimap, BRDF_MODEL brdf_model);

    // GetAtSurfaceRadiance3D_CPU() inputs sensor FOV and desired spectral domain, the terrain and objects within the sensor's VOI, and an ENVIRONMENTAL_INFLUENCES_MAP,
    // and calculates the 2D spectral at-surface radiance field corresponding to the sensor's FOV. 
    // OUTPUTS: radiance3D is a pointer to a 2D spectral radiance map [W/cm2/sr/um] at-surface.
    //         HDR_map is a pointer to a 2D HDR (Hemispherical-Directional Reflectivity) map [unitless] at-surface.
    //         los_map is a pointer to a 2D LOS_DB_INTERSECT array so that hitpoint info (object_id, etc) can be returned.
    SIGSIM49_API int GetAtSurfaceRadiance3D_CPU(FOV fov, SPECTRAL_DOMAIN spectrum, double **radiance3D, double **HDR_map, LOS_2D_MAP *los_map, METIN metin, OBJECT *terrain, int num_voiobjects, OBJECT *voiobject, ENVIRONMENTAL_INFLUENCE_MAP eimap, BRDF_MODEL brdf_model);

    // CalcDirectionalRadiance_rademit() inputs a hitpoint location and an ENVIRONMENTAL_INFLUENCE_MAP at that location, 
    // and outputs a spectral at-surface radiance and HDR in the direction hitpoint.to_eye, at desired resolution given by sens.spectrum.
    SIGSIM49_API int CalcDirectionalRadiance_rademit(METIN *metin, ENVIRONMENTAL_INFLUENCE_MAP eimap, LOS_DB_INTERSECT hitpoint, 
        long nmatls, MATL_PROP_TABLE *mp_table, BRDF_MODEL brdf_model, 
        SENSOR sens, jrmbool emission_enable, jrmbool light_enable, double *atsurface, double *HDR);

    // CalcDirectionalRadiance() inputs a hitpoint location and an ENVIRONMENTAL_INFLUENCE_MAP at that location, 
    // and outputs a spectral at-surface radiance and HDR in the direction hitpoint.to_eye, at desired resolution given by spectrum.
    SIGSIM49_API int CalcDirectionalRadiance(METIN *metin, ENVIRONMENTAL_INFLUENCE_MAP eimap, LOS_DB_INTERSECT hitpoint, long nmatls, MATL_PROP_TABLE *mp_table, BRDF_MODEL brdf_model, SPECTRAL_DOMAIN spectrum, double *atsurface, double *HDR);


    // ---------------------------- RF SIGNATURES ----------------------------------------------------

    // AllocateRFPowerDensity() allocates memory for RF_POWER_DENSITY spectral arrays, each of nlambda elements.
    SIGSIM49_API int AllocateRFPowerDensity(RF_POWER_DENSITY *rf, long nlambda);

    // AllocateRFPower() allocates memory for RF_POWER spectral arrays, each of nlambda elements.
    SIGSIM49_API int AllocateRFPower(RF_POWER *rf, long nlambda);

    // CalcRFReflectedPower_Object inputs an object and sensor, along with the hitpoint at that object, orientation of the ifov, and 1-way RF transmittance and noise,
    // and calculates (based on the object->rcs table and sensor power density distribution) the reflected (spectral) RF_POWER and RCS [dBm2] returned.
    SIGSIM49_API int CalcRFReflectedPower_Object(SPECTRAL_DOMAIN spectrum, OBJECT object, LOS_DB_INTERSECT intersect, double **RCS, double *rftrans1way, double *rfnoise1way, RF_POWER *rfpower);

    // CalcRFReflectedPower_Terrain inputs a terrain object, along with the hitpoint, orientation of the ifov, and with the 1-way RF transmittance and noise,
    // and calculates (based on the object->mp_table[ms_index] Ulaby-Dobson RCS parameters and sensor power density distribution) the reflected (spectral) RF_POWER and RCS [dBm2] returned.
    SIGSIM49_API int CalcRFReflectedPower_Terrain(SPECTRAL_DOMAIN spectrum, OBJECT terrain, LOS_DB_INTERSECT intersect, double **RCS, double *rftrans1way, double *rfnoise1way, RF_POWER *rfpower);

    // CalcRFReflectedPower inputs the sensor, orientation of the ifov, meteorological conditions, and geometry, 
    // and calculates the post-reflection (spectral) RF_POWER, along with the 1-way transmittance and RF noise [W/cm2/um], RCS [dBm2], and hitpoint information.
    // To be used when the endpoint intersection is unknown.
    SIGSIM49_API int CalcRFReflectedPower(SENSOR sens, EULERzyx ifov_orient_NED, METIN metin, OBJECT *terrain, int num_voiobjects, OBJECT *voiobject, LOS_DB_INTERSECT *hitpoint, double **RCS, double **rftrans1way, double **rfnoise1way, RF_POWER *rfpower);

    // CalcRFReflectedPowerKE inputs the sensor fov and spectrum, orientation of the ifov, meteorological conditions, and geometry, 
    // and calculates the post-reflection (spectral) RF_POWER, along with the 1-way transmittance and RF noise [W/cm2/um], RCS [dBm2], and hitpoint information.
    // To be used when the endpoint intersection is known.
    SIGSIM49_API int CalcRFReflectedPowerKE(FOV sensfov, SPECTRAL_DOMAIN spectrum, EULERzyx *ifov_orient_NED, METIN metin, OBJECT *terrain, int num_voiobjects, OBJECT *voiobject, LOS_DB_INTERSECT *hitpoint, double **RCS, double **rftrans1way, double **rfnoise1way, RF_POWER *rfpower);

    // RFPowerCoherentSum performs coherent sum of RF_POWER at relative range_m.  
    SIGSIM49_API int RFPowerCoherentSum(RF_POWER A, RF_POWER B, RF_POWER *sum, double range_m, SPECTRAL_DOMAIN spectrum);

    // GetRFReflectedPower2DHV_GPU() calculates the 2D at-surface RF power field corresponding to the sensor's FOV. 
    // INPUTS : sens = the transmitter/receiver
    //         terrain = pointer to the terrain object (can be NULL)
    //         voi_object = an array of entities/non-entities (can be NULL)
    //         num_voiobjects = number of entities/non-entities in the voiobject array
    //         object_index_map = an FOV array of indices into the voiobject array, indexed as object_index_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE: object_index = -1 for terrain, = -2 for no intersect.
    //         ms_index_map = an FOV array of indices into the mp_table array for the corresponding terrain or object, indexed as ms_index_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE : ms_index = -1 for no intersect.
    //         range_map = an FOV array of ranges to the corresponding hitpoint, indexed as range_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE: range for no-intersect can be taken to be any large number, or use IntersectEllipsoid(sens.geoc_loc, NED2XYZ(metin.fm.E,sens.fov.ned_view,sens.fov.geoc_loc), metin.fm.E, &hitpoint_geoC, &range); to find range to TOA in that direction.
    //         normal_map = an FOV array of surface normals (local NED) at the corresponding hitpoint, indexed as normal_map[horiz_index*sens.fov.vsamples+vert_index]. NOTE: Take advantage of XYZ2NED or FRD2NED functions in ellipsoid.h to translate to NED.
    //         metin = meteorological & atmospheric conditions to be passed to the LOS atmospherics routine for each pixel LOS.
    // OUTPUTS: power2DHV is a pointer to an FOV spectral RF power array at-surface, indexed as power2DHV[horiz_index*sens.fov.vsamples+vert_index].
    //         RCS_map is a pointer to an FOV RCS array at-surface [dBm2], indexed as RCS_map[horiz_index*sens.fov.vsamples+vert_index].
    //         rdot_map is a pointer to an FOV range rate map [m/s], indexed as rdot_map[horiz_index*sens.fov.vsamples+vert_index].
    //         rftrans1way_map is a pointer to an FOV transmission map, indexed as rftrans1way_map[horiz_index*sens.fov.vsamples*sens.spectrum.nlambda+vert_index*sens.spectrum.nlambda].
    //         rfnoise1way_map is a pointer to an FOV rf noise map [W/cm2/um], indexed as rfnoise1way_map[horiz_index*sens.fov.vsamples*sens.spectrum.nlambda+vert_index*sens.spectrum.nlambda].
    SIGSIM49_API int GetRFReflectedPower2DHV_GPU(SENSOR sens, RF_POWER **power2DHV, double **RCS_map, double **rdot_map, double **rftrans1way_map, double **rfnoise1way_map, int *object_index_map, int *ms_index_map, double *range_map, VECTOR *normal_map, METIN metin, OBJECT *terrain, int num_voiobjects, OBJECT *voiobject);

    // GetRFReflectedPower2DHV_CPU() inputs a sensor, the terrain and objects within the sensor's VOI, and the meterolorogical conditions,
    // and calculates the 2D at-surface RF power field corresponding to the sensor's FOV. 
    // OUTPUTS: power2DHV is a pointer to a 2D spectral RF power array at-surface.
    //         los_map is a pointer to a 2D LOS_DB_INTERSECT array so that hitpoint info (object_id, etc) can be returned.
    SIGSIM49_API int GetRFReflectedPower2DHV_CPU(SENSOR sens, RF_POWER **power2DHV, LOS_2D_MAP *los_map, METIN metin, OBJECT *terrain, int num_voiobjects, OBJECT *voiobject);

    // GetTotalRFPower2D() calculates the band-integrated, polarization-summed 2D power ,
    // given a fully polarized, spectral description in a 2D array of RF_POWERs.
    SIGSIM49_API int GetTotalRFPower2D(SENSOR sens, double **power2D, RF_POWER *power2DHV);

    // FreePowerHVArrays() frees the memory associated with an RF_POWER's spectral arrays.
    SIGSIM49_API int FreePowerHVArrays(RF_POWER *powerHV);

    // FreePower2DHVMap() frees the memory associated with a 2D RF_POWER map.
    SIGSIM49_API int FreePower2DHVMap(RF_POWER *power2DHV, int hsamples, int vsamples);

    // FreePowerMap() frees the memory associated with a power map.
    SIGSIM49_API int FreePowerMap(double *power);



    // ---- The following routines should really all be in At-Aperture.c/h ------------------------

    //   WeddingCakeRectangular returns Wedding Cake distribution (rectangular format, no phase) defined by 
    //   WeddingCake (theta [rad]) :  
    //                        Param    Meaning
    //                           0     [deg] angular half-width of main lobe
    //                           1     [dB] ratio of 1st side lobe max power relative to main lobe ( = 10 log10(1st_side_lobe_max/main_max) )
    //                           2     [deg] angular half-width of 1st side lobe
    //                           3     [dB] ratio of 2nd side lobe max power relative to main lobe ( = 10 log10(2nd_side_lobe_max/main_max) )
    //                           4     [deg] angular half-width of 2nd side lobe
    //                           5     [dB] ratio of 3rd side lobe max power relative to main lobe ( = 10 log10(3rd_side_lobe_max/main_max) )
    //                           6     [deg] angular half-width of 3rd side lobe
    //                           7     [UNUSED]
    SIGSIM49_API double WeddingCakeRectangular(double *coef, double theta);


    //   WeddingCakeRadial returns Wedding Cake distribution (radial axis, no phase) defined by 
    //   WeddingCake (theta [rad]) :  
    //                        Param    Meaning
    //                           0     [deg] angular half-width of main lobe
    //                           1     [dB] ratio of 1st side lobe max power relative to main lobe ( = 10 log10(1st_side_lobe_max/main_max) )
    //                           2     [deg] angular half-width of 1st side lobe
    //                           3     [dB] ratio of 2nd side lobe max power relative to main lobe ( = 10 log10(2nd_side_lobe_max/main_max) )
    //                           4     [deg] angular half-width of 2nd side lobe
    //                           5     [dB] ratio of 3rd side lobe max power relative to main lobe ( = 10 log10(3rd_side_lobe_max/main_max) )
    //                           6     [deg] angular half-width of 3rd side lobe
    //                           7     [UNUSED]
    SIGSIM49_API double WeddingCakeRadial(double *coef, double theta);

    // GaussianRadial() returns radial Gaussian distribution of -3dB point beamwidth/2 [rad] sampled at angle theta [rad] from centerline.
    SIGSIM49_API double GaussianRadial(double beamwidth, double theta);


    // GetRFPowerEmitted() returns an RF_POWER (which contains spectral arrays) for a given spectral array of TRANSMITTER_RECEIVER DISTRIBUTIONs defined by spectrum and transmitter, at the transmitter antenna.
    // INPUTS : pixel_angle is a 2D vector of angles [rad] measured from FRONT, which define the desired FOV sample direction.
    //         spectrum defines the spectral array.
    //         transmitter is a pre-allocated and filled array of TRANSMITTER_RECEIVERs of number spectrum.nlambda, each of which contains the DISTRIBUTION information of the RF transmitter source, at-antenna.
    // OUTPUTS: rfpower is a pointer to an RF_POWER whose spectral arrays will be allocated and filled by this routine.
    SIGSIM49_API int GetRFPowerEmitted(dVEC_HV pixel_angle, SPECTRAL_DOMAIN spectrum, TRANSMITTER_RECEIVER *transmitter, RF_POWER *rfpower);

    // GetRFPowerDensityAccepted() returns an RF_POWER_DENSITY (which contains spectral arrays) for a given spectral array of TRANSMITTER_RECEIVER DISTRIBUTIONs defined by spectrum and receiver, at the receiver antenna.
    // INPUTS : pixel_angle is a 2D vector of angles [rad] measured from FRONT, which define the desired FOV sample direction.
    //         spectrum defines the spectral array.
    //         receiver is a pre-allocated and filled array of TRANSMITTER_RECEIVERs of number spectrum.nlambda, each of which contains the DISTRIBUTION information of the RF receiver acceptance.
    //         rfpowerdensity_ataperture describes the RF_POWER_DENSITY at the receiver aperture, but not all of this power is necessarily accepted due to efficiency and polarization losses. 
    // OUTPUTS: rfpowerdensity_accepted is a pointer to an RF_POWER_DENSITY whose spectral arrays will be allocated and filled by this routine.
    SIGSIM49_API int GetRFPowerDensityAccepted(dVEC_HV pixel_angle, SPECTRAL_DOMAIN spectrum, TRANSMITTER_RECEIVER *receiver, RF_POWER_DENSITY rfpowerdensity_ataperture, RF_POWER_DENSITY *rfpowerdensity_accepted);

    // GetRFPowerDensityAccepted_2DHV merely loops over GetRFPowerDensityAccepted to provide a 2D map of accepted powerdensities, one for each pixel.
    // INPUTS : fov defines an array of 2D vectors of angles [rad] measured from FRONT, which define the desired FOV sample direction.
    //         spectrum defines the spectral array.
    //         receiver is a pre-allocated and filled array of TRANSMITTER_RECEIVERs of number spectrum.nlambda, each of which contains the DISTRIBUTION information of the RF receiver acceptance.
    //         rfpowerdensity_ataperture describes the RF_POWER_DENSITY at the receiver aperture, for each pixel, but not all of this power is necessarily accepted due to efficiency and polarization losses. 
    // OUTPUTS: rfpowerdensity_accepted is a pointer to an unallocated RF_POWER_DENSITY array, each of whose spectral arrays will be allocated and filled by this routine.
    SIGSIM49_API int GetRFPowerDensityAccepted_2DHV(FOV fov, SPECTRAL_DOMAIN spectrum, TRANSMITTER_RECEIVER *receiver, RF_POWER_DENSITY *rfpowerdensity_ataperture, RF_POWER_DENSITY **rfpowerdensity_accepted);

    // FreePowerDensityHVArrays() frees the memory associated with an RF_POWER_DENSITY's spectral arrays.
    SIGSIM49_API int FreePowerDensityHVArrays(RF_POWER_DENSITY *powerdensityHV);

    // FreePowerDensity2DHVMap() frees the memory associated with a 2D RF_POWER_DENSITY map.
    SIGSIM49_API int FreePowerDensity2DHVMap(RF_POWER_DENSITY *powerdensity2DHV, int hsamples, int vsamples);

    // FreeRadianceMap() frees the memory associated with a power density map.
    SIGSIM49_API int FreePowerDensityMap(double *powerdensity);


#ifdef __cplusplus
}
#endif // __cplusplus


#endif // _At_Surface_