particles.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 _PARTICLES_H_
#define _PARTICLES_H_

#include "JRMlibrary.h"
#include "atm_common.h"
#include "SigSimDefines.h"
#include "SourceData.h"
#include "sigsim.h"
#include "sigsimDLLstub.h"


#ifdef __cplusplus
extern "C"
{
#endif

    typedef struct 
    {
        double fuel_type;           // The ratio of H (hydrogen mols) to C (Carbon mols) in the fuel molecules.  
                              // If this is not available, then pass a negative number to use C8H18 as a default.
        double fuel_rate;           // [kg/s] Rate of fuel consumption for the engine.
        double air_inlet_radius;    // [m]     Radius of the effective air intake.
        double air_speed;           // [m/s]  Velocity of plane relative to the surrounding atmosphere (not the ground). Overridden by current state when applicable.
        double air_pressure;        // [mb]   Pressure of the surrounding atmosphere. Overridden by current state.
        double air_temperature;        // [degK] Temperature of the surrounding atmosphere. Overridden by current state.
      double airexhaustmixratio;    // [unitless 0-1] Ratio of air to exhaust
        double exhaust_nozzle_radius;  // [m]    Radius of the exhaust nozzle
        double exhaust_temperature;    // [degK] Temperature of the exhaust at the nozzle exit.
      VECTOR exhaust_offset_vector; // [m]     Offset of exhaust nozzle from platform center.
      VECTOR effect_symmetry_axis;  // [unitless] Symmetry axis of effect (generally points away from body)
    } ENGINE_TYPE;               // Particle System Engine Type Input Data

   typedef struct
   {
        double fuel_type;           // The ratio of H (hydrogen mols) to C (Carbon mols) in the fuel molecules.  
                              // If this is not available, then pass a negative number to use C8H18 as a default.
      double heat_of_combustion;    // [J/g] Heat of combustion of bulk fuel type
      double fuel_density;       // [g/m3] Density of fuel in the pellets
      double flare_volume;       // [m3] Flare cartridge or fuel source initial volume
      double ground_burnrate;       // [m3/s] Static volumetric burn rate at standard ground-level atmospheric pressure P0
      double burnrate_exponent;     // [unitless] Exponent of ratio (P/P0) where P is current ambient pressure.
      double color_temperature;     // [degK] Effective color temperature of flare combustion
      double air_speed;          // [m/s] Current velocity of the flare (assumed initialized to aircraft velocity)
      double drop_rate;          // [Hz] Rate at which flares are dropped (meaningless for flames).
   }  FLARE_FLAME;               // Particle System Flare/Flame Input Data    

   typedef struct
   {
      HEAVY_OBSCURANT_TYPE type;    // [enum]      Type of obscurant
      double emission_rate;         // [m3/s]      Volumetric rate of obscurant emission into atmosphere
      double initial_concentration; // [kg/m3]     Mass concentration of initial obscurant emission in atmosphere (not specific gravity of particles)
      double total_volume;       // [m3]        Total volume of obscurant releasable.
        double initial_temperature;    // [degK]      Temperature of the obscurant at the nozzle exit.
      VECTOR offset_vector;         // [m]         Offset of exhaust nozzle from platform center.
      VECTOR effect_symmetry_axis;  // [unitless]  Symmetry axis of effect (generally points away from body)
   }  HEAVY_OBSCURANT;           // Particle System Heavy Obscurant Input Data

   typedef enum
   {
      smoke_trail=0,
      smoke_plume,
      explosion,
      rain,
      snow,
      dust,
      flare,
      chaff,
      fire,
      muzzle_flash,
      exhaust_plume
   }  PARTICLESYSTEM_TYPE;

#define NUM_OBSC_TYPES 21
#define NUM_FLOW_TYPES 11


typedef struct
{
   PARTICLESYSTEM_TYPE flow_type;   // [enum] Type of particle system flow
   HEAVY_OBSCURANT_TYPE obsc_type;  // [enum] Type of obscurant present in particle cloud or fuel combustion product
   double fuelO2toX;          // [unitless] Ratio of O2 to fuel molecules in combustion reaction equation 
   double fuelHtoC;           // [unitless] Ratio of Hydrogen to Carbon in fuel molecule
   double burn_rate;          // [m3/s] Ground volumetric fuel burn rate
   double density;               // [kg/m3] For fuels, mass density of fuel in unburned state. Otherwise mass density of particle cloud as dispersed in air.
   double xsec_exposed;       // [m2] Total area exposed to emitted radiance release, e.g. flare cylinder cross-sectional area.
   double tot_volume;            // [m3] For fuels, total volume of fuel available. Otherwise total volume of particle cloud boundary.
   double heat_of_combustion;    // [J/kg] Heat of combustion of fuel. Not applicable for non-fuel psystem types.
   double temperature;           // [degK] Effective color temperature of Planckian spectral shape envelope for hot unburned particle cloud.
   double air_speed;          // [m/s] Speed of particle disperser platform through static air, if applicable.
   double maxburnefficiency;     // [unitless0-1] Max burn efficiency even in the presence of an infinite supply of oxygen.
   VECTOR effect_offset_vector;  // [m] Offset of effect from platform body center.
   VECTOR effect_symmetry_axis;  // [unitless] Symmetry axis of effect (generally points away from platform body)
   int   processpath;            // 0=model_absolute, 1=vis_relative calculation path. Does not affect units of resultant prediction. 
   double rendered_radius;       // [m] Assigned nonphysical "depth" of rendered particles, used to translate (e.g.) extinction per unit pathlength into extinction per particle.
   char external_spectrum_file[SIGSIM_STRING_SIZE];   // If present, specifies a 2-column file {[um], [1/um]} giving the normalized non-Planckian part of the combustion spectrum.
}  PARTICLEINPUT;

/*
   typedef struct
   {
      PARTICLESYSTEM_TYPE flow_type;
      ENGINE_TYPE       engine_type;
      FLARE_FLAME       flare_flame;
      HEAVY_OBSCURANT      heavy_obscurant;
   }  PARTICLEINPUT;    // Particle System Input Parameters Wrapper
*/

   typedef struct
   {
      double theta[2];           // [rad] low & high range of angle between particle trajectory vector and Z-axis
      double phi[2];             // [rad] low & high range of angle between particle trajectory vector X-Y-plane projection and X-axis.
      double linspeed[2];           // [m/s] low & high range of particle trajectory speed
      double rate[2];               // [Hz]     low & high range of particle creation frequency
      double accelZ;             // [m/s2]   acceleration along Z-axis  (Gravity = -9.98)
      double vert1[3];           // [m]      1st vertex of line defining trajectory XYZ system, expressed in global system
      double vert2[3];           // [m]      2nd vertex of line defining trajectory XYZ system, expressed in global system
   }  PARTICLERADIALSHOOTER;        // Particle Radial Shooter Parameters

   typedef struct
   {
      double density;               // [kg/m3] density of fluid   : air=1.2929, water=1.0
      double viscosity;          // [Pa s] = [kg/m/s] dynamic viscosity of fluid : air=1.8E-5, water=1.002E-3
   }  PARTICLECARRIERFLUID;         // Particle Carrier Fluid Parameters

   typedef struct
   {
      char sensorName[SIGSIM_STRING_SIZE]; // Sensor (unique) name
      double alphaRange[2];         // [0-1] Transparency range (alpha=0=transparent and alpha=1=opaque)
      double colorRange[2];         // [0-1] Color range
      double reflectRange[2];       // [0-1] Reflectivity range
   }  PARTICLEBANDSIGNATURE;        // Particle signature for given waveband

   typedef struct
   {
      double lifeTime;           // [s] Lifetime
      double sizeRange[2];       // [m] Size range
      double mass;               // [kg] Mass
      double radius;             // [m] Radius
      //PARTICLEBANDSIGNATURE *sig;    // Array of particle signatures for different wavebands.
      //int nsigs;                  // Number of signatures stored in the sig array.
      double *emission;          // [W/cm2/sr/um] Emission spectral array (over metin.inf.spectrum)
      double *reflectivity;         // [unitless] Reflectivity spectral array (over metin.inf.spectrum)
      double *alpha;             // [unitless] Alpha spectral array (over metin.inf.spectrum)
   }  PARTICLE;                  // Particle for rendering smoke clouds, plumes, etc.

   typedef struct
   {
      PARTICLESYSTEM_TYPE flow_type;   // [enum] particle system type
      PARTICLE particle;            // Characteristics of each particle
      PARTICLERADIALSHOOTER shooter;   // Characteristics of the particle radial shooter (if any)
      PARTICLECARRIERFLUID fluid;      // Characteristics of the particle carrier medium
   }  PARTICLESYSTEM;               // Particle system for rendering smoke clouds, plumes, etc.

   SIGSIM_API int LoadPARTICLEINPUTData(char *filename, PARTICLEINPUT **pinput);
   SIGSIM_API int AllocateSingleParticleSystem(PARTICLESYSTEM **psystem);
   SIGSIM_API void FreeParticleSystemArray(PARTICLESYSTEM **psystem);
   SIGSIM_API void FreeParticleSystemSignatures(PARTICLESYSTEM *psystem);
   SIGSIM_API int AllocateParticleSystemSignatures(PARTICLESYSTEM *psystem, long nlambda);
   SIGSIM_API int CreateAndProcessParticleSystem(char *sigsim_atm_dir, METIN *metin, PARTICLEINPUT *pinput, PARTICLESYSTEM *psystem, double alt_km, PARTICLESYSTEM_TYPE type);
   int ProcessATMVolume(char *sigsim_atm_dir, METIN *metin, PARTICLEINPUT *pinput, double alt_km, double *plumelength, double timestep_s, ATM_VOL_PROPS *atm);
   int CalcATMVolumeProperties(PARTICLEINPUT *pinput, METIN *metin, double alt_km, double mass_burn_rate, ATM_VOL_PROPS *atm, double *plumelength, double *burn_fraction, double *densityinair);


   //int Fill_ENGINE_TYPE_ATMVolume(char *sigsim_atm_dir, METIN *metin, ENGINE_TYPE *engine, double altitude_km, ATM_VOL_PROPS *atm, double *plumelength);
   //int Fill_FLARE_FLAME_ATMVolume(char *sigsim_atm_dir, METIN *metin, FLARE_FLAME *ff, double altitude_km, double timestep_s, ATM_VOL_PROPS *atm, double *refdist, PARTICLESYSTEM_TYPE type);

   SIGSIM_API void UpdateParticleBandSignature(PARTICLE *particle, SPECTRAL_DOMAIN *spectrum, SENSOR *sens, PARTICLEBANDSIGNATURE *psig);

   double CalcFlareVolumeProperties(ATM_VOL_PROPS *atm, double surfarea, double mass_burn_rate, double air_speed, double maxburnefficiency, double *burn_fraction, double *densityinair);
   double CalcFlameVolumeProperties(ATM_VOL_PROPS *atm, double surfarea, double fuelO2toX, double fuelHtoC, double mass_burn_rate, double air_speed, double maxburnefficiency, double *burn_fraction, double *densityinair);
   int GetMgPTFESpectralShape(SPECTRAL_DOMAIN spectrum, double *shape);
   int GetPropaneSpectralShape(SPECTRAL_DOMAIN spectrum, double *shape);
   int GetObscurantRefractiveIndex(double RHratio, HEAVY_OBSCURANT_TYPE type, SPECTRAL_DOMAIN spectrum, jrmComplex *refract);
   SIGSIM_API int CalculateObscurantMassAtmosphericCoefficients(HEAVY_OBSCURANT_TYPE type, double RHratio, SPECTRAL_DOMAIN spectrum, double *massabsorb, double *massscatter);

   //int Fill_Obscurant_ATMVolume(METIN *metin, HEAVY_OBSCURANT *obscurant, double altitude_km, double timestep_s, ATM_VOL_PROPS *atm);
   // CreateAndProcessParticleObscurant fills a PARTICLE solid structure with physical data, given an input environment, obscurant type, and altitude.
   // It calls Fill_Obscurant_ATMVolume, then fills the PARTICLE structure accordingly.
   //SIGSIM_API int CreateAndProcessParticleObscurant(char *sigsim_atm_dir, METIN *metin, HEAVY_OBSCURANT *obscurant, PARTICLESYSTEM *psystem, double altitude_km, PARTICLESYSTEM_TYPE type);

   // CreateAndProcessParticlePlume fills a PARTICLE solid structure with physical data, given an input environment, engine type, altitude, and airexhaustmixratio.
   // It calls Fill_ENGINE_TYPE_ATMVolume, then fills the PARTICLE structure accordingly.
   //SIGSIM_API int CreateAndProcessParticlePlume(char *sigsim_atm_dir, METIN *metin, ENGINE_TYPE *engine, PARTICLESYSTEM *psystem, double altitude_km, PARTICLESYSTEM_TYPE type);

   // CreateAndProcessParticleFlareFlame fills a PARTICLE solid structure with physical data, given an input environment, flare/flame type, and altitude.
   // It calls Fill_FLARE_FLAME_ATMVolume, then fills the PARTICLE structure accordingly.
   //SIGSIM_API int CreateAndProcessParticleFlareFlame(char *sigsim_atm_dir, METIN *metin, FLARE_FLAME *ff, PARTICLESYSTEM *psystem, double altitude_km, PARTICLESYSTEM_TYPE type);


#ifdef __cplusplus
}
#endif

#endif // _PARTICLES_H_