sim_flux_lens.h

Go to the documentation of this file.

 
#ifndef OAKFIELD_SIM_FLUX_LENS_H
#define OAKFIELD_SIM_FLUX_LENS_H
 
#include <complex.h>
#include <stdbool.h>
#include <stddef.h>
 
#include "field.h"
#include "operators/common/fft_plan.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct SimContext;
struct SimField;
 
typedef struct FluxMarks {
    bool valid;            
    double kc;             
    double k50;            
    double k90;            
    double pi_at_kc;       
    double total_abs_work; 
    double pi_min;         
    double pi_max;         
    double kmax;           
} FluxMarks;
 
typedef struct FluxLensState {
    bool enabled;              
    bool locked;               
    bool force_update;         
    bool band_ready;           
    size_t field_index;        
    double smoothing;          
    double min_bandwidth;      
    size_t update_period;      
    size_t last_update_step;   
    double band_lo;            
    double band_hi;            
    double target_band_lo;     
    double target_band_hi;     
    double band_max_component; 
    double band_max_magnitude; 
    double max_k;              
    double complex *band_spec; 
    double complex *band_phys; 
    size_t band_capacity;      
    double *S;                 
    double *Pi;                
    double *bucket_k;          
    double *bucket_pi;         
    double *bucket_S;          
    double *bucket_absS;       
    size_t bucket_capacity;    
    size_t bucket_count;       
    double pi_min;             
    double pi_max;             
    double absS_total;         
    FluxMarks marks;           
    size_t scratch_bytes;      
} FluxLensState;
 
typedef struct FluxLensWorkspace {
    double complex *tmp_spec1; 
    double complex *tmp_phys1; 
    double *tmp_real1;         
    bool use_dealias;          
    FFTPlan plan;              
    size_t capacity;           
    bool plan_ready;           
    size_t scratch_bytes;      
} FluxLensWorkspace;
 
void flux_lens_init(FluxLensState *lens);
void flux_lens_workspace_init(FluxLensWorkspace *workspace);
void flux_lens_force_refresh(FluxLensState *lens);
void flux_lens_set_field_index(FluxLensState *lens, size_t field_index);
void flux_lens_scale_width(FluxLensState *lens, double scale);
void flux_lens_shift_center(FluxLensState *lens, double shift);
void flux_lens_set_band(FluxLensState *lens, double band_lo, double band_hi);
SimResult flux_lens_ensure_capacity(FluxLensState *lens, FluxLensWorkspace *workspace,
                                    struct SimContext *context, size_t length);
void flux_lens_release(FluxLensState *lens, FluxLensWorkspace *workspace,
                       struct SimContext *context);
 
bool flux_compute(const struct SimField *field, FluxLensState *lens, FluxLensWorkspace *workspace,
                  struct SimContext *context);
 
void flux_lens_after_flux(FluxLensState *lens);
void flux_lens_update_targets_from_marks(FluxLensState *lens);
void flux_lens_relax_band(FluxLensState *lens);
bool flux_lens_reconstruct(const struct SimField *field, FluxLensState *lens,
                           FluxLensWorkspace *workspace);
 
void flux_lens_update(struct SimContext *context);
 
double flux_total_work(const double *S, size_t length);
double flux_total_energy(const double complex *u_hat, size_t length);
 
void flux_release_scratch(FluxLensWorkspace *workspace, struct SimContext *context);
 
#ifdef __cplusplus
}
#endif
 
#endif /* OAKFIELD_SIM_FLUX_LENS_H */