A sphere with three ocean waves in differing shades of blue. Next to the sphere, there is the bolded text "Ocean Color". Under that, there are two acronyms, separated by a vertical pipe: OB.DAAC (Ocean Biology Distributed Active Archive Center) and OBPG (Ocean Biology Processing Group). Lorem ipsum dolor sit amet
NASA Logo
Ocean Color Science Software

ocssw V2022
mng_ms.cpp
Go to the documentation of this file.
1 /*
2  * mng_ms.cpp - take over the management of the large multi-scattering
3  * reflectance arrays for the cloud processing
4  * W Robinson, SAIC, 17 Dec 2021
5  */
6 #include <string.h>
7 #include <netcdf.h>
8 //#include "mfhdf.h"
9 #include "dim_mgr.hpp"
10 #include "passthebuck.h"
11 
12 struct ms_finfo_struc_def
13  {
14  int fid_ms; /* fid of MS table file */
15  int fid_ms_std; /* fid of MS std file (for files over water */
16  int sds_id; /* the SDS id refl table */
17  int sds_id_std; /* the SDS id refl SD table */
18  int32_t *dim_siz; /* array of dim sizes */
19  double **dim_vals; /* arrays of each dim value set */
20  };
21 typedef struct ms_finfo_struc_def ms_finfo_struc;
22 
23 ms_finfo_struc wtrcld_landsfc_info, icecld_landsfc_info;
24 // for the water surface
25 ms_finfo_struc wtrcld_wtrsfc_info[3], icecld_wtrsfc_info[3];
26 
27 dim_mgr land_mgr( 3, 83 ); /* manage separately for over water, land */
28 dim_mgr wtr_mgr( 3, 83 );
29 
30 // storage for the size of each reflectance / sd table size
31 // the water has 18 radii and the ice has 12
32 int32_t wtrcld_nelts, icecld_nelts; // size of water, ice cloud arrays
33 
34 /*
35  * mng_ms_init - start the management of the large tables
36  */
37 /*******************************************************************
38  mng_ms_init_ initialize the management of the large cloud multi-scatering
39  reflectance arrays
40 
41  Returns:
42  int32_t - nothing at the moment
43 
44  Parameters: (in calling order)
45  Type Name I/O Description
46  ---- ---- --- -----------
47  char * fil_wtrcld_landsfc I file name for water cloud
48  land sfc arrays
49  char * fil_icecld_landsfc I file name for ice cloud
50  land sfc arrays
51  int len1 I length of 1st char *
52  int len2 I length of 2nd char *
53  The above is for 2 land surface files and their lengths
54  The rest are the files for the water surface and the lengths after
55  them all (a fortran convention). below, I'll just list the file names
56  and their lengths same types as above
57  file name length Description
58  ----------------------- ---------- -----------------------------
59  fil_wtrcld_landsfc len1 water cloud, land sfc
60  fil_icecld_landsfc len2 ice cloud, land sfc
61  fil_wtrcld_wtrsfc1 len_ww1 water cloud, water sfc wind1
62  fil_wtrcld_wtrsfc1_sd len_ww1sd water cloud, water sfc wind1 sd
63  fil_icecld_wtrsfc1 len_iw1 ice cloud, water sfc wind1
64  fil_icecld_wtrsfc1_sd len_iw1sd ice cloud, water sfc wind1 sd
65  fil_wtrcld_wtrsfc2 len_ww2 water cloud, water sfc wind2
66  fil_wtrcld_wtrsfc2_sd len_ww2sd water cloud, water sfc wind2 sd
67  fil_icecld_wtrsfc2 len_iw2 ice cloud, water sfc wind2
68  fil_icecld_wtrsfc2_sd len_iw2sd ice cloud, water sfc wind sd
69  fil_wtrcld_wtrsfc3 len_ww3 water cloud, water sfc wind3
70  fil_wtrcld_wtrsfc3_sd len_ww3sd water cloud, water sfc wind3 sd
71  fil_icecld_wtrsfc3 len_iw3 ice cloud, water sfc wind3
72  fil_icecld_wtrsfc3_sd len_iw3sd ice cloud, water sfc wind3 sd
73 
74 ********************************************************************/
75 extern"C" int32_t mng_ms_init_( char *fil_wtrcld_landsfc,
76  char *fil_icecld_landsfc,
77  char *fil_wtrcld_wtrsfc1, char *fil_wtrcld_wtrsfc1_sd,
78  char *fil_icecld_wtrsfc1, char *fil_icecld_wtrsfc1_sd,
79  char *fil_wtrcld_wtrsfc2, char *fil_wtrcld_wtrsfc2_sd,
80  char *fil_icecld_wtrsfc2, char *fil_icecld_wtrsfc2_sd,
81  char *fil_wtrcld_wtrsfc3, char *fil_wtrcld_wtrsfc3_sd,
82  char *fil_icecld_wtrsfc3, char *fil_icecld_wtrsfc3_sd,
83  int len1, int len2, int len_ww1, int len_ww1sd, int len_iw1, int len_iw1sd,
84  int len_ww2, int len_ww2sd, int len_iw2, int len_iw2sd,
85  int len_ww3, int len_ww3sd, int len_iw3, int len_iw3sd )
86  {
87  char *fn, *fn2;
88  char *ftn_str_cond( char *, int );
89  int32_t status;
90  int32_t set_ms_file( char *, char *, int32_t , ms_finfo_struc * );
91 
92  /* set up the water and ice cloud over land file table info */
93  fn = ftn_str_cond( fil_wtrcld_landsfc, len1 );
94  set_ms_file( fn, NULL, 0, &wtrcld_landsfc_info );
95  free( fn );
96 
97  fn = ftn_str_cond( fil_icecld_landsfc, len2 );
98  set_ms_file( fn, NULL, 0, &icecld_landsfc_info );
99  free( fn );
100 
101  /* make sure the first 5 dims, less radius, are equal
102  Also, set up the # elements for ice, water in the last 3 dims */
103  status = 0;
104  wtrcld_nelts = wtrcld_landsfc_info.dim_siz[3] + 1; // for tau
105  icecld_nelts = icecld_landsfc_info.dim_siz[3] + 1;
106  for( int idim = 0; idim < 6; idim++ )
107  {
108  if( ( idim != 5 ) && ( wtrcld_landsfc_info.dim_siz[idim] !=
109  icecld_landsfc_info.dim_siz[idim] ) )
110  {
111  status = 1;
112  printf( "%s, %d, E: Water and ice cloud over land dimension mismatch\n",
113  __FILE__, __LINE__ );
114  printf( " file_water: %s\n", fil_wtrcld_landsfc );
115  printf( " file_ice : %s\n", fil_icecld_landsfc );
116  }
117  // set up the size of the water and ice # elements,
118  // that will go in the data blob
119  if( idim > 3 ) // for band and radius
120  {
121  wtrcld_nelts *= wtrcld_landsfc_info.dim_siz[idim];
122  icecld_nelts *= icecld_landsfc_info.dim_siz[idim];
123  }
124  }
125  if( status != 0 ) exit(27);
126 
127 /*
128  * setup the water and ice cloud over water surface tables
129  * loop through all 3 water surface types (3, 7, 15 m/s), get the SDS IDs
130  * and check consostency of dims with over-land info
131  */
132  status = 0;
133  for( int32_t isfc = 0; isfc < 3; isfc++ )
134  {
135  if( isfc == 0 ) {
136  fn = ftn_str_cond( fil_wtrcld_wtrsfc1, len_ww1 );
137  fn2 = ftn_str_cond( fil_wtrcld_wtrsfc1_sd, len_ww1sd );
138  } else if( isfc == 1 ) {
139  fn = ftn_str_cond( fil_wtrcld_wtrsfc2, len_ww2 );
140  fn2 = ftn_str_cond( fil_wtrcld_wtrsfc2_sd, len_ww2sd );
141  } else if( isfc == 2 ) {
142  fn = ftn_str_cond( fil_wtrcld_wtrsfc3, len_ww3 );
143  fn2 = ftn_str_cond( fil_wtrcld_wtrsfc3_sd, len_ww3sd );
144  }
145  set_ms_file( fn, fn2, 1, &wtrcld_wtrsfc_info[isfc] );
146  free( fn );
147  free( fn2 );
148 
149  if( isfc == 0 ) {
150  fn = ftn_str_cond( fil_icecld_wtrsfc1, len_iw1 );
151  fn2 = ftn_str_cond( fil_icecld_wtrsfc1_sd, len_iw1sd );
152  } else if( isfc == 1 ) {
153  fn = ftn_str_cond( fil_icecld_wtrsfc2, len_iw2 );
154  fn2 = ftn_str_cond( fil_icecld_wtrsfc2_sd, len_iw2sd );
155  } else if( isfc == 2 ) {
156  fn = ftn_str_cond( fil_icecld_wtrsfc3, len_iw3 );
157  fn2 = ftn_str_cond( fil_icecld_wtrsfc3_sd, len_iw3sd );
158  }
159  set_ms_file( fn, fn2, 1, &icecld_wtrsfc_info[isfc] );
160  free( fn );
161  free( fn2 );
162 
163  for( int idim = 0; idim < 6; idim++ )
164  {
165  if( ( ( idim == 3 ) && ( wtrcld_wtrsfc_info[isfc].dim_siz[idim] !=
166  wtrcld_landsfc_info.dim_siz[idim] + 1 ) )
167  || ( ( idim != 3 ) && (wtrcld_wtrsfc_info[isfc].dim_siz[idim] !=
168  wtrcld_landsfc_info.dim_siz[idim] ) ) )
169  {
170  status = 1;
171  printf(
172  "%s, %d, E: water cloud over-water MS file dimension mismatch\n",
173  __FILE__, __LINE__ );
174  printf( " dim # %d, water sfc # %d\n", idim, isfc );
175  }
176  if( status != 0 ) exit(27);
177 
178  if( ( ( idim == 3 ) && ( icecld_wtrsfc_info[isfc].dim_siz[idim] !=
179  icecld_landsfc_info.dim_siz[idim] + 1 ) )
180  || ( ( idim != 3 ) && (icecld_wtrsfc_info[isfc].dim_siz[idim] !=
181  icecld_landsfc_info.dim_siz[idim] ) ) )
182  {
183  status = 1;
184  printf(
185  "%s, %d, E: ice cloud over-water MS file dimension mismatch\n",
186  __FILE__, __LINE__ );
187  printf( " dim # %d, water sfc # %d\n", idim, isfc );
188  }
189  if( status != 0 ) exit(27);
190  }
191  }
192  /* set up the dimension manager for points over land */
193  //dim_mgr land_mgr( 3, 80 );
194  for( int idim = 0; idim < 3; idim++ )
195  {
196  land_mgr.init_dim( idim, wtrcld_landsfc_info.dim_siz[idim],
197  wtrcld_landsfc_info.dim_vals[idim] );
198  wtr_mgr.init_dim( idim, wtrcld_wtrsfc_info[0].dim_siz[idim],
199  wtrcld_wtrsfc_info[0].dim_vals[idim] );
200  }
201 
202  return 0;
203  }
204 
205 /********************************************************************
206  ftn_str_cond - Just condition a string to be null terminated
207 
208  Returns:
209  char * the good null terminated astring
210  Parameters: (in calling order)
211  Type Name I/O Description
212  ---- ---- --- -----------
213  char * str I initial fortran string
214  int len I string length
215 ********************************************************************/
216 extern"C" char *ftn_str_cond( char *str, int len )
217  {
218  char *fn;
219 
220  fn = (char *) malloc( ( len + 1 ) * sizeof( char ) );
221  strncpy( fn, str, len );
222  fn[ len ] = (char) 0;
223  return fn;
224  }
225 
226 extern"C" int32_t set_ms_file( char *fil_ms, char *fil_ms_std, int32_t fil_typ,
227  ms_finfo_struc *finfo )
228 /*******************************************************************
229 
230  set_ms_file - set up all the info for the multi-scattering file table
231 
232  Returns type: int - size of dimension or -1 if problem
233 
234  Parameters: (in calling order)
235  Type Name I/O Description
236  ---- ---- --- -----------
237  char * fil_ms I name of multi-scatering file
238  char * fil_ms_std I name of multi-scatering std
239  file
240  int32_t fil_typ I 0 for a land surface file
241  (has the MS and MSstd tables, 1 for the
242  water surface files (each file has the MS or MSstd)
243  ms_finfo_struc * finfo O all information of the file(s)
244 
245  Modification history:
246  Programmer Date Description of change
247  ---------- ---- ---------------------
248  W. Robinson 20 Dec 2017 original development
249 
250 *******************************************************************/
251  {
252  int rank, dim_id_lst[7], nattr, ret1, vtyp;
253  size_t dim_lens[7];
254  int sds_id;
255  size_t start[7], end[7];
256  int32_t trg_rank = 6;
257  float *fstore;
258 
259  char *dim_sds_names[] = { "ReflectanceSensorZenith", "ReflectanceSolarZenith",
260  "ReflectanceRelativeAzimuth", "OpticalThickness", "Wavelengths",
261  "ParticleRadius" };
262 
263  /*
264  * open the file and get the refl array SDS ID
265  */
266  // finfo->fid_ms = SDstart( fil_ms, DFACC_READ );
267  DPTB( nc_open( fil_ms, NC_NOWRITE, &(finfo->fid_ms) ) );
268  //finfo->sds_id = SDselect( finfo->fid_ms, SDnametoindex( finfo->fid_ms,
269  // "MultiScatBDReflectance" ) );
270  DPTB( nc_inq_varid( finfo->fid_ms, "MultiScatBDReflectance",
271  &(finfo->sds_id) ) );
272 
273  //SDgetinfo( finfo->sds_id, bl_nam, &rank, dim_lens, &vtyp, &nattr );
274  DPTB( nc_inq_var( finfo->fid_ms, finfo->sds_id, NULL, &vtyp, &rank,
275  dim_id_lst, &nattr ) );
276 
277  if( rank != trg_rank )
278  {
279  printf( "E: %s, %d: MS refl in cloud table file has wrong size\n",
280  __FILE__, __LINE__ );
281  printf( " file: %s", fil_ms );
282  printf( " SDS: MultiScatBDReflectance\n" );
283  exit(27);
284  }
285  /*
286  * get dim lengths
287  */
288  for( int i = 0; i < rank; i++ )
289  DPTB( nc_inq_dimlen( finfo->fid_ms, dim_id_lst[i], dim_lens + i ) );
290  /*
291  * for the wind-dependent tables, the SD is in separate file
292  */
293  if( fil_typ == 0 )
294  finfo->fid_ms_std = finfo->fid_ms;
295  else
296  DPTB( nc_open( fil_ms_std, NC_NOWRITE, &(finfo->fid_ms_std) ) );
297  //finfo->fid_ms_std = SDstart( fil_ms_std, DFACC_READ );
298  /*
299  * get the Std Dev SDS ID
300  */
301  //finfo->sds_id_std = SDselect( finfo->fid_ms_std,
302  // SDnametoindex( finfo->fid_ms_std, "StdDevMultiScatBDReflectance" ) );
303  DPTB( nc_inq_varid( finfo->fid_ms_std, "StdDevMultiScatBDReflectance",
304  &(finfo->sds_id_std) ) );
305 
306  //SDgetinfo( finfo->sds_id_std, bl_nam, &rank, dim_lens2, &vtyp, &nattr );
307  DPTB( nc_inq_var( finfo->fid_ms_std, finfo->sds_id_std, NULL, &vtyp, &rank,
308  dim_id_lst, &nattr ) );
309 
310  if( rank != trg_rank )
311  {
312  printf( "E: %s, %d: MS refl std in cloud table file has wrong size\n",
313  __FILE__, __LINE__ );
314  printf( " file: %s", fil_ms );
315  printf( " SDS: StdMultiScatBDReflectance\n" );
316  exit(27);
317  }
318  /* Note that the data in the file is float and we are putting it into
319  double, so some translation will be needed */
320  finfo->dim_siz = (int32_t *) malloc( trg_rank * sizeof( int32_t ) );
321  finfo->dim_vals = ( double **) malloc( trg_rank * sizeof( double * ) );
322 
323  /*
324  * get information for all 6 dimensions
325  */
326  for( int32_t isds = 0; isds < 6; isds++ )
327  {
328  if( nc_inq_varid( finfo->fid_ms, dim_sds_names[isds], &sds_id )
329  != NC_NOERR )
330  {
331  printf( "E: %s, %d: Can't read table SDS %s\n", __FILE__, __LINE__,
332  dim_sds_names[isds] );
333  exit(26);
334  }
335  //SDgetinfo( sds_id, bl_nam, &rank, dim_lens2, &vtyp, &nattr );
336  DPTB( nc_inq_var( finfo->fid_ms, sds_id, NULL, &vtyp, &rank,
337  dim_id_lst, &nattr ) );
338  DPTB( nc_inq_dimlen( finfo->fid_ms, dim_id_lst[0], dim_lens ) );
339 
340  finfo->dim_siz[isds] = dim_lens[0];
341  finfo->dim_vals[isds] = (double *) malloc( dim_lens[0] * sizeof(double) );
342  fstore = (float *) malloc( dim_lens[0] * sizeof(float) );
343  start[0] = 0;
344  end[0] = dim_lens[0];
345  //ret1 = SDreaddata( sds_id, start, NULL, end, (float *)fstore );
346  ret1 = nc_get_vara_float( finfo->fid_ms, sds_id, start, end,
347  (float *)fstore );
348  if( ret1 != NC_NOERR )
349  {
350  printf( "E: %s, %d: Can't read table SDS %s\n", __FILE__, __LINE__,
351  dim_sds_names[isds] );
352  exit(26);
353  }
354  for( size_t ipx = 0; ipx < end[0]; ipx++ )
355  finfo->dim_vals[isds][ipx] = *(fstore + ipx );
356  free( fstore );
357  //ret2 = SDendaccess( sds_id );
358  }
359  return 0;
360  }
361 
362 /* the next is the retrieval of data side. It will have a part to get the
363  structure defining the set of data grid points and the weights to apply
364  And, a part to make the particular interpolated array requested
365 */
366 
367 extern"C" int mng_ms_get_lib_( float *sol_ang, float *sen_ang,
368  float *relaz_ang, int *sfc_typ, int *meas_typ, int *scan, float *wtr_int,
369  float *ice_int, int *stat )
370 /*******************************************************************
371 
372  mng_ms_get_lib - get the portion of the MS reflectance library
373  interpolated to the solar, sensor and relative azimuth angles
374 
375  Returns type: int - 0 good, otherwise an error
376  Note that in th ecase where the point is outside the table, a 2 status
377  is returned ans will be handled by making the final table all 0,
378  hopefully that will just make for fill values in cloud quantities
379  dealing with the calling code is horrendous.
380 
381  Parameters: (in calling order)
382  Type Name I/O Description
383  ---- ---- --- -----------
384  float * sol_ang I solar angle
385  float * sen_ang I sensor angle
386  float * relaz_ang I relative azimuth angle
387  int * sfc_typ I underlying surface type:
388  0 - land, 1 - water, 3 m/s
389  wind, 2 - water, 7 m/s,
390  3 - water, 15 m/s
391  int * meas_typ I measurement type to return:
392  0 - reflectance, 1 - Std Dev
393  int * scan I current scan line, use as
394  access id
395  float * wtr_int O interpolated water array
396  float * ice_int O interpolated ice array
397  int * stat O status - 0 is good, 5 is out
398  of table bounds
399 
400  Modification history:
401  Programmer Date Description of change
402  ---------- ---- ---------------------
403  W. Robinson 23 Dec 2021 original development
404 
405 NOTE - organization of data blobs
406 position
407  1 - reflectance wtrcld size wtrcld_nelts
408  2 - SD wtrcld size wtrcld_nelts
409  3 - reflectance icecld size icecld_nelts
410  2 - SD icecld size icecld_nelts
411  This repeats 2 more for the water surface arrays
412 
413 *******************************************************************/
414  {
415  /* follow the test program for dim_mgr */
416  /* */
417  int32_t access_id;
418  //static pt_info_struc *pt_info;
419  pt_info_struc *pt_info;
420  double pt[3];
421  int32_t status, ndat;
422  int32_t nsfc; // nsfc will be for the # of surface types (1 land, 3 water)
423  int32_t narr = 4; // # of arrays to get out from the wtrcld, wtrcld_sd,
424  // icecld, icecld_sd SDSes
425  int32_t ndim = 3, off_wtr, off_ice;
426  int32_t ntau, ntau1, nwav, nrad_wtr, nrad_ice, nrad;
427  static int32_t prune_called = 0;
428 
429  // ntau1 represents ntau + 1 the size in tau of the final storage
430  // the over-water data has ntau+1 while the over-land has ntau
431  // its just the (odd) way the cloud code, files were set up
432 
433  // WDR temp to report the points managed when the access_id changes
434  /* leave out normally */
435 //printf( "%s, %d, SCAN: %d\n", __FILE__, __LINE__, *scan );
436  //if( ( *scan % 20 ) == 19 )
437 /*
438  if( *scan == 300 )
439  {
440  double way = 0.;
441  printf( "%s, %d, LAND MANAGER DUMP\n", __FILE__, __LINE__ );
442  land_mgr.dump_mgr( &way );
443  //printf( "%s, %d, WATER MANAGER DUMP\n", __FILE__, __LINE__ );
444  // no need wtr_mgr.dump_mgr( &way );
445  exit( 0 );
446  }
447  */
448  // WDR end of the probe of points
449 
450  // WDR add the prune, every 200 lines prune all 100 less than current line
451  if( ( *scan % 200 ) == 199 )
452  //if( ( *scan % 300 ) == 299 )
453  {
454  if( prune_called == 0 )
455  {
456  //double way = 0.;
457  //printf( "LAND MANAGER DUMP PRE, scan %d\n", *scan );
458  //land_mgr.dump_mgr( &way );
459  //printf( "WATER MANAGER DUMP PRE, scan %d\n", *scan );
460  //wtr_mgr.dump_mgr( &way );
461  land_mgr.prune( *scan - 100 );
462  wtr_mgr.prune( *scan - 100 );
463  prune_called = 1;
464  //printf( "LAND MANAGER DUMP POST, scan %d\n", *scan );
465  //land_mgr.dump_mgr( &way );
466  }
467  }
468  else
469  prune_called = 0;
470 
471  access_id = *scan;
472  ndat = pow( 2, ndim );
473  // Note that the organization is senz, solz, relaz
474  pt[0] = *sen_ang;
475  pt[1] = *sol_ang;
476  pt[2] = *relaz_ang;
477 
478  // do over-land and over-water separately - no need to read land table
479  // over water or visa-versa
480  if( *sfc_typ == 0 ) // a request for over-land table data
481  {
482  pt_info = land_mgr.mng_pt( pt, access_id, &status );
483  nsfc = 1;
484  }
485  else
486  {
487  pt_info = wtr_mgr.mng_pt( pt, access_id, &status );
488  nsfc = 3;
489  }
490 
491  if( status != 0 )
492  {
493  // trying to deal with exceptions in the calling code is a mess
494  // so the error 2 will end up returning an unfilled table
495  if( status == 2 ) // out of table bounds
496  {
497  *stat = 5;
498  return 5;
499  }
500  printf( "%s, %d: mng_ms_get_lib error found of %d\n", __FILE__,
501  __LINE__, status );
502  exit( 27 );
503  }
504  else
505  {
506  ntau = wtrcld_landsfc_info.dim_siz[3];
507  ntau1 = ntau + 1;
508  nwav = wtrcld_landsfc_info.dim_siz[4];
509  nrad_wtr = wtrcld_landsfc_info.dim_siz[5];
510  nrad_ice = icecld_landsfc_info.dim_siz[5];
511 
512  if( pt_info->interval_needs_data == 1 )
513  {
514  /* we need to read data for some of the grid points in the interval */
515  int32_t n_new_blobs = 0;
516  int32_t offset[3], arr_off, tau_off;
517  int tsds_id, tfil_id;
518  /* set-up for the use of MS arrays symmetric in senz / solz */
519  double *senz_set = &( wtrcld_landsfc_info.dim_vals[0][0] );
520  double *solz_set = &( wtrcld_landsfc_info.dim_vals[1][0] );
521  int32_t n_senz = wtrcld_landsfc_info.dim_siz[0];
522  int32_t n_solz = wtrcld_landsfc_info.dim_siz[1];
523  int32_t i;
524  double grid_senz, grid_solz;
525  /* end */
526  size_t istart[6] = { 0, 0, 0, 0, 0, 0 };
527  size_t icount[6] = { 1, 1, 1, (size_t)ntau, (size_t)nwav,
528  (size_t)nrad_wtr };
529  if( *sfc_typ != 0 ) icount[3] = ntau1;
530 
531  for( int32_t idat = 0; idat < ndat; idat++ ) // loop interval corners
532  {
533  if( pt_info->pt_status[idat] == -1 )
534  {
535  n_new_blobs++;
536  /* do the read, reorg, store in struc and deposit in
537  a data blob pointer, use calloc to avoid needing to zero
538  the array for a particular tau index that changes */
539  float *dat_blob = (float *)calloc( ( wtrcld_nelts * 2 +
540  icecld_nelts * 2 ) * nsfc, sizeof(float) );
541  linear_to_offset( ndim, idat, offset );
542  for( int32_t idim = 0; idim < 3; idim++ )
543  istart[idim] = pt_info->pt_base_loc[idim] + offset[idim];
544 
545  // to use only part of MS tables where solz <= senz
546  grid_senz = senz_set[ istart[0] ];
547  grid_solz = solz_set[ istart[1] ];
548  if( grid_senz < grid_solz )
549  // for removing the flip if( 0 )
550  {
551  for( i = 0; i < n_solz; i++ )
552  {
553  if( solz_set[i] == grid_senz )
554  {
555  istart[1] = i;
556  break;
557  }
558  }
559  for( i = 0; i < n_senz; i++ )
560  {
561  if( senz_set[i] == grid_solz )
562  {
563  istart[0] = i;
564  break;
565  }
566  }
567  }
568  else {
569  //printf( "not a flip\n" );
570  }
571 // just re-set the istart to see if intervening code has any effect
572  //for( int32_t idim = 0; idim < 3; idim++ )
573  // istart[idim] = pt_info->pt_base_loc[idim] + offset[idim];
574 
575  // loop thru the nsfc surface types (3 for water sfc, 1 for land
576  for( int32_t isfc = 0; isfc < nsfc; isfc++ )
577  {
578  // loop thru the arrays to fill the data blob, do - 4 of them
579  // per surface: wtrcld ref, sd, icecld ref, sd (etc for more sfc)
580  for( int32_t iarr = 0; iarr < narr; iarr++ )
581  {
582  nrad = nrad_wtr;
583  tau_off = 0; /* for land sfc: is 0 to transfer data to tau
584  dim of blob starting at 0, 1 to start at
585  1 for the SD (to get expected arrays)
586  for wtr sfc: is always 0 */
587  if( *sfc_typ == 0 ) // the land sfc tables are 1 way
588  {
589  switch (iarr)
590  {
591  case 0: // water cloud refl
592  tsds_id = wtrcld_landsfc_info.sds_id;
593  tfil_id = wtrcld_landsfc_info.fid_ms;
594  arr_off = 0;
595  break;
596  case 1: // water cloud SD
597  tsds_id = wtrcld_landsfc_info.sds_id_std;
598  tfil_id = wtrcld_landsfc_info.fid_ms_std;
599  arr_off = wtrcld_nelts;
600  tau_off = 1;
601  break;
602  case 2: // ice cloud refl
603  tsds_id = icecld_landsfc_info.sds_id;
604  tfil_id = icecld_landsfc_info.fid_ms;
605  arr_off = 2 * wtrcld_nelts;
606  nrad = nrad_ice;
607  break;
608  case 3: // ice cloud SD
609  tsds_id = icecld_landsfc_info.sds_id_std;
610  tfil_id = icecld_landsfc_info.fid_ms_std;
611  arr_off = 2 * wtrcld_nelts + icecld_nelts;
612  nrad = nrad_ice;
613  tau_off = 1;
614  break;
615  }
616  }
617  else // the water surface tables are another way
618  {
619  tau_off = 0;
620  switch (iarr)
621  {
622  case 0: // water cloud refl
623  tsds_id = wtrcld_wtrsfc_info[isfc].sds_id;
624  tfil_id = wtrcld_wtrsfc_info[isfc].fid_ms;
625  arr_off = isfc * 2 * ( wtrcld_nelts + icecld_nelts );
626  break;
627  case 1: // water cloud SD
628  tsds_id = wtrcld_wtrsfc_info[isfc].sds_id_std;
629  tfil_id = wtrcld_wtrsfc_info[isfc].fid_ms_std;
630  arr_off = wtrcld_nelts +
631  isfc * 2 * ( wtrcld_nelts + icecld_nelts );
632  break;
633  case 2: // ice cloud refl
634  tsds_id = icecld_wtrsfc_info[isfc].sds_id;
635  tfil_id = icecld_wtrsfc_info[isfc].fid_ms;
636  arr_off = 2 * wtrcld_nelts +
637  isfc * 2 * ( wtrcld_nelts + icecld_nelts );
638  nrad = nrad_ice;
639  break;
640  case 3: // ice cloud SD
641  tsds_id = icecld_wtrsfc_info[isfc].sds_id_std;
642  tfil_id = icecld_wtrsfc_info[isfc].fid_ms_std;
643  arr_off = 2 * wtrcld_nelts + icecld_nelts +
644  isfc * 2 * ( wtrcld_nelts + icecld_nelts );
645  nrad = nrad_ice;
646  break;
647  }
648  }
649  icount[5] = nrad;
650  /* read from the file */
651  int32_t ntau_mod = ( *sfc_typ == 0 ) ? ntau : ntau1;
652  float *tmp_dat = (float *)malloc( ntau_mod * nwav * nrad *
653  sizeof(float) );
654  //if( status = ( SDreaddata( tsds_id, istart, NULL, icount,
655  // (void *)tmp_dat ) ) != SUCCEED )
656  if( status = nc_get_vara_float( tfil_id, tsds_id, istart, icount,
657  tmp_dat ) != NC_NOERR )
658  {
659  printf(
660  "E: %s, %d, Read of cloud table data failed with status: %d\n",
661  __FILE__, __LINE__, status );
662  exit(27);
663  }
664  /* transfer water ref to data blob */
665  for( int32_t irad = 0; irad < nrad; irad++ )
666  {
667  for( int32_t iwav = 0; iwav < nwav; iwav++ )
668  {
669  // for water sfc, they have 1 more tau, so the setting 0
670  // not needed
671  if( *sfc_typ == 0 ) // = land, do this stuff
672  {
673  for( int32_t itau = 0; itau < ntau; itau++ )
674  {
675  *( dat_blob + arr_off + ( itau + tau_off ) + ntau1 *
676  ( iwav + nwav * irad ) ) =
677  *( tmp_dat + irad + nrad * ( iwav + nwav * itau ) );
678  }
679  }
680  else // - water surface, it has a 0 tau in the sds
681  {
682  for( int32_t itau = 0; itau < ntau + 1; itau++ )
683  {
684  *( dat_blob + arr_off + itau + ntau1 *
685  ( iwav + nwav * irad ) ) =
686  *( tmp_dat + irad + nrad * (iwav + nwav * itau ) );
687  }
688  }
689  }
690  }
691  free(tmp_dat);
692  }
693  }
694  /* place data blob pointer into the pt_info */
695  pt_info->dat_ptrs[idat] = (void *)dat_blob;
696  /* set status of the point to say data is there */
697  pt_info->pt_status[idat] = 1;
698  }
699  }
700 
701  /* update knowlege of point status and data location */
702 //printf( "%s %d, before update, sfc type: %d\n", __FILE__, __LINE__, *sfc_typ );
703  if( *sfc_typ == 0 ) // over land
704  {
705  land_mgr.update_new_data( );
706  land_mgr.add_pts( n_new_blobs );
707  }
708  else
709  {
710  wtr_mgr.update_new_data( );
711  wtr_mgr.add_pts( n_new_blobs );
712  }
713  }
714 
715  /* at this point, go through the interval grid points and weight the
716  proper data and sum to the interpolated array */
717  // NOTE - this assumes the interpolated array is ZERO on input
718  int32_t sfc_typ_mult [] = { 0, 0, 1, 2 };
719  int32_t sfc_typ_off = 2 * ( wtrcld_nelts + icecld_nelts );
720 
721  if( *meas_typ == 0 ) // refl
722  {
723  off_wtr = 0 + sfc_typ_mult[*sfc_typ] * sfc_typ_off;
724  off_ice = 2 * wtrcld_nelts + sfc_typ_mult[*sfc_typ] * sfc_typ_off;
725  }
726  else // SD
727  {
728  off_wtr = wtrcld_nelts + sfc_typ_mult[*sfc_typ] * sfc_typ_off;
729  off_ice = 2 * wtrcld_nelts + icecld_nelts +
730  sfc_typ_mult[*sfc_typ] * sfc_typ_off;
731  }
732  for( int idat = 0; idat < ndat; idat++ )
733  {
734  // this is just for doc, may go soon
735  //printf( "%s, %d, for interval at point %d, weight: %f\n", __FILE__,
736  // __LINE__, idat, pt_info->wt_pt[idat] );
737  for( int32_t itau = 0; itau < ntau1; itau++ )
738  {
739  for( int32_t iwav = 0; iwav < nwav; iwav++ )
740  {
741  for( int32_t irad = 0; irad < nrad_wtr; irad++ )
742  {
743  *( wtr_int + itau + ntau1 * ( iwav + nwav * irad ) ) +=
744  pt_info->wt_pt[idat] *
745  *( (float *)pt_info->dat_ptrs[idat] + off_wtr + itau + ntau1 *
746  ( iwav + nwav * irad ) );
747  }
748 
749  for( int32_t irad = 0; irad < nrad_ice; irad++ )
750  {
751  *( ice_int + itau + ntau1 * ( iwav + nwav * irad ) ) +=
752  pt_info->wt_pt[idat] *
753  *( (float *)pt_info->dat_ptrs[idat] + off_ice + itau + ntau1 *
754  ( iwav + nwav * irad ) );
755  }
756  }
757  }
758  }
759  }
760  /* at the end... */
761  //printf( "I %s, %d, interval loc: %d, %d, %d\n", __FILE__, __LINE__, pt_info->pt_base_loc[0], pt_info->pt_base_loc[1], pt_info->pt_base_loc[2] );
762  return 0;
763  }
dim_mgr::init_dim
int32_t init_dim(int32_t, int32_t, double *)
Definition: dim_mgr.cpp:172
wtrcld_nelts
int32_t wtrcld_nelts
Definition: mng_ms.cpp:32
pt_info_struc::dat_ptrs
void ** dat_ptrs
Definition: dim_mgr.hpp:70
ms_finfo_struc_def::sds_id_std
int sds_id_std
Definition: mng_ms.cpp:17
icecld_landsfc_info
ms_finfo_struc icecld_landsfc_info
Definition: mng_ms.cpp:23
status
int status
Definition: l1_czcs_hdf.c:32
dim_mgr
Definition: dim_mgr.hpp:79
ms_finfo_struc_def
Definition: mng_ms.cpp:12
mng_ms_init_
int32_t mng_ms_init_(char *fil_wtrcld_landsfc, char *fil_icecld_landsfc, char *fil_wtrcld_wtrsfc1, char *fil_wtrcld_wtrsfc1_sd, char *fil_icecld_wtrsfc1, char *fil_icecld_wtrsfc1_sd, char *fil_wtrcld_wtrsfc2, char *fil_wtrcld_wtrsfc2_sd, char *fil_icecld_wtrsfc2, char *fil_icecld_wtrsfc2_sd, char *fil_wtrcld_wtrsfc3, char *fil_wtrcld_wtrsfc3_sd, char *fil_icecld_wtrsfc3, char *fil_icecld_wtrsfc3_sd, int len1, int len2, int len_ww1, int len_ww1sd, int len_iw1, int len_iw1sd, int len_ww2, int len_ww2sd, int len_iw2, int len_iw2sd, int len_ww3, int len_ww3sd, int len_iw3, int len_iw3sd)
Definition: mng_ms.cpp:75
NULL
#define NULL
Definition: decode_rs.h:63
wtrcld_wtrsfc_info
ms_finfo_struc wtrcld_wtrsfc_info[3]
Definition: mng_ms.cpp:25
scan
MOD_PR01 Production producing one five minute granule of output data in each run It can be configured to produce as many as three five minute granules per run Each execution with one construction record and one date file for each dataset In normal these are created by which splits them out of the hour datasets For LANCE they are created by which merges all session MODIS L0 datasets overlapping the requested time and extracts from the merged data those packets which fall within that time period Each scan of data is stored in the L1A granule that covers the start time of that scan
Definition: MOD_PR01_pr.txt:19
ms_finfo_struc_def::fid_ms_std
int fid_ms_std
Definition: mng_ms.cpp:15
ftn_str_cond
char * ftn_str_cond(char *str, int len)
Definition: mng_ms.cpp:216
dim_mgr::prune
int32_t prune(int32_t)
Definition: dim_mgr.cpp:821
pt_info_struc::wt_pt
double * wt_pt
Definition: dim_mgr.hpp:69
pt_info_struc::pt_status
int32_t * pt_status
Definition: dim_mgr.hpp:63
ms_finfo_struc_def::sds_id
int sds_id
Definition: mng_ms.cpp:16
dim_mgr.hpp
dim_mgr::add_pts
void add_pts(int32_t)
Definition: dim_mgr.cpp:113
DPTB
#define DPTB(function)
Definition: passthebuck.h:24
wtrcld_landsfc_info
ms_finfo_struc wtrcld_landsfc_info
Definition: mng_ms.cpp:23
icecld_nelts
int32_t icecld_nelts
Definition: mng_ms.cpp:32
ms_finfo_struc_def::dim_siz
int32_t * dim_siz
Definition: mng_ms.cpp:18
icecld_wtrsfc_info
ms_finfo_struc icecld_wtrsfc_info[3]
Definition: mng_ms.cpp:25
dim_mgr::mng_pt
pt_info_struc * mng_pt(double *, int32_t, int32_t *)
Definition: dim_mgr.cpp:246
pt_info_struc
Definition: dim_mgr.hpp:60
dim_mgr::update_new_data
void update_new_data()
Definition: dim_mgr.cpp:202
pt_info_struc::interval_needs_data
int32_t interval_needs_data
Definition: dim_mgr.hpp:62
seadasutils.aquarius_utils.start
start
Definition: aquarius_utils.py:27
linear_to_offset
int32_t linear_to_offset(int32_t n_dim, int32_t dat_ix, int32_t *offset)
Definition: dim_mgr.cpp:1015
ms_finfo_struc_def::dim_vals
double ** dim_vals
Definition: mng_ms.cpp:19
land_mgr
dim_mgr land_mgr(3, 83)
mng_ms_get_lib_
int mng_ms_get_lib_(float *sol_ang, float *sen_ang, float *relaz_ang, int *sfc_typ, int *meas_typ, int *scan, float *wtr_int, float *ice_int, int *stat)
Definition: mng_ms.cpp:367
set_ms_file
int32_t set_ms_file(char *fil_ms, char *fil_ms_std, int32_t fil_typ, ms_finfo_struc *finfo)
Definition: mng_ms.cpp:226
rank
Extra metadata that will be written to the HDF4 file l2prod rank
Definition: HOWTO_Add_a_product.txt:80
wtr_mgr
dim_mgr wtr_mgr(3, 83)
strncpy
PARAM_TYPE_NONE Default value No parameter is buried in the product name name_prefix is case insensitive string compared to the product name PARAM_TYPE_VIS_WAVE The visible wavelength bands from the sensor are buried in the product name The product name is compared by appending and name_suffix ie aph_412_giop where prod_ix will be set to PARAM_TYPE_IR_WAVE same search method as PARAM_TYPE_VIS_WAVE except only wavelength above are looped through but prod_ix is still based ie aph_2_giop for the second and prod_ix set to PARAM_TYPE_INT name_prefix is compared with the beginning of the product name If name_suffix is not empty the it must match the end of the product name The characters right after the prefix are read as an integer and prod_ix is set to that number strncpy(l2prod->name_prefix, "myprod", UNITLEN)
offset
l2prod offset
Definition: HOWTO_Add_a_product.txt:70
pt_info_struc::pt_base_loc
int32_t * pt_base_loc
Definition: dim_mgr.hpp:66
check_products.end
end
Definition: check_products.py:189
i
int i
Definition: decode_rs.h:71
str
Definition: aerosol.c:136
ms_finfo_struc_def::fid_ms
int fid_ms
Definition: mng_ms.cpp:14


ABOUT

Our Team

Contact Us

DATA

Get Started

Find Data

Use Data

TOOLS

SeaBASS

SeaDAS

Giovanni Data Visualizer

Worldview Mapping Interface

Mission Quality Monitor

HELP

How to Use Earthdata Search

Level 3 & 4 Browser Help

File Search Help

Search & Download Help

Earthdata Forum

Join Mailing List

How to Cite Data

CONNECT WITH US
COMPLIANCE

Web Privacy Policy

Data & Information Policy

Communications Policy

Accessibility

Freedom of Information Act

USA.gov

Responsible NASA Official: Sean Bailey
Curator: OceanColor Webmaster