OB.DAAC Logo
NASA Logo
Ocean Color Science Software

ocssw V2022
write_scan_metadata.c
Go to the documentation of this file.
1 #include "L1A_prototype.h"
2 #include "mapi.h"
3 #include "MD_metadata.h"
4 #include "PGS_MODIS_35005.h"
5 #include "mapiL1A.h"
6 #include "PGS_SMF.h"
7 
8 PGSt_SMF_status write_scan_metadata (MODFILE *L1A_file_ptr,
9  MD_SCAN_MET_t *scan_meta)
10 
11 /*
12 !C*****************************************************************************
13 
14 !Description: This function will write out the Scan Level Metadata (section
15  2 of the MODIS Level 1A Data Product Format) to the L1A file.
16 
17 !Input Parameters:
18  MODFILE L1A_file_ptr ** A pointer to the L1A file **
19  MD_SCAN_MET_t scan_meta ** Scan level metadata for
20  this scan **
21 
22 !Output Parameters:
23  None
24 
25 Return Values:
26  MODIS_S_SUCCESS (PGS_MODIS_35005.h)
27  MODIS_E_ARRAY_OUTPUT_ERR (PGS_MODIS_35005.h)
28 
29 Externally Defined:
30  PGSt_SMF_status (PGS_SMF.h)
31  MD_SCAN_MET_t (MD_metadata.h)
32  MODFILE (mapi.h)
33  M01SCAN_NUMBER (mapiL1A.h)
34  M01FRAME_COUNT_ARRAY (mapiL1A.h)
35  M01SCAN_TYPE (mapiL1A.h)
36  M01SD_START_TIME (mapiL1A.h)
37  M01SRCA_START_TIME (mapiL1A.h)
38  M01BB_START_TIME (mapiL1A.h)
39  M01SV_START_TIME (mapiL1A.h)
40  M01EV_START_TIME (mapiL1A.h)
41  M01SRCA_CALIBRATION_MODE (mapiL1A.h)
42  M01PACKET_SCAN_COUNT (mapiL1A.h)
43  M01CCSDS_APID (mapiL1A.h)
44  M01PACKET_QL (mapiL1A.h)
45  M01MIRROR_SIDE (mapiL1A.h)
46  M01SCAN_QUALITY_ARRAY (mapiL1A.h)
47 
48 Called By:
49  write_scan
50  handle_missing_scans
51 
52 Routines Called:
53  putMODISarray
54  log_fmt_msg
55 
56 !Revision History:
57  revision 1.0 1997/09/04 17:30:00
58  Qi Huang/RDC (qhuang@ltpmail.gsfc.nasa.gov)
59  Original development
60 
61 !Team-unique Header:
62  This software is developed by the MODIS Science
63  Data Support Team (SDST) for the National Aeronautics
64  and Space Administration (NASA), Goddard Space Flight
65  Center (GSFC), under contract NAS5-32373.
66 
67 !References and Credits:
68  None
69 
70 !Design Notes:
71  None
72 
73 !END**********************************************************************
74 */
75 {
76  char *routine = "write_scan_metadata";
77  char msg[300];
78  PGSt_SMF_status returnStatus;
79  long int start[2];
80  long int dimsize[2] = {1,0};
81  long int dimsize_1[1] = {1};
82 
83  start[0] = scan_meta->scan_num -1;
84  start[1] = 0;
85 
86  /******************************************************************************/
87  /* */
88  /* set returnStatus to MODIS_S_SUCCESS */
89  /* */
90  /******************************************************************************/
91 
92  returnStatus = MODIS_S_SUCCESS;
93 
94 
95  /******************************************************************************/
96  /* */
97  /* Compute dimsize array for the Scan number */
98  /* Compute the start for the Scan number */
99  /* CALL putMODISarray to write the Scan number to the L1A granule */
100  /* INPUTS: MODFILE, M01SCAN_NUMBER, NULL, start, dimsize array, */
101  /* MD_SCAN_MET_t.scan_num */
102  /* OUTPUT: None */
103  /* RETURN: mapiStatus */
104  /* */
105  /* IF mapiStatus equals MFAIL */
106  /* THEN */
107  /* set msg to "The Scan number could not be written to the L1A granule" */
108  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
109  /* CALL log_fmt_msg to report that the Scan number could not be written to*/
110  /* the L1A granule */
111  /* INPUTS: returnStatus, routine, msg */
112  /* OUTPUT: None */
113  /* RETURN: None */
114  /* ENDIF */
115  /* */
116  /******************************************************************************/
117 
118  if (putMODISarray(L1A_file_ptr, M01SCAN_NUMBER ,NULL, start, dimsize_1,
119  &scan_meta->scan_num) == MFAIL)
120  {
121  sprintf(msg,"The Scan number could not be written to the L1A granule %s ",
122  L1A_file_ptr->filename);
123  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
124  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
125  }
126 
127 
128  /******************************************************************************/
129  /* */
130  /* Compute dimsize array for the Frame count array */
131  /* Compute the start for the Frame count array */
132  /* CALL putMODISarray to write the Frame count array to the L1A granule */
133  /* INPUTS: MODFILE, M01FRAME_COUNT_ARRAY, NULL, start, dimsize array, */
134  /* MD_SCAN_MET_t.frame_count_array */
135  /* OUTPUT: None */
136  /* RETURN: mapiStatus */
137  /* */
138  /* IF mapiStatus equals MFAIL */
139  /* THEN */
140  /* set routine to "write_scan_metadata" */
141  /* set msg to "The Frame count array could not be written to the L1A */
142  /* granule" */
143  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
144  /* CALL log_fmt_msg to report that the Frame count array could not be */
145  /* written to the L1A granule */
146  /* INPUTS: returnStatus, routine, msg */
147  /* OUTPUT: None */
148  /* RETURN: None */
149  /* ENDIF */
150  /* */
151  /******************************************************************************/
152 
153  dimsize[1] = 6;
154 
155  if (putMODISarray(L1A_file_ptr, M01FRAME_COUNT_ARRAY, NULL, start, dimsize,
156  scan_meta->frame_count_array) == MFAIL)
157  {
158  sprintf(msg,"The Frame count array could not be written to the L1A granule: %s ",
159  L1A_file_ptr->filename);
160  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
161  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
162  }
163 
164 
165  /******************************************************************************/
166  /* */
167  /* Compute dimsize array for the Scan Type */
168  /* Compute the start for the Scan Type */
169  /* CALL putMODISarray to write the Scan Type to the L1A granule */
170  /* INPUTS: MODFILE, M01SCAN_TYPE, NULL, start, dimsize array, */
171  /* MD_SCAN_MET_t.scan_type */
172  /* OUTPUT: None */
173  /* RETURN: mapiStatus */
174  /* */
175  /* IF mapiStatus equals MFAIL */
176  /* THEN */
177  /* set routine to "write_scan_metadata" */
178  /* set msg to "The Scan Type could not be written to the L1A granule" */
179  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
180  /* CALL log_fmt_msg to report that the Scan Type could not be written to */
181  /* the L1A granule */
182  /* INPUTS: returnStatus, routine, msg */
183  /* OUTPUT: None */
184  /* RETURN: None */
185  /* ENDIF */
186  /* */
187  /******************************************************************************/
188 
189  dimsize[1] = 10;
190 
191  if (putMODISarray(L1A_file_ptr, M01SCAN_TYPE, NULL, start, dimsize,
192  scan_meta->scan_type) == MFAIL)
193  {
194  sprintf(msg,"The Scan Type could not be written to the L1A granule %s",
195  L1A_file_ptr->filename);
196  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
197  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
198  }
199 
200 
201  /******************************************************************************/
202  /* */
203  /* Compute dimsize array for the SD start time */
204  /* Compute the start for the SD start time */
205  /* CALL putMODISarray to write the SD start time to the L1A granule */
206  /* INPUTS: MODFILE, M01SD_START_TIME, NULL, start, dimsize array, */
207  /* MD_SCAN_MET_t.sd_start_time */
208  /* OUTPUT: None */
209  /* RETURN: mapiStatus */
210  /* */
211  /* IF mapiStatus equals MFAIL */
212  /* THEN */
213  /* set routine to "write_scan_metadata" */
214  /* set msg to "The SD start time could not be written to the L1A granule" */
215  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
216  /* CALL log_fmt_msg to report that the SD start time could not be */
217  /* written to the L1A granule */
218  /* INPUTS: returnStatus, routine, msg */
219  /* OUTPUT: None */
220  /* RETURN: None */
221  /* ENDIF */
222  /* */
223  /******************************************************************************/
224 
225  if (putMODISarray(L1A_file_ptr, M01SD_START_TIME, NULL, start, dimsize_1,
226  &scan_meta->sd_start_time) == MFAIL)
227  {
228  sprintf(msg,"The SD start time could not be written to the L1A granule %s",
229  L1A_file_ptr->filename);
230  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
231  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
232  }
233 
234 
235  /******************************************************************************/
236  /* */
237  /* Compute dimsize array for the SRCA start time */
238  /* Compute the start for the SRCA start time */
239  /* CALL putMODISarray to write the SRCA start time to the L1A granule */
240  /* INPUTS: MODFILE, M01SRCA_START_TIME, NULL, start, dimsize array, */
241  /* MD_SCAN_MET_t.srca_start_time */
242  /* OUTPUT: None */
243  /* RETURN: mapiStatus */
244  /* */
245  /* IF mapiStatus equals MFAIL */
246  /* THEN */
247  /* set routine to "write_scan_metadata" */
248  /* set msg to "The SRCA start time could not be written to the L1A */
249  /* granule" */
250  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
251  /* CALL log_fmt_msg to report that the SRCA start time could not be */
252  /* written to the L1A granule */
253  /* INPUTS: returnStatus, routine, msg */
254  /* OUTPUT: None */
255  /* RETURN: None */
256  /* ENDIF */
257  /* */
258  /******************************************************************************/
259 
260  if (putMODISarray(L1A_file_ptr, M01SRCA_START_TIME, NULL, start, dimsize_1,
261  &scan_meta->srca_start_time) == MFAIL)
262  {
263  sprintf(msg,"The SRCA start time could not be written to the L1A granule %s",
264  L1A_file_ptr->filename);
265  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
266  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
267  }
268 
269 
270  /******************************************************************************/
271  /* */
272  /* Compute dimsize array for the BB start time */
273  /* Compute the start for the BB start time */
274  /* CALL putMODISarray to write the BB start time to the L1A granule */
275  /* INPUTS: MODFILE, M01BB_START_TIME, NULL, start, dimsize array, */
276  /* MD_SCAN_MET_t.bb_start_time */
277  /* OUTPUT: None */
278  /* RETURN: mapiStatus */
279  /* */
280  /* IF mapiStatus equals MFAIL */
281  /* THEN */
282  /* set routine to "write_scan_metadata" */
283  /* set msg to "The BB start time could not be written to the L1A granule" */
284  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
285  /* CALL log_fmt_msg to report that the BB start time could not be */
286  /* written to the L1A granule */
287  /* INPUTS: returnStatus, routine, msg */
288  /* OUTPUT: None */
289  /* RETURN: None */
290  /* ENDIF */
291  /* */
292  /******************************************************************************/
293 
294  if (putMODISarray(L1A_file_ptr, M01BB_START_TIME, NULL, start, dimsize_1,
295  &scan_meta->bb_start_time) == MFAIL)
296  {
297  sprintf(msg,"The BB start time could not be written to the L1A granule %s",
298  L1A_file_ptr->filename);
299  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
300  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
301  }
302 
303 
304  /******************************************************************************/
305  /* */
306  /* Compute dimsize array for the SV start time */
307  /* Compute the start for the SV start time */
308  /* CALL putMODISarray to write the SV start time to the L1A granule */
309  /* INPUTS: MODFILE, M01SV_START_TIME, NULL, start, dimsize array, */
310  /* MD_SCAN_MET_t.sv_start_time */
311  /* OUTPUT: None */
312  /* RETURN: mapiStatus */
313  /* */
314  /* IF mapiStatus equals MFAIL */
315  /* THEN */
316  /* set routine to "write_scan_metadata" */
317  /* set msg to "The SV start time could not be written to the L1A granule" */
318  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
319  /* CALL log_fmt_msg to report that the SV start time could not be */
320  /* written to the L1A granule */
321  /* INPUTS: returnStatus, routine, msg */
322  /* OUTPUT: None */
323  /* RETURN: None */
324  /* ENDIF */
325  /* */
326  /******************************************************************************/
327 
328  if (putMODISarray(L1A_file_ptr, M01SV_START_TIME, NULL, start, dimsize_1,
329  &scan_meta->sv_start_time) == MFAIL)
330  {
331  sprintf(msg,"The SV start time could not be written to the L1A granule %s",
332  L1A_file_ptr->filename);
333  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
334  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
335  }
336 
337 
338  /******************************************************************************/
339  /* */
340  /* Compute dimsize array for the EV start time */
341  /* Compute the start for the EV start time */
342  /* CALL putMODISarray to write the EV start time to the L1A granule */
343  /* INPUTS: MODFILE, M01EV_START_TIME, NULL, start, dimsize array, */
344  /* MD_SCAN_MET_t.ev_start_time */
345  /* OUTPUT: None */
346  /* RETURN: mapiStatus */
347  /* */
348  /* IF mapiStatus equals MFAIL */
349  /* THEN */
350  /* set routine to "write_scan_metadata" */
351  /* set msg to "The EV start time could not be written to the L1A granule" */
352  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
353  /* CALL log_fmt_msg to report that the EV start time could not be */
354  /* written to the L1A granule */
355  /* INPUTS: returnStatus, routine, msg */
356  /* OUTPUT: None */
357  /* RETURN: None */
358  /* ENDIF */
359  /* */
360  /******************************************************************************/
361 
362  if (putMODISarray(L1A_file_ptr, M01EV_START_TIME, NULL, start, dimsize_1,
363  &scan_meta->ev_start_time) == MFAIL)
364  {
365  sprintf(msg,"The EV start time could not be written to the L1A granule %s",
366  L1A_file_ptr->filename);
367  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
368  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
369  }
370 
371 
372  /******************************************************************************/
373  /* */
374  /* Compute dimsize array for the SRCA calibration mode */
375  /* Compute the start for the SRCA calibration mode */
376  /* CALL putMODISarray to write the SRCA calibration mode to the L1A granule */
377  /* INPUTS: MODFILE, M01SRCA_CALIBRATION_MODE, NULL, start, dimsize array, */
378  /* MD_SCAN_MET_t.srca_cal_mode */
379  /* OUTPUT: None */
380  /* RETURN: mapiStatus */
381  /* */
382  /* IF mapiStatus equals MFAIL */
383  /* THEN */
384  /* set routine to "write_scan_metadata" */
385  /* set msg to "The SRCA calibration mode could not be written to the L1A */
386  /* granule" */
387  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
388  /* CALL log_fmt_msg to report that the SRCA calibration mode could not be */
389  /* written to the L1A granule */
390  /* INPUTS: returnStatus, routine, msg */
391  /* OUTPUT: None */
392  /* RETURN: None */
393  /* ENDIF */
394  /* */
395  /******************************************************************************/
396 
397  if (putMODISarray(L1A_file_ptr, M01SRCA_CALIBRATION_MODE, NULL, start, dimsize_1,
398  &scan_meta->srca_cal_mode) == MFAIL)
399  {
400  sprintf(msg,"The SRCA calibration mode could not be written to the L1A granule %s",
401  L1A_file_ptr->filename);
402  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
403  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
404  }
405 
406 
407  /******************************************************************************/
408  /* */
409  /* Compute dimsize array for the Packet scan count */
410  /* Compute the start for the Packet scan count */
411  /* CALL putMODISarray to write the Packet scan count to the L1A granule */
412  /* INPUTS: MODFILE, M01PACKET_SCAN_COUNT, NULL, start, dimsize array, */
413  /* MD_SCAN_MET_t.packet_scan_count */
414  /* OUTPUT: None */
415  /* RETURN: mapiStatus */
416  /* */
417  /* IF mapiStatus equals MFAIL */
418  /* THEN */
419  /* set routine to "write_scan_metadata" */
420  /* set msg to "The Packet scan count could not be written to the L1A */
421  /* granule" */
422  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
423  /* CALL log_fmt_msg to report that the Packet scan count could not be */
424  /* written to the L1A granule */
425  /* INPUTS: returnStatus, routine, msg */
426  /* OUTPUT: None */
427  /* RETURN: None */
428  /* ENDIF */
429  /* */
430  /******************************************************************************/
431 
432  if (putMODISarray(L1A_file_ptr, M01PACKET_SCAN_COUNT, NULL, start, dimsize_1,
433  &scan_meta->packet_scan_count) == MFAIL)
434  {
435  sprintf(msg,"The Packet scan count could not be written to the L1A granule %s",
436  L1A_file_ptr->filename);
437  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
438  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
439  }
440 
441 
442  /******************************************************************************/
443  /* */
444  /* Compute dimsize array for the CCSDS Application Identifiers */
445  /* Compute the start for the CCSDS Application Identifiers */
446  /* CALL putMODISarray to write the CCSDS Application Identifiers to the */
447  /* L1A granule */
448  /* INPUTS: MODFILE, M01CCSDS_APID, NULL, start, dimsize array, */
449  /* MD_SCAN_MET_t.ccsds_apids */
450  /* OUTPUT: None */
451  /* RETURN: mapiStatus */
452  /* */
453  /* IF mapiStatus equals MFAIL */
454  /* THEN */
455  /* set routine to "write_scan_metadata" */
456  /* set msg to "The CCSDS Application Identifiers could not be written to */
457  /* the L1A granule" */
458  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
459  /* CALL log_fmt_msg to report that the CCSDS Application Identifiers could*/
460  /* not be written to the L1A granule */
461  /* INPUTS: returnStatus, routine, msg */
462  /* OUTPUT: None */
463  /* RETURN: None */
464  /* ENDIF */
465  /* */
466  /******************************************************************************/
467 
468  dimsize[1] = 3;
469 
470  if (putMODISarray(L1A_file_ptr, M01CCSDS_APID, NULL, start, dimsize,
471  scan_meta->ccsds_apids) == MFAIL)
472  {
473  sprintf(msg,"The CCSDS Application Identifiers could not be written to the L1A granule %s",
474  L1A_file_ptr->filename);
475  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
476  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
477  }
478 
479 
480  /******************************************************************************/
481  /* */
482  /* Compute dimsize array for the Packet expedited data flag */
483  /* Compute the start for the Packet expedited data flag */
484  /* CALL putMODISarray to write the Packet expedited data flag to the L1A */
485  /* granule */
486  /* INPUTS: MODFILE, M01PACKET_QL, NULL, start, dimsize array, */
487  /* MD_SCAN_MET_t.packet_expedited_data_flag */
488  /* OUTPUT: None */
489  /* RETURN: mapiStatus */
490  /* */
491  /* IF mapiStatus equals MFAIL */
492  /* THEN */
493  /* set routine to "write_scan_metadata" */
494  /* set msg to "The Packet expedited data flag could not be written to the */
495  /* L1A granule" */
496  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
497  /* CALL log_fmt_msg to report that the Packet expedited data flag could */
498  /* not be written to the L1A granule */
499  /* INPUTS: returnStatus, routine, msg */
500  /* OUTPUT: None */
501  /* RETURN: None */
502  /* ENDIF */
503  /* */
504  /******************************************************************************/
505 
506  if (putMODISarray(L1A_file_ptr, M01PACKET_QL, NULL, start, dimsize_1,
507  &scan_meta->packet_expedited_data_flag) == MFAIL)
508  {
509  sprintf(msg,"The Packet expedited data flag could not be written to the L1A granule %s",
510  L1A_file_ptr->filename);
511  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
512  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
513  }
514 
515 
516  /******************************************************************************/
517  /* */
518  /* Compute dimsize array for the Mirror side */
519  /* Compute the start for the Mirror side */
520  /* CALL putMODISarray to write the Mirror side to the L1A granule */
521  /* INPUTS: MODFILE, M01MIRROR_SIDE, NULL, start, dimsize array, */
522  /* MD_SCAN_MET_t.mirror_side */
523  /* OUTPUT: None */
524  /* RETURN: mapiStatus */
525  /* */
526  /* IF mapiStatus equals MFAIL */
527  /* THEN */
528  /* set routine to "write_scan_metadata" */
529  /* set msg to "The Mirror side could not be written to the L1A granule" */
530  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
531  /* CALL log_fmt_msg to report that the Mirror side could not be */
532  /* written to the L1A granule */
533  /* INPUTS: returnStatus, routine, msg */
534  /* OUTPUT: None */
535  /* RETURN: None */
536  /* ENDIF */
537  /* */
538  /******************************************************************************/
539 
540  if (putMODISarray(L1A_file_ptr, M01MIRROR_SIDE, NULL, start, dimsize_1,
541  &scan_meta->mirror_side) == MFAIL)
542  {
543  sprintf(msg,"The Mirror side could not be written to the L1A granule %s",
544  L1A_file_ptr->filename);
545  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
546  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
547  }
548 
549 
550  /******************************************************************************/
551  /* */
552  /* Compute dimsize array for the Scan quality array */
553  /* Compute the start for the Scan quality array */
554  /* CALL putMODISarray to write the Scan quality array to the L1A granule */
555  /* INPUTS: MODFILE, M01SCAN_QUALITY_ARRAY, NULL, start, dimsize array, */
556  /* MD_SCAN_MET_t.scan_qual_array */
557  /* OUTPUT: None */
558  /* RETURN: mapiStatus */
559  /* */
560  /* IF mapiStatus equals MFAIL */
561  /* THEN */
562  /* set routine to "write_scan_metadata" */
563  /* set msg to "The Scan quality array could not be written to the L1A */
564  /* granule" */
565  /* set returnStatus to MODIS_E_ARRAY_OUTPUT_ERR */
566  /* CALL log_fmt_msg to report that the Scan quality array could not be */
567  /* written to the L1A granule */
568  /* INPUTS: returnStatus, routine, msg */
569  /* OUTPUT: None */
570  /* RETURN: None */
571  /* ENDIF */
572  /* */
573  /******************************************************************************/
574 
575  dimsize[1] = 4;
576 
577  if (putMODISarray(L1A_file_ptr, M01SCAN_QUALITY_ARRAY, NULL, start, dimsize,
578  scan_meta->scan_qual_array) == MFAIL)
579  {
580  sprintf(msg,"The Scan quality array could not be written to the L1A granule %s",
581  L1A_file_ptr->filename);
582  returnStatus = MODIS_E_ARRAY_OUTPUT_ERR;
583  log_fmt_msg(MODIS_E_ARRAY_OUTPUT_ERR, routine, msg);
584  }
585 
586 
587  /******************************************************************************/
588  /* */
589  /* RETURN returnStatus */
590  /* */
591  /******************************************************************************/
592 
593  return (returnStatus);
594 
595 }
write_scan_metadata
PGSt_SMF_status write_scan_metadata(MODFILE *L1A_file_ptr, MD_SCAN_MET_t *scan_meta)
Definition: write_scan_metadata.c:8
MD_SCAN_MET_t::srca_cal_mode
int16 srca_cal_mode
Definition: MD_metadata.h:226
MD_SCAN_MET_t::packet_expedited_data_flag
int16 packet_expedited_data_flag
Definition: MD_metadata.h:229
NULL
#define NULL
Definition: decode_rs.h:63
PGS_MODIS_35005.h
MD_metadata.h
MD_SCAN_MET_t::scan_num
int16 scan_num
Definition: MD_metadata.h:218
MD_SCAN_MET_t::bb_start_time
float64 bb_start_time
Definition: MD_metadata.h:223
log_fmt_msg
void log_fmt_msg(PGSt_SMF_status code, const char *routine, const char *msg_fmt,...)
Definition: log_fmt_msg.c:6
MD_SCAN_MET_t::mirror_side
int16 mirror_side
Definition: MD_metadata.h:230
MD_SCAN_MET_t::sv_start_time
float64 sv_start_time
Definition: MD_metadata.h:224
MODIS_E_ARRAY_OUTPUT_ERR
#define MODIS_E_ARRAY_OUTPUT_ERR
Definition: PGS_MODIS_35005.h:3
MD_SCAN_MET_t::scan_qual_array
int32 scan_qual_array[4]
Definition: MD_metadata.h:231
MD_SCAN_MET_t::ev_start_time
float64 ev_start_time
Definition: MD_metadata.h:225
MD_SCAN_MET_t::frame_count_array
int16 frame_count_array[6]
Definition: MD_metadata.h:219
seadasutils.aquarius_utils.start
start
Definition: aquarius_utils.py:27
MODIS_S_SUCCESS
#define MODIS_S_SUCCESS
Definition: PGS_MODIS_35005.h:75
MD_SCAN_MET_t::sd_start_time
float64 sd_start_time
Definition: MD_metadata.h:221
MD_SCAN_MET_t::srca_start_time
float64 srca_start_time
Definition: MD_metadata.h:222
mapgen.msg
string msg
Definition: mapgen.py:227
MD_SCAN_MET_t
Definition: MD_metadata.h:216
MD_SCAN_MET_t::ccsds_apids
int16 ccsds_apids[3]
Definition: MD_metadata.h:228
MD_SCAN_MET_t::packet_scan_count
int16 packet_scan_count
Definition: MD_metadata.h:227
L1A_prototype.h
MD_SCAN_MET_t::scan_type
char scan_type[10]
Definition: MD_metadata.h:220


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

Level 1 & 2 Browser Help

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 Policy

Freedom of Information Act

USA.gov

Responsible NASA Official: Sean Bailey
Curator: OceanColor Webmaster