##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » CHUST » LFR_basic-parameters
RSS

Fork of HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/LFR_basic-parameters

version 1.7 qui prend en compte les modifs de Paul (entêtes) + correction erreurs...
chust -
r15:d896e2303340 TCH
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,20
1 TEMPLATE = app
2 CONFIG += console
3 CONFIG -= app_bundle
4 CONFIG -= qt
5
6 DEFINES += DEBUG_TCH
7 DEFINES += LSB_FIRST_TCH # PC convention
8 #DEFINES += MSB_FIRST_TCH # SPARC convention
9
10 SOURCES += main.c \
11 basic_parameters.c \
12 file_utilities.c
13
14 HEADERS += \
15 basic_parameters.h \
16 basic_parameters_params.h \
17 basic_parameters_utilities.h \
18 file_utilities.h
19
20
Show file before | Show file after | Hide comments
@@ -1,57 +1,53
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
2 // version 1.0: 31/07/2013
2 // version 1.0: 31/07/2013
3 // version 1.1: 02/04/2014
3 // version 1.1: 02/04/2014
4 // version 1.2: 30/04/2014
4 // version 1.2: 30/04/2014
5 // version 1.3: 02/05/2014
5 // version 1.3: 02/05/2014
6 // version 1.4: 16/05/2014
6 // version 1.4: 16/05/2014
7 // version 1.5: 20/05/2014
7 // version 1.5: 20/05/2014
8 // version 1.6: 19/12/2014
8 // version 1.6: 19/12/2014
9 // version 1.7: 15/01/2015 (modifs de Paul + correction erreurs qui se compensaient (LSB <=> MSB + indices [0,2] <=> [1,3])
10
9
11
10 #include <stdint.h>
12 #include <stdint.h>
11
12 #include "basic_parameters_params.h"
13 #include "basic_parameters_params.h"
13
14
14 void init_k_coefficients( float *k_coefficients_f0, \
15 void init_k_coefficients(float *k_coefficients,
15 float *k_coefficients_f1, \
16 unsigned char nb_binscompressed_matrix )
16 float *k_coefficients_f2 )
17 {
17 {
18 uint16_t i; // 16 bits unsigned
18 uint16_t i; // 16 bits unsigned
19
19 for(i=0; i<nb_binscompressed_matrix; i++){
20 for(i=0; i<NB_BINS_COMPRESSED_MATRIX_f0; i++){
20 k_coefficients[i*NB_K_COEFF_PER_BIN+K44_PE] = 1;
21 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K44_PE] = 1;
21 k_coefficients[i*NB_K_COEFF_PER_BIN+K55_PE] = 1;
22 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K55_PE] = 1;
22 k_coefficients[i*NB_K_COEFF_PER_BIN+K45_PE_RE] = 1;
23 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K45_PE_RE] = 1;
23 k_coefficients[i*NB_K_COEFF_PER_BIN+K45_PE_IM] = 1;
24 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K45_PE_IM] = 1;
24 k_coefficients[i*NB_K_COEFF_PER_BIN+K14_SX_RE] = 1;
25
25 k_coefficients[i*NB_K_COEFF_PER_BIN+K14_SX_IM] = 1;
26 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K14_SX_RE] = 1;
26 k_coefficients[i*NB_K_COEFF_PER_BIN+K15_SX_RE] = 1;
27 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K14_SX_IM] = 1;
27 k_coefficients[i*NB_K_COEFF_PER_BIN+K15_SX_IM] = 1;
28 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K15_SX_RE] = 1;
28 k_coefficients[i*NB_K_COEFF_PER_BIN+K24_SX_RE] = 1;
29 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K15_SX_IM] = 1;
29 k_coefficients[i*NB_K_COEFF_PER_BIN+K24_SX_IM] = 1;
30 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K24_SX_RE] = 1;
30 k_coefficients[i*NB_K_COEFF_PER_BIN+K25_SX_RE] = 1;
31 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K24_SX_IM] = 1;
31 k_coefficients[i*NB_K_COEFF_PER_BIN+K25_SX_IM] = 1;
32 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K25_SX_RE] = 1;
32 k_coefficients[i*NB_K_COEFF_PER_BIN+K34_SX_RE] = 1;
33 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K25_SX_IM] = 1;
33 k_coefficients[i*NB_K_COEFF_PER_BIN+K34_SX_IM] = 1;
34 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K34_SX_RE] = 1;
34 k_coefficients[i*NB_K_COEFF_PER_BIN+K35_SX_RE] = 1;
35 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K34_SX_IM] = 1;
35 k_coefficients[i*NB_K_COEFF_PER_BIN+K35_SX_IM] = 1;
36 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K35_SX_RE] = 1;
36 k_coefficients[i*NB_K_COEFF_PER_BIN+K24_NY_RE] = 1;
37 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K35_SX_IM] = 1;
37 k_coefficients[i*NB_K_COEFF_PER_BIN+K24_NY_IM] = 1;
38
38 k_coefficients[i*NB_K_COEFF_PER_BIN+K25_NY_RE] = 1;
39 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K24_NY_RE] = 1;
39 k_coefficients[i*NB_K_COEFF_PER_BIN+K25_NY_IM] = 1;
40 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K24_NY_IM] = 1;
40 k_coefficients[i*NB_K_COEFF_PER_BIN+K34_NY_RE] = 1;
41 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K25_NY_RE] = 1;
41 k_coefficients[i*NB_K_COEFF_PER_BIN+K34_NY_IM] = 1;
42 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K25_NY_IM] = 1;
42 k_coefficients[i*NB_K_COEFF_PER_BIN+K35_NY_RE] = 1;
43 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K34_NY_RE] = 1;
43 k_coefficients[i*NB_K_COEFF_PER_BIN+K35_NY_IM] = 1;
44 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K34_NY_IM] = 1;
44 k_coefficients[i*NB_K_COEFF_PER_BIN+K24_NZ_RE] = 1;
45 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K35_NY_RE] = 1;
45 k_coefficients[i*NB_K_COEFF_PER_BIN+K24_NZ_IM] = 1;
46 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K35_NY_IM] = 1;
46 k_coefficients[i*NB_K_COEFF_PER_BIN+K25_NZ_RE] = 1;
47
47 k_coefficients[i*NB_K_COEFF_PER_BIN+K25_NZ_IM] = 1;
48 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K24_NZ_RE] = 1;
48 k_coefficients[i*NB_K_COEFF_PER_BIN+K34_NZ_RE] = 1;
49 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K24_NZ_IM] = 1;
49 k_coefficients[i*NB_K_COEFF_PER_BIN+K34_NZ_IM] = 1;
50 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K25_NZ_RE] = 1;
50 k_coefficients[i*NB_K_COEFF_PER_BIN+K35_NZ_RE] = 1;
51 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K25_NZ_IM] = 1;
51 k_coefficients[i*NB_K_COEFF_PER_BIN+K35_NZ_IM] = 1;
52 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K34_NZ_RE] = 1;
53 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K34_NZ_IM] = 1;
54 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K35_NZ_RE] = 1;
55 k_coefficients_f0[i*NB_K_COEFF_PER_BIN+K35_NZ_IM] = 1;
56 }
52 }
57 }
53 }
Show file before | Show file after | Hide comments
@@ -1,867 +1,870
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
2 // version 1.0: 31/07/2013
2 // version 1.0: 31/07/2013
3 // version 1.1: 02/04/2014
3 // version 1.1: 02/04/2014
4 // version 1.2: 30/04/2014
4 // version 1.2: 30/04/2014
5 // version 1.3: 02/05/2014
5 // version 1.3: 02/05/2014
6 // version 1.4: 16/05/2014
6 // version 1.4: 16/05/2014
7 // version 1.5: 20/05/2014
7 // version 1.5: 20/05/2014
8 // version 1.6: 19/12/2014
8 // version 1.6: 19/12/2014
9 // version 1.7: 15/01/2015 (modifs de Paul + correction erreurs qui se compensaient (LSB <=> MSB + indices [0,2] <=> [1,3])
9
10
10 #ifndef BASIC_PARAMETERS_H_INCLUDED
11 #ifndef BASIC_PARAMETERS_H_INCLUDED
11 #define BASIC_PARAMETERS_H_INCLUDED
12 #define BASIC_PARAMETERS_H_INCLUDED
12
13
13 #include <math.h>
14 #include <math.h>
14 #include <stdio.h>
15 #include <stdio.h>
15 #include <stdint.h>
16 #include <stdint.h>
16
17
17 #include "basic_parameters_params.h"
18 #include "basic_parameters_params.h"
18
19
19 static inline void BP1_set(float * compressed_spec_mat, float * k_coeff_intercalib, unsigned char nb_bins_compressed_spec_mat, unsigned char * lfr_bp1);
20 static inline void BP1_set(float * compressed_spec_mat, float * k_coeff_intercalib, unsigned char nb_bins_compressed_spec_mat, unsigned char * lfr_bp1);
20 static inline void BP2_set(float * compressed_spec_mat, unsigned char nb_bins_compressed_spec_mat, unsigned char * lfr_bp2);
21 static inline void BP2_set(float * compressed_spec_mat, unsigned char nb_bins_compressed_spec_mat, unsigned char * lfr_bp2);
21
22
22 void init_k_coefficients( float *k_coefficients_f0, float *k_coefficients_f1, float *k_coefficients_f2 );
23 void init_k_coefficients( float *k_coefficients_f0, unsigned char nb_binscompressed_matrix );
23
24
24 //***********************************
25 //***********************************
25 // STATIC INLINE FUNCTION DEFINITIONS
26 // STATIC INLINE FUNCTION DEFINITIONS
26
27
27 void BP1_set( float * compressed_spec_mat, float * k_coeff_intercalib, uint8_t nb_bins_compressed_spec_mat, uint8_t * lfr_bp1 ){
28 void BP1_set( float * compressed_spec_mat, float * k_coeff_intercalib, uint8_t nb_bins_compressed_spec_mat, uint8_t * lfr_bp1 ){
28 float PSDB; // 32-bit floating point
29 float PSDB; // 32-bit floating point
29 float PSDE;
30 float PSDE;
30 float tmp;
31 float tmp;
31 float NVEC_V0;
32 float NVEC_V0;
32 float NVEC_V1;
33 float NVEC_V1;
33 float NVEC_V2;
34 float NVEC_V2;
34 float aux;
35 float aux;
35 float tr_SB_SB;
36 float tr_SB_SB;
36 float e_cross_b_re;
37 float e_cross_b_re;
37 float e_cross_b_im;
38 float e_cross_b_im;
38 float n_cross_e_scal_b_re;
39 float n_cross_e_scal_b_re;
39 float n_cross_e_scal_b_im;
40 float n_cross_e_scal_b_im;
40 float ny;
41 float ny;
41 float nz;
42 float nz;
42 float bx_bx_star;
43 float bx_bx_star;
43 float vphi;
44 float vphi;
44 float significand;
45 float significand;
45 int exponent; // 32-bit signed integer
46 int exponent; // 32-bit signed integer
46 float alpha_M;
47 float alpha_M;
47
48
48 uint8_t nbitexp; // 8-bit unsigned integer
49 uint8_t nbitexp; // 8-bit unsigned integer
49 uint8_t nbitsig;
50 uint8_t nbitsig;
50 uint8_t tmp_uint8;
51 uint8_t tmp_uint8;
51 uint8_t *pt_uint8; // pointer on unsigned 8-bit integer
52 uint8_t *pt_uint8; // pointer on unsigned 8-bit integer
52 int8_t expmin; // 8-bit signed integer
53 int8_t expmin; // 8-bit signed integer
53 int8_t expmax;
54 int8_t expmax;
54 uint16_t rangesig; // 16-bit unsigned integer
55 uint16_t rangesig; // 16-bit unsigned integer
55 uint16_t psd;
56 uint16_t psd;
56 uint16_t exp;
57 uint16_t exp;
57 uint16_t tmp_uint16;
58 uint16_t tmp_uint16;
58 uint16_t i;
59 uint16_t i;
59
60
60 alpha_M = 45 * (3.1415927/180);
61 alpha_M = 45 * (3.1415927/180);
61
62
62 #ifdef DEBUG_TCH
63 #ifdef DEBUG_TCH
63 printf("BP1 : \n");
64 printf("BP1 : \n");
64 printf("Number of bins: %d\n", nb_bins_compressed_spec_mat);
65 printf("Number of bins: %d\n", nb_bins_compressed_spec_mat);
65 #endif
66 #endif
66
67
67 // initialization for managing the exponents of the floating point data:
68 // initialization for managing the exponents of the floating point data:
68 nbitexp = 5; // number of bits for the exponent
69 nbitexp = 5; // number of bits for the exponent
69 expmax = 30; // maximum value of the exponent
70 expmax = 30; // maximum value of the exponent
70 expmin = expmax - (1 << nbitexp) + 1; // accordingly the minimum exponent value
71 expmin = expmax - (1 << nbitexp) + 1; // accordingly the minimum exponent value
71 // for floating point data to be recorded on 12-bit words:
72 // for floating point data to be recorded on 12-bit words:
72 nbitsig = 12 - nbitexp; // number of bits for the significand
73 nbitsig = 12 - nbitexp; // number of bits for the significand
73 rangesig = (1 << nbitsig)-1; // == 2^nbitsig - 1
74 rangesig = (1 << nbitsig)-1; // == 2^nbitsig - 1
74
75
75 #ifdef DEBUG_TCH
76 #ifdef DEBUG_TCH
76 printf("nbitexp : %d, expmax : %d, expmin : %d\n", nbitexp, expmax, expmin);
77 printf("nbitexp : %d, expmax : %d, expmin : %d\n", nbitexp, expmax, expmin);
77 printf("nbitsig : %d, rangesig : %d\n", nbitsig, rangesig);
78 printf("nbitsig : %d, rangesig : %d\n", nbitsig, rangesig);
78 #endif
79 #endif
79
80
80 for(i=0; i<nb_bins_compressed_spec_mat; i++){
81 for(i=0; i<nb_bins_compressed_spec_mat; i++){
81 //==============================================
82 //==============================================
82 // BP1 PSDB == PA_LFR_SC_BP1_PB_F0 == 12 bits = 5 bits (exponent) + 7 bits (significand)
83 // BP1 PSDB == PA_LFR_SC_BP1_PB_F0 == 12 bits = 5 bits (exponent) + 7 bits (significand)
83 PSDB = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX] // S11
84 PSDB = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX] // S11
84 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9] // S22
85 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9] // S22
85 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]; // S33
86 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]; // S33
86
87
87 significand = frexpf(PSDB/3, &exponent); // 0.5 <= significand < 1
88 significand = frexpf(PSDB/3, &exponent); // 0.5 <= significand < 1
88 // PSDB/3 = significand * 2^exponent
89 // PSDB/3 = significand * 2^exponent
89 // the division by 3 is to ensure that max value <= 2^30
90 // the division by 3 is to ensure that max value <= 2^30
90
91
91 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
92 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
92 exponent = expmin;
93 exponent = expmin;
93 significand = 0.5; // min value that can be recorded
94 significand = 0.5; // min value that can be recorded
94 }
95 }
95 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
96 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
96 exponent = expmax;
97 exponent = expmax;
97 significand = 1.0; // max value that can be recorded
98 significand = 1.0; // max value that can be recorded
98 }
99 }
99 if (significand == 0) { // in that case exponent == 0 too
100 if (significand == 0) { // in that case exponent == 0 too
100 exponent = expmin;
101 exponent = expmin;
101 significand = 0.5; // min value that can be recorded
102 significand = 0.5; // min value that can be recorded
102 }
103 }
103
104
104 psd = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
105 psd = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
105 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
106 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
106 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
107 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
107 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
108 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
108 tmp_uint16 = psd | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
109 tmp_uint16 = psd | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
109 // left place of the significand bits (nbitsig),
110 // left place of the significand bits (nbitsig),
110 // making the 16-bit word to be recorded
111 // making the 16-bit word to be recorded
111 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
112 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
112 #ifdef LSB_FIRST_TCH
113 #ifdef MSB_FIRST_TCH
113 lfr_bp1[i*NB_BYTES_BP1+2] = pt_uint8[0]; // Record LSB of tmp_uint16
114 lfr_bp1[i*NB_BYTES_BP1+2] = pt_uint8[0]; // Record MSB of tmp_uint16
114 lfr_bp1[i*NB_BYTES_BP1+3] = pt_uint8[1]; // Record MSB of tmp_uint16
115 lfr_bp1[i*NB_BYTES_BP1+3] = pt_uint8[1]; // Record LSB of tmp_uint16
115 #endif
116 #endif
116 #ifdef MSB_FIRST_TCH
117 #ifdef LSB_FIRST_TCH
117 lfr_bp1[i*NB_BYTES_BP1+2] = pt_uint8[1]; // Record LSB of tmp_uint16
118 lfr_bp1[i*NB_BYTES_BP1+2] = pt_uint8[1]; // Record MSB of tmp_uint16
118 lfr_bp1[i*NB_BYTES_BP1+3] = pt_uint8[0]; // Record MSB of tmp_uint16
119 lfr_bp1[i*NB_BYTES_BP1+3] = pt_uint8[0]; // Record LSB of tmp_uint16
119 #endif
120 #endif
120 #ifdef DEBUG_TCH
121 #ifdef DEBUG_TCH
121 printf("\nBin number: %d\n", i);
122 printf("\nBin number: %d\n", i);
122 printf("PSDB / 3 : %16.8e\n",PSDB/3);
123 printf("PSDB / 3 : %16.8e\n",PSDB/3);
123 printf("significand : %16.8e\n",significand);
124 printf("significand : %16.8e\n",significand);
124 printf("exponent : %d\n" ,exponent);
125 printf("exponent : %d\n" ,exponent);
125 printf("psd for PSDB significand : %d\n",psd);
126 printf("psd for PSDB significand : %d\n",psd);
126 printf("exp for PSDB exponent : %d\n",exp);
127 printf("exp for PSDB exponent : %d\n",exp);
127 printf("pt_uint8[1] for PSDB exponent + significand: %.3d or %.2x\n",pt_uint8[1], pt_uint8[1]);
128 printf("pt_uint8[1] for PSDB exponent + significand: %.3d or %.2x\n",pt_uint8[1], pt_uint8[1]);
128 printf("pt_uint8[0] for PSDB exponent + significand: %.3d or %.2x\n",pt_uint8[0], pt_uint8[0]);
129 printf("pt_uint8[0] for PSDB exponent + significand: %.3d or %.2x\n",pt_uint8[0], pt_uint8[0]);
129 printf("lfr_bp1[i*NB_BYTES_BP1+3] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+3], lfr_bp1[i*NB_BYTES_BP1+3]);
130 printf("lfr_bp1[i*NB_BYTES_BP1+3] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+3], lfr_bp1[i*NB_BYTES_BP1+3]);
130 printf("lfr_bp1[i*NB_BYTES_BP1+2] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+2], lfr_bp1[i*NB_BYTES_BP1+2]);
131 printf("lfr_bp1[i*NB_BYTES_BP1+2] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+2], lfr_bp1[i*NB_BYTES_BP1+2]);
131 #endif
132 #endif
132 //==============================================
133 //==============================================
133 // BP1 PSDE == PA_LFR_SC_BP1_PE_F0 == 12 bits = 5 bits (exponent) + 7 bits (significand)
134 // BP1 PSDE == PA_LFR_SC_BP1_PE_F0 == 12 bits = 5 bits (exponent) + 7 bits (significand)
134 PSDE = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21] * k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K44_PE] // S44
135 PSDE = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21] * k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K44_PE] // S44
135 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24] * k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K55_PE] // S55
136 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24] * k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K55_PE] // S55
136 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+22] * k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K45_PE_RE] // S45 Re
137 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+22] * k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K45_PE_RE] // S45 Re
137 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+23] * k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K45_PE_IM]; // S45 Im
138 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+23] * k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K45_PE_IM]; // S45 Im
138
139
139 significand = frexpf(PSDE/2, &exponent); // 0.5 <= significand < 1
140 significand = frexpf(PSDE/2, &exponent); // 0.5 <= significand < 1
140 // PSDE/2 = significand * 2^exponent
141 // PSDE/2 = significand * 2^exponent
141 // the division by 2 is to ensure that max value <= 2^30
142 // the division by 2 is to ensure that max value <= 2^30
142 // should be reconsidered by taking into account the k-coefficients ...
143 // should be reconsidered by taking into account the k-coefficients ...
143
144
144 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
145 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
145 exponent = expmin;
146 exponent = expmin;
146 significand = 0.5; // min value that can be recorded
147 significand = 0.5; // min value that can be recorded
147 }
148 }
148 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
149 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
149 exponent = expmax;
150 exponent = expmax;
150 significand = 1.0; // max value that can be recorded
151 significand = 1.0; // max value that can be recorded
151 }
152 }
152 if (significand == 0) {// in that case exponent == 0 too
153 if (significand == 0) {// in that case exponent == 0 too
153 exponent = expmin;
154 exponent = expmin;
154 significand = 0.5; // min value that can be recorded
155 significand = 0.5; // min value that can be recorded
155 }
156 }
156
157
157 psd = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
158 psd = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
158 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
159 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
159 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
160 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
160 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
161 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
161 tmp_uint16 = psd | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
162 tmp_uint16 = psd | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
162 // left place of the significand bits (nbitsig),
163 // left place of the significand bits (nbitsig),
163 // making the 16-bit word to be recorded
164 // making the 16-bit word to be recorded
164 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
165 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
165 #ifdef LSB_FIRST_TCH
166 #ifdef MSB_FIRST_TCH
166 lfr_bp1[i*NB_BYTES_BP1+0] = pt_uint8[0]; // Record LSB of tmp_uint16
167 lfr_bp1[i*NB_BYTES_BP1+0] = pt_uint8[0]; // Record MSB of tmp_uint16
167 lfr_bp1[i*NB_BYTES_BP1+1] = pt_uint8[1]; // Record MSB of tmp_uint16
168 lfr_bp1[i*NB_BYTES_BP1+1] = pt_uint8[1]; // Record LSB of tmp_uint16
168 #endif
169 #endif
169 #ifdef MSB_FIRST_TCH
170 #ifdef LSB_FIRST_TCH
170 lfr_bp1[i*NB_BYTES_BP1+0] = pt_uint8[1]; // Record LSB of tmp_uint16
171 lfr_bp1[i*NB_BYTES_BP1+0] = pt_uint8[1]; // Record MSB of tmp_uint16
171 lfr_bp1[i*NB_BYTES_BP1+1] = pt_uint8[0]; // Record MSB of tmp_uint16
172 lfr_bp1[i*NB_BYTES_BP1+1] = pt_uint8[0]; // Record LSB of tmp_uint16
172 #endif
173 #endif
173 #ifdef DEBUG_TCH
174 #ifdef DEBUG_TCH
174 printf("Bin number: %d\n", i);
175 printf("Bin number: %d\n", i);
175 printf("PSDE/2 : %16.8e\n",PSDE/2);
176 printf("PSDE/2 : %16.8e\n",PSDE/2);
176 printf("significand : %16.8e\n",significand);
177 printf("significand : %16.8e\n",significand);
177 printf("exponent : %d\n" ,exponent);
178 printf("exponent : %d\n" ,exponent);
178 printf("psd for PSDE significand : %d\n",psd);
179 printf("psd for PSDE significand : %d\n",psd);
179 printf("exp for PSDE exponent : %d\n",exp);
180 printf("exp for PSDE exponent : %d\n",exp);
180 printf("pt_uint8[1] for PSDE exponent + significand: %.3d or %.2x\n",pt_uint8[1], pt_uint8[1]);
181 printf("pt_uint8[1] for PSDE exponent + significand: %.3d or %.2x\n",pt_uint8[1], pt_uint8[1]);
181 printf("pt_uint8[0] for PSDE exponent + significand: %.3d or %.2x\n",pt_uint8[0], pt_uint8[0]);
182 printf("pt_uint8[0] for PSDE exponent + significand: %.3d or %.2x\n",pt_uint8[0], pt_uint8[0]);
182 printf("lfr_bp1[i*NB_BYTES_BP1+1] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+1], lfr_bp1[i*NB_BYTES_BP1+1]);
183 printf("lfr_bp1[i*NB_BYTES_BP1+1] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+1], lfr_bp1[i*NB_BYTES_BP1+1]);
183 printf("lfr_bp1[i*NB_BYTES_BP1+0] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+0], lfr_bp1[i*NB_BYTES_BP1+0]);
184 printf("lfr_bp1[i*NB_BYTES_BP1+0] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+0], lfr_bp1[i*NB_BYTES_BP1+0]);
184 #endif
185 #endif
185 //==============================================================================
186 //==============================================================================
186 // BP1 normal wave vector == PA_LFR_SC_BP1_NVEC_V0_F0 == 8 bits
187 // BP1 normal wave vector == PA_LFR_SC_BP1_NVEC_V0_F0 == 8 bits
187 // == PA_LFR_SC_BP1_NVEC_V1_F0 == 8 bits
188 // == PA_LFR_SC_BP1_NVEC_V1_F0 == 8 bits
188 // == PA_LFR_SC_BP1_NVEC_V2_F0 == 1 sign bit
189 // == PA_LFR_SC_BP1_NVEC_V2_F0 == 1 sign bit
189 tmp = sqrt( compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] //Im S12
190 tmp = sqrt( compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] //Im S12
190 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] //Im S13
191 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] //Im S13
191 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11] //Im S23
192 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11] //Im S23
192 );
193 );
193 NVEC_V0 = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11]/ tmp; // S23 Im => n1
194 NVEC_V0 = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11]/ tmp; // S23 Im => n1
194 NVEC_V1 = -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] / tmp; // S13 Im => n2
195 NVEC_V1 = -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] / tmp; // S13 Im => n2
195 NVEC_V2 = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] / tmp; // S12 Im => n3
196 NVEC_V2 = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] / tmp; // S12 Im => n3
196
197
197 lfr_bp1[i*NB_BYTES_BP1+4] = (uint8_t) (NVEC_V0*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
198 lfr_bp1[i*NB_BYTES_BP1+4] = (uint8_t) (NVEC_V0*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
198 lfr_bp1[i*NB_BYTES_BP1+5] = (uint8_t) (NVEC_V1*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
199 lfr_bp1[i*NB_BYTES_BP1+5] = (uint8_t) (NVEC_V1*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
199 pt_uint8 = (uint8_t*) &NVEC_V2; // Affect an uint8_t pointer with the adress of NVEC_V2
200 pt_uint8 = (uint8_t*) &NVEC_V2; // Affect an uint8_t pointer with the adress of NVEC_V2
200 #ifdef LSB_FIRST_TCH
201 #ifdef LSB_FIRST_TCH
201 lfr_bp1[i*NB_BYTES_BP1+6] = pt_uint8[3] & 0x80; // Extract the sign bit of NVEC_V2 (32-bit float, sign bit in the 4th octet:PC convention)
202 lfr_bp1[i*NB_BYTES_BP1+6] = pt_uint8[3] & 0x80; // Extract the sign bit of NVEC_V2 (32-bit float, sign bit in the 4th octet:PC convention)
202 // Record it at the 8th bit position (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
203 // Record it at the 8th bit position (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
203 #endif
204 #endif
204 #ifdef MSB_FIRST_TCH
205 #ifdef MSB_FIRST_TCH
205 lfr_bp1[i*NB_BYTES_BP1+6] = pt_uint8[0] & 0x80; // Extract the sign bit of NVEC_V2 (32-bit float, sign bit in the 0th octet:SPARC convention)
206 lfr_bp1[i*NB_BYTES_BP1+6] = pt_uint8[0] & 0x80; // Extract the sign bit of NVEC_V2 (32-bit float, sign bit in the 1th octet:SPARC convention)
206 // Record it at the 8th bit position (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
207 // Record it at the 8th bit position (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
207 #endif
208 #endif
208 #ifdef DEBUG_TCH
209 #ifdef DEBUG_TCH
209 printf("NVEC_V0 : %16.8e\n",NVEC_V0);
210 printf("NVEC_V0 : %16.8e\n",NVEC_V0);
210 printf("NVEC_V1 : %16.8e\n",NVEC_V1);
211 printf("NVEC_V1 : %16.8e\n",NVEC_V1);
211 printf("NVEC_V2 : %16.8e\n",NVEC_V2);
212 printf("NVEC_V2 : %16.8e\n",NVEC_V2);
212 printf("lfr_bp1[i*NB_BYTES_BP1+4] for NVEC_V0 : %u\n",lfr_bp1[i*NB_BYTES_BP1+4]);
213 printf("lfr_bp1[i*NB_BYTES_BP1+4] for NVEC_V0 : %u\n",lfr_bp1[i*NB_BYTES_BP1+4]);
213 printf("lfr_bp1[i*NB_BYTES_BP1+5] for NVEC_V1 : %u\n",lfr_bp1[i*NB_BYTES_BP1+5]);
214 printf("lfr_bp1[i*NB_BYTES_BP1+5] for NVEC_V1 : %u\n",lfr_bp1[i*NB_BYTES_BP1+5]);
214 printf("lfr_bp1[i*NB_BYTES_BP1+6] for NVEC_V2 : %u\n",lfr_bp1[i*NB_BYTES_BP1+6]);
215 printf("lfr_bp1[i*NB_BYTES_BP1+6] for NVEC_V2 : %u\n",lfr_bp1[i*NB_BYTES_BP1+6]);
215 #endif
216 #endif
216 //=======================================================
217 //=======================================================
217 // BP1 ellipticity == PA_LFR_SC_BP1_ELLIP_F0 == 4 bits
218 // BP1 ellipticity == PA_LFR_SC_BP1_ELLIP_F0 == 4 bits
218 aux = 2*tmp / PSDB; // Compute the ellipticity
219 aux = 2*tmp / PSDB; // Compute the ellipticity
219
220
220 tmp_uint8 = (uint8_t) (aux*15 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
221 tmp_uint8 = (uint8_t) (aux*15 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
221 // where just the first 4 bits are used (0, ..., 15)
222 // where just the first 4 bits are used (0, ..., 15)
222 lfr_bp1[i*NB_BYTES_BP1+6] = lfr_bp1[i*NB_BYTES_BP1+6] | (tmp_uint8 << 3); // Put these 4 bits next to the right place
223 lfr_bp1[i*NB_BYTES_BP1+6] = lfr_bp1[i*NB_BYTES_BP1+6] | (tmp_uint8 << 3); // Put these 4 bits next to the right place
223 // of the sign bit of NVEC_V2 (recorded
224 // of the sign bit of NVEC_V2 (recorded
224 // previously in lfr_bp1[i*NB_BYTES_BP1+6])
225 // previously in lfr_bp1[i*NB_BYTES_BP1+6])
225 #ifdef DEBUG_TCH
226 #ifdef DEBUG_TCH
226 printf("ellipticity : %16.8e\n",aux);
227 printf("ellipticity : %16.8e\n",aux);
227 printf("tmp_uint8 for ellipticity : %u\n",tmp_uint8);
228 printf("tmp_uint8 for ellipticity : %u\n",tmp_uint8);
228 printf("lfr_bp1[i*NB_BYTES_BP1+6] for NVEC_V2 + ellipticity : %u\n",lfr_bp1[i*NB_BYTES_BP1+6]);
229 printf("lfr_bp1[i*NB_BYTES_BP1+6] for NVEC_V2 + ellipticity : %u\n",lfr_bp1[i*NB_BYTES_BP1+6]);
229 #endif
230 #endif
230 //==============================================================
231 //==============================================================
231 // BP1 degree of polarization == PA_LFR_SC_BP1_DOP_F0 == 3 bits
232 // BP1 degree of polarization == PA_LFR_SC_BP1_DOP_F0 == 3 bits
232 tr_SB_SB = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]
233 tr_SB_SB = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]
233 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]
234 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]
234 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]
235 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]
235 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+1] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+1]
236 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+1] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+1]
236 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2]
237 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2]
237 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+3] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+3]
238 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+3] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+3]
238 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4]
239 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] *compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4]
239 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10]
240 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10]
240 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11];
241 + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11];
241 aux = PSDB*PSDB;
242 aux = PSDB*PSDB;
242 tmp = ( 3*tr_SB_SB - aux ) / ( 2 * aux ); // Compute the degree of polarisation
243 tmp = ( 3*tr_SB_SB - aux ) / ( 2 * aux ); // Compute the degree of polarisation
243
244
244 tmp_uint8 = (uint8_t) (tmp*7 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
245 tmp_uint8 = (uint8_t) (tmp*7 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
245 // where just the first 3 bits are used (0, ..., 7)
246 // where just the first 3 bits are used (0, ..., 7)
246 lfr_bp1[i*NB_BYTES_BP1+6] = lfr_bp1[i*NB_BYTES_BP1+6] | tmp_uint8; // Record these 3 bits at the 3 first bit positions
247 lfr_bp1[i*NB_BYTES_BP1+6] = lfr_bp1[i*NB_BYTES_BP1+6] | tmp_uint8; // Record these 3 bits at the 3 first bit positions
247 // (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
248 // (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
248 #ifdef DEBUG_TCH
249 #ifdef DEBUG_TCH
249 printf("DOP : %16.8e\n",tmp);
250 printf("DOP : %16.8e\n",tmp);
250 printf("tmp_uint8 for DOP : %u\n",tmp_uint8);
251 printf("tmp_uint8 for DOP : %u\n",tmp_uint8);
251 printf("lfr_bp1[i*NB_BYTES_BP1+6] for NVEC_V2 + ellipticity + DOP : %u\n",lfr_bp1[i*NB_BYTES_BP1+6]);
252 printf("lfr_bp1[i*NB_BYTES_BP1+6] for NVEC_V2 + ellipticity + DOP : %u\n",lfr_bp1[i*NB_BYTES_BP1+6]);
252 #endif
253 #endif
253 //=======================================================================================
254 //=======================================================================================
254 // BP1 X_SO-component of the Poynting flux == PA_LFR_SC_BP1_SX_F0 == 8 (+ 2) bits
255 // BP1 X_SO-component of the Poynting flux == PA_LFR_SC_BP1_SX_F0 == 8 (+ 2) bits
255 // = 5 bits (exponent) + 3 bits (significand)
256 // = 5 bits (exponent) + 3 bits (significand)
256 // + 1 sign bit + 1 argument bit (two sectors)
257 // + 1 sign bit + 1 argument bit (two sectors)
257 e_cross_b_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_SX_RE] //S34 Re
258 e_cross_b_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_SX_RE] //S34 Re
258 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_SX_RE] //S35 Re
259 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_SX_RE] //S35 Re
259 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+5] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K14_SX_RE] //S14 Re
260 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+5] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K14_SX_RE] //S14 Re
260 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+7] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K15_SX_RE] //S15 Re
261 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+7] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K15_SX_RE] //S15 Re
261 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_SX_RE] //S24 Re
262 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_SX_RE] //S24 Re
262 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_SX_RE] //S25 Re
263 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_SX_RE] //S25 Re
263 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_SX_IM] //S34 Im
264 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_SX_IM] //S34 Im
264 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_SX_IM] //S35 Im
265 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_SX_IM] //S35 Im
265 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+6] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K14_SX_IM] //S14 Im
266 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+6] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K14_SX_IM] //S14 Im
266 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+8] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K15_SX_IM] //S15 Im
267 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+8] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K15_SX_IM] //S15 Im
267 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_SX_IM] //S24 Im
268 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_SX_IM] //S24 Im
268 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_SX_IM]; //S25 Im
269 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_SX_IM]; //S25 Im
269 // Im(S_ji) = -Im(S_ij)
270 // Im(S_ji) = -Im(S_ij)
270 // k_ji = k_ij
271 // k_ji = k_ij
271 e_cross_b_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_SX_IM] //S34 Re
272 e_cross_b_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_SX_IM] //S34 Re
272 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_SX_IM] //S35 Re
273 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_SX_IM] //S35 Re
273 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+5] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K14_SX_IM] //S14 Re
274 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+5] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K14_SX_IM] //S14 Re
274 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+7] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K15_SX_IM] //S15 Re
275 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+7] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K15_SX_IM] //S15 Re
275 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_SX_IM] //S24 Re
276 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_SX_IM] //S24 Re
276 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_SX_IM] //S25 Re
277 + compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_SX_IM] //S25 Re
277 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_SX_RE] //S34 Im
278 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_SX_RE] //S34 Im
278 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_SX_RE] //S35 Im
279 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_SX_RE] //S35 Im
279 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+6] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K14_SX_RE] //S14 Im
280 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+6] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K14_SX_RE] //S14 Im
280 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+8] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K15_SX_RE] //S15 Im
281 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+8] *k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K15_SX_RE] //S15 Im
281 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_SX_RE] //S24 Im
282 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_SX_RE] //S24 Im
282 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_SX_RE]; //S25 Im
283 - compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_SX_RE]; //S25 Im
283 #ifdef DEBUG_TCH
284 #ifdef DEBUG_TCH
284 printf("ReaSX / 2 : %16.8e\n",e_cross_b_re/2);
285 printf("ReaSX / 2 : %16.8e\n",e_cross_b_re/2);
285 #endif
286 #endif
286 pt_uint8 = (uint8_t*) &e_cross_b_re; // Affect an uint8_t pointer with the adress of e_cross_b_re
287 pt_uint8 = (uint8_t*) &e_cross_b_re; // Affect an uint8_t pointer with the adress of e_cross_b_re
287 #ifdef LSB_FIRST_TCH
288 #ifdef LSB_FIRST_TCH
288 lfr_bp1[i*NB_BYTES_BP1+1] = lfr_bp1[i*NB_BYTES_BP1+1] | (pt_uint8[3] & 0x80); // Extract its sign bit (32-bit float, sign bit in the 4th octet:PC convention)
289 lfr_bp1[i*NB_BYTES_BP1+0] = lfr_bp1[i*NB_BYTES_BP1+0] | (pt_uint8[3] & 0x80); // Extract its sign bit (32-bit float, sign bit in the 4th octet:PC convention)
289 // Record it at the 8th bit position (from the right to the left)
290 // Record it at the 8th bit position (from the right to the left)
290 // of lfr_bp1[i*NB_BYTES_BP1+1]
291 // of lfr_bp1[i*NB_BYTES_BP1+0]
291 pt_uint8[3] = (pt_uint8[3] & 0x7f); // Make e_cross_b_re be positive in any case: |ReaSX|
292 pt_uint8[3] = (pt_uint8[3] & 0x7f); // Make e_cross_b_re be positive in any case: |ReaSX|
292 #endif
293 #endif
293 #ifdef MSB_FIRST_TCH
294 #ifdef MSB_FIRST_TCH
294 lfr_bp1[i*NB_BYTES_BP1+1] = lfr_bp1[i*NB_BYTES_BP1+1] | (pt_uint8[0] & 0x80); // Extract its sign bit (32-bit float, sign bit in the 0th octet:SPARC convention)
295 lfr_bp1[i*NB_BYTES_BP1+0] = lfr_bp1[i*NB_BYTES_BP1+0] | (pt_uint8[0] & 0x80); // Extract its sign bit (32-bit float, sign bit in the 1th octet:SPARC convention)
295 // Record it at the 8th bit position (from the right to the left)
296 // Record it at the 8th bit position (from the right to the left)
296 // of lfr_bp1[i*NB_BYTES_BP1+1]
297 // of lfr_bp1[i*NB_BYTES_BP1+0]
297 pt_uint8[0] = (pt_uint8[0] & 0x7f); // Make e_cross_b_re be positive in any case: |ReaSX|
298 pt_uint8[0] = (pt_uint8[0] & 0x7f); // Make e_cross_b_re be positive in any case: |ReaSX|
298 #endif
299 #endif
299 significand = frexpf(e_cross_b_re/2, &exponent); // 0.5 <= significand < 1
300 significand = frexpf(e_cross_b_re/2, &exponent); // 0.5 <= significand < 1
300 // ReaSX/2 = significand * 2^exponent
301 // ReaSX/2 = significand * 2^exponent
301 // The division by 2 is to ensure that max value <= 2^30 (rough estimate)
302 // The division by 2 is to ensure that max value <= 2^30 (rough estimate)
302 // Should be reconsidered by taking into account the k-coefficients ...
303 // Should be reconsidered by taking into account the k-coefficients ...
303
304
304 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
305 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
305 exponent = expmin;
306 exponent = expmin;
306 significand = 0.5; // min value that can be recorded
307 significand = 0.5; // min value that can be recorded
307 }
308 }
308 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
309 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
309 exponent = expmax;
310 exponent = expmax;
310 significand = 1.0; // max value that can be recorded
311 significand = 1.0; // max value that can be recorded
311 }
312 }
312 if (significand == 0) { // in that case exponent == 0 too
313 if (significand == 0) { // in that case exponent == 0 too
313 exponent = expmin;
314 exponent = expmin;
314 significand = 0.5; // min value that can be recorded
315 significand = 0.5; // min value that can be recorded
315 }
316 }
316
317
317 lfr_bp1[i*NB_BYTES_BP1+7] = (uint8_t) ((significand*2-1)*7 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
318 lfr_bp1[i*NB_BYTES_BP1+7] = (uint8_t) ((significand*2-1)*7 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
318 // where just the first 3 bits are used (0, ..., 7)
319 // where just the first 3 bits are used (0, ..., 7)
319 tmp_uint8 = (uint8_t) (exponent-expmin); // Shift and cast into a 8-bit uint8_t where
320 tmp_uint8 = (uint8_t) (exponent-expmin); // Shift and cast into a 8-bit uint8_t where
320 // just the first 5 bits are used (0, ..., 2^5-1)
321 // just the first 5 bits are used (0, ..., 2^5-1)
321 #ifdef DEBUG_TCH
322 #ifdef DEBUG_TCH
322 printf("|ReaSX| / 2 : %16.8e\n",e_cross_b_re/2);
323 printf("|ReaSX| / 2 : %16.8e\n",e_cross_b_re/2);
323 printf("significand : %16.8e\n",significand);
324 printf("significand : %16.8e\n",significand);
324 printf("exponent : %d\n" ,exponent);
325 printf("exponent : %d\n" ,exponent);
325 printf("lfr_bp1[i*NB_BYTES_BP1+7] for ReaSX significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+7]);
326 printf("lfr_bp1[i*NB_BYTES_BP1+7] for ReaSX significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+7]);
326 printf("tmp_uint8 for ReaSX exponent : %d\n",tmp_uint8);
327 printf("tmp_uint8 for ReaSX exponent : %d\n",tmp_uint8);
327 #endif
328 #endif
328 lfr_bp1[i*NB_BYTES_BP1+7] = lfr_bp1[i*NB_BYTES_BP1+7] | (tmp_uint8 << 3); // Shift these 5 bits to the left before logical addition
329 lfr_bp1[i*NB_BYTES_BP1+7] = lfr_bp1[i*NB_BYTES_BP1+7] | (tmp_uint8 << 3); // Shift these 5 bits to the left before logical addition
329 // with lfr_bp1[i*NB_BYTES_BP1+7]
330 // with lfr_bp1[i*NB_BYTES_BP1+7]
330 #ifdef DEBUG_TCH
331 #ifdef DEBUG_TCH
331 printf("lfr_bp1[i*NB_BYTES_BP1+7] for ReaSX exponent + significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+7]);
332 printf("lfr_bp1[i*NB_BYTES_BP1+7] for ReaSX exponent + significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+7]);
332 printf("lfr_bp1[i*NB_BYTES_BP1+1] for ReaSX sign + PSDE 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+1]);
333 printf("lfr_bp1[i*NB_BYTES_BP1+0] for ReaSX sign + PSDE 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+0]);
333 printf("ImaSX / 2 : %16.8e\n",e_cross_b_im/2);
334 printf("ImaSX / 2 : %16.8e\n",e_cross_b_im/2);
334 #endif
335 #endif
335 pt_uint8 = (uint8_t*) &e_cross_b_im; // Affect an uint8_t pointer with the adress of e_cross_b_im
336 pt_uint8 = (uint8_t*) &e_cross_b_im; // Affect an uint8_t pointer with the adress of e_cross_b_im
336 #ifdef LSB_FIRST_TCH
337 #ifdef LSB_FIRST_TCH
337 pt_uint8[3] = pt_uint8[3] & 0x7f; // Make e_cross_b_im be positive in any case: |ImaSX|
338 pt_uint8[3] = pt_uint8[3] & 0x7f; // Make e_cross_b_im be positive in any case: |ImaSX| (32-bit float, sign bit in the 4th octet:PC convention)
338 #endif
339 #endif
339 #ifdef MSB_FIRST_TCH
340 #ifdef MSB_FIRST_TCH
340 pt_uint8[0] = pt_uint8[0] & 0x7f; // Make e_cross_b_im be positive in any case: |ImaSX|
341 pt_uint8[0] = pt_uint8[0] & 0x7f; // Make e_cross_b_im be positive in any case: |ImaSX| (32-bit float, sign bit in the 1th octet:SPARC convention)
341 #endif
342 #endif
342 tmp_uint8 = (e_cross_b_im > e_cross_b_re) ? 0x40 : 0x00; // Determine the sector argument of SX. If |Im| > |Re| affect
343 tmp_uint8 = (e_cross_b_im > e_cross_b_re) ? 0x40 : 0x00; // Determine the sector argument of SX. If |Im| > |Re| affect
343 // an unsigned 8-bit char with 01000000; otherwise with null.
344 // an unsigned 8-bit char with 01000000; otherwise with null.
344 lfr_bp1[i*NB_BYTES_BP1+1] = lfr_bp1[i*NB_BYTES_BP1+1] | tmp_uint8; // Record it as a sign bit at the 7th bit position (from the right
345 lfr_bp1[i*NB_BYTES_BP1+0] = lfr_bp1[i*NB_BYTES_BP1+0] | tmp_uint8; // Record it as a sign bit at the 7th bit position (from the right
345 // to the left) of lfr_bp1[i*NB_BYTES_BP1+1], by simple logical addition.
346 // to the left) of lfr_bp1[i*NB_BYTES_BP1+0], by simple logical addition.
346 #ifdef DEBUG_TCH
347 #ifdef DEBUG_TCH
347 printf("|ImaSX| / 2 : %16.8e\n",e_cross_b_im/2);
348 printf("|ImaSX| / 2 : %16.8e\n",e_cross_b_im/2);
348 printf("ArgSX sign : %u\n",tmp_uint8);
349 printf("ArgSX sign : %u\n",tmp_uint8);
349 printf("lfr_bp1[i*NB_BYTES_BP1+1] for ReaSX & ArgSX signs + PSDE 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+1]);
350 printf("lfr_bp1[i*NB_BYTES_BP1+0] for ReaSX & ArgSX signs + PSDE 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+0]);
350 #endif
351 #endif
351 //======================================================================
352 //======================================================================
352 // BP1 phase velocity estimator == PA_LFR_SC_BP1_VPHI_F0 == 8 (+ 2) bits
353 // BP1 phase velocity estimator == PA_LFR_SC_BP1_VPHI_F0 == 8 (+ 2) bits
353 // = 5 bits (exponent) + 3 bits (significand)
354 // = 5 bits (exponent) + 3 bits (significand)
354 // + 1 sign bit + 1 argument bit (two sectors)
355 // + 1 sign bit + 1 argument bit (two sectors)
355 ny = sin(alpha_M)*NVEC_V1 + cos(alpha_M)*NVEC_V2;
356 ny = sin(alpha_M)*NVEC_V1 + cos(alpha_M)*NVEC_V2;
356 nz = NVEC_V0;
357 nz = NVEC_V0;
357 bx_bx_star = cos(alpha_M)*cos(alpha_M)*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9] // S22 Re
358 bx_bx_star = cos(alpha_M)*cos(alpha_M)*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9] // S22 Re
358 + sin(alpha_M)*sin(alpha_M)*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16] // S33 Re
359 + sin(alpha_M)*sin(alpha_M)*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16] // S33 Re
359 - 2*sin(alpha_M)*cos(alpha_M)*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10]; // S23 Re
360 - 2*sin(alpha_M)*cos(alpha_M)*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10]; // S23 Re
360
361
361 n_cross_e_scal_b_re = ny * (compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NY_RE] //S24 Re
362 n_cross_e_scal_b_re = ny * (compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NY_RE] //S24 Re
362 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NY_RE] //S25 Re
363 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NY_RE] //S25 Re
363 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NY_RE] //S34 Re
364 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NY_RE] //S34 Re
364 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NY_RE] //S35 Re
365 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NY_RE] //S35 Re
365 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NY_IM] //S24 Im
366 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NY_IM] //S24 Im
366 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NY_IM] //S25 Im
367 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NY_IM] //S25 Im
367 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NY_IM] //S34 Im
368 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NY_IM] //S34 Im
368 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NY_IM]) //S35 Im
369 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NY_IM]) //S35 Im
369 + nz * (compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NZ_RE] //S24 Re
370 + nz * (compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NZ_RE] //S24 Re
370 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NZ_RE] //S25 Re
371 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NZ_RE] //S25 Re
371 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NZ_RE] //S34 Re
372 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NZ_RE] //S34 Re
372 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NZ_RE] //S35 Re
373 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NZ_RE] //S35 Re
373 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NZ_IM] //S24 Im
374 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NZ_IM] //S24 Im
374 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NZ_IM] //S25 Im
375 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NZ_IM] //S25 Im
375 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NZ_IM] //S34 Im
376 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NZ_IM] //S34 Im
376 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NZ_IM]);//S35 Im
377 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NZ_IM]);//S35 Im
377 // Im(S_ji) = -Im(S_ij)
378 // Im(S_ji) = -Im(S_ij)
378 // k_ji = k_ij
379 // k_ji = k_ij
379 n_cross_e_scal_b_im = ny * (compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NY_IM] //S24 Re
380 n_cross_e_scal_b_im = ny * (compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NY_IM] //S24 Re
380 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NY_IM] //S25 Re
381 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NY_IM] //S25 Re
381 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NY_IM] //S34 Re
382 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NY_IM] //S34 Re
382 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NY_IM] //S35 Re
383 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NY_IM] //S35 Re
383 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NY_RE] //S24 Im
384 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NY_RE] //S24 Im
384 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NY_RE] //S25 Im
385 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NY_RE] //S25 Im
385 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NY_RE] //S34 Im
386 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NY_RE] //S34 Im
386 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NY_RE]) //S35 Im
387 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NY_RE]) //S35 Im
387 + nz * (compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NZ_IM] //S24 Re
388 + nz * (compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NZ_IM] //S24 Re
388 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NZ_IM] //S25 Re
389 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NZ_IM] //S25 Re
389 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NZ_IM] //S34 Re
390 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NZ_IM] //S34 Re
390 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NZ_IM] //S35 Re
391 +compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NZ_IM] //S35 Re
391 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NZ_RE] //S24 Im
392 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K24_NZ_RE] //S24 Im
392 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NZ_RE] //S25 Im
393 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K25_NZ_RE] //S25 Im
393 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NZ_RE] //S34 Im
394 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K34_NZ_RE] //S34 Im
394 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NZ_RE]);//S35 Im
395 -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]*k_coeff_intercalib[i*NB_K_COEFF_PER_BIN+K35_NZ_RE]);//S35 Im
395 #ifdef DEBUG_TCH
396 #ifdef DEBUG_TCH
396 printf("n_cross_e_scal_b_re : %16.8e\n",n_cross_e_scal_b_re);
397 printf("n_cross_e_scal_b_re : %16.8e\n",n_cross_e_scal_b_re);
397 printf("n_cross_e_scal_b_im : %16.8e\n",n_cross_e_scal_b_im);
398 printf("n_cross_e_scal_b_im : %16.8e\n",n_cross_e_scal_b_im);
398 #endif
399 #endif
399 // vphi = n_cross_e_scal_b_re / bx_bx_star => sign(VPHI) = sign(n_cross_e_scal_b_re)
400 // vphi = n_cross_e_scal_b_re / bx_bx_star => sign(VPHI) = sign(n_cross_e_scal_b_re)
400 pt_uint8 = (uint8_t*) &n_cross_e_scal_b_re; // Affect an uint8_t pointer with the adress of n_cross_e_scal_b_re
401 pt_uint8 = (uint8_t*) &n_cross_e_scal_b_re; // Affect an uint8_t pointer with the adress of n_cross_e_scal_b_re
401 #ifdef LSB_FIRST_TCH
402 #ifdef LSB_FIRST_TCH
402 lfr_bp1[i*NB_BYTES_BP1+3] = lfr_bp1[i*NB_BYTES_BP1+3] | (pt_uint8[3] & 0x80); // Extract its sign bit (32-bit float, sign bit in the 4th octet:PC convention)
403 lfr_bp1[i*NB_BYTES_BP1+2] = lfr_bp1[i*NB_BYTES_BP1+2] | (pt_uint8[3] & 0x80); // Extract its sign bit (32-bit float, sign bit in the 4th octet:PC convention)
403 // Record it at the 8th bit position (from the right to the left)
404 // Record it at the 8th bit position (from the right to the left)
404 // of lfr_bp1[i*NB_BYTES_BP1+3]
405 // of lfr_bp1[i*NB_BYTES_BP1+2]
405 pt_uint8[3] = (pt_uint8[3] & 0x7f); // Make n_cross_e_scal_b_re be positive in any case: |n_cross_e_scal_b_re|
406 pt_uint8[3] = (pt_uint8[3] & 0x7f); // Make n_cross_e_scal_b_re be positive in any case: |n_cross_e_scal_b_re|
406 #endif
407 #endif
407 #ifdef MSB_FIRST_TCH
408 #ifdef MSB_FIRST_TCH
408 lfr_bp1[i*NB_BYTES_BP1+3] = lfr_bp1[i*NB_BYTES_BP1+3] | (pt_uint8[0] & 0x80); // Extract its sign bit (32-bit float, sign bit in the 0th octet:SPARC convention)
409 lfr_bp1[i*NB_BYTES_BP1+2] = lfr_bp1[i*NB_BYTES_BP1+2] | (pt_uint8[0] & 0x80); // Extract its sign bit (32-bit float, sign bit in the 1th octet:SPARC convention)
409 // Record it at the 8th bit position (from the right to the left)
410 // Record it at the 8th bit position (from the right to the left)
410 // of lfr_bp1[i*NB_BYTES_BP1+3]
411 // of lfr_bp1[i*NB_BYTES_BP1+2]
411 pt_uint8[0] = (pt_uint8[0] & 0x7f); // Make n_cross_e_scal_b_re be positive in any case: |n_cross_e_scal_b_re|
412 pt_uint8[0] = (pt_uint8[0] & 0x7f); // Make n_cross_e_scal_b_re be positive in any case: |n_cross_e_scal_b_re|
412 #endif
413 #endif
413 vphi = n_cross_e_scal_b_re / bx_bx_star; // Compute |VPHI|
414 vphi = n_cross_e_scal_b_re / bx_bx_star; // Compute |VPHI|
414
415
415 significand = frexpf(vphi/2, &exponent); // 0.5 <= significand < 1
416 significand = frexpf(vphi/2, &exponent); // 0.5 <= significand < 1
416 // vphi/2 = significand * 2^exponent
417 // vphi/2 = significand * 2^exponent
417 // The division by 2 is to ensure that max value <= 2^30 (rough estimate)
418 // The division by 2 is to ensure that max value <= 2^30 (rough estimate)
418 // Should be reconsidered by taking into account the k-coefficients ...
419 // Should be reconsidered by taking into account the k-coefficients ...
419
420
420 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
421 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
421 exponent = expmin;
422 exponent = expmin;
422 significand = 0.5; // min value that can be recorded
423 significand = 0.5; // min value that can be recorded
423 }
424 }
424 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
425 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
425 exponent = expmax;
426 exponent = expmax;
426 significand = 1.0; // max value that can be recorded
427 significand = 1.0; // max value that can be recorded
427 }
428 }
428 if (significand == 0) {// in that case exponent == 0 too
429 if (significand == 0) {// in that case exponent == 0 too
429 exponent = expmin;
430 exponent = expmin;
430 significand = 0.5; // min value that can be recorded
431 significand = 0.5; // min value that can be recorded
431 }
432 }
432 #ifdef DEBUG_TCH
433 #ifdef DEBUG_TCH
433 printf("|VPHI| / 2 : %16.8e\n",vphi/2);
434 printf("|VPHI| / 2 : %16.8e\n",vphi/2);
434 printf("significand : %16.8e\n",significand);
435 printf("significand : %16.8e\n",significand);
435 printf("exponent : %d\n" ,exponent);
436 printf("exponent : %d\n" ,exponent);
436 #endif
437 #endif
437 lfr_bp1[i*NB_BYTES_BP1+8] = (uint8_t) ((significand*2-1)*7 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
438 lfr_bp1[i*NB_BYTES_BP1+8] = (uint8_t) ((significand*2-1)*7 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
438 // where just the first 3 bits are used (0, ..., 7)
439 // where just the first 3 bits are used (0, ..., 7)
439 tmp_uint8 = (uint8_t) (exponent-expmin); // Shift and cast into a 8-bit uint8_t where
440 tmp_uint8 = (uint8_t) (exponent-expmin); // Shift and cast into a 8-bit uint8_t where
440 // just the first 5 bits are used (0, ..., 2^5-1)
441 // just the first 5 bits are used (0, ..., 2^5-1)
441 #ifdef DEBUG_TCH
442 #ifdef DEBUG_TCH
442 printf("lfr_bp1[i*NB_BYTES_BP1+8] for VPHI significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+8]);
443 printf("lfr_bp1[i*NB_BYTES_BP1+8] for VPHI significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+8]);
443 printf("tmp_uint8 for VPHI exponent : %d\n",tmp_uint8);
444 printf("tmp_uint8 for VPHI exponent : %d\n",tmp_uint8);
444 #endif
445 #endif
445 lfr_bp1[i*NB_BYTES_BP1+8] = lfr_bp1[i*NB_BYTES_BP1+8] | (tmp_uint8 << 3); // shift these 5 bits to the left before logical addition
446 lfr_bp1[i*NB_BYTES_BP1+8] = lfr_bp1[i*NB_BYTES_BP1+8] | (tmp_uint8 << 3); // shift these 5 bits to the left before logical addition
446 // with lfr_bp1[i*NB_BYTES_BP1+8]
447 // with lfr_bp1[i*NB_BYTES_BP1+8]
447 #ifdef DEBUG_TCH
448 #ifdef DEBUG_TCH
448 printf("lfr_bp1[i*NB_BYTES_BP1+8] for VPHI exponent + significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+8]);
449 printf("lfr_bp1[i*NB_BYTES_BP1+8] for VPHI exponent + significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+8]);
449 printf("lfr_bp1[i*NB_BYTES_BP1+3] for VPHI sign + PSDB 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+3]);
450 printf("lfr_bp1[i*NB_BYTES_BP1+2] for VPHI sign + PSDB 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+2]);
450 #endif
451 #endif
451 pt_uint8 = (uint8_t*) &n_cross_e_scal_b_im; // Affect an uint8_t pointer with the adress of n_cross_e_scal_b_im
452 pt_uint8 = (uint8_t*) &n_cross_e_scal_b_im; // Affect an uint8_t pointer with the adress of n_cross_e_scal_b_im
452 #ifdef LSB_FIRST_TCH
453 #ifdef LSB_FIRST_TCH
453 pt_uint8[3] = pt_uint8[3] & 0x7f; // Make n_cross_e_scal_b_im be positive in any case: |ImaSX|
454 pt_uint8[3] = pt_uint8[3] & 0x7f; // Make n_cross_e_scal_b_im be positive in any case: |ImaSX| (32-bit float, sign bit in the 4th octet:PC convention)
454 #endif
455 #endif
455 #ifdef MSB_FIRST_TCH
456 #ifdef MSB_FIRST_TCH
456 pt_uint8[0] = pt_uint8[0] & 0x7f; // Make n_cross_e_scal_b_im be positive in any case: |ImaSX|
457 pt_uint8[0] = pt_uint8[0] & 0x7f; // Make n_cross_e_scal_b_im be positive in any case: |ImaSX| (32-bit float, sign bit in the 1th octet:SPARC convention)
457 #endif
458 #endif
458 tmp_uint8 = (n_cross_e_scal_b_im > n_cross_e_scal_b_re) ? 0x40 : 0x00; // Determine the sector argument of SX. If |Im| > |Re| affect
459 tmp_uint8 = (n_cross_e_scal_b_im > n_cross_e_scal_b_re) ? 0x40 : 0x00; // Determine the sector argument of SX. If |Im| > |Re| affect
459 // an unsigned 8-bit char with 01000000; otherwise with null.
460 // an unsigned 8-bit char with 01000000; otherwise with null.
460 lfr_bp1[i*NB_BYTES_BP1+3] = lfr_bp1[i*NB_BYTES_BP1+3] | tmp_uint8; // Record it as a sign bit at the 7th bit position (from the right
461 lfr_bp1[i*NB_BYTES_BP1+2] = lfr_bp1[i*NB_BYTES_BP1+2] | tmp_uint8; // Record it as a sign bit at the 7th bit position (from the right
461 // to the left) of lfr_bp1[i*NB_BYTES_BP1+3], by simple logical addition.
462 // to the left) of lfr_bp1[i*NB_BYTES_BP1+3], by simple logical addition.
462 #ifdef DEBUG_TCH
463 #ifdef DEBUG_TCH
463 printf("|n_cross_e_scal_b_im| : %16.8e\n",n_cross_e_scal_b_im);
464 printf("|n_cross_e_scal_b_im| : %16.8e\n",n_cross_e_scal_b_im);
464 printf("|n_cross_e_scal_b_im|/bx_bx_star/2: %16.8e\n",n_cross_e_scal_b_im/bx_bx_star/2);
465 printf("|n_cross_e_scal_b_im|/bx_bx_star/2: %16.8e\n",n_cross_e_scal_b_im/bx_bx_star/2);
465 printf("ArgNEBX sign : %u\n",tmp_uint8);
466 printf("ArgNEBX sign : %u\n",tmp_uint8);
466 printf("lfr_bp1[i*NB_BYTES_BP1+3] for VPHI & ArgNEBX signs + PSDB 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+3]);
467 printf("lfr_bp1[i*NB_BYTES_BP1+2] for VPHI & ArgNEBX signs + PSDB 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+2]);
467 #endif
468 #endif
468 }
469 }
469 }
470 }
470
471
471 void BP2_set( float * compressed_spec_mat, uint8_t nb_bins_compressed_spec_mat, uint8_t * lfr_bp2 )
472 void BP2_set( float * compressed_spec_mat, uint8_t nb_bins_compressed_spec_mat, uint8_t * lfr_bp2 )
472 {
473 {
473 float cross_re; // 32-bit floating point
474 float cross_re; // 32-bit floating point
474 float cross_im;
475 float cross_im;
475 float aux;
476 float aux;
476 float significand;
477 float significand;
477 int exponent; // 32-bit signed integer
478 int exponent; // 32-bit signed integer
478 uint8_t nbitexp; // 8-bit unsigned integer
479 uint8_t nbitexp; // 8-bit unsigned integer
479 uint8_t nbitsig;
480 uint8_t nbitsig;
480 uint8_t *pt_uint8; // pointer on unsigned 8-bit integer
481 uint8_t *pt_uint8; // pointer on unsigned 8-bit integer
481 int8_t expmin; // 8-bit signed integer
482 int8_t expmin; // 8-bit signed integer
482 int8_t expmax;
483 int8_t expmax;
483 uint16_t rangesig; // 16-bit unsigned integer
484 uint16_t rangesig; // 16-bit unsigned integer
484 uint16_t autocor;
485 uint16_t autocor;
485 uint16_t exp;
486 uint16_t exp;
486 uint16_t tmp_uint16;
487 uint16_t tmp_uint16;
487 uint16_t i;
488 uint16_t i;
488
489
489 #ifdef DEBUG_TCH
490 #ifdef DEBUG_TCH
490 printf("BP2 : \n");
491 printf("BP2 : \n");
491 printf("Number of bins: %d\n", nb_bins_compressed_spec_mat);
492 printf("Number of bins: %d\n", nb_bins_compressed_spec_mat);
492 #endif
493 #endif
493
494
494 // For floating point data to be recorded on 16-bit words :
495 // For floating point data to be recorded on 16-bit words :
495 nbitexp = 6; // number of bits for the exponent
496 nbitexp = 6; // number of bits for the exponent
496 nbitsig = 16 - nbitexp; // number of bits for the significand
497 nbitsig = 16 - nbitexp; // number of bits for the significand
497 rangesig = (1 << nbitsig)-1; // == 2^nbitsig - 1
498 rangesig = (1 << nbitsig)-1; // == 2^nbitsig - 1
498 expmax = 32;
499 expmax = 32;
499 expmin = expmax - (1 << nbitexp) + 1;
500 expmin = expmax - (1 << nbitexp) + 1;
500
501
501 #ifdef DEBUG_TCH
502 #ifdef DEBUG_TCH
502 printf("nbitexp : %d, nbitsig : %d, rangesig : %d\n", nbitexp, nbitsig, rangesig);
503 printf("nbitexp : %d, nbitsig : %d, rangesig : %d\n", nbitexp, nbitsig, rangesig);
503 printf("expmin : %d, expmax : %d\n", expmin, expmax);
504 printf("expmin : %d, expmax : %d\n", expmin, expmax);
504 #endif
505 #endif
505
506
506 for(i = 0; i<nb_bins_compressed_spec_mat; i++){
507 for(i = 0; i<nb_bins_compressed_spec_mat; i++){
507 //==============================================
508 //==============================================
508 // BP2 normalized cross correlations == PA_LFR_SC_BP2_CROSS_F0 == 10 * (8+8) bits
509 // BP2 normalized cross correlations == PA_LFR_SC_BP2_CROSS_F0 == 10 * (8+8) bits
509 // == PA_LFR_SC_BP2_CROSS_RE_0_F0 == 8 bits
510 // == PA_LFR_SC_BP2_CROSS_RE_0_F0 == 8 bits
510 // == PA_LFR_SC_BP2_CROSS_IM_0_F0 == 8 bits
511 // == PA_LFR_SC_BP2_CROSS_IM_0_F0 == 8 bits
511 // == PA_LFR_SC_BP2_CROSS_RE_1_F0 == 8 bits
512 // == PA_LFR_SC_BP2_CROSS_RE_1_F0 == 8 bits
512 // == PA_LFR_SC_BP2_CROSS_IM_1_F0 == 8 bits
513 // == PA_LFR_SC_BP2_CROSS_IM_1_F0 == 8 bits
513 // == PA_LFR_SC_BP2_CROSS_RE_2_F0 == 8 bits
514 // == PA_LFR_SC_BP2_CROSS_RE_2_F0 == 8 bits
514 // == PA_LFR_SC_BP2_CROSS_IM_2_F0 == 8 bits
515 // == PA_LFR_SC_BP2_CROSS_IM_2_F0 == 8 bits
515 // == PA_LFR_SC_BP2_CROSS_RE_3_F0 == 8 bits
516 // == PA_LFR_SC_BP2_CROSS_RE_3_F0 == 8 bits
516 // == PA_LFR_SC_BP2_CROSS_IM_3_F0 == 8 bits
517 // == PA_LFR_SC_BP2_CROSS_IM_3_F0 == 8 bits
517 // == PA_LFR_SC_BP2_CROSS_RE_4_F0 == 8 bits
518 // == PA_LFR_SC_BP2_CROSS_RE_4_F0 == 8 bits
518 // == PA_LFR_SC_BP2_CROSS_IM_4_F0 == 8 bits
519 // == PA_LFR_SC_BP2_CROSS_IM_4_F0 == 8 bits
519 // == PA_LFR_SC_BP2_CROSS_RE_5_F0 == 8 bits
520 // == PA_LFR_SC_BP2_CROSS_RE_5_F0 == 8 bits
520 // == PA_LFR_SC_BP2_CROSS_IM_5_F0 == 8 bits
521 // == PA_LFR_SC_BP2_CROSS_IM_5_F0 == 8 bits
521 // == PA_LFR_SC_BP2_CROSS_RE_6_F0 == 8 bits
522 // == PA_LFR_SC_BP2_CROSS_RE_6_F0 == 8 bits
522 // == PA_LFR_SC_BP2_CROSS_IM_6_F0 == 8 bits
523 // == PA_LFR_SC_BP2_CROSS_IM_6_F0 == 8 bits
523 // == PA_LFR_SC_BP2_CROSS_RE_7_F0 == 8 bits
524 // == PA_LFR_SC_BP2_CROSS_RE_7_F0 == 8 bits
524 // == PA_LFR_SC_BP2_CROSS_IM_7_F0 == 8 bits
525 // == PA_LFR_SC_BP2_CROSS_IM_7_F0 == 8 bits
525 // == PA_LFR_SC_BP2_CROSS_RE_8_F0 == 8 bits
526 // == PA_LFR_SC_BP2_CROSS_RE_8_F0 == 8 bits
526 // == PA_LFR_SC_BP2_CROSS_IM_8_F0 == 8 bits
527 // == PA_LFR_SC_BP2_CROSS_IM_8_F0 == 8 bits
527 // == PA_LFR_SC_BP2_CROSS_RE_9_F0 == 8 bits
528 // == PA_LFR_SC_BP2_CROSS_RE_9_F0 == 8 bits
528 // == PA_LFR_SC_BP2_CROSS_IM_9_F0 == 8 bits
529 // == PA_LFR_SC_BP2_CROSS_IM_9_F0 == 8 bits
529 // S12
530 // S12
530 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]);
531 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]);
531 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+1] / aux;
532 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+1] / aux;
532 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] / aux;
533 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] / aux;
533 lfr_bp2[i*NB_BYTES_BP2+10] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
534 lfr_bp2[i*NB_BYTES_BP2+10] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
534 lfr_bp2[i*NB_BYTES_BP2+20] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
535 lfr_bp2[i*NB_BYTES_BP2+20] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
535 #ifdef DEBUG_TCH
536 #ifdef DEBUG_TCH
536 printf("\nBin number: %d\n", i);
537 printf("\nBin number: %d\n", i);
537 printf("lfr_bp2[i*NB_BYTES_BP2+10] for cross12_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+10]);
538 printf("lfr_bp2[i*NB_BYTES_BP2+10] for cross12_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+10]);
538 printf("lfr_bp2[i*NB_BYTES_BP2+20] for cross12_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+20]);
539 printf("lfr_bp2[i*NB_BYTES_BP2+20] for cross12_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+20]);
539 #endif
540 #endif
540 // S13
541 // S13
541 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]);
542 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]);
542 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+3] / aux;
543 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+3] / aux;
543 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] / aux;
544 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] / aux;
544 lfr_bp2[i*NB_BYTES_BP2+11] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
545 lfr_bp2[i*NB_BYTES_BP2+11] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
545 lfr_bp2[i*NB_BYTES_BP2+21] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
546 lfr_bp2[i*NB_BYTES_BP2+21] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
546 #ifdef DEBUG_TCH
547 #ifdef DEBUG_TCH
547 printf("lfr_bp2[i*NB_BYTES_BP2+11] for cross13_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+11]);
548 printf("lfr_bp2[i*NB_BYTES_BP2+11] for cross13_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+11]);
548 printf("lfr_bp2[i*NB_BYTES_BP2+21] for cross13_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+21]);
549 printf("lfr_bp2[i*NB_BYTES_BP2+21] for cross13_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+21]);
549 #endif
550 #endif
550 // S14
551 // S14
551 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
552 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
552 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+5] / aux;
553 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+5] / aux;
553 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+6] / aux;
554 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+6] / aux;
554 lfr_bp2[i*NB_BYTES_BP2+12] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
555 lfr_bp2[i*NB_BYTES_BP2+12] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
555 lfr_bp2[i*NB_BYTES_BP2+22] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
556 lfr_bp2[i*NB_BYTES_BP2+22] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
556 #ifdef DEBUG_TCH
557 #ifdef DEBUG_TCH
557 printf("lfr_bp2[i*NB_BYTES_BP2+12] for cross14_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+12]);
558 printf("lfr_bp2[i*NB_BYTES_BP2+12] for cross14_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+12]);
558 printf("lfr_bp2[i*NB_BYTES_BP2+22] for cross14_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+22]);
559 printf("lfr_bp2[i*NB_BYTES_BP2+22] for cross14_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+22]);
559 #endif
560 #endif
560 // S15
561 // S15
561 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
562 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
562 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+7] / aux;
563 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+7] / aux;
563 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+8] / aux;
564 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+8] / aux;
564 lfr_bp2[i*NB_BYTES_BP2+13] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
565 lfr_bp2[i*NB_BYTES_BP2+13] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
565 lfr_bp2[i*NB_BYTES_BP2+23] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
566 lfr_bp2[i*NB_BYTES_BP2+23] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
566 #ifdef DEBUG_TCH
567 #ifdef DEBUG_TCH
567 printf("lfr_bp2[i*NB_BYTES_BP2+13] for cross15_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+13]);
568 printf("lfr_bp2[i*NB_BYTES_BP2+13] for cross15_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+13]);
568 printf("lfr_bp2[i*NB_BYTES_BP2+23] for cross15_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+23]);
569 printf("lfr_bp2[i*NB_BYTES_BP2+23] for cross15_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+23]);
569 #endif
570 #endif
570 // S23
571 // S23
571 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]);
572 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]);
572 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10] / aux;
573 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10] / aux;
573 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11] / aux;
574 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11] / aux;
574 lfr_bp2[i*NB_BYTES_BP2+14] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
575 lfr_bp2[i*NB_BYTES_BP2+14] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
575 lfr_bp2[i*NB_BYTES_BP2+24] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
576 lfr_bp2[i*NB_BYTES_BP2+24] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
576 #ifdef DEBUG_TCH
577 #ifdef DEBUG_TCH
577 printf("lfr_bp2[i*NB_BYTES_BP2+14] for cross23_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+14]);
578 printf("lfr_bp2[i*NB_BYTES_BP2+14] for cross23_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+14]);
578 printf("lfr_bp2[i*NB_BYTES_BP2+24] for cross23_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+24]);
579 printf("lfr_bp2[i*NB_BYTES_BP2+24] for cross23_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+24]);
579 #endif
580 #endif
580 // S24
581 // S24
581 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
582 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
582 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12] / aux;
583 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12] / aux;
583 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13] / aux;
584 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13] / aux;
584 lfr_bp2[i*NB_BYTES_BP2+15] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
585 lfr_bp2[i*NB_BYTES_BP2+15] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
585 lfr_bp2[i*NB_BYTES_BP2+25] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
586 lfr_bp2[i*NB_BYTES_BP2+25] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
586 #ifdef DEBUG_TCH
587 #ifdef DEBUG_TCH
587 printf("lfr_bp2[i*NB_BYTES_BP2+15] for cross24_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+15]);
588 printf("lfr_bp2[i*NB_BYTES_BP2+15] for cross24_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+15]);
588 printf("lfr_bp2[i*NB_BYTES_BP2+25] for cross24_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+25]);
589 printf("lfr_bp2[i*NB_BYTES_BP2+25] for cross24_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+25]);
589 #endif
590 #endif
590 // S25
591 // S25
591 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
592 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
592 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14] / aux;
593 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14] / aux;
593 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15] / aux;
594 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15] / aux;
594 lfr_bp2[i*NB_BYTES_BP2+16] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
595 lfr_bp2[i*NB_BYTES_BP2+16] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
595 lfr_bp2[i*NB_BYTES_BP2+26] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
596 lfr_bp2[i*NB_BYTES_BP2+26] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
596 #ifdef DEBUG_TCH
597 #ifdef DEBUG_TCH
597 printf("lfr_bp2[i*NB_BYTES_BP2+16] for cross25_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+16]);
598 printf("lfr_bp2[i*NB_BYTES_BP2+16] for cross25_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+16]);
598 printf("lfr_bp2[i*NB_BYTES_BP2+26] for cross25_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+26]);
599 printf("lfr_bp2[i*NB_BYTES_BP2+26] for cross25_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+26]);
599 #endif
600 #endif
600 // S34
601 // S34
601 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
602 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
602 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17] / aux;
603 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17] / aux;
603 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18] / aux;
604 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18] / aux;
604 lfr_bp2[i*NB_BYTES_BP2+17] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
605 lfr_bp2[i*NB_BYTES_BP2+17] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
605 lfr_bp2[i*NB_BYTES_BP2+27] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
606 lfr_bp2[i*NB_BYTES_BP2+27] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
606 #ifdef DEBUG_TCH
607 #ifdef DEBUG_TCH
607 printf("lfr_bp2[i*NB_BYTES_BP2+17] for cross34_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+17]);
608 printf("lfr_bp2[i*NB_BYTES_BP2+17] for cross34_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+17]);
608 printf("lfr_bp2[i*NB_BYTES_BP2+27] for cross34_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+27]);
609 printf("lfr_bp2[i*NB_BYTES_BP2+27] for cross34_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+27]);
609 #endif
610 #endif
610 // S35
611 // S35
611 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
612 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
612 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19] / aux;
613 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19] / aux;
613 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20] / aux;
614 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20] / aux;
614 lfr_bp2[i*NB_BYTES_BP2+18] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
615 lfr_bp2[i*NB_BYTES_BP2+18] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
615 lfr_bp2[i*NB_BYTES_BP2+28] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
616 lfr_bp2[i*NB_BYTES_BP2+28] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
616 #ifdef DEBUG_TCH
617 #ifdef DEBUG_TCH
617 printf("lfr_bp2[i*NB_BYTES_BP2+18] for cross35_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+18]);
618 printf("lfr_bp2[i*NB_BYTES_BP2+18] for cross35_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+18]);
618 printf("lfr_bp2[i*NB_BYTES_BP2+28] for cross35_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+28]);
619 printf("lfr_bp2[i*NB_BYTES_BP2+28] for cross35_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+28]);
619 #endif
620 #endif
620 // S45
621 // S45
621 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
622 aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
622 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+22] / aux;
623 cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+22] / aux;
623 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+23] / aux;
624 cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+23] / aux;
624 lfr_bp2[i*NB_BYTES_BP2+19] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
625 lfr_bp2[i*NB_BYTES_BP2+19] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
625 lfr_bp2[i*NB_BYTES_BP2+29] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
626 lfr_bp2[i*NB_BYTES_BP2+29] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
626 #ifdef DEBUG_TCH
627 #ifdef DEBUG_TCH
627 printf("lfr_bp2[i*NB_BYTES_BP2+19] for cross45_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+19]);
628 printf("lfr_bp2[i*NB_BYTES_BP2+19] for cross45_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+19]);
628 printf("lfr_bp2[i*NB_BYTES_BP2+29] for cross45_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+29]);
629 printf("lfr_bp2[i*NB_BYTES_BP2+29] for cross45_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+29]);
629 #endif
630 #endif
630 //==============================================
631 //==============================================
631 // BP2 auto correlations == PA_LFR_SC_BP2_AUTO_F0 == 5*16 bits = 5*[6 bits (exponent) + 10 bits (significand)]
632 // BP2 auto correlations == PA_LFR_SC_BP2_AUTO_F0 == 5*16 bits = 5*[6 bits (exponent) + 10 bits (significand)]
632 // == PA_LFR_SC_BP2_AUTO_A0_F0 == 16 bits
633 // == PA_LFR_SC_BP2_AUTO_A0_F0 == 16 bits
633 // == PA_LFR_SC_BP2_AUTO_A1_F0 == 16 bits
634 // == PA_LFR_SC_BP2_AUTO_A1_F0 == 16 bits
634 // == PA_LFR_SC_BP2_AUTO_A2_F0 == 16 bits
635 // == PA_LFR_SC_BP2_AUTO_A2_F0 == 16 bits
635 // == PA_LFR_SC_BP2_AUTO_A3_F0 == 16 bits
636 // == PA_LFR_SC_BP2_AUTO_A3_F0 == 16 bits
636 // == PA_LFR_SC_BP2_AUTO_A4_F0 == 16 bits
637 // == PA_LFR_SC_BP2_AUTO_A4_F0 == 16 bits
637 // S11
638 // S11
638 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX], &exponent); // 0.5 <= significand < 1
639 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX], &exponent); // 0.5 <= significand < 1
639 // S11 = significand * 2^exponent
640 // S11 = significand * 2^exponent
640 #ifdef DEBUG_TCH
641 #ifdef DEBUG_TCH
641 printf("S11 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]);
642 printf("S11 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]);
642 printf("significand : %16.8e\n",significand);
643 printf("significand : %16.8e\n",significand);
643 printf("exponent : %d\n" ,exponent);
644 printf("exponent : %d\n" ,exponent);
644 #endif
645 #endif
645 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
646 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
646 exponent = expmin;
647 exponent = expmin;
647 significand = 0.5; // min value that can be recorded
648 significand = 0.5; // min value that can be recorded
648 }
649 }
649 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
650 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
650 exponent = expmax;
651 exponent = expmax;
651 significand = 1.0; // max value that can be recorded
652 significand = 1.0; // max value that can be recorded
652 }
653 }
653 if (significand == 0) { // in that case exponent == 0 too
654 if (significand == 0) { // in that case exponent == 0 too
654 exponent = expmin;
655 exponent = expmin;
655 significand = 0.5; // min value that can be recorded
656 significand = 0.5; // min value that can be recorded
656 }
657 }
657
658
658 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
659 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
659 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
660 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
660 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
661 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
661 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
662 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
662 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
663 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
663 // left place of the significand bits (nbitsig),
664 // left place of the significand bits (nbitsig),
664 // making the 16-bit word to be recorded
665 // making the 16-bit word to be recorded
665 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
666 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
666 #ifdef LSB_FIRST_TCH
667 #ifdef MSB_FIRST_TCH
667 lfr_bp2[i*NB_BYTES_BP2+0] = pt_uint8[0]; // Record LSB of tmp_uint16
668 lfr_bp2[i*NB_BYTES_BP2+0] = pt_uint8[0]; // Record MSB of tmp_uint16
668 lfr_bp2[i*NB_BYTES_BP2+1] = pt_uint8[1]; // Record MSB of tmp_uint16
669 lfr_bp2[i*NB_BYTES_BP2+1] = pt_uint8[1]; // Record LSB of tmp_uint16
669 #endif
670 #endif
670 #ifdef MSB_FIRST_TCH
671 #ifdef LSB_FIRST_TCH
671 lfr_bp2[i*NB_BYTES_BP2+0] = pt_uint8[1]; // Record LSB of tmp_uint16
672 lfr_bp2[i*NB_BYTES_BP2+0] = pt_uint8[1]; // Record MSB of tmp_uint16
672 lfr_bp2[i*NB_BYTES_BP2+1] = pt_uint8[0]; // Record MSB of tmp_uint16
673 lfr_bp2[i*NB_BYTES_BP2+1] = pt_uint8[0]; // Record LSB of tmp_uint16
673 #endif
674 #endif
674 #ifdef DEBUG_TCH
675 #ifdef DEBUG_TCH
675 printf("autocor for S11 significand : %u\n",autocor);
676 printf("autocor for S11 significand : %u\n",autocor);
676 printf("exp for S11 exponent : %u\n",exp);
677 printf("exp for S11 exponent : %u\n",exp);
677 printf("pt_uint8[1] for S11 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
678 printf("pt_uint8[1] for S11 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
678 printf("pt_uint8[0] for S11 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
679 printf("pt_uint8[0] for S11 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
679 printf("lfr_bp2[i*NB_BYTES_BP2+1] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+1], lfr_bp2[i*NB_BYTES_BP2+1]);
680 printf("lfr_bp2[i*NB_BYTES_BP2+1] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+1], lfr_bp2[i*NB_BYTES_BP2+1]);
680 printf("lfr_bp2[i*NB_BYTES_BP2+0] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+0], lfr_bp2[i*NB_BYTES_BP2+0]);
681 printf("lfr_bp2[i*NB_BYTES_BP2+0] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+0], lfr_bp2[i*NB_BYTES_BP2+0]);
681 #endif
682 #endif
682 // S22
683 // S22
683 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9], &exponent); // 0.5 <= significand < 1
684 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9], &exponent); // 0.5 <= significand < 1
684 // S22 = significand * 2^exponent
685 // S22 = significand * 2^exponent
685 #ifdef DEBUG_TCH
686 #ifdef DEBUG_TCH
686 printf("S22 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]);
687 printf("S22 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]);
687 printf("significand : %16.8e\n",significand);
688 printf("significand : %16.8e\n",significand);
688 printf("exponent : %d\n" ,exponent);
689 printf("exponent : %d\n" ,exponent);
689 #endif
690 #endif
690 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
691 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
691 exponent = expmin;
692 exponent = expmin;
692 significand = 0.5; // min value that can be recorded
693 significand = 0.5; // min value that can be recorded
693 }
694 }
694 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
695 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
695 exponent = expmax;
696 exponent = expmax;
696 significand = 1.0; // max value that can be recorded
697 significand = 1.0; // max value that can be recorded
697 }
698 }
698 if (significand == 0) { // in that case exponent == 0 too
699 if (significand == 0) { // in that case exponent == 0 too
699 exponent = expmin;
700 exponent = expmin;
700 significand = 0.5; // min value that can be recorded
701 significand = 0.5; // min value that can be recorded
701 }
702 }
702
703
703 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
704 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
704 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
705 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
705 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
706 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
706 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
707 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
707 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
708 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
708 // left place of the significand bits (nbitsig),
709 // left place of the significand bits (nbitsig),
709 // making the 16-bit word to be recorded
710 // making the 16-bit word to be recorded
710 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
711 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
711 #ifdef LSB_FIRST_TCH
712 #ifdef MSB_FIRST_TCH
712 lfr_bp2[i*NB_BYTES_BP2+2] = pt_uint8[0]; // Record LSB of tmp_uint16
713 lfr_bp2[i*NB_BYTES_BP2+2] = pt_uint8[0]; // Record MSB of tmp_uint16
713 lfr_bp2[i*NB_BYTES_BP2+3] = pt_uint8[1]; // Record MSB of tmp_uint16
714 lfr_bp2[i*NB_BYTES_BP2+3] = pt_uint8[1]; // Record LSB of tmp_uint16
714 #endif
715 #endif
715 #ifdef MSB_FIRST_TCH
716 #ifdef LSB_FIRST_TCH
716 lfr_bp2[i*NB_BYTES_BP2+2] = pt_uint8[1]; // Record LSB of tmp_uint16
717 lfr_bp2[i*NB_BYTES_BP2+2] = pt_uint8[1]; // Record MSB of tmp_uint16
717 lfr_bp2[i*NB_BYTES_BP2+3] = pt_uint8[0]; // Record MSB of tmp_uint16
718 lfr_bp2[i*NB_BYTES_BP2+3] = pt_uint8[0]; // Record LSB of tmp_uint16
718 #endif
719 #endif
719 #ifdef DEBUG_TCH
720 #ifdef DEBUG_TCH
720 printf("autocor for S22 significand : %u\n",autocor);
721 printf("autocor for S22 significand : %u\n",autocor);
721 printf("exp for S11 exponent : %u\n",exp);
722 printf("exp for S11 exponent : %u\n",exp);
722 printf("pt_uint8[1] for S22 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
723 printf("pt_uint8[1] for S22 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
723 printf("pt_uint8[0] for S22 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
724 printf("pt_uint8[0] for S22 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
724 printf("lfr_bp2[i*NB_BYTES_BP2+3] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+3], lfr_bp2[i*NB_BYTES_BP2+3]);
725 printf("lfr_bp2[i*NB_BYTES_BP2+3] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+3], lfr_bp2[i*NB_BYTES_BP2+3]);
725 printf("lfr_bp2[i*NB_BYTES_BP2+2] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+2], lfr_bp2[i*NB_BYTES_BP2+2]);
726 printf("lfr_bp2[i*NB_BYTES_BP2+2] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+2], lfr_bp2[i*NB_BYTES_BP2+2]);
726 #endif
727 #endif
727 // S33
728 // S33
728 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16], &exponent); // 0.5 <= significand < 1
729 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16], &exponent); // 0.5 <= significand < 1
729 // S33 = significand * 2^exponent
730 // S33 = significand * 2^exponent
730 #ifdef DEBUG_TCH
731 #ifdef DEBUG_TCH
731 printf("S33 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]);
732 printf("S33 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]);
732 printf("significand : %16.8e\n",significand);
733 printf("significand : %16.8e\n",significand);
733 printf("exponent : %d\n" ,exponent);
734 printf("exponent : %d\n" ,exponent);
734 #endif
735 #endif
735 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
736 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
736 exponent = expmin;
737 exponent = expmin;
737 significand = 0.5; // min value that can be recorded
738 significand = 0.5; // min value that can be recorded
738 }
739 }
739 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
740 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
740 exponent = expmax;
741 exponent = expmax;
741 significand = 1.0; // max value that can be recorded
742 significand = 1.0; // max value that can be recorded
742 }
743 }
743 if (significand == 0) { // in that case exponent == 0 too
744 if (significand == 0) { // in that case exponent == 0 too
744 exponent = expmin;
745 exponent = expmin;
745 significand = 0.5; // min value that can be recorded
746 significand = 0.5; // min value that can be recorded
746 }
747 }
747
748
748 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
749 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
749 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
750 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
750 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
751 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
751 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
752 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
752 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
753 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
753 // left place of the significand bits (nbitsig),
754 // left place of the significand bits (nbitsig),
754 // making the 16-bit word to be recorded
755 // making the 16-bit word to be recorded
755 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
756 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
756 #ifdef LSB_FIRST_TCH
757 #ifdef MSB_FIRST_TCH
757 lfr_bp2[i*NB_BYTES_BP2+4] = pt_uint8[0]; // Record LSB of tmp_uint16
758 lfr_bp2[i*NB_BYTES_BP2+4] = pt_uint8[0]; // Record MSB of tmp_uint16
758 lfr_bp2[i*NB_BYTES_BP2+5] = pt_uint8[1]; // Record MSB of tmp_uint16
759 lfr_bp2[i*NB_BYTES_BP2+5] = pt_uint8[1]; // Record LSB of tmp_uint16
759 #endif
760 #endif
760 #ifdef MSB_FIRST_TCH
761 #ifdef LSB_FIRST_TCH
761 lfr_bp2[i*NB_BYTES_BP2+4] = pt_uint8[1]; // Record LSB of tmp_uint16
762 lfr_bp2[i*NB_BYTES_BP2+4] = pt_uint8[1]; // Record MSB of tmp_uint16
762 lfr_bp2[i*NB_BYTES_BP2+5] = pt_uint8[0]; // Record MSB of tmp_uint16
763 lfr_bp2[i*NB_BYTES_BP2+5] = pt_uint8[0]; // Record LSB of tmp_uint16
763 #endif
764 #endif
764 #ifdef DEBUG_TCH
765 #ifdef DEBUG_TCH
765 printf("autocor for S33 significand : %u\n",autocor);
766 printf("autocor for S33 significand : %u\n",autocor);
766 printf("exp for S33 exponent : %u\n",exp);
767 printf("exp for S33 exponent : %u\n",exp);
767 printf("pt_uint8[1] for S33 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
768 printf("pt_uint8[1] for S33 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
768 printf("pt_uint8[0] for S33 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
769 printf("pt_uint8[0] for S33 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
769 printf("lfr_bp2[i*NB_BYTES_BP2+5] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+5], lfr_bp2[i*NB_BYTES_BP2+5]);
770 printf("lfr_bp2[i*NB_BYTES_BP2+5] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+5], lfr_bp2[i*NB_BYTES_BP2+5]);
770 printf("lfr_bp2[i*NB_BYTES_BP2+4] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+4], lfr_bp2[i*NB_BYTES_BP2+4]);
771 printf("lfr_bp2[i*NB_BYTES_BP2+4] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+4], lfr_bp2[i*NB_BYTES_BP2+4]);
771 #endif
772 #endif
772 // S44
773 // S44
773 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21], &exponent); // 0.5 <= significand < 1
774 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21], &exponent); // 0.5 <= significand < 1
774 // S44 = significand * 2^exponent
775 // S44 = significand * 2^exponent
775 #ifdef DEBUG_TCH
776 #ifdef DEBUG_TCH
776 printf("S44 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
777 printf("S44 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
777 printf("significand : %16.8e\n",significand);
778 printf("significand : %16.8e\n",significand);
778 printf("exponent : %d\n" ,exponent);
779 printf("exponent : %d\n" ,exponent);
779 #endif
780 #endif
780
781
781 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
782 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
782 exponent = expmin;
783 exponent = expmin;
783 significand = 0.5; // min value that can be recorded
784 significand = 0.5; // min value that can be recorded
784 }
785 }
785 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
786 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
786 exponent = expmax;
787 exponent = expmax;
787 significand = 1.0; // max value that can be recorded
788 significand = 1.0; // max value that can be recorded
788 }
789 }
789 if (significand == 0) { // in that case exponent == 0 too
790 if (significand == 0) { // in that case exponent == 0 too
790 exponent = expmin;
791 exponent = expmin;
791 significand = 0.5; // min value that can be recorded
792 significand = 0.5; // min value that can be recorded
792 }
793 }
793
794
794 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
795 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
795 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
796 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
796 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
797 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
797 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
798 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
798 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
799 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
799 // left place of the significand bits (nbitsig),
800 // left place of the significand bits (nbitsig),
800 // making the 16-bit word to be recorded
801 // making the 16-bit word to be recorded
801 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
802 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
802 #ifdef LSB_FIRST_TCH
803 #ifdef MSB_FIRST_TCH
803 lfr_bp2[i*NB_BYTES_BP2+6] = pt_uint8[0]; // Record LSB of tmp_uint16
804 lfr_bp2[i*NB_BYTES_BP2+6] = pt_uint8[0]; // Record MSB of tmp_uint16
804 lfr_bp2[i*NB_BYTES_BP2+7] = pt_uint8[1]; // Record MSB of tmp_uint16
805 lfr_bp2[i*NB_BYTES_BP2+7] = pt_uint8[1]; // Record LSB of tmp_uint16
805 #endif
806 #endif
806 #ifdef MSB_FIRST_TCH
807 #ifdef LSB_FIRST_TCH
807 lfr_bp2[i*NB_BYTES_BP2+6] = pt_uint8[1]; // Record LSB of tmp_uint16
808 lfr_bp2[i*NB_BYTES_BP2+6] = pt_uint8[1]; // Record MSB of tmp_uint16
808 lfr_bp2[i*NB_BYTES_BP2+7] = pt_uint8[0]; // Record MSB of tmp_uint16
809 lfr_bp2[i*NB_BYTES_BP2+7] = pt_uint8[0]; // Record LSB of tmp_uint16
809 #endif
810 #endif
810 #ifdef DEBUG_TCH
811 #ifdef DEBUG_TCH
811 printf("autocor for S44 significand : %u\n",autocor);
812 printf("autocor for S44 significand : %u\n",autocor);
812 printf("exp for S44 exponent : %u\n",exp);
813 printf("exp for S44 exponent : %u\n",exp);
813 printf("pt_uint8[1] for S44 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
814 printf("pt_uint8[1] for S44 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
814 printf("pt_uint8[0] for S44 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
815 printf("pt_uint8[0] for S44 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
815 printf("lfr_bp2[i*NB_BYTES_BP2+7] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+7], lfr_bp2[i*NB_BYTES_BP2+7]);
816 printf("lfr_bp2[i*NB_BYTES_BP2+7] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+7], lfr_bp2[i*NB_BYTES_BP2+7]);
816 printf("lfr_bp2[i*NB_BYTES_BP2+6] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+6], lfr_bp2[i*NB_BYTES_BP2+6]);
817 printf("lfr_bp2[i*NB_BYTES_BP2+6] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+6], lfr_bp2[i*NB_BYTES_BP2+6]);
817 #endif
818 #endif
818 // S55
819 // S55
819 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24], &exponent); // 0.5 <= significand < 1
820 significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24], &exponent); // 0.5 <= significand < 1
820 // S55 = significand * 2^exponent
821 // S55 = significand * 2^exponent
821 #ifdef DEBUG_TCH
822 #ifdef DEBUG_TCH
822 printf("S55 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
823 printf("S55 : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
823 printf("significand : %16.8e\n",significand);
824 printf("significand : %16.8e\n",significand);
824 printf("exponent : %d\n" ,exponent);
825 printf("exponent : %d\n" ,exponent);
825 #endif
826 #endif
826 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
827 if (exponent < expmin) { // value should be >= 0.5 * 2^expmin
827 exponent = expmin;
828 exponent = expmin;
828 significand = 0.5; // min value that can be recorded
829 significand = 0.5; // min value that can be recorded
829 }
830 }
830 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
831 if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1)
831 exponent = expmax;
832 exponent = expmax;
832 significand = 1.0; // max value that can be recorded
833 significand = 1.0; // max value that can be recorded
833 }
834 }
834 if (significand == 0) { // in that case exponent == 0 too
835 if (significand == 0) { // in that case exponent == 0 too
835 exponent = expmin;
836 exponent = expmin;
836 significand = 0.5; // min value that can be recorded
837 significand = 0.5; // min value that can be recorded
837 }
838 }
838
839
839 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
840 autocor = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
840 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
841 // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
841 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
842 exp = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int where just
842 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
843 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
843 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
844 tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
844 // left place of the significand bits (nbitsig),
845 // left place of the significand bits (nbitsig),
845 // making the 16-bit word to be recorded
846 // making the 16-bit word to be recorded
846 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
847 pt_uint8 = (uint8_t*) &tmp_uint16; // Affect an uint8_t pointer with the adress of tmp_uint16
847 #ifdef LSB_FIRST_TCH
848 #ifdef MSB_FIRST_TCH
848 lfr_bp2[i*NB_BYTES_BP2+8] = pt_uint8[0]; // Record LSB of tmp_uint16
849 lfr_bp2[i*NB_BYTES_BP2+8] = pt_uint8[0]; // Record MSB of tmp_uint16
849 lfr_bp2[i*NB_BYTES_BP2+9] = pt_uint8[1]; // Record MSB of tmp_uint16
850 lfr_bp2[i*NB_BYTES_BP2+9] = pt_uint8[1]; // Record LSB of tmp_uint16
851 //printf("MSB:\n");
850 #endif
852 #endif
851 #ifdef MSB_FIRST_TCH
853 #ifdef LSB_FIRST_TCH
852 lfr_bp2[i*NB_BYTES_BP2+8] = pt_uint8[1]; // Record LSB of tmp_uint16
854 lfr_bp2[i*NB_BYTES_BP2+8] = pt_uint8[1]; // Record MSB of tmp_uint16
853 lfr_bp2[i*NB_BYTES_BP2+9] = pt_uint8[0]; // Record MSB of tmp_uint16
855 lfr_bp2[i*NB_BYTES_BP2+9] = pt_uint8[0]; // Record LSB of tmp_uint16
856 //printf("LSB:\n");
854 #endif
857 #endif
855 #ifdef DEBUG_TCH
858 #ifdef DEBUG_TCH
856 printf("autocor for S55 significand : %u\n",autocor);
859 printf("autocor for S55 significand : %u\n",autocor);
857 printf("exp for S55 exponent : %u\n",exp);
860 printf("exp for S55 exponent : %u\n",exp);
858 printf("pt_uint8[1] for S55 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
861 printf("pt_uint8[1] for S55 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
859 printf("pt_uint8[0] for S55 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
862 printf("pt_uint8[0] for S55 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
860 printf("lfr_bp2[i*NB_BYTES_BP2+9] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+9], lfr_bp2[i*NB_BYTES_BP2+9]);
863 printf("lfr_bp2[i*NB_BYTES_BP2+9] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+9], lfr_bp2[i*NB_BYTES_BP2+9]);
861 printf("lfr_bp2[i*NB_BYTES_BP2+8] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+8], lfr_bp2[i*NB_BYTES_BP2+8]);
864 printf("lfr_bp2[i*NB_BYTES_BP2+8] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+8], lfr_bp2[i*NB_BYTES_BP2+8]);
862 #endif
865 #endif
863 }
866 }
864 }
867 }
865
868
866
869
867 #endif // BASIC_PARAMETERS_H_INCLUDED
870 #endif // BASIC_PARAMETERS_H_INCLUDED
Show file before | Show file after | Hide comments
@@ -1,57 +1,57
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
1 // version 1.4: 16/05/2014
2 // version 1.4: 16/05/2014
2 // version 1.5: 20/05/2014
3 // version 1.5: 20/05/2014
3 // version 1.6: 19/12/2014
4 // version 1.6: 19/12/2014
5 // version 1.7: 15/01/2015 (modifs de Paul + correction erreurs qui se compensaient (LSB <=> MSB + indices [0,2] <=> [1,3])
6
4
7
5 #ifndef BASIC_PARAMETERS_PARAMS_H
8 #ifndef BASIC_PARAMETERS_PARAMS_H
6 #define BASIC_PARAMETERS_PARAMS_H
9 #define BASIC_PARAMETERS_PARAMS_H
7
10
8 #define NB_VALUES_PER_SPECTRAL_MATRIX 25
11 #define NB_VALUES_PER_SPECTRAL_MATRIX 25
9 #define NB_BINS_COMPRESSED_MATRIX_f0 1
10 #define NB_BINS_COMPRESSED_MATRIX_f1 13
11 #define NB_BINS_COMPRESSED_MATRIX_f2 12
12
12
13 #define NB_BYTES_BP1 9
13 #define NB_BYTES_BP1 9
14 #define NB_BYTES_BP2 30
14 #define NB_BYTES_BP2 30
15
15
16 //********************************************
16 //********************************************
17 // K-COEFFICIENTS FOR ONBOARD INTERCALIBRATION
17 // K-COEFFICIENTS FOR ONBOARD INTERCALIBRATION
18
18
19 #define NB_K_COEFF_PER_BIN 32
19 #define NB_K_COEFF_PER_BIN 32
20
20
21 #define K44_PE 0
21 #define K44_PE 0
22 #define K55_PE 1
22 #define K55_PE 1
23 #define K45_PE_RE 2
23 #define K45_PE_RE 2
24 #define K45_PE_IM 3
24 #define K45_PE_IM 3
25
25
26 #define K14_SX_RE 4
26 #define K14_SX_RE 4
27 #define K14_SX_IM 5
27 #define K14_SX_IM 5
28 #define K15_SX_RE 6
28 #define K15_SX_RE 6
29 #define K15_SX_IM 7
29 #define K15_SX_IM 7
30 #define K24_SX_RE 8
30 #define K24_SX_RE 8
31 #define K24_SX_IM 9
31 #define K24_SX_IM 9
32 #define K25_SX_RE 10
32 #define K25_SX_RE 10
33 #define K25_SX_IM 11
33 #define K25_SX_IM 11
34 #define K34_SX_RE 12
34 #define K34_SX_RE 12
35 #define K34_SX_IM 13
35 #define K34_SX_IM 13
36 #define K35_SX_RE 14
36 #define K35_SX_RE 14
37 #define K35_SX_IM 15
37 #define K35_SX_IM 15
38
38
39 #define K24_NY_RE 16
39 #define K24_NY_RE 16
40 #define K24_NY_IM 17
40 #define K24_NY_IM 17
41 #define K25_NY_RE 18
41 #define K25_NY_RE 18
42 #define K25_NY_IM 19
42 #define K25_NY_IM 19
43 #define K34_NY_RE 20
43 #define K34_NY_RE 20
44 #define K34_NY_IM 21
44 #define K34_NY_IM 21
45 #define K35_NY_RE 22
45 #define K35_NY_RE 22
46 #define K35_NY_IM 23
46 #define K35_NY_IM 23
47
47
48 #define K24_NZ_RE 24
48 #define K24_NZ_RE 24
49 #define K24_NZ_IM 25
49 #define K24_NZ_IM 25
50 #define K25_NZ_RE 26
50 #define K25_NZ_RE 26
51 #define K25_NZ_IM 27
51 #define K25_NZ_IM 27
52 #define K34_NZ_RE 28
52 #define K34_NZ_RE 28
53 #define K34_NZ_IM 29
53 #define K34_NZ_IM 29
54 #define K35_NZ_RE 30
54 #define K35_NZ_RE 30
55 #define K35_NZ_IM 31
55 #define K35_NZ_IM 31
56
56
57 #endif // BASIC_PARAMETERS_PARAMS_H
57 #endif // BASIC_PARAMETERS_PARAMS_H
Show file before | Show file after | Hide comments
@@ -1,19 +1,26
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
1 // version 1.6: 19/12/2014
2 // version 1.6: 19/12/2014
3 // version 1.7: 15/01/2015 (modifs de Paul + correction erreurs qui se compensaient (LSB <=> MSB + indices [0,2] <=> [1,3])
4
2
5
3 #ifndef BASIC_PARAMETERS_UTILITIES_H
6 #ifndef BASIC_PARAMETERS_UTILITIES_H
4 #define BASIC_PARAMETERS_UTILITIES_H
7 #define BASIC_PARAMETERS_UTILITIES_H
5
8
6 #include <stdio.h>
9 #include <stdio.h>
7 #include <malloc.h>
10 #include <malloc.h>
8
11
9 #include "basic_parameters_params.h"
12 #include "basic_parameters_params.h"
10
13
14 #define NB_BINS_COMPRESSED_MATRIX_f0 1
15 #define NB_BINS_COMPRESSED_MATRIX_f1 13
16 #define NB_BINS_COMPRESSED_MATRIX_f2 12
17
11 float compressed_spectral_matrix_f0[NB_BINS_COMPRESSED_MATRIX_f0 * NB_VALUES_PER_SPECTRAL_MATRIX];
18 float compressed_spectral_matrix_f0[NB_BINS_COMPRESSED_MATRIX_f0 * NB_VALUES_PER_SPECTRAL_MATRIX];
12 float k_coefficients_f0[NB_BINS_COMPRESSED_MATRIX_f0 * NB_K_COEFF_PER_BIN];
19 float k_coefficients_f0[NB_BINS_COMPRESSED_MATRIX_f0 * NB_K_COEFF_PER_BIN];
13 float k_coefficients_f1[NB_BINS_COMPRESSED_MATRIX_f1 * NB_K_COEFF_PER_BIN];
20 float k_coefficients_f1[NB_BINS_COMPRESSED_MATRIX_f1 * NB_K_COEFF_PER_BIN];
14 float k_coefficients_f2[NB_BINS_COMPRESSED_MATRIX_f2 * NB_K_COEFF_PER_BIN];
21 float k_coefficients_f2[NB_BINS_COMPRESSED_MATRIX_f2 * NB_K_COEFF_PER_BIN];
15
22
16 unsigned char LFR_BP1_f0[NB_BINS_COMPRESSED_MATRIX_f0*NB_BYTES_BP1];
23 unsigned char LFR_BP1_f0[NB_BINS_COMPRESSED_MATRIX_f0*NB_BYTES_BP1];
17 unsigned char LFR_BP2_f0[NB_BINS_COMPRESSED_MATRIX_f0*NB_BYTES_BP2];
24 unsigned char LFR_BP2_f0[NB_BINS_COMPRESSED_MATRIX_f0*NB_BYTES_BP2];
18
25
19 #endif // BASIC_PARAMETERS_UTILITIES_H
26 #endif // BASIC_PARAMETERS_UTILITIES_H
Show file before | Show file after | Hide comments
@@ -1,70 +1,72
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
2 // version 1.0: 31/07/2013
2 // version 1.0: 31/07/2013
3 // version 1.1: 02/04/2014
3 // version 1.1: 02/04/2014
4 // version 1.2: 30/04/2014
4 // version 1.2: 30/04/2014
5 // version 1.3: 02/05/2014
5 // version 1.3: 02/05/2014
6 // version 1.4: 16/05/2014
6 // version 1.4: 16/05/2014
7 // version 1.5: 20/05/2014
7 // version 1.5: 20/05/2014
8 // version 1.6: 19/12/2014
8 // version 1.6: 19/12/2014
9 // version 1.7: 15/01/2015 (modifs de Paul + correction erreurs qui se compensaient (LSB <=> MSB + indices [0,2] <=> [1,3])
10
9
11
10 #include "basic_parameters_utilities.h"
12 #include "basic_parameters_utilities.h"
11
13
12 int lecture_file_sm(const char *fileName)
14 int lecture_file_sm(const char *fileName)
13 {
15 {
14 int i;
16 int i;
15
17
16 FILE *infile;
18 FILE *infile;
17 infile = fopen(fileName, "rb"); // open explicitely a binary file !!! ...
19 infile = fopen(fileName, "rb"); // open explicitely a binary file !!! ...
18 if(infile == NULL) {
20 if(infile == NULL) {
19 printf("Hello I cannot open the file! \n");
21 printf("Hello I cannot open the file! \n");
20 return 0;
22 return 0;
21 }
23 }
22 (void) fread(compressed_spectral_matrix_f0, sizeof(compressed_spectral_matrix_f0), 1, infile);
24 (void) fread(compressed_spectral_matrix_f0, sizeof(compressed_spectral_matrix_f0), 1, infile);
23 (void) fclose(infile);
25 (void) fclose(infile);
24
26
25 printf("Compressed_spectral_matrix_f0 : \n");
27 printf("Compressed_spectral_matrix_f0 : \n");
26 printf("Number of bins: %d\n", NB_BINS_COMPRESSED_MATRIX_f0);
28 printf("Number of bins: %d\n", NB_BINS_COMPRESSED_MATRIX_f0);
27 printf("Number of values per spectral matrix: %d\n", NB_VALUES_PER_SPECTRAL_MATRIX);
29 printf("Number of values per spectral matrix: %d\n", NB_VALUES_PER_SPECTRAL_MATRIX);
28 printf("Size of compressed_spectral_matrix_f0 : %lu\n", sizeof(compressed_spectral_matrix_f0));
30 printf("Size of compressed_spectral_matrix_f0 : %lu\n", sizeof(compressed_spectral_matrix_f0));
29
31
30 for(i=0; i<NB_BINS_COMPRESSED_MATRIX_f0; i++){
32 for(i=0; i<NB_BINS_COMPRESSED_MATRIX_f0; i++){
31
33
32 printf("Bin number: %d\n", i);
34 printf("Bin number: %d\n", i);
33
35
34 printf("Element %.2d (S11) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 1, 0,
36 printf("Element %.2d (S11) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 1, 0,
35 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+0], 0.);
37 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+0], 0.);
36 printf("Element %.2d (S12) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 2, 1, 2,
38 printf("Element %.2d (S12) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 2, 1, 2,
37 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+1], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+2]);
39 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+1], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+2]);
38 printf("Element %.2d (S13) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 3, 3, 4,
40 printf("Element %.2d (S13) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 3, 3, 4,
39 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+3], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+4]);
41 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+3], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+4]);
40 printf("Element %.2d (S14) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 4, 5, 6,
42 printf("Element %.2d (S14) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 4, 5, 6,
41 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+5], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+6]);
43 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+5], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+6]);
42 printf("Element %.2d (S15) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 5, 7, 8,
44 printf("Element %.2d (S15) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 5, 7, 8,
43 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+7], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+8]);
45 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+7], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+8]);
44 printf("Element %.2d (S22) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 6, 9,
46 printf("Element %.2d (S22) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 6, 9,
45 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+9], 0.);
47 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+9], 0.);
46 printf("Element %.2d (S23) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 7, 10, 11,
48 printf("Element %.2d (S23) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 7, 10, 11,
47 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+10], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+11]);
49 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+10], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+11]);
48 printf("Element %.2d (S24) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 8, 12, 13,
50 printf("Element %.2d (S24) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 8, 12, 13,
49 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+12], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]);
51 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+12], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+13]);
50 printf("Element %.2d (S25) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 9, 14, 15,
52 printf("Element %.2d (S25) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 9, 14, 15,
51 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+14], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]);
53 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+14], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+15]);
52 printf("Element %.2d (S33) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 10, 16,
54 printf("Element %.2d (S33) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 10, 16,
53 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+16], 0.);
55 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+16], 0.);
54 printf("Element %.2d (S34) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 11, 17, 18,
56 printf("Element %.2d (S34) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 11, 17, 18,
55 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+17], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]);
57 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+17], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+18]);
56 printf("Element %.2d (S35) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 12, 19, 20,
58 printf("Element %.2d (S35) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 12, 19, 20,
57 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+19], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]);
59 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+19], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+20]);
58 printf("Element %.2d (S44) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 13, 21,
60 printf("Element %.2d (S44) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 13, 21,
59 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+21], 0.);
61 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+21], 0.);
60 printf("Element %.2d (S45) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 14, 22, 23,
62 printf("Element %.2d (S45) (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", 14, 22, 23,
61 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+22], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+23]);
63 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+22], compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+23]);
62 printf("Element %.2d (S55) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 15, 24,
64 printf("Element %.2d (S55) (%.2d & --) => Re:%16.8e Im:%16.8e\n", 15, 24,
63 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+24], 0.);
65 compressed_spectral_matrix_f0[i*NB_VALUES_PER_SPECTRAL_MATRIX+24], 0.);
64
66
65 }
67 }
66 return 0;
68 return 0;
67 }
69 }
68
70
69
71
70
72
Show file before | Show file after | Hide comments
@@ -1,15 +1,17
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
2 // version 1.0: 31/07/2013
2 // version 1.0: 31/07/2013
3 // version 1.1: 02/04/2014
3 // version 1.1: 02/04/2014
4 // version 1.2: 30/04/2014
4 // version 1.2: 30/04/2014
5 // version 1.3: 02/05/2014
5 // version 1.3: 02/05/2014
6 // version 1.4: 16/05/2014
6 // version 1.4: 16/05/2014
7 // version 1.5: 20/05/2014
7 // version 1.5: 20/05/2014
8 // version 1.6: 19/12/2014
8 // version 1.6: 19/12/2014
9 // version 1.7: 15/01/2015 (modifs de Paul + correction erreurs qui se compensaient (LSB <=> MSB + indices [0,2] <=> [1,3])
10
9
11
10 #ifndef FILE_UTILITIES_H
12 #ifndef FILE_UTILITIES_H
11 #define FILE_UTILITIES_H
13 #define FILE_UTILITIES_H
12
14
13 int lecture_file_sm(const char *fileName);
15 int lecture_file_sm(const char *fileName);
14
16
15 #endif // FILE_UTILITIES_H
17 #endif // FILE_UTILITIES_H
Show file before | Show file after | Hide comments
@@ -1,64 +1,67
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
1 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
2 // version 1.O: 31/07/2013
2 // version 1.O: 31/07/2013
3 // version 1.1: 02/04/2014
3 // version 1.1: 02/04/2014
4 // version 1.2: 30/04/2014
4 // version 1.2: 30/04/2014
5 // version 1.3: 02/05/2014
5 // version 1.3: 02/05/2014
6 // version 1.4: 16/05/2014
6 // version 1.4: 16/05/2014
7 // version 1.5: 20/05/2014
7 // version 1.5: 20/05/2014
8 // version 1.6: 19/12/2014
8 // version 1.6: 19/12/2014
9 // version 1.7: 15/01/2015 (modifs de Paul + correction erreurs qui se compensaient (LSB <=> MSB + indices [0,2] <=> [1,3])
10
9
11
10 #include <stdio.h>
12 #include <stdio.h>
11
13
12 #include "file_utilities.h"
14 #include "file_utilities.h"
13 #include "basic_parameters_utilities.h"
15 #include "basic_parameters_utilities.h"
14 #include "basic_parameters.h"
16 #include "basic_parameters.h"
15
17
16 int main(void)
18 int main(void)
17 {
19 {
18 const char *filename;
20 const char *filename;
19 printf("Hello World!\n\n");
21 printf("Hello World!\n\n");
20
22
21 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
23 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
22 //LSB FIRST
24 //LSB FIRST
23 printf("The multi-byte quantities are laid out in a LSB FIRST (little endian) fashion \n\n");
25 printf("The multi-byte quantities are laid out in a LSB FIRST (little endian) fashion \n\n");
24 #endif
26 #endif
25
27
26 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
28 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
27 //MSB FIRST
29 //MSB FIRST
28 printf("The multi-byte quantities are laid out in a MSB FIRST (big endian) fashion\n\n");
30 printf("The multi-byte quantities are laid out in a MSB FIRST (big endian) fashion\n\n");
29 #endif
31 #endif
30
32
31 //filename="/WIN/Users/chust/DD CHUST/Missions/Solar Orbiter/LFR/Prog C/tests bp Paul/tests2/sm_test2.dat";
33 filename="/WIN/Users/chust/DD CHUST/Missions/Solar Orbiter/LFR/Prog C/tests bp Paul/tests2/sm_test2.dat";
32 filename="sm_test2.dat";
33 lecture_file_sm(filename);
34 lecture_file_sm(filename);
34
35
35 init_k_coefficients(k_coefficients_f0, k_coefficients_f1, k_coefficients_f2);
36 init_k_coefficients(k_coefficients_f0, NB_BINS_COMPRESSED_MATRIX_f0);
37 init_k_coefficients(k_coefficients_f1, NB_BINS_COMPRESSED_MATRIX_f1);
38 init_k_coefficients(k_coefficients_f2, NB_BINS_COMPRESSED_MATRIX_f2);
36
39
37 printf("\n");
40 printf("\n");
38
41
39 BP1_set(compressed_spectral_matrix_f0, k_coefficients_f0, NB_BINS_COMPRESSED_MATRIX_f0, LFR_BP1_f0);
42 BP1_set(compressed_spectral_matrix_f0, k_coefficients_f0, NB_BINS_COMPRESSED_MATRIX_f0, LFR_BP1_f0);
40
43
41 printf("\n");
44 printf("\n");
42
45
43 BP2_set(compressed_spectral_matrix_f0, NB_BINS_COMPRESSED_MATRIX_f0, LFR_BP2_f0);
46 BP2_set(compressed_spectral_matrix_f0, NB_BINS_COMPRESSED_MATRIX_f0, LFR_BP2_f0);
44
47
45 return 0;
48 return 0;
46 }
49 }
47
50
48
51
49
52
50
53
51
54
52
55
53
56
54
57
55
58
56
59
57
60
58
61
59
62
60
63
61
64
62
65
63
66
64
67
General Comments 0
You need to be logged in to leave comments. Login now