40#include "HDF4RequestHandler.h"
42const char *_BACK_SLASH=
"/";
48#define ERR_LOC2(x) ERR_LOC1(x)
49#define ERR_LOC __FILE__ " : " ERR_LOC2(__LINE__)
51template <
typename T,
typename U,
typename V,
typename W,
typename X >
static void
52_throw5 (
const char *fname,
int line,
int numarg,
53 const T & a1,
const U & a2,
const V & a3,
const W & a4,
const X & a5)
55 std::ostringstream ss;
56 ss << fname <<
":" << line <<
":";
57 for (
int i = 0; i < numarg; ++i) {
77 ss <<
" Argument number is beyond 5";
86#define throw1(a1) _throw5(__FILE__, __LINE__, 1, a1, 0, 0, 0, 0)
87#define throw2(a1, a2) _throw5(__FILE__, __LINE__, 2, a1, a2, 0, 0, 0)
88#define throw3(a1, a2, a3) _throw5(__FILE__, __LINE__, 3, a1, a2, a3, 0, 0)
89#define throw4(a1, a2, a3, a4) _throw5(__FILE__, __LINE__, 4, a1, a2, a3, a4, 0)
90#define throw5(a1, a2, a3, a4, a5) _throw5(__FILE__, __LINE__, 5, a1, a2, a3, a4, a5)
92#define assert_throw0(e) do { if (!(e)) throw1("assertion failure"); } while (false)
93#define assert_range_throw0(e, ge, l) assert_throw0((ge) <= (e) && (e) < (l))
99 template <
typename T >
void operator () (T * ptr)
111 if (this->sdfd != -1) {
123 if (this->fileid != -1) {
126 for (vector < VDATA * >::const_iterator i = this->vds.begin ();
127 i != this->vds.end (); ++i) {
131 for (vector < AttrContainer * >::const_iterator i = this->vg_attrs.begin ();
132 i != this->vg_attrs.end (); ++i) {
137 std::for_each (this->vds.begin (), this->vds.end (), delete_elem ());
138 std::for_each (this->vg_attrs.begin (), this->vg_attrs.end (), delete_elem ());
153 std::for_each (this->vdfields.begin (), this->vdfields.end (),
157 std::for_each (this->attrs.begin (), this->attrs.end (), delete_elem ());
164 std::for_each (this->attrs.begin (), this->attrs.end (), delete_elem ());
167 std::for_each (this->sdfields.begin (), this->sdfields.end (),
176 std::for_each (this->dims.begin (), this->dims.end (), delete_elem ());
179 std::for_each (this->correcteddims.begin (), this->correcteddims.end (),
183 std::for_each (this->dims_info.begin (), this->dims_info.end (), delete_elem ());
195 std::for_each (this->
attrs.begin (), this->attrs.end (), delete_elem ());
199AttrContainer::~AttrContainer()
201 std::for_each (this->attrs.begin (), this->attrs.end (), delete_elem ());
213 auto file =
new File (path);
220 SDstart (
const_cast < char *
>(file->path.c_str ()),
221 DFACC_READ)) == -1) {
223 throw2 (
"SDstart", path);
232 file->fileid = myfileid;
236 int32 status = Vstart (file->fileid);
237 if (status == FAIL) {
239 throw2 (
"Cannot start vdata/vgroup interface", path);
245 file->sd =
SD::Read (file->sdfd, file->fileid);
250 file->ReadLoneVdatas(file);
267 auto file =
new File (path);
269 throw1(
"Memory allocation for file class failed. ");
279 SDstart (
const_cast < char *
>(file->path.c_str ()),
280 DFACC_READ)) == -1) {
282 throw2 (
"SDstart", path);
291 file->fileid = myfileid;
294 int status = Vstart (file->fileid);
295 if (status == FAIL) {
297 throw2 (
"Cannot start vdata/vgroup interface", path);
310 file->ReadLoneVdatas(file);
313 file->ReadHybridNonLoneVdatas(file);
335 int status = Vstart (file->fileid);
337 throw2 (
"Cannot start vdata/vgroup interface", path);
341 int num_lone_vdata = VSlone (file->fileid,
nullptr, 0);
343 if (num_lone_vdata == FAIL)
344 throw2 (
"Fail to obtain lone vdata number", path);
350 char vdata_class[VSNAMELENMAX];
351 char vdata_name[VSNAMELENMAX];
353 if (num_lone_vdata > 0) {
355 vector<int32>ref_array;
356 ref_array.resize(num_lone_vdata);
358 if (VSlone (file->fileid, ref_array.data(), num_lone_vdata) == FAIL) {
359 throw2 (
"cannot obtain lone vdata reference arrays", path);
362 for (
int i = 0; i < num_lone_vdata; i++) {
366 vdata_id = VSattach (file->fileid, ref_array[i],
"r");
367 if (vdata_id == FAIL) {
368 throw2 (
"Fail to attach Vdata", path);
370 status = VSgetclass (vdata_id, vdata_class);
371 if (status == FAIL) {
373 throw2 (
"Fail to obtain Vdata class", path);
376 if (VSgetname (vdata_id, vdata_name) == FAIL) {
378 throw3 (
"Fail to obtain Vdata name", path, vdata_name);
383 if (VSisattr (vdata_id) == TRUE
384 || !strncmp (vdata_class, _HDF_CHK_TBL_CLASS,
385 strlen (_HDF_CHK_TBL_CLASS))
386 || !strncmp (vdata_class, _HDF_SDSVAR, strlen (_HDF_SDSVAR))
387 || !strncmp (vdata_class, _HDF_CRDVAR, strlen (_HDF_CRDVAR))
388 || !strncmp (vdata_class, DIM_VALS, strlen (DIM_VALS))
389 || !strncmp (vdata_class, DIM_VALS01, strlen (DIM_VALS01))
390 || !strncmp (vdata_class, RIGATTRCLASS, strlen (RIGATTRCLASS))
391 || !strncmp (vdata_name, RIGATTRNAME, strlen (RIGATTRNAME))) {
393 status = VSdetach (vdata_id);
394 if (status == FAIL) {
395 throw3 (
"VSdetach failed ",
"Vdata name ", vdata_name);
400 VDATA*vdataobj =
nullptr;
414 for (
const auto &vdf:vdataobj->
getFields ()) {
418 vdf->newname =
"vdata_" + vdataobj->newname +
"_vdf_" + vdf->name;
426 file->vds.push_back (vdataobj);
440 (vdata_name, CERE_META_NAME, strlen (CERE_META_NAME))) {
442 char *fieldname =
nullptr;
445 int num_field = VFnfields (vdata_id);
446 if (num_field == FAIL) {
448 throw3 (
"number of fields at Vdata ", vdata_name,
" is -1");
452 for (
int j = 0; j < num_field; j++) {
454 fieldname = VFfieldname (vdata_id, j);
455 if (fieldname ==
nullptr) {
457 throw5 (
"vdata ", vdata_name,
" field index ", j,
458 " field name is nullptr.");
462 else if (!strcmp (fieldname, CERE_META_FIELD_NAME)) {
464 int32 fieldsize = -1;
468 fieldsize = VFfieldesize (vdata_id, j);
469 if (fieldsize == FAIL) {
471 throw5 (
"vdata ", vdata_name,
" field ",fieldname,
" size is wrong.");
475 nelms = VSelts (vdata_id);
478 throw5 (
"vdata ", vdata_name,
479 " number of field record ", nelms,
" is wrong.");
483 bool data_buf_err =
false;
484 bool VS_fun_err =
false;
487 auto databuf = (
char *) malloc (fieldsize * nelms);
488 if (databuf ==
nullptr) {
489 err_msg = string(ERR_LOC) +
"No enough memory to allocate buffer.";
495 if (VSseek (vdata_id, 0) == FAIL) {
496 err_msg = string(ERR_LOC) +
"VSseek failed";
502 if (VSsetfields (vdata_id, CERE_META_FIELD_NAME) == FAIL) {
503 err_msg =
"VSsetfields failed";
509 if (VSread(vdata_id, (uint8 *) databuf, 1,FULL_INTERLACE)
511 err_msg =
"VSread failed";
517 if (!strncmp(databuf, CER_AVG_NAME,strlen (CER_AVG_NAME)))
518 file->sptype = CER_AVG;
520 (databuf, CER_ES4_NAME,strlen(CER_ES4_NAME)))
521 file->sptype = CER_ES4;
523 (databuf, CER_CDAY_NAME,strlen (CER_CDAY_NAME)))
524 file->sptype = CER_CDAY;
526 (databuf, CER_CGEO_NAME,strlen (CER_CGEO_NAME)))
527 file->sptype = CER_CGEO;
529 (databuf, CER_SRB_NAME,strlen (CER_SRB_NAME)))
530 file->sptype = CER_SRB;
532 (databuf, CER_SYN_NAME,strlen (CER_SYN_NAME)))
533 file->sptype = CER_SYN;
535 (databuf, CER_ZAVG_NAME,
536 strlen (CER_ZAVG_NAME)))
537 file->sptype = CER_ZAVG;
540 if(data_buf_err ==
true || VS_fun_err ==
true) {
542 if(data_buf_err ==
true)
546 throw5(
"vdata ",vdata_name,
"field ",
547 CERE_META_FIELD_NAME,err_msg);
569 int32 vgroup_id = -1;
581 int32 lone_vg_number = 0;
582 int32 num_of_lones = -1;
583 int32 num_gobjects = 0;
588 char vdata_name[VSNAMELENMAX];
589 char vdata_class[VSNAMELENMAX];
590 char vgroup_name[VGNAMELENMAX*4];
591 char vgroup_class[VGNAMELENMAX*4];
594 char *full_path =
nullptr;
597 char *cfull_path =
nullptr;
600 file_id = file->fileid;
605 status = Vstart (file_id);
607 throw2 (
"Cannot start vdata/vgroup interface", path);
613 num_of_lones = Vlone (file_id,
nullptr, 0);
614 if (num_of_lones == FAIL)
615 throw3 (
"Fail to obtain lone vgroup number",
"file id is", file_id);
618 if (num_of_lones > 0) {
624 vector<int32>ref_array;
625 ref_array.resize(num_of_lones);
629 num_of_lones = Vlone (file_id, ref_array.data(), num_of_lones);
630 if (num_of_lones == FAIL) {
631 throw3 (
"Cannot obtain lone vgroup reference arrays ",
632 "file id is ", file_id);
636 for (lone_vg_number = 0; lone_vg_number < num_of_lones;
640 vgroup_id = Vattach (file_id, ref_array[lone_vg_number],
"r");
641 if (vgroup_id == FAIL) {
642 throw3 (
"Vattach failed ",
"Reference number is ",
643 ref_array[lone_vg_number]);
647 status = Vgetname (vgroup_id, vgroup_name);
648 if (status == FAIL) {
650 throw3 (
"Vgetname failed ",
"vgroup_id is ", vgroup_id);
654 status = Vgetclass (vgroup_id, vgroup_class);
655 if (status == FAIL) {
657 throw3 (
"Vgetclass failed ",
"vgroup_name is ", vgroup_name);
661 if (strcmp (vgroup_class, _HDF_ATTRIBUTE) == 0
662 || strcmp (vgroup_class, _HDF_VARIABLE) == 0
663 || strcmp (vgroup_class, _HDF_DIMENSION) == 0
664 || strcmp (vgroup_class, _HDF_UDIMENSION) == 0
665 || strcmp (vgroup_class, _HDF_CDF) == 0
666 || strcmp (vgroup_class, GR_NAME) == 0
667 || strcmp (vgroup_class, RI_NAME) == 0) {
673 num_gobjects = Vntagrefs (vgroup_id);
674 if (num_gobjects < 0) {
676 throw3 (
"Vntagrefs failed ",
"vgroup_name is ", vgroup_name);
681 bool VS_or_mem_err =
false;
687 full_path = (
char *) malloc (MAX_FULL_PATH_LEN);
688 if (full_path ==
nullptr) {
689 err_msg =
"No enough memory to allocate the buffer for full_path.";
690 VS_or_mem_err =
true;
699 memset(full_path,
'\0',MAX_FULL_PATH_LEN);
702 strncpy (full_path,_BACK_SLASH,strlen(_BACK_SLASH));
703 strncat(full_path,vgroup_name,strlen(vgroup_name));
704 strncat(full_path,_BACK_SLASH,strlen(_BACK_SLASH));
707 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
708 if (cfull_path ==
nullptr) {
711 err_msg =
"No enough memory to allocate the buffer for cfull_path.";
712 VS_or_mem_err =
true;
720 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
721 strncpy(cfull_path,full_path,strlen(full_path));
725 for (
int i = 0; i < num_gobjects; i++) {
728 if (Vgettagref (vgroup_id, i, &obj_tag, &obj_ref) == FAIL) {
729 err_msg =
"Vgettagref failed";
730 VS_or_mem_err =
true;
743 if (Visvg (vgroup_id, obj_ref) == TRUE) {
744 strncpy(full_path,cfull_path,strlen(cfull_path)+1);
745 full_path[strlen(cfull_path)]=
'\0';
746 obtain_vdata_path (file_id, full_path, obj_ref);
750 else if (Visvs (vgroup_id, obj_ref)) {
753 vdata_id = VSattach (file_id, obj_ref,
"r");
754 if (vdata_id == FAIL) {
755 err_msg =
"VSattach failed";
756 VS_or_mem_err =
true;
761 status = VSgetname (vdata_id, vdata_name);
762 if (status == FAIL) {
763 err_msg =
"VSgetname failed";
764 VS_or_mem_err =
true;
769 status = VSgetclass (vdata_id, vdata_class);
770 if (status == FAIL) {
771 err_msg =
"VSgetclass failed";
772 VS_or_mem_err =
true;
777 if (VSisattr (vdata_id) == TRUE
778 || !strncmp (vdata_class, _HDF_CHK_TBL_CLASS,
779 strlen (_HDF_CHK_TBL_CLASS))
780 || !strncmp (vdata_class, _HDF_SDSVAR,
781 strlen (_HDF_SDSVAR))
782 || !strncmp (vdata_class, _HDF_CRDVAR,
783 strlen (_HDF_CRDVAR))
784 || !strncmp (vdata_class, DIM_VALS, strlen (DIM_VALS))
785 || !strncmp (vdata_class, DIM_VALS01,
787 || !strncmp (vdata_class, RIGATTRCLASS,
788 strlen (RIGATTRCLASS))
789 || !strncmp (vdata_name, RIGATTRNAME,
790 strlen (RIGATTRNAME))) {
792 status = VSdetach (vdata_id);
793 if (status == FAIL) {
794 err_msg =
"VSdetach failed in the if block to ignore the HDF4 internal attributes.";
795 VS_or_mem_err =
true;
803 VDATA *vdataobj =
nullptr;
815 if(full_path !=
nullptr)
816 vdataobj->newname = full_path +vdataobj->name;
821 for (
const auto &vdf:vdataobj->
getFields ()) {
827 "vdata" + vdataobj->newname +
"_vdf_" + vdf->name;
839 this->vds.push_back (vdataobj);
841 status = VSdetach (vdata_id);
842 if (status == FAIL) {
843 err_msg =
"VSdetach failed in the user-defined vdata block";
844 VS_or_mem_err =
true;
859 if(full_path !=
nullptr)
861 if(cfull_path !=
nullptr)
864 status = Vdetach (vgroup_id);
865 if (status == FAIL) {
866 throw3 (
"Vdetach failed ",
"vgroup_name is ", vgroup_name);
868 if(
true == VS_or_mem_err)
869 throw3(err_msg,
"vgroup_name is ",vgroup_name);
886File::Check_update_special(
const string& grid_name)
throw(
Exception) {
888 set<string> dimnameset;
889 set<SDField*> fldset;
902 FullXDim= FullXDim+grid_name;
903 FullYDim =FullYDim+grid_name;
905 for (
const auto &sdf:this->sd->getFields ()) {
907 for (
const auto &dim:sdf->getDimensions()) {
908 if(dim->getName() !=FullXDim && dim->getName()!=FullYDim)
909 dimnameset.insert(dim->getName());
912 if (1==sdf->getRank())
921 if (fldset.size() < (dimnameset.size()+2))
924 int total_num_dims = 0;
925 size_t grid_name_size = grid_name.size();
926 string reduced_dimname;
928 for (
const auto &fld:fldset) {
929 size_t dim_size = (fld->getDimensions())[0]->getName().size();
930 if( dim_size > grid_name_size){
931 reduced_dimname = (fld->getDimensions())[0]->getName().substr(0,dim_size-grid_name_size-1);
932 if (fld->getName() == reduced_dimname)
937 if((
size_t)total_num_dims != (dimnameset.size()+2))
941 for (
const auto &sdf:this->sd->getFields()) {
943 for (
const auto &dim:sdf->getDimensions ()) {
945 size_t dim_size = dim->getName().size();
946 if( dim_size > grid_name_size){
947 reduced_dimname = dim->getName().substr(0,dim_size-grid_name_size-1);
948 dim->name = reduced_dimname;
957 for (
const auto &fld:fldset) {
959 if (fld->getName() == (fld->getDimensions())[0]->getName()) {
961 if(
"XDim" == fld->getName()){
962 std::string tempunits =
"degrees_east";
963 fld->setUnits (tempunits);
967 else if(
"YDim" == fld->getName()){
968 std::string tempunits =
"degrees_north";
969 fld->setUnits (tempunits);
973 else if(
"Pressure_Level" == fld->getName()) {
974 std::string tempunits =
"hPa";
975 fld->setUnits (tempunits);
979 std::string tempunits =
"level";
980 fld->setUnits (tempunits);
998File::Check_if_special(
const string& grid_name)
throw(
Exception) {
1001 bool xdim_is_lon =
false;
1002 bool ydim_is_lat =
false;
1003 bool pre_unit_hpa =
true;
1004 for (vector < SDField * >::const_iterator i =
1005 this->sd->getFields ().begin ();
1006 i != this->sd->getFields ().end (); ++i) {
1007 if (1==(*i)->getRank()) {
1008 if(1 == ((*i)->fieldtype)) {
1009 if(
"YDim" == (*j)->getName()
1019File::Handle_AIRS_L23() throw(
Exception) {
1023 bool airs_l3 =
true;
1024 if(basename(file->path).find(
".L2.")!=string::npos)
1028 set<string> scaled_dname_set;
1031 set<string> non_scaled_dname_set;
1032 pair<set<string>::iterator,
bool> ret;
1035 map<string,int> non_scaled_dname_to_size;
1039 for (
const auto &sdf:file->sd->sdfields) {
1041 string tempname = sdf->name;
1042 size_t found_colon = tempname.find_first_of(
':');
1043 if(found_colon!=string::npos)
1044 sdf->newname = tempname.substr(0,found_colon);
1046 for (
const auto &dim:sdf->getDimensions()) {
1048 tempname = dim->name;
1049 found_colon = tempname.find_first_of(
':');
1050 if(found_colon!=string::npos)
1051 dim->name = tempname.substr(0,found_colon);
1053 if(0==dim->getType()) {
1054 ret = non_scaled_dname_set.insert(dim->name);
1055 if (
true == ret.second)
1056 non_scaled_dname_to_size[dim->name] = dim->dimsize;
1059 scaled_dname_set.insert(dim->name);
1066for(set<string>::const_iterator sdim_it = scaled_dname_set.begin();
1067 sdim_it !=scaled_dname_set.end();
1069cerr<<
"scaled dim. name "<<*sdim_it <<endl;
1082 if(
true == airs_l3) {
1084 set<string>scaled_dname_set_marker = scaled_dname_set;
1093 for (std::vector < SDField * >::iterator i =
1094 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ) {
1095 if(1 == (*i)->getRank()) {
1096 if(scaled_dname_set.find((*i)->getNewName())!=scaled_dname_set.end()) {
1097 if(scaled_dname_set_marker.find((*i)->getNewName())!=scaled_dname_set_marker.end()) {
1098 scaled_dname_set_marker.erase((*i)->getNewName());
1104 i= file->sd->sdfields.erase(i);
1112 else if( 2 == (*i)->getRank()) {
1113 if (
"Latitude" == (*i)->getNewName() ||
"Longitude" == (*i)->getNewName()) {
1115 i = file->sd->sdfields.erase(i);
1127for(set<string>::const_iterator sdim_it = scaled_dname_set.begin();
1128 sdim_it !=scaled_dname_set.end();
1130cerr<<
"new scaled dim. name "<<*sdim_it <<endl;
1138 set<string>final_non_scaled_dname_set;
1139 for (
const auto &non_sdim:non_scaled_dname_set) {
1140 if(scaled_dname_set.find(non_sdim)==scaled_dname_set.end())
1141 final_non_scaled_dname_set.insert(non_sdim);
1145 for (
const auto &non_sdim:final_non_scaled_dname_set) {
1147 auto missingfield =
new SDField ();
1151 missingfield->type = DFNT_INT32;
1152 missingfield->name = non_sdim;
1153 missingfield->newname = non_sdim;
1154 missingfield->rank = 1;
1155 missingfield->fieldtype = 4;
1156 missingfield->setUnits(
"level");
1157 auto dim =
new Dimension (non_sdim,non_scaled_dname_to_size[non_sdim] , 0);
1159 missingfield->dims.push_back (dim);
1160 file->sd->sdfields.push_back (missingfield);
1166 if (
true == airs_l3) {
1167 for (
const auto &sdf:file->sd->sdfields) {
1169 if(1 ==sdf->getRank()){
1170 if (
"XDim" == sdf->newname)
1171 sdf->newname =
"Longitude";
1172 else if (
"YDim" == sdf->newname)
1173 sdf->newname =
"Latitude";
1176 for (
const auto &dim:sdf->getDimensions()) {
1177 if(
"XDim" == dim->name)
1178 dim->name =
"Longitude";
1179 else if (
"YDim" == dim->name)
1180 dim->name =
"Latitude";
1187 if(
false == airs_l3) {
1189 bool change_lat_unit =
false;
1190 bool change_lon_unit =
false;
1191 string ll_dimname1 =
"";
1192 string ll_dimname2 =
"";
1196 for (
const auto &sdf:file->sd->sdfields) {
1198 if(2 == sdf->getRank()) {
1199 if(
"Latitude" == sdf->newname){
1201 change_lat_unit =
true;
1202 string tempunits =
"degrees_north";
1203 sdf->setUnits(tempunits);
1204 ll_dimname1 = sdf->getDimensions()[0]->getName();
1205 ll_dimname2 = sdf->getDimensions()[1]->getName();
1208 else if(
"Longitude" == sdf->newname) {
1210 change_lon_unit =
true;
1211 string tempunits =
"degrees_east";
1212 sdf->setUnits(tempunits);
1214 if((
true == change_lat_unit) && (
true == change_lon_unit))
1220 string tempcoordinates =
"";
1221 string tempfieldname =
"";
1224 for (
const auto &sdf:file->sd->sdfields) {
1227 bool dimscale_var =
false;
1228 dimscale_var = (sdf->rank == 1) & ((sdf->newname) == (sdf->getDimensions()[0]->getName()));
1230 if ((0 ==sdf->fieldtype) && (
false == dimscale_var)) {
1233 tempcoordinates =
"";
1237 bool has_lldim1 =
false;
1238 bool has_lldim2 =
false;
1239 for (
const auto &dim:sdf->getDimensions ()) {
1240 if(dim->name == ll_dimname1)
1242 else if (dim->name == ll_dimname2)
1244 if((
true == has_lldim1) && (
true == has_lldim2))
1249 if ((
true == has_lldim1) && (
true == has_lldim2)) {
1250 for (
const auto &dim:sdf->getDimensions ()) {
1251 if(dim->name == ll_dimname1)
1252 tempfieldname =
"Latitude";
1253 else if (dim->name == ll_dimname2)
1254 tempfieldname =
"Longitude";
1256 tempfieldname = dim->name;
1259 tempcoordinates = tempfieldname;
1261 tempcoordinates = tempcoordinates +
" " + tempfieldname;
1266 for (
const auto &dim:sdf->getDimensions()) {
1268 tempcoordinates = dim->name;
1270 tempcoordinates = tempcoordinates +
" " + dim->name;
1274 sdf->setCoordinates (tempcoordinates);
1292 if (this->sptype == OTHERHDF) {
1294 int trmm_multi_gridflag = 0;
1295 int trmm_single_gridflag = 0;
1296 int trmm_swathflag = 0;
1299 if (attr->getName () ==
"FileHeader") {
1300 trmm_multi_gridflag++;
1301 trmm_single_gridflag++;
1304 if (attr->getName () ==
"FileInfo") {
1305 trmm_multi_gridflag++;
1306 trmm_single_gridflag++;
1309 if (attr->getName () ==
"SwathHeader")
1312 if (attr->getName () ==
"GridHeader")
1313 trmm_single_gridflag++;
1315 else if ((attr->getName ().find (
"GridHeader") == 0) &&
1316 ((attr->getName()).size() >10))
1317 trmm_multi_gridflag++;
1322 if(3 == trmm_single_gridflag)
1323 this->sptype = TRMML3S_V7;
1324 else if(3 == trmm_swathflag)
1325 this->sptype = TRMML2_V7;
1326 else if(trmm_multi_gridflag >3)
1327 this->sptype = TRMML3M_V7;
1333 if (this->sptype == OTHERHDF) {
1335 int metadataflag = 0;
1338 if (attr->getName () ==
"CoreMetadata.0")
1340 if (attr->getName () ==
"ArchiveMetadata.0")
1342 if (attr->getName () ==
"StructMetadata.0")
1344 if (attr->getName ().find (
"SubsettingMethod") !=
1353 if (metadataflag == 4)
1354 this->sptype = MODISARNSS;
1358 if (metadataflag == 2) {
1360 for (
const auto &sdf:this->sd->
getFields ()) {
1361 if ((sdf->getName () ==
"geolocation")
1362 && sdf->getNewName ().find (
"DATA_GRANULE") != string::npos
1363 && sdf->getNewName ().find (
"SwathData") != string::npos
1364 && sdf->getRank () == 3) {
1365 this->sptype = TRMML2_V6;
1378 if (this->sptype == OTHERHDF) {
1379 for (
const auto &sdf:this->sd->
getFields ()) {
1380 if (sdf->getNewName ().find (
"DATA_GRANULE") != string::npos) {
1381 bool l3b_v6_lonflag =
false;
1382 bool l3b_v6_latflag =
false;
1383 for (std::vector < Dimension * >::const_iterator k =
1384 sdf->getDimensions ().begin ();
1385 k != sdf->getDimensions ().end (); ++k) {
1386 if ((*k)->getSize () == 1440)
1387 l3b_v6_lonflag =
true;
1389 if ((*k)->getSize () == 400)
1390 l3b_v6_latflag =
true;
1392 if (l3b_v6_lonflag ==
true && l3b_v6_latflag ==
true) {
1393 this->sptype = TRMML3B_V6;
1397 bool l3a_v6_latflag =
false;
1398 bool l3a_v6_lonflag =
false;
1400 bool l3c_v6_lonflag =
false;
1401 bool l3c_v6_latflag =
false;
1403 if (sdf->getRank()>2) {
1404 for (
const auto &dim:sdf->getDimensions()) {
1405 if (dim->getSize () == 360)
1406 l3a_v6_lonflag =
true;
1408 if (dim->getSize () == 180)
1409 l3a_v6_latflag =
true;
1411 if (dim->getSize () == 720)
1412 l3c_v6_lonflag =
true;
1414 if (dim->getSize () == 148)
1415 l3c_v6_latflag =
true;
1420 if (
true == l3a_v6_latflag &&
true == l3a_v6_lonflag) {
1421 this->sptype = TRMML3A_V6;
1425 if (
true == l3c_v6_latflag &&
true == l3c_v6_lonflag) {
1426 this->sptype = TRMML3C_V6;
1436if(this->sptype == TRMML3A_V6)
1437cerr<<
"3A46 products "<<endl;
1438if(this->sptype == TRMML3C_V6)
1439cerr<<
"CSH products "<<endl;
1449 if (this->sptype == OTHERHDF) {
1452 int modisal2flag = 0;
1455 int modistl2flag = 0;
1461 int seawifsl2flag = 0;
1467 int modisal3mflag = 0;
1470 int modistl3mflag = 0;
1473 int octsl3mflag = 0;
1476 int seawifsl3mflag = 0;
1479 int czcsl3mflag = 0;
1487 if (attr->getName () ==
"Product Name") {
1489 std::string attrvalue (attr->getValue ().begin (),
1490 attr->getValue ().end ());
1491 if ((attrvalue.find_first_of (
'A', 0) == 0)
1492 && (attrvalue.find (
".L2", 0) != std::string::npos))
1494 else if ((attrvalue.find_first_of (
'A', 0) == 0)
1495 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1497 else if ((attrvalue.find_first_of (
'T', 0) == 0)
1498 && (attrvalue.find (
".L2", 0) != std::string::npos))
1500 else if ((attrvalue.find_first_of (
'T', 0) == 0)
1501 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1503 else if ((attrvalue.find_first_of (
'O', 0) == 0)
1504 && (attrvalue.find (
".L2", 0) != std::string::npos))
1506 else if ((attrvalue.find_first_of (
'O', 0) == 0)
1507 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1509 else if ((attrvalue.find_first_of (
'S', 0) == 0)
1510 && (attrvalue.find (
".L2", 0) != std::string::npos))
1512 else if ((attrvalue.find_first_of (
'S', 0) == 0)
1513 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1515 else if ((attrvalue.find_first_of (
'C', 0) == 0)
1516 && ((attrvalue.find (
".L2", 0) != std::string::npos)
1518 (attrvalue.find (
".L1A", 0) != std::string::npos)))
1520 else if ((attrvalue.find_first_of (
'C', 0) == 0)
1521 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1524 if (attr->getName () ==
"Sensor Name") {
1526 std::string attrvalue (attr->getValue ().begin (),
1527 attr->getValue ().end ());
1528 if (attrvalue.find (
"MODISA", 0) != std::string::npos) {
1532 else if (attrvalue.find (
"MODIST", 0) != std::string::npos) {
1536 else if (attrvalue.find (
"OCTS", 0) != std::string::npos) {
1540 else if (attrvalue.find (
"SeaWiFS", 0) != std::string::npos) {
1544 else if (attrvalue.find (
"CZCS", 0) != std::string::npos) {
1550 if ((modisal2flag == 2) || (modisal3mflag == 2)
1551 || (modistl2flag == 2) || (modistl3mflag == 2)
1552 || (octsl2flag == 2) || (octsl3mflag == 2)
1553 || (seawifsl2flag == 2) || (seawifsl3mflag == 2)
1554 || (czcsl2flag == 2) || (czcsl3mflag == 2))
1561 if ((modisal2flag == 2) || (modistl2flag == 2) ||
1562 (octsl2flag == 2) || (seawifsl2flag == 2) || (czcsl2flag == 2))
1563 this->sptype = OBPGL2;
1565 if ((modisal3mflag == 2) ||
1566 (modistl3mflag == 2) || (octsl3mflag == 2) ||
1567 (seawifsl3mflag == 2) || (czcsl3mflag == 2))
1568 this->sptype = OBPGL3;
1586 int32 n_sd_attrs = 0;
1592 int32 dim_sizes[H4_MAX_VAR_DIMS];
1595 int32 n_sds_attrs = 0;
1601 char sds_name[H4_MAX_NC_NAME];
1604 char dim_name[H4_MAX_NC_NAME];
1607 char attr_name[H4_MAX_NC_NAME];
1625 int32 attr_value_count = 0;
1628 auto sd =
new SD ();
1632 if (SDfileinfo (sdfd, &n_sds, &n_sd_attrs) == FAIL) {
1634 throw2 (
"SDfileinfo failed ", sdfd);
1638 for (
int sds_index = 0; sds_index < n_sds; sds_index++) {
1644 sds_id = SDselect (sdfd, sds_index);
1645 if (sds_id == FAIL) {
1649 SDendaccess (sds_id);
1650 throw3 (
"SDselect Failed ",
"SDS index ", sds_index);
1654 sds_ref = SDidtoref (sds_id);
1655 if (sds_ref == FAIL) {
1658 SDendaccess (sds_id);
1659 throw3 (
"Cannot obtain SDS reference number",
" SDS ID is ",
1664 status = SDgetinfo (sds_id, sds_name, &field->rank, dim_sizes,
1665 &field->type, &n_sds_attrs);
1666 if (status == FAIL) {
1669 SDendaccess (sds_id);
1670 throw2 (
"SDgetinfo failed ", sds_name);
1674 string tempname (sds_name);
1675 field->name = tempname;
1676 field->newname = field->name;
1677 field->fieldref = sds_ref;
1679 sd->refindexlist[sds_ref] = sds_index;
1682 bool dim_no_dimscale =
false;
1683 vector <int> dimids;
1685 dimids.assign(field->rank,0);
1688 vector <int>num_dim_attrs;
1690 num_dim_attrs.assign(field->rank,0);
1693 for (
int dimindex = 0; dimindex < field->rank; dimindex++) {
1696 int dimid = SDgetdimid (sds_id, dimindex);
1697 if (dimid == FAIL) {
1700 SDendaccess (sds_id);
1701 throw5 (
"SDgetdimid failed ",
"SDS name ", sds_name,
1702 "dim index= ", dimindex);
1706 int32 temp_num_dim_attrs = 0;
1707 status = SDdiminfo (dimid, dim_name, &dim_size, &dim_type, &temp_num_dim_attrs);
1708 if (status == FAIL) {
1711 SDendaccess (sds_id);
1712 throw5 (
"SDdiminfo failed ",
"SDS name ", sds_name,
1713 "dim index= ", dimindex);
1716 num_dim_attrs[dimindex] = temp_num_dim_attrs;
1735 string dim_name_str (dim_name);
1739 auto dim =
new Dimension (dim_name_str, dim_sizes[dimindex], dim_type);
1742 field->dims.push_back (dim);
1746 dimids[dimindex] = dimid;
1747 if (0 == dim_type) {
1748 if (
false == dim_no_dimscale)
1749 dim_no_dimscale =
true;
1750 if ((dim_name_str == field->name) && (1 == field->rank))
1751 field->is_noscale_dim =
true;
1758 if(
true == dim_no_dimscale) {
1760 for (
int dimindex = 0; dimindex < field->rank; dimindex++) {
1762 string dim_name_str = (field->dims)[dimindex]->name;
1765 stringstream out_index;
1766 out_index << dimindex;
1767 index_str = out_index.str();
1768 dim_info->name =
"_dim_" + index_str;
1772 bool dimname_flag =
false;
1774 int32 dummy_type = 0;
1775 int32 dummy_value_count = 0;
1778 for (
int attrindex = 0; attrindex < num_dim_attrs[dimindex]; attrindex++) {
1780 status = SDattrinfo(dimids[dimindex],attrindex,attr_name,
1781 &dummy_type,&dummy_value_count);
1782 if (status == FAIL) {
1785 SDendaccess (sds_id);
1786 throw3 (
"SDattrinfo failed ",
"SDS name ", sds_name);
1789 string tempname2(attr_name);
1790 if (
"name"==tempname2) {
1791 dimname_flag =
true;
1797 for (
int attrindex = 0; attrindex < num_dim_attrs[dimindex]; attrindex++) {
1800 status = SDattrinfo(dimids[dimindex],attrindex,attr_name,
1801 &attr->type,&attr_value_count);
1802 if (status == FAIL) {
1805 SDendaccess (sds_id);
1806 throw3 (
"SDattrinfo failed ",
"SDS name ", sds_name);
1808 string tempname3 (attr_name);
1809 attr->name = tempname3;
1812 attr->newname = tempname3;
1813 attr->count = attr_value_count;
1814 attr->value.resize (attr_value_count * DFKNTsize (attr->type));
1815 if (SDreadattr (dimids[dimindex], attrindex, &attr->value[0]) == -1) {
1818 SDendaccess (sds_id);
1819 throw5 (
"read SDS attribute failed ",
"Field name ",
1820 field->name,
" Attribute name ", attr->name);
1823 dim_info->attrs.push_back (attr);
1829 if (
false == dimname_flag) {
1832 attr->name =
"name";
1833 attr->newname =
"name";
1834 attr->type = DFNT_CHAR;
1835 attr->count = dim_name_str.size();
1836 attr->value.resize(attr->count);
1837 copy(dim_name_str.begin(),dim_name_str.end(),attr->value.begin());
1838 dim_info->attrs.push_back(attr);
1841 field->dims_info.push_back(dim_info);
1846 for (
int attrindex = 0; attrindex < n_sds_attrs; attrindex++) {
1849 SDattrinfo (sds_id, attrindex, attr_name, &attr->type,
1852 if (status == FAIL) {
1856 SDendaccess (sds_id);
1857 throw3 (
"SDattrinfo failed ",
"SDS name ", sds_name);
1860 if(attr !=
nullptr) {
1861 string tempname4 (attr_name);
1862 attr->name = tempname4;
1865 attr->newname = tempname4;
1866 attr->count = attr_value_count;
1867 attr->value.resize (attr_value_count * DFKNTsize (attr->type));
1868 if (SDreadattr (sds_id, attrindex, &attr->value[0]) == -1) {
1869 string temp_field_name = field->name;
1870 string temp_attr_name = attr->name;
1874 SDendaccess (sds_id);
1875 throw5 (
"read SDS attribute failed ",
"Field name ",
1876 temp_field_name,
" Attribute name ", temp_attr_name);
1878 field->attrs.push_back (attr);
1881 SDendaccess (sds_id);
1882 sd->sdfields.push_back (field);
1886 for (
int attrindex = 0; attrindex < n_sd_attrs; attrindex++) {
1889 status = SDattrinfo (sdfd, attrindex, attr_name, &attr->type,
1891 if (status == FAIL) {
1894 throw3 (
"SDattrinfo failed ",
"SD id ", sdfd);
1896 if(attr !=
nullptr) {
1897 std::string tempname5 (attr_name);
1898 attr->name = tempname5;
1902 attr->newname = tempname5;
1903 attr->count = attr_value_count;
1904 attr->value.resize (attr_value_count * DFKNTsize (attr->type));
1905 if (SDreadattr (sdfd, attrindex, &attr->value[0]) == -1) {
1908 throw3 (
"Cannot read SD attribute",
" Attribute name ",
1911 sd->attrs.push_back (attr);
1931 int32 n_sd_attrs = 0;
1937 int extra_sds_index = 0;
1943 int32 dim_sizes[H4_MAX_VAR_DIMS];
1946 int32 n_sds_attrs = 0;
1952 char sds_name[H4_MAX_NC_NAME];
1955 char dim_name[H4_MAX_NC_NAME];
1958 char attr_name[H4_MAX_NC_NAME];
1971 int32 num_dim_attrs = 0;
1974 int32 attr_value_count = 0;
1978 int32 vgroup_id = 0;
1981 int32 lone_vg_number = 0;
1984 int32 num_of_lones = -1;
1986 int32 num_gobjects = 0;
1995 char vgroup_name[VGNAMELENMAX*4];
1996 char vgroup_class[VGNAMELENMAX*4];
1999 char *full_path =
nullptr;
2003 char *cfull_path =
nullptr;
2010 if (SDfileinfo (sdfd, &n_sds, &n_sd_attrs) == FAIL) {
2013 throw2 (
"SDfileinfo failed ", sdfd);
2018 for (sds_index = 0; sds_index < n_sds; sds_index++) {
2019 sds_id = SDselect (sdfd, sds_index);
2021 if (sds_id == FAIL) {
2026 SDendaccess (sds_id);
2027 throw3 (
"SDselect Failed ",
"SDS index ", sds_index);
2030 sds_ref = SDidtoref (sds_id);
2031 if (sds_ref == FAIL) {
2034 SDendaccess (sds_id);
2035 throw3 (
"Cannot obtain SDS reference number",
" SDS ID is ",
2038 sd->sds_ref_list.push_back(sds_ref);
2039 SDendaccess(sds_id);
2048 num_of_lones = Vlone (fileid,
nullptr, 0);
2049 if (num_of_lones == FAIL){
2052 throw3 (
"Fail to obtain lone vgroup number",
"file id is", fileid);
2056 if (num_of_lones > 0) {
2060 vector<int32>ref_array;
2061 ref_array.resize(num_of_lones);
2065 num_of_lones = Vlone (fileid, ref_array.data(), num_of_lones);
2066 if (num_of_lones == FAIL) {
2069 throw3 (
"Cannot obtain lone vgroup reference arrays ",
2070 "file id is ", fileid);
2074 for (lone_vg_number = 0; lone_vg_number < num_of_lones;
2078 vgroup_id = Vattach (fileid, ref_array[lone_vg_number],
"r");
2079 if (vgroup_id == FAIL) {
2082 throw3 (
"Vattach failed ",
"Reference number is ",
2083 ref_array[lone_vg_number]);
2086 status = Vgetname (vgroup_id, vgroup_name);
2087 if (status == FAIL) {
2090 Vdetach (vgroup_id);
2091 throw3 (
"Vgetname failed ",
"vgroup_id is ", vgroup_id);
2094 status = Vgetclass (vgroup_id, vgroup_class);
2095 if (status == FAIL) {
2098 Vdetach (vgroup_id);
2099 throw3 (
"Vgetclass failed ",
"vgroup_name is ", vgroup_name);
2103 if (strcmp (vgroup_class, _HDF_ATTRIBUTE) == 0
2104 || strcmp (vgroup_class, _HDF_VARIABLE) == 0
2105 || strcmp (vgroup_class, _HDF_DIMENSION) == 0
2106 || strcmp (vgroup_class, _HDF_UDIMENSION) == 0
2107 || strcmp (vgroup_class, _HDF_CDF) == 0
2108 || strcmp (vgroup_class, GR_NAME) == 0
2109 || strcmp (vgroup_class, RI_NAME) == 0) {
2110 Vdetach (vgroup_id);
2115 num_gobjects = Vntagrefs (vgroup_id);
2116 if (num_gobjects < 0) {
2119 Vdetach (vgroup_id);
2120 throw3 (
"Vntagrefs failed ",
"vgroup_name is ", vgroup_name);
2133 full_path = (
char *) malloc (MAX_FULL_PATH_LEN);
2134 if (full_path ==
nullptr) {
2137 Vdetach (vgroup_id);
2138 throw1 (
"No enough memory to allocate the buffer.");
2141 memset(full_path,
'\0',MAX_FULL_PATH_LEN);
2142 strncpy(full_path,_BACK_SLASH,strlen(_BACK_SLASH));
2143 strncat(full_path, vgroup_name,strlen(vgroup_name));
2145 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
2146 if (cfull_path ==
nullptr) {
2149 Vdetach (vgroup_id);
2150 if(full_path !=
nullptr)
2152 throw1 (
"No enough memory to allocate the buffer.");
2155 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
2156 strncpy (cfull_path, full_path,strlen(full_path));
2159 for (
int i = 0; i < num_gobjects; i++) {
2162 if (Vgettagref (vgroup_id, i, &obj_tag, &obj_ref) == FAIL) {
2165 Vdetach (vgroup_id);
2166 if(full_path !=
nullptr)
2168 if(cfull_path !=
nullptr)
2170 throw5 (
"Vgettagref failed ",
"vgroup_name is ",
2171 vgroup_name,
" reference number is ", obj_ref);
2175 if (Visvg (vgroup_id, obj_ref) == TRUE) {
2176 strncpy(full_path,cfull_path,strlen(cfull_path)+1);
2177 full_path[strlen(cfull_path)]=
'\0';
2182 else if (obj_tag == DFTAG_NDG || obj_tag == DFTAG_SDG
2183 || obj_tag == DFTAG_SD) {
2189 auto temp_str = string(full_path);
2190 if((temp_str.find(
"Data Fields") != std::string::npos)||
2191 (temp_str.find(
"Geolocation Fields") != std::string::npos))
2192 sd->sds_ref_list.remove(obj_ref);
2200 status = Vdetach (vgroup_id);
2202 if (status == FAIL) {
2205 throw3 (
"Vdetach failed ",
"vgroup_name is ", vgroup_name);
2213 for(std::list<int32>::iterator sds_ref_it = sd->sds_ref_list.begin();
2214 sds_ref_it!=sd->sds_ref_list.end();++sds_ref_it) {
2216 for (
const auto &sds_ref:sd->sds_ref_list) {
2218 extra_sds_index = SDreftoindex(sdfd,sds_ref);
2219 if(extra_sds_index == FAIL) {
2221 throw3(
"SDreftoindex Failed ",
"SDS reference number ", sds_ref);
2225 sds_id = SDselect (sdfd, extra_sds_index);
2226 if (sds_id == FAIL) {
2230 SDendaccess (sds_id);
2231 throw3 (
"SDselect Failed ",
"SDS index ", extra_sds_index);
2235 status = SDgetinfo (sds_id, sds_name, &field->rank, dim_sizes,
2236 &field->type, &n_sds_attrs);
2237 if (status == FAIL) {
2240 SDendaccess (sds_id);
2241 throw2 (
"SDgetinfo failed ", sds_name);
2245 string tempname (sds_name);
2246 field->name = tempname;
2248 field->newname = tempname+
"_"+
"NONEOS";
2249 field->fieldref = sds_ref;
2250 sd->refindexlist[sds_ref] = extra_sds_index;
2253 for (
int dimindex = 0; dimindex < field->rank; dimindex++) {
2254 int dimid = SDgetdimid (sds_id, dimindex);
2255 if (dimid == FAIL) {
2258 SDendaccess (sds_id);
2259 throw5 (
"SDgetdimid failed ",
"SDS name ", sds_name,
2260 "dim index= ", dimindex);
2262 status = SDdiminfo (dimid, dim_name, &dim_size, &dim_type,
2265 if (status == FAIL) {
2268 SDendaccess (sds_id);
2269 throw5 (
"SDdiminfo failed ",
"SDS name ", sds_name,
2270 "dim index= ", dimindex);
2273 string dim_name_str (dim_name);
2277 auto dim =
new Dimension (dim_name_str, dim_sizes[dimindex], dim_type);
2279 field->dims.push_back (dim);
2299 new Dimension (cfdimname, dim_sizes[dimindex], dim_type);
2301 field->correcteddims.push_back (correcteddim);
2306 for (
int attrindex = 0; attrindex < n_sds_attrs; attrindex++) {
2310 status = SDattrinfo (sds_id, attrindex, attr_name, &attr->type,
2312 if (status == FAIL) {
2316 SDendaccess (sds_id);
2317 throw3 (
"SDattrinfo failed ",
"SDS name ", sds_name);
2320 string temp_attrname (attr_name);
2321 attr->name = temp_attrname;
2325 attr->newname = temp_attrname;
2326 attr->count = attr_value_count;
2327 attr->value.resize (attr_value_count * DFKNTsize (attr->type));
2328 if (SDreadattr (sds_id, attrindex, &attr->value[0]) == -1) {
2332 SDendaccess (sds_id);
2333 throw5 (
"read SDS attribute failed ",
"Field name ",
2334 field->name,
" Attribute name ", attr->name);
2336 field->attrs.push_back (attr);
2338 SDendaccess (sds_id);
2339 sd->sdfields.push_back (field);
2351 int32 fieldsize = 0;
2354 int32 fieldtype = 0;
2357 int32 fieldorder = 0;
2360 char *fieldname =
nullptr;
2364 char vdata_name[VSNAMELENMAX];
2366 auto vdata =
new VDATA (obj_ref);
2368 vdata->vdref = obj_ref;
2370 if (VSQueryname (vdata_id, vdata_name) == FAIL){
2372 throw3 (
"VSQueryname failed ",
"vdata id is ", vdata_id);
2375 string vdatanamestr (vdata_name);
2377 vdata->name = vdatanamestr;
2379 int32 num_field = VFnfields (vdata_id);
2381 if (num_field == -1){
2383 throw3 (
"For vdata, VFnfields failed. ",
"vdata name is ",
2387 int32 num_record = VSelts (vdata_id);
2389 if (num_record == -1) {
2391 throw3 (
"For vdata, VSelts failed. ",
"vdata name is ", vdata->name);
2402 if (num_record <= 10 &&
true == HDF4RequestHandler::get_enable_vdata_attr())
2403 vdata->TreatAsAttrFlag =
true;
2405 vdata->TreatAsAttrFlag =
false;
2408 for (
int i = 0; i < num_field; i++) {
2412 if(field ==
nullptr) {
2414 throw1(
"Memory allocation for field class failed.");
2417 fieldsize = VFfieldesize (vdata_id, i);
2418 if (fieldsize == FAIL) {
2419 string temp_vdata_name = vdata->name;
2422 throw5 (
"For vdata field, VFfieldsize failed. ",
"vdata name is ",
2423 temp_vdata_name,
" index is ", i);
2426 fieldname = VFfieldname (vdata_id, i);
2427 if (fieldname ==
nullptr) {
2428 string temp_vdata_name = vdata->name;
2431 throw5 (
"For vdata field, VFfieldname failed. ",
"vdata name is ",
2432 temp_vdata_name,
" index is ", i);
2435 fieldtype = VFfieldtype (vdata_id, i);
2436 if (fieldtype == FAIL) {
2437 string temp_vdata_name = vdata->name;
2440 throw5 (
"For vdata field, VFfieldtype failed. ",
"vdata name is ",
2441 temp_vdata_name,
" index is ", i);
2444 fieldorder = VFfieldorder (vdata_id, i);
2445 if (fieldorder == FAIL) {
2446 string temp_vdata_name = vdata->name;
2449 throw5 (
"For vdata field, VFfieldtype failed. ",
"vdata name is ",
2450 temp_vdata_name,
" index is ", i);
2453 if(fieldname !=
nullptr)
2454 field->name = fieldname;
2456 field->type = fieldtype;
2457 field->order = fieldorder;
2458 field->size = fieldsize;
2460 field->numrec = num_record;
2468 if (vdata->getTreatAsAttrFlag () && num_record > 0) {
2470 field->value.resize (num_record * fieldsize);
2471 if (VSseek (vdata_id, 0) == FAIL) {
2472 if(field !=
nullptr)
2474 if(vdata !=
nullptr)
2476 throw5 (
"vdata ", vdata_name,
"field ", fieldname,
2480 if (VSsetfields (vdata_id, fieldname) == FAIL) {
2481 if(field !=
nullptr)
2483 if(vdata !=
nullptr)
2485 throw3 (
"vdata field ", fieldname,
" VSsetfields failed.");
2489 (vdata_id, (uint8 *) & field->value[0], num_record,
2490 FULL_INTERLACE) == FAIL){
2491 if(field !=
nullptr)
2493 if(vdata !=
nullptr)
2495 throw3 (
"vdata field ", fieldname,
" VSread failed.");
2500 if(field !=
nullptr) {
2503 field->ReadAttributes (vdata_id, i);
2510 vdata->vdfields.push_back (field);
2516 vdata->ReadAttributes (vdata_id);
2534 char attr_name[H4_MAX_NC_NAME];
2546 nattrs = VSfnattrs (vdata_id, _HDF_VDATA);
2551 throw3 (
"VSfnattrs failed ",
"vdata id is ", vdata_id);
2557 for (
int i = 0; i < nattrs; i++) {
2561 status = VSattrinfo (vdata_id, _HDF_VDATA, i, attr_name,
2562 &attr->type, &attr->count, &attrsize);
2563 if (status == FAIL) {
2565 throw5 (
"VSattrinfo failed ",
"vdata id is ", vdata_id,
2566 " attr index is ", i);
2570 string tempname(attr_name);
2571 if(attr !=
nullptr) {
2572 attr->name = tempname;
2574 attr->value.resize (attrsize);
2576 if (VSgetattr (vdata_id, _HDF_VDATA, i, &attr->value[0]) == FAIL) {
2578 throw5 (
"VSgetattr failed ",
"vdata id is ", vdata_id,
2579 " attr index is ", i);
2581 attrs.push_back (attr);
2596 char attr_name[H4_MAX_NC_NAME];
2608 nattrs = VSfnattrs (vdata_id, fieldindex);
2613 throw5 (
"VSfnattrs failed ",
"vdata id is ", vdata_id,
2614 "Field index is ", fieldindex);
2620 for (
int i = 0; i < nattrs; i++) {
2624 status = VSattrinfo (vdata_id, fieldindex, i, attr_name,
2625 &attr->type, &attr->count, &attrsize);
2627 if (status == FAIL) {
2629 throw5 (
"VSattrinfo failed ",
"vdata field index ",
2630 fieldindex,
" attr index is ", i);
2633 if (attr !=
nullptr) {
2635 string tempname(attr_name);
2636 attr->name = tempname;
2641 attr->value.resize (attrsize);
2642 if (VSgetattr (vdata_id, fieldindex, i, &attr->value[0]) == FAIL) {
2644 throw5 (
"VSgetattr failed ",
"vdata field index is ",
2645 fieldindex,
" attr index is ", i);
2647 attrs.push_back (attr);
2658 char attr_name[H4_MAX_NC_NAME];
2661 intn n_attrs = Vnattrs(vgroup_id);
2663 throw1(
"Vnattrs failed");
2666 string temp_container_name(fullpath);
2670 for(
int attr_index = 0; attr_index <n_attrs; attr_index++) {
2673 int32 value_size_32 = 0;
2674 status_n = Vattrinfo(vgroup_id, attr_index, attr_name, &attr->type,
2675 &attr->count, &value_size_32);
2676 if(status_n == FAIL) {
2678 throw1(
"Vattrinfo failed.");
2680 int value_size = value_size_32;
2682 string tempname (attr_name);
2683 if(attr !=
nullptr) {
2684 attr->name = tempname;
2686 attr->newname = tempname;
2687 attr->value.resize (value_size);
2689 status_n = Vgetattr(vgroup_id,(intn)attr_index,&attr->value[0]);
2690 if(status_n == FAIL) {
2693 throw3(
"Vgetattr failed. ",
"The attribute name is ",attr->name);
2695 vg_attr->attrs.push_back(attr);
2699 if(vg_attr !=
nullptr)
2700 vg_attrs.push_back(vg_attr);
2720 int32 vgroup_id = 0;
2726 int32 num_of_lones = -1;
2729 int32 num_gobjects = 0;
2739 char vdata_name[VSNAMELENMAX];
2742 char vdata_class[VSNAMELENMAX];
2745 char vgroup_name[VGNAMELENMAX*4];
2748 char vgroup_class[VGNAMELENMAX*4];
2751 char *full_path =
nullptr;
2754 char *cfull_path =
nullptr;
2759 file_id = this->fileid;
2765 num_of_lones = Vlone (file_id,
nullptr, 0);
2766 if (num_of_lones == FAIL)
2767 throw3 (
"Fail to obtain lone vgroup number",
"file id is", file_id);
2770 if (num_of_lones > 0) {
2774 vector<int32>ref_array;
2775 ref_array.resize(num_of_lones);
2779 num_of_lones = Vlone (file_id, ref_array.data(), num_of_lones);
2780 if (num_of_lones == FAIL) {
2781 throw3 (
"Cannot obtain lone vgroup reference arrays ",
2782 "file id is ", file_id);
2786 for (
int lone_vg_number = 0; lone_vg_number < num_of_lones;
2790 vgroup_id = Vattach (file_id, ref_array[lone_vg_number],
"r");
2791 if (vgroup_id == FAIL) {
2792 throw3 (
"Vattach failed ",
"Reference number is ",
2793 ref_array[lone_vg_number]);
2796 status = Vgetname (vgroup_id, vgroup_name);
2797 if (status == FAIL) {
2798 Vdetach (vgroup_id);
2799 throw3 (
"Vgetname failed ",
"vgroup_id is ", vgroup_id);
2802 status = Vgetclass (vgroup_id, vgroup_class);
2803 if (status == FAIL) {
2804 Vdetach (vgroup_id);
2805 throw3 (
"Vgetclass failed ",
"vgroup_name is ", vgroup_name);
2809 if (strcmp (vgroup_class, _HDF_ATTRIBUTE) == 0
2810 || strcmp (vgroup_class, _HDF_VARIABLE) == 0
2811 || strcmp (vgroup_class, _HDF_DIMENSION) == 0
2812 || strcmp (vgroup_class, _HDF_UDIMENSION) == 0
2813 || strcmp (vgroup_class, _HDF_CDF) == 0
2814 || strcmp (vgroup_class, GR_NAME) == 0
2815 || strcmp (vgroup_class, RI_NAME) == 0) {
2820 num_gobjects = Vntagrefs (vgroup_id);
2821 if (num_gobjects < 0) {
2822 Vdetach (vgroup_id);
2823 throw3 (
"Vntagrefs failed ",
"vgroup_name is ", vgroup_name);
2831 full_path = (
char *) malloc (MAX_FULL_PATH_LEN);
2832 if (full_path ==
nullptr) {
2833 Vdetach (vgroup_id);
2834 throw1 (
"No enough memory to allocate the buffer.");
2837 memset(full_path,
'\0',MAX_FULL_PATH_LEN);
2838 strncpy (full_path,_BACK_SLASH,strlen(_BACK_SLASH));
2839 strncat(full_path,vgroup_name,strlen(vgroup_name));
2846 Vdetach (vgroup_id);
2848 throw1 (
"ReadVgattrs failed ");
2850 strncat(full_path,_BACK_SLASH,strlen(_BACK_SLASH));
2852 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
2853 if (cfull_path ==
nullptr) {
2854 Vdetach (vgroup_id);
2856 throw1 (
"No enough memory to allocate the buffer.");
2859 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
2860 strncpy (cfull_path, full_path,strlen(full_path));
2864 for (
int i = 0; i < num_gobjects; i++) {
2865 if (Vgettagref (vgroup_id, i, &obj_tag, &obj_ref) == FAIL) {
2866 Vdetach (vgroup_id);
2869 throw5 (
"Vgettagref failed ",
"vgroup_name is ",
2870 vgroup_name,
" reference number is ", obj_ref);
2874 if (Visvg (vgroup_id, obj_ref) == TRUE) {
2875 strncpy (full_path, cfull_path,strlen(cfull_path)+1);
2876 full_path[strlen(cfull_path)]=
'\0';
2880 else if (Visvs (vgroup_id, obj_ref)) {
2882 vdata_id = VSattach (file_id, obj_ref,
"r");
2883 if (vdata_id == FAIL) {
2884 Vdetach (vgroup_id);
2887 throw5 (
"VSattach failed ",
"vgroup_name is ",
2888 vgroup_name,
" reference number is ",
2891 status = VSgetname (vdata_id, vdata_name);
2892 if (status == FAIL) {
2893 Vdetach (vgroup_id);
2896 throw5 (
"VSgetclass failed ",
"vgroup_name is ",
2897 vgroup_name,
" reference number is ",
2901 status = VSgetclass (vdata_id, vdata_class);
2902 if (status == FAIL) {
2903 Vdetach (vgroup_id);
2906 throw5 (
"VSgetclass failed ",
"vgroup_name is ",
2907 vgroup_name,
" reference number is ",
2920 if (VSisattr (vdata_id) == TRUE
2921 || !strncmp (vdata_class, _HDF_CHK_TBL_CLASS,
2922 strlen (_HDF_CHK_TBL_CLASS))
2923 || !strncmp (vdata_class, _HDF_SDSVAR,
2924 strlen (_HDF_SDSVAR))
2925 || !strncmp (vdata_class, _HDF_CRDVAR,
2926 strlen (_HDF_CRDVAR))
2927 || !strncmp (vdata_class, DIM_VALS, strlen (DIM_VALS))
2928 || !strncmp (vdata_class, DIM_VALS01,
2929 strlen (DIM_VALS01))
2930 || !strncmp (vdata_class, RIGATTRCLASS,
2931 strlen (RIGATTRCLASS))
2932 || !strncmp (vdata_name, RIGATTRNAME,
2933 strlen (RIGATTRNAME))) {
2935 status = VSdetach (vdata_id);
2936 if (status == FAIL) {
2937 Vdetach (vgroup_id);
2940 throw3 (
"VSdetach failed ",
2941 "Vdata is under vgroup ", vgroup_name);
2947 VDATA*vdataobj =
nullptr;
2955 Vdetach (vgroup_id);
2960 vdataobj->newname = full_path +vdataobj->name;
2965 for (
const auto &vdf:vdataobj->
getFields ()) {
2971 "vdata" + vdataobj->newname +
"_vdf_" + vdf->name;
2980 this->vds.push_back (vdataobj);
2982 status = VSdetach (vdata_id);
2983 if (status == FAIL) {
2984 Vdetach (vgroup_id);
2987 throw3 (
"VSdetach failed ",
2988 "Vdata is under vgroup ", vgroup_name);
2994 else if (obj_tag == DFTAG_NDG || obj_tag == DFTAG_SDG
2995 || obj_tag == DFTAG_SD) {
2998 if (this->sd->refindexlist.find (obj_ref) != sd->refindexlist.end ()) {
3002 if(full_path !=
nullptr) {
3003 this->sd->sdfields[this->sd->refindexlist[obj_ref]]->newname =
3005 this->sd->sdfields[this->sd->refindexlist[obj_ref]]->name;
3009 Vdetach (vgroup_id);
3012 throw3 (
"SDS with the reference number ", obj_ref,
3020 status = Vdetach (vgroup_id);
3021 if (status == FAIL) {
3022 throw3 (
"Vdetach failed ",
"vgroup_name is ", vgroup_name);
3038 int32 vgroup_pid = -1;
3047 int num_gobjects = 0;
3055 char cvgroup_name[VGNAMELENMAX*4];
3058 char vdata_name[VSNAMELENMAX];
3061 char vdata_class[VSNAMELENMAX];
3064 int32 vdata_id = -1;
3073 char *cfull_path =
nullptr;
3075 bool unexpected_fail =
false;
3077 vgroup_pid = Vattach (file_id, pobj_ref,
"r");
3078 if (vgroup_pid == FAIL)
3079 throw3 (
"Vattach failed ",
"Object reference number is ", pobj_ref);
3082 if (Vgetname (vgroup_pid, cvgroup_name) == FAIL) {
3083 Vdetach (vgroup_pid);
3084 throw3 (
"Vgetname failed ",
"Object reference number is ", pobj_ref);
3086 num_gobjects = Vntagrefs (vgroup_pid);
3087 if (num_gobjects < 0) {
3088 Vdetach (vgroup_pid);
3089 throw3 (
"Vntagrefs failed ",
"Object reference number is ", pobj_ref);
3100 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
3101 if (cfull_path ==
nullptr)
3102 throw1 (
"No enough memory to allocate the buffer");
3104 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
3106 strncpy(cfull_path,full_path,strlen(full_path));
3107 strncat(cfull_path,cvgroup_name,strlen(cvgroup_name));
3109 ReadVgattrs(vgroup_pid,cfull_path);
3113 Vdetach (vgroup_pid);
3115 throw1 (
"ReadVgattrs failed ");
3118 strncat(cfull_path,_BACK_SLASH,strlen(_BACK_SLASH));
3124 for (i = 0; i < num_gobjects; i++) {
3126 if (Vgettagref (vgroup_pid, i, &obj_tag, &obj_ref) == FAIL) {
3127 unexpected_fail =
true;
3128 err_msg = string(ERR_LOC) +
" Vgettagref failed. ";
3132 if (Visvg (vgroup_pid, obj_ref) == TRUE) {
3133 strncpy(full_path,cfull_path,strlen(cfull_path)+1);
3134 full_path[strlen(cfull_path)]=
'\0';
3135 obtain_path (file_id, sd_id, full_path, obj_ref);
3137 else if (Visvs (vgroup_pid, obj_ref)) {
3139 vdata_id = VSattach (file_id, obj_ref,
"r");
3140 if (vdata_id == FAIL) {
3141 unexpected_fail =
true;
3142 err_msg = string(ERR_LOC) +
" VSattach failed. ";
3146 status = VSQueryname (vdata_id, vdata_name);
3147 if (status == FAIL) {
3148 unexpected_fail =
true;
3149 err_msg = string(ERR_LOC) +
" VSQueryname failed. ";
3153 status = VSgetclass (vdata_id, vdata_class);
3154 if (status == FAIL) {
3155 unexpected_fail =
true;
3156 err_msg = string(ERR_LOC) +
" VSgetclass failed. ";
3160 if (VSisattr (vdata_id) != TRUE) {
3162 (vdata_class, _HDF_CHK_TBL_CLASS,
3163 strlen (_HDF_CHK_TBL_CLASS))) {
3165 VDATA *vdataobj =
nullptr;
3173 Vdetach (vgroup_pid);
3179 vdataobj->newname = cfull_path + vdataobj->name;
3183 for (std::vector <VDField * >::const_iterator it_vdf =
3185 it_vdf != vdataobj->
getFields ().end ();
3190 (*it_vdf)->newname =
3191 "vdata" + vdataobj->newname +
"_vdf_" +
3199 this->vds.push_back (vdataobj);
3202 status = VSdetach (vdata_id);
3203 if (status == FAIL) {
3204 unexpected_fail =
true;
3205 err_msg = string(ERR_LOC) +
" VSdetach failed. ";
3209 else if (obj_tag == DFTAG_NDG || obj_tag == DFTAG_SDG
3210 || obj_tag == DFTAG_SD) {
3211 if (this->sd->refindexlist.find (obj_ref) !=
3212 this->sd->refindexlist.end ())
3213 this->sd->sdfields[this->sd->refindexlist[obj_ref]]->newname =
3215 cfull_path + this->sd->sdfields[this->sd->refindexlist[obj_ref]]->name;
3217 unexpected_fail =
true;
3218 stringstream temp_ss;
3220 err_msg = string(ERR_LOC) +
"SDS with the reference number"
3221 + temp_ss.str() +
" is not found.";
3232 if(vdata_id != -1) {
3233 status = VSdetach(vdata_id);
3234 if (status == FAIL) {
3235 Vdetach(vgroup_pid);
3236 string err_msg2 =
"In the cleanup " + string(ERR_LOC) +
" VSdetached failed. ";
3237 err_msg = err_msg + err_msg2;
3240 else if(
true == unexpected_fail)
3245 if(vgroup_pid != -1) {
3246 status = Vdetach(vgroup_pid);
3247 if (status == FAIL) {
3248 string err_msg2 =
"In the cleanup " + string(ERR_LOC) +
" VSdetached failed. ";
3249 err_msg = err_msg + err_msg2;
3252 else if(
true == unexpected_fail)
3269 int32 vgroup_cid = -1;
3271 int num_gobjects = 0;
3276 char cvgroup_name[VGNAMELENMAX*4];
3280 char *cfull_path =
nullptr;
3282 bool unexpected_fail =
false;
3284 vgroup_cid = Vattach (file_id, pobj_ref,
"r");
3285 if (vgroup_cid == FAIL)
3286 throw3 (
"Vattach failed ",
"Object reference number is ", pobj_ref);
3288 if (Vgetname (vgroup_cid, cvgroup_name) == FAIL) {
3289 Vdetach (vgroup_cid);
3290 throw3 (
"Vgetname failed ",
"Object reference number is ", pobj_ref);
3292 num_gobjects = Vntagrefs (vgroup_cid);
3293 if (num_gobjects < 0) {
3294 Vdetach (vgroup_cid);
3295 throw3 (
"Vntagrefs failed ",
"Object reference number is ", pobj_ref);
3307 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
3308 if (cfull_path ==
nullptr)
3309 throw1 (
"No enough memory to allocate the buffer");
3311 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
3315 strncpy(cfull_path,full_path,strlen(full_path));
3316 strncat(cfull_path,cvgroup_name,strlen(cvgroup_name));
3317 strncat(cfull_path,_BACK_SLASH,strlen(_BACK_SLASH));
3321 for (
int i = 0; i < num_gobjects; i++) {
3323 if (Vgettagref (vgroup_cid, i, &obj_tag, &obj_ref) == FAIL) {
3324 unexpected_fail =
true;
3325 err_msg = string(ERR_LOC) +
" Vgettagref failed. ";
3329 if (Visvg (vgroup_cid, obj_ref) == TRUE) {
3330 strncpy (full_path, cfull_path,strlen(cfull_path)+1);
3331 full_path[strlen(cfull_path)]=
'\0';
3332 obtain_noneos2_sds_path (file_id, full_path, obj_ref);
3334 else if (obj_tag == DFTAG_NDG || obj_tag == DFTAG_SDG
3335 || obj_tag == DFTAG_SD) {
3341 string temp_str = string(cfull_path);
3342 if((temp_str.find(
"Data Fields") != std::string::npos)||
3343 (temp_str.find(
"Geolocation Fields") != std::string::npos))
3344 sds_ref_list.remove(obj_ref);
3352 if(vgroup_cid != -1) {
3353 status = Vdetach(vgroup_cid);
3354 if (status == FAIL) {
3355 string err_msg2 =
"In the cleanup " + string(ERR_LOC) +
" Vdetached failed. ";
3356 err_msg = err_msg + err_msg2;
3359 else if(
true == unexpected_fail)
3376 int32 vgroup_cid = -1;
3379 int num_gobjects = -1;
3384 char cvgroup_name[VGNAMELENMAX*4];
3385 char vdata_name[VSNAMELENMAX];
3386 char vdata_class[VSNAMELENMAX];
3387 int32 vdata_id = -1;
3390 char *cfull_path =
nullptr;
3393 bool unexpected_fail =
false;
3404 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
3405 if (cfull_path ==
nullptr)
3406 throw1 (
"No enough memory to allocate the buffer");
3408 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
3410 vgroup_cid = Vattach (file_id, pobj_ref,
"r");
3411 if (vgroup_cid == FAIL) {
3412 unexpected_fail =
true;
3413 err_msg = string(ERR_LOC)+
"Vattach failed";
3418 if (Vgetname (vgroup_cid, cvgroup_name) == FAIL) {
3419 unexpected_fail =
true;
3420 err_msg = string(ERR_LOC)+
"Vgetname failed";
3423 num_gobjects = Vntagrefs (vgroup_cid);
3424 if (num_gobjects < 0) {
3425 unexpected_fail =
true;
3426 err_msg = string(ERR_LOC)+
"Vntagrefs failed";
3430 strncpy(cfull_path,full_path,strlen(full_path));
3431 strncat(cfull_path,cvgroup_name,strlen(cvgroup_name));
3432 strncat(cfull_path,_BACK_SLASH,strlen(_BACK_SLASH));
3436 temp_str = string(cfull_path);
3438 if (temp_str.find(
"Geolocation Fields") != string::npos) {
3439 if(
false == this->EOS2Swathflag)
3440 this->EOS2Swathflag =
true;
3443 for (i = 0; i < num_gobjects; i++) {
3445 if (Vgettagref (vgroup_cid, i, &obj_tag, &obj_ref) == FAIL) {
3446 unexpected_fail =
true;
3447 err_msg = string(ERR_LOC)+
"Vgettagref failed";
3451 if (Visvg (vgroup_cid, obj_ref) == TRUE) {
3452 strncpy(full_path,cfull_path,strlen(cfull_path)+1);
3453 full_path[strlen(cfull_path)] =
'\0';
3454 obtain_vdata_path (file_id, full_path, obj_ref);
3456 else if (Visvs (vgroup_cid, obj_ref)) {
3458 vdata_id = VSattach (file_id, obj_ref,
"r");
3459 if (vdata_id == FAIL) {
3460 unexpected_fail =
true;
3461 err_msg = string(ERR_LOC)+
"VSattach failed";
3465 status = VSQueryname (vdata_id, vdata_name);
3466 if (status == FAIL) {
3467 unexpected_fail =
true;
3468 err_msg = string(ERR_LOC)+
"VSQueryname failed";
3472 status = VSgetclass (vdata_id, vdata_class);
3473 if (status == FAIL) {
3474 unexpected_fail =
true;
3475 err_msg = string(ERR_LOC)+
"VSgetclass failed";
3480 string temp_str2 = string(cfull_path);
3490 bool ignore_eos2_geo_vdata =
false;
3491 bool ignore_eos2_data_vdata =
false;
3492 if (temp_str2.find(
"Geolocation Fields") != string::npos) {
3493 ignore_eos2_geo_vdata =
true;
3497 if (temp_str2.find(
"Data Fields") != string::npos) {
3498 if (
true == this->EOS2Swathflag)
3499 ignore_eos2_data_vdata =
true;
3501 if ((
true == ignore_eos2_data_vdata)
3502 ||(
true == ignore_eos2_geo_vdata)
3503 || VSisattr (vdata_id) == TRUE
3504 || !strncmp (vdata_class, _HDF_CHK_TBL_CLASS,
3505 strlen (_HDF_CHK_TBL_CLASS))
3506 || !strncmp (vdata_class, _HDF_SDSVAR,
3507 strlen (_HDF_SDSVAR))
3508 || !strncmp (vdata_class, _HDF_CRDVAR,
3509 strlen (_HDF_CRDVAR))
3510 || !strncmp (vdata_class, DIM_VALS, strlen (DIM_VALS))
3511 || !strncmp (vdata_class, DIM_VALS01,
3512 strlen (DIM_VALS01))
3513 || !strncmp (vdata_class, RIGATTRCLASS,
3514 strlen (RIGATTRCLASS))
3515 || !strncmp (vdata_name, RIGATTRNAME,
3516 strlen (RIGATTRNAME))) {
3518 status = VSdetach (vdata_id);
3519 if (status == FAIL) {
3520 unexpected_fail =
true;
3521 err_msg = string(ERR_LOC)+
"VSdetach failed";
3527 VDATA *vdataobj =
nullptr;
3534 Vdetach (vgroup_cid);
3539 vdataobj->newname = cfull_path + vdataobj->name;
3543 for (std::vector <VDField * >::const_iterator it_vdf =
3545 it_vdf != vdataobj->
getFields ().end ();
3550 (*it_vdf)->newname =
3551 "vdata" + vdataobj->newname +
"_vdf_" +
3559 this->vds.push_back (vdataobj);
3560 status = VSdetach (vdata_id);
3561 if (status == FAIL) {
3562 unexpected_fail =
true;
3563 err_msg = string(ERR_LOC)+
"VSdetach failed";
3575 if(vgroup_cid != -1) {
3576 status = Vdetach(vgroup_cid);
3577 if (status == FAIL) {
3578 string err_msg2 =
"In the cleanup " + string(ERR_LOC) +
" Vdetached failed. ";
3579 err_msg = err_msg + err_msg2;
3580 throw3(err_msg,
"vgroup name is ",cvgroup_name);
3582 else if(
true == unexpected_fail)
3583 throw3(err_msg,
"vgroup name is ",cvgroup_name);
3607 std::string tempdimname;
3608 std::pair < std::set < std::string >::iterator,
bool > ret;
3609 std::string temppath;
3610 std::set < int32 > fakedimsizeset;
3611 std::pair < std::set < int32 >::iterator,
bool > fakedimsizeit;
3612 std::map < int32, std::string > fakedimsizenamelist;
3613 std::map < int32, std::string >::iterator fakedimsizenamelistit;
3615 for (
const auto &sdf:file->sd->sdfields) {
3617 for (
const auto &sdim:sdf->getDimensions ()) {
3620 if (file->sptype != OTHERHDF)
3621 tempdimname = sdim->getName ();
3623 tempdimname = sdim->getName () + temppath;
3626 new Dimension (tempdimname, sdim->getSize (),
3628 sdf->correcteddims.push_back (dim);
3629 if (tempdimname.find (
"fakeDim") != std::string::npos) {
3630 fakedimsizeit = fakedimsizeset.insert (sdim->getSize ());
3631 if (fakedimsizeit.second ==
true) {
3632 fakedimsizenamelist[sdim->getSize ()] = sdim->getName ();
3642 if (file->sptype != OTHERHDF) {
3643 for (std::vector < SDField * >::const_iterator i =
3644 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
3645 for (std::vector < Dimension * >::const_iterator j =
3646 (*i)->getCorrectedDimensions ().begin ();
3647 j != (*i)->getCorrectedDimensions ().end (); ++j) {
3648 if ((*j)->getName ().find (
"fakeDim") != std::string::npos) {
3649 if (fakedimsizenamelist.find ((*j)->getSize ()) !=
3650 fakedimsizenamelist.end ()) {
3651 (*j)->name = fakedimsizenamelist[(*j)->getSize ()];
3654 throw5 (
"The fakeDim name ", (*j)->getName (),
3655 "with the size", (*j)->getSize (),
3656 "does not in the fakedimsize list");
3669 for (
const auto &sdf:file->sd->sdfields) {
3670 for (
const auto &dim:sdf->getCorrectedDimensions ()) {
3671 std::pair < std::set < std::string >::iterator,
bool > ret;
3672 ret = file->sd->fulldimnamelist.insert (dim->getName ());
3675 if (ret.second ==
true) {
3676 file->sd->n1dimnamelist[dim->getName ()] = dim->getSize ();
3693 for (std::map < std::string, int32 >::const_iterator i =
3694 file->sd->n1dimnamelist.begin ();
3695 i != file->sd->n1dimnamelist.end (); ++i) {
3697 if (file->sd->nonmisscvdimnamelist.find ((*i).first) == file->sd->nonmisscvdimnamelist.end ()) {
3704 missingfield->
type = DFNT_INT32;
3705 missingfield->
name = (*i).first;
3706 missingfield->
newname = (*i).first;
3707 missingfield->
rank = 1;
3708 missingfield->fieldtype = 4;
3711 missingfield->dims.push_back (dim);
3712 dim =
new Dimension ((*i).first, (*i).second, 0);
3713 missingfield->correcteddims.push_back (dim);
3714 file->sd->sdfields.push_back (missingfield);
3729 vector<string>tempfulldimnamelist;
3730 for (std::set < std::string >::const_iterator i =
3731 file->sd->fulldimnamelist.begin ();
3732 i != file->sd->fulldimnamelist.end (); ++i)
3738 int total_dcounter = 0;
3739 for (std::set < std::string >::const_iterator i =
3740 file->sd->fulldimnamelist.begin ();
3741 i != file->sd->fulldimnamelist.end (); ++i) {
3747 std::map < std::string, std::string >::iterator tempmapit;
3748 for (std::vector < SDField * >::const_iterator i =
3749 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
3750 for (std::vector < Dimension * >::const_iterator j =
3751 (*i)->getCorrectedDimensions ().begin ();
3752 j != (*i)->getCorrectedDimensions ().end (); ++j) {
3753 tempmapit = file->sd->n2dimnamelist.find ((*j)->getName ());
3754 if (tempmapit != file->sd->n2dimnamelist.end ())
3755 (*j)->name = tempmapit->second;
3757 throw5 (
"This dimension with the name ", (*j)->name,
3758 "and the field name ", (*i)->name,
3759 " is not found in the dimension list.");
3783 string check_ceres_short_name_key=
"H4.EnableCERESMERRAShortName";
3784 bool turn_on_ceres_short_name_key=
false;
3786 turn_on_ceres_short_name_key = HDFCFUtil::check_beskeys(check_ceres_short_name_key);
3790 if (
true == HDF4RequestHandler::get_enable_ceres_merra_short_name() && (file->sptype == CER_ES4 || file->sptype == CER_SRB
3791 || file->sptype == CER_CDAY || file->sptype == CER_CGEO
3792 || file->sptype == CER_SYN || file->sptype == CER_ZAVG
3793 || file->sptype == CER_AVG)) {
3795 for (
unsigned int i = 0; i < file->sd->sdfields.size (); ++i) {
3796 file->sd->sdfields[i]->special_product_fullpath = file->sd->sdfields[i]->newname;
3797 file->sd->sdfields[i]->newname = file->sd->sdfields[i]->name;
3802 vector<string>sd_data_fieldnamelist;
3803 vector<string>sd_latlon_fieldnamelist;
3804 vector<string>sd_nollcv_fieldnamelist;
3806 set<string>sd_fieldnamelist;
3808 for (std::vector < SDField * >::const_iterator i =
3809 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
3810 if ((*i)->fieldtype ==0)
3812 else if ((*i)->fieldtype == 1 || (*i)->fieldtype == 2)
3825 int total_data_counter = 0;
3826 int total_latlon_counter = 0;
3827 int total_nollcv_counter = 0;
3834 std::map < std::string, std::string >::iterator tempmapit;
3837 for (std::vector < SDField * >::const_iterator i =
3838 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
3853 if ((*i)->fieldtype != 0) {
3854 if ((*i)->fieldtype == 1 || (*i)->fieldtype == 2) {
3856 (*i)->newname = sd_latlon_fieldnamelist[total_latlon_counter];
3857 total_latlon_counter++;
3859 if ((*i)->getRank () > 2)
3860 throw3 (
"the lat/lon rank should NOT be greater than 2",
3861 (*i)->name, (*i)->getRank ());
3862 else if ((*i)->getRank () == 2) {
3863 for (std::vector < Dimension * >::const_iterator j =
3864 (*i)->getCorrectedDimensions ().begin ();
3865 j != (*i)->getCorrectedDimensions ().end (); ++j) {
3867 file->sd->dimcvarlist.find ((*j)->getName ());
3868 if (tempmapit == file->sd->dimcvarlist.end ()) {
3872 if (lldimname1 ==
"")
3873 lldimname1 =(*j)->name;
3875 lldimname2 = (*j)->name;
3886 (*i)->getCorrectedDimensions ()[0]->getName ();
3887 HDFCFUtil::insert_map(file->sd->dimcvarlist, (*i)->getCorrectedDimensions()[0]->getName(), (*i)->newname);
3894 (*i)->newname = sd_data_fieldnamelist[total_data_counter];
3895 total_data_counter++;
3900 for (std::vector < SDField * >::const_iterator i =
3901 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
3917 if ((*i)->fieldtype != 0) {
3918 if ((*i)->fieldtype != 1 && (*i)->fieldtype != 2) {
3921 (*i)->newname = sd_nollcv_fieldnamelist[total_nollcv_counter];
3922 total_nollcv_counter++;
3924 if ((*i)->getRank () > 1)
3925 throw3 (
"The lat/lon rank should be 1", (*i)->name,
3932 if (COARDFLAG || file->sptype == OTHERHDF)
3934 (*i)->getCorrectedDimensions ()[0]->getName ();
3938 (*i)->getCorrectedDimensions ()[0]->getName ();
3942 (*i)->newname = (*i)->getCorrectedDimensions ()[0]->getName ();
3944 HDFCFUtil::insert_map(file->sd->dimcvarlist, (*i)->getCorrectedDimensions()[0]->getName(), (*i)->newname);
3959 std::map < std::string, std::string >::iterator tempmapit;
3962 std::string tempcoordinates;
3963 std::string tempfieldname;
3964 for (std::vector < SDField * >::const_iterator i =
3965 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
3966 if ((*i)->fieldtype == 0) {
3968 tempcoordinates =
"";
3971 for (std::vector < Dimension * >::const_iterator j =
3972 (*i)->getCorrectedDimensions ().begin ();
3973 j != (*i)->getCorrectedDimensions ().end (); ++j) {
3974 tempmapit = (file->sd->dimcvarlist).find ((*j)->getName ());
3975 if (tempmapit != (file->sd->dimcvarlist).end ())
3976 tempfieldname = tempmapit->second;
3978 throw3 (
"The dimension with the name ", (*j)->getName (),
3979 "must have corresponding coordinate variables.");
3981 tempcoordinates = tempfieldname;
3983 tempcoordinates = tempcoordinates +
" " + tempfieldname;
3986 (*i)->setCoordinates (tempcoordinates);
3990 if ((*i)->fieldtype == 1) {
3991 std::string tempunits =
"degrees_north";
3992 (*i)->setUnits (tempunits);
3995 if ((*i)->fieldtype == 2) {
3996 std::string tempunits =
"degrees_east";
3997 (*i)->setUnits (tempunits);
4001 if (((*i)->fieldtype == 3) || ((*i)->fieldtype == 4)) {
4002 std::string tempunits =
"level";
4003 (*i)->setUnits (tempunits);
4011 if (
false == COARDFLAG) {
4012 for (std::vector < SDField * >::const_iterator i =
4013 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4014 if ((*i)->fieldtype == 0) {
4015 bool has_lldim1 =
false;
4016 bool has_lldim2 =
false;
4017 for (std::vector < Dimension * >::const_iterator j =
4018 (*i)->getCorrectedDimensions ().begin ();
4019 j != (*i)->getCorrectedDimensions ().end (); ++j) {
4020 if(lldimname1 == (*j)->name)
4022 else if(lldimname2 == (*j)->name)
4027 if (has_lldim1^has_lldim2)
4028 (*i)->coordinates =
"";
4049 string check_disable_vdata_nameclashing_key=
"H4.DisableVdataNameclashingCheck";
4050 bool turn_on_disable_vdata_nameclashing_key =
false;
4052 turn_on_disable_vdata_nameclashing_key = HDFCFUtil::check_beskeys(check_disable_vdata_nameclashing_key);
4057 if (
false == HDF4RequestHandler::get_disable_vdata_nameclashing_check()) {
4059 vector<string> tempvdatafieldnamelist;
4061 for (std::vector < VDATA * >::const_iterator i = file->vds.begin ();
4062 i != file->vds.end (); ++i) {
4063 for (std::vector < VDField * >::const_iterator j =
4064 (*i)->getFields ().begin (); j != (*i)->getFields ().end ();
4066 tempvdatafieldnamelist.push_back((*j)->newname);
4071 int total_vfd_counter = 0;
4073 for (std::vector < VDATA * >::const_iterator i = file->vds.begin ();
4074 i != file->vds.end (); ++i) {
4075 for (std::vector < VDField * >::const_iterator j =
4076 (*i)->getFields ().begin (); j != (*i)->getFields ().end ();
4078 (*j)->newname = tempvdatafieldnamelist[total_vfd_counter];
4079 total_vfd_counter++;
4103 if (file->sptype != OTHERHDF) {
4105 for (std::vector < SDField * >::const_iterator i =
4106 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4107 for (vector<AttrContainer *>::iterator j = (*i)->dims_info.begin();
4108 j!= (*i)->dims_info.end(); ) {
4110 j = (*i)->dims_info.erase(j);
4113 if ((*i)->dims_info.size() != 0)
4114 throw1(
"Not totally erase the dimension container ");
4124 switch (file->sptype) {
4219 throw3 (
"No such SP datatype ",
"sptype is ", sptype);
4234 bool COARDFLAG =
false;
4252 for (std::vector < Attribute * >::const_iterator i =
4254 i != this->sd->getAttributes ().end (); ++i) {
4256 if ((*i)->getName () ==
"GridHeader") {
4257 float lat_start = 0.;
4258 float lon_start = 0.;
4262 HDFCFUtil::parser_trmm_v7_gridheader((*i)->getValue(),latsize,lonsize,
4263 lat_start,lon_start,
4264 lat_res,lon_res,
false);
4275bool File:: Obtain_TRMM_V7_latlon_name(
const SDField* sdfield,
const int latsize,
4276 const int lonsize,
string& latname,
string& lonname)
throw(
Exception) {
4281 int latname_index = -1;
4282 int lonname_index = -1;
4283 for (
int temp_index = 0; temp_index <sdfield->getRank(); ++temp_index) {
4284 if(-1==latname_index && sdfield->getCorrectedDimensions()[temp_index]->getSize() == latsize) {
4285 latname_index = temp_index;
4287 latname = sdfield->getCorrectedDimensions()[temp_index]->getName();
4289 else if (-1 == lonname_index && sdfield->getCorrectedDimensions()[temp_index]->getSize() == lonsize) {
4290 lonname_index = temp_index;
4292 lonname = sdfield->getCorrectedDimensions()[temp_index]->getName();
4296 return (latname_index + lonname_index == 1);
4305 std::string tempdimname1;
4306 std::string tempdimname2;
4307 std::string tempnewdimname1;
4308 std::string tempnewdimname2;
4309 std::string temppath;
4316 std::set < int32 > tempdimsizeset;
4317 std::map < int32, std::string > tempdimsizenamelist;
4318 std::map < int32, std::string >::iterator tempsizemapit;
4319 std::pair < std::set < int32 >::iterator,
bool > tempsetit;
4322 for (std::vector < SDField * >::const_iterator i =
4323 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4324 for (std::vector < Dimension * >::const_iterator j =
4325 (*i)->getCorrectedDimensions ().begin ();
4326 j != (*i)->getCorrectedDimensions ().end (); ++j) {
4327 if (((*j)->getName ()).find (
"fakeDim") == std::string::npos) {
4328 tempsetit = tempdimsizeset.insert ((*j)->getSize ());
4329 if (tempsetit.second ==
true)
4330 tempdimsizenamelist[(*j)->getSize ()] = (*j)->getName ();
4336 for (std::vector < SDField * >::const_iterator i =
4337 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4339 string temp_name = (*i)->newname.substr(1) ;
4340 size_t temp_pos = temp_name.find_first_of(
'/');
4341 if (temp_pos !=string::npos)
4342 (*i)->newname = temp_name.substr(temp_pos+1);
4347 for (std::vector < SDField * >::const_iterator i =
4348 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4350 if((*i)->getName() ==
"Latitude") {
4351 if((*i)->getRank() ==2) {
4354 ((*i)->getCorrectedDimensions ())[0]->getName ();
4356 ((*i)->getCorrectedDimensions ())[1]->getName ();
4359 (*i)->fieldtype = 1;
4362 else if ((*i)->getName() ==
"Longitude") {
4363 (*i)->fieldtype = 2;
4370 for (std::vector < Dimension * >::const_iterator k =
4371 (*i)->getCorrectedDimensions ().begin ();
4372 k != (*i)->getCorrectedDimensions ().end (); ++k) {
4373 size_t fakeDimpos = ((*k)->getName ()).find (
"fakeDim");
4375 if (fakeDimpos != std::string::npos) {
4377 tempdimsizenamelist.find ((*k)->getSize ());
4378 if (tempsizemapit != tempdimsizenamelist.end ())
4379 (*k)->name = tempdimsizenamelist[(*k)->getSize ()];
4387 if(tempnewdimname1.empty()!=
true)
4388 file->sd->nonmisscvdimnamelist.insert (tempnewdimname1);
4390 if(tempnewdimname2.empty()!=
true)
4391 file->sd->nonmisscvdimnamelist.insert (tempnewdimname2);
4393 string base_filename;
4394 size_t last_slash_pos = file->
getPath().find_last_of(
"/");
4395 if(last_slash_pos != string::npos)
4396 base_filename = file->
getPath().substr(last_slash_pos+1);
4397 if(
""==base_filename)
4398 base_filename = file->
getPath();
4401 if(base_filename.find(
"2A12")!=string::npos) {
4403 string nlayer_name =
"nlayer";
4405 for (vector < SDField * >::iterator i =
4406 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4408 bool has_nlayer =
false;
4410 for (vector < Dimension * >::const_iterator k =
4411 (*i)->getDimensions ().begin ();
4412 k != (*i)->getDimensions ().end (); ++k) {
4414 if((*k)->getSize() == 28 && (*k)->name == nlayer_name) {
4417 nlayer->
name = nlayer_name;
4419 nlayer->
type = DFNT_FLOAT32;
4420 nlayer->fieldtype = 6;
4425 nlayer->dims.push_back(dim);
4428 nlayer->correcteddims.push_back(dim);
4436 if(
true == has_nlayer)
4440 if(nlayer !=
nullptr) {
4441 file->sd->sdfields.push_back(nlayer);
4442 file->sd->nonmisscvdimnamelist.insert (nlayer_name);
4452 for (std::vector < SDField * >::iterator i =
4453 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ) {
4456 if((*i)->name ==
"InputFileNames") {
4458 i = file->sd->sdfields.erase(i);
4460 else if((*i)->name ==
"InputAlgorithmVersions") {
4462 i = file->sd->sdfields.erase(i);
4464 else if((*i)->name ==
"InputGenerationDateTimes") {
4466 i = file->sd->sdfields.erase(i);
4469 (*i)->newname = (*i)->name;
4476 string nlayer_name =
"nlayer";
4478 for (vector < SDField * >::iterator i =
4479 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4481 bool has_nlayer =
false;
4483 for (vector < Dimension * >::const_iterator k =
4484 (*i)->getDimensions ().begin ();
4485 k != (*i)->getDimensions ().end (); ++k) {
4487 if((*k)->getSize() == 28 && (*k)->name == nlayer_name) {
4490 nlayer->
name = nlayer_name;
4492 nlayer->
type = DFNT_FLOAT32;
4493 nlayer->fieldtype = 6;
4498 nlayer->dims.push_back(dim);
4501 nlayer->correcteddims.push_back(dim);
4509 if(
true == has_nlayer)
4513 if(nlayer !=
nullptr) {
4514 file->sd->sdfields.push_back(nlayer);
4515 file->sd->nonmisscvdimnamelist.insert (nlayer_name);
4528 bool llname_found =
false;
4529 for (std::vector < SDField * >::iterator i =
4530 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4532 if(2 == (*i)->getRank()) {
4534 llname_found = Obtain_TRMM_V7_latlon_name((*i),latsize,lonsize,latname,lonname);
4535 if (
true == llname_found)
4545 longitude->
name = lonname;
4546 longitude->
rank = 1;
4547 longitude->
type = DFNT_FLOAT32;
4548 longitude->fieldtype = 2;
4553 longitude->dims.push_back (dim);
4555 dim =
new Dimension (lonname, lonsize, 0);
4556 longitude->correcteddims.push_back (dim);
4557 file->sd->sdfields.push_back(longitude);
4560 latitude->
name = latname;
4562 latitude->
type = DFNT_FLOAT32;
4563 latitude->fieldtype = 1;
4566 dim =
new Dimension (latname, latsize, 0);
4567 latitude->dims.push_back (dim);
4569 dim =
new Dimension (latname, latsize, 0);
4570 latitude->correcteddims.push_back (dim);
4571 file->sd->sdfields.push_back(latitude);
4574 file->sd->nonmisscvdimnamelist.insert (latname);
4575 file->sd->nonmisscvdimnamelist.insert (lonname);
4580 string base_filename;
4581 if(path.find_last_of(
"/") != string::npos)
4582 base_filename = path.substr(path.find_last_of(
"/")+1);
4583 if(base_filename.find(
"3A26")!=string::npos) {
4585 bool ZOflag =
false;
4586 bool SRTflag =
false;
4587 bool HBflag =
false;
4588 string nthrsh_base_name =
"nthrsh";
4589 string nthrsh_zo_name =
"nthrshZO";
4590 string nthrsh_hb_name =
"nthrshHB";
4591 string nthrsh_srt_name =
"nthrshSRT";
4595 SDField* nthrsh_srt =
nullptr;
4597 for (vector < SDField * >::iterator i =
4598 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4600 if(ZOflag !=
true) {
4601 if((*i)->name.find(
"Order")!=string::npos) {
4602 for (vector < Dimension * >::const_iterator k =
4603 (*i)->getDimensions ().begin ();
4604 k != (*i)->getDimensions ().end (); ++k) {
4606 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4607 if(nthrsh_zo ==
nullptr) {
4609 nthrsh_zo->
name = nthrsh_zo_name;
4610 nthrsh_zo->
rank = 1;
4611 nthrsh_zo->
type = DFNT_FLOAT32;
4612 nthrsh_zo->fieldtype = 6;
4617 nthrsh_zo->dims.push_back(dim);
4620 nthrsh_zo->correcteddims.push_back(dim);
4631 else if(SRTflag !=
true) {
4632 if((*i)->name.find(
"2A25")!=string::npos) {
4634 for (vector < Dimension * >::const_iterator k =
4635 (*i)->getDimensions ().begin ();
4636 k != (*i)->getDimensions ().end (); ++k) {
4638 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4639 if(nthrsh_srt ==
nullptr) {
4641 nthrsh_srt->
name = nthrsh_srt_name;
4642 nthrsh_srt->
rank = 1;
4643 nthrsh_srt->
type = DFNT_FLOAT32;
4644 nthrsh_srt->fieldtype = 6;
4649 nthrsh_srt->dims.push_back(dim);
4652 nthrsh_srt->correcteddims.push_back(dim);
4661 else if(HBflag !=
true) {
4662 if((*i)->name.find(
"hb")!=string::npos || (*i)->name.find(
"HB")!=string::npos) {
4664 for (vector < Dimension * >::const_iterator k =
4665 (*i)->getDimensions ().begin ();
4666 k != (*i)->getDimensions ().end (); ++k) {
4668 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4670 if(nthrsh_hb ==
nullptr) {
4672 nthrsh_hb->
name = nthrsh_hb_name;
4673 nthrsh_hb->
rank = 1;
4674 nthrsh_hb->
type = DFNT_FLOAT32;
4675 nthrsh_hb->fieldtype = 6;
4680 nthrsh_hb->dims.push_back(dim);
4683 nthrsh_hb->correcteddims.push_back(dim);
4694 for (vector < SDField * >::iterator i =
4695 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4697 if((*i)->name.find(
"Order")!=string::npos && ZOflag ==
true) {
4698 for (vector < Dimension * >::const_iterator k =
4699 (*i)->getDimensions ().begin ();
4700 k != (*i)->getDimensions ().end (); ++k) {
4702 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4703 (*k)->name = nthrsh_zo_name;
4708 for (std::vector < Dimension * >::const_iterator k =
4709 (*i)->getCorrectedDimensions ().begin ();
4710 k != (*i)->getCorrectedDimensions ().end (); ++k) {
4711 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4712 (*k)->name = nthrsh_zo_name;
4719 else if(((*i)->name.find(
"hb")!=string::npos || (*i)->name.find(
"HB")!=string::npos)&& HBflag ==
true) {
4720 for (vector < Dimension * >::const_iterator k =
4721 (*i)->getDimensions ().begin ();
4722 k != (*i)->getDimensions ().end (); ++k) {
4724 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4725 (*k)->name = nthrsh_hb_name;
4730 for (std::vector < Dimension * >::const_iterator k =
4731 (*i)->getCorrectedDimensions ().begin ();
4732 k != (*i)->getCorrectedDimensions ().end (); ++k) {
4733 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4734 (*k)->name = nthrsh_hb_name;
4740 else if(((*i)->name.find(
"2A25")!=string::npos) && SRTflag ==
true) {
4741 for (vector < Dimension * >::const_iterator k =
4742 (*i)->getDimensions ().begin ();
4743 k != (*i)->getDimensions ().end (); ++k) {
4745 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4746 (*k)->name = nthrsh_srt_name;
4751 for (std::vector < Dimension * >::const_iterator k =
4752 (*i)->getCorrectedDimensions ().begin ();
4753 k != (*i)->getCorrectedDimensions ().end (); ++k) {
4754 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4755 (*k)->name = nthrsh_srt_name;
4765 if(nthrsh_zo !=
nullptr) {
4766 file->sd->sdfields.push_back(nthrsh_zo);
4767 file->sd->nonmisscvdimnamelist.insert (nthrsh_zo_name);
4770 if(nthrsh_hb !=
nullptr) {
4771 file->sd->sdfields.push_back(nthrsh_hb);
4772 file->sd->nonmisscvdimnamelist.insert (nthrsh_hb_name);
4775 if(nthrsh_srt !=
nullptr) {
4776 file->sd->sdfields.push_back(nthrsh_srt);
4777 file->sd->nonmisscvdimnamelist.insert (nthrsh_srt_name);
4788 for (std::vector < SDField * >::iterator i =
4789 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ) {
4791 if((*i)->name ==
"InputFileNames") {
4793 i = file->sd->sdfields.erase(i);
4796 else if((*i)->name ==
"InputAlgorithmVersions") {
4798 i = file->sd->sdfields.erase(i);
4801 else if((*i)->name ==
"InputGenerationDateTimes") {
4803 i = file->sd->sdfields.erase(i);
4814 NOTE
for programming:
4815 1. Outer loop: loop global attribute
for GridHeader?. Retrieve ? as a number
for index.
4816 1.5. Obtain the lat/lon sizes
for this grid.
4817 The following steps are to retrieve lat/lon names
for this grid.
4818 2. Inner loop: Then loop through the field
4819 3. Check the field rank,
4820 3.1
if the rank is not 2, (
if the index is the first index, change the newname to name )
4823 3.2.1 Retrieve the index from the field
new name(retrieve last path Grid1 then retrieve 1)
4824 3.2.2 If the index from the field is the same as that from the GridHeader,
continue checking
4825 the lat/lon name
for this grid as the single grid.
4826 change the newname to name.
4833 int first_index = -1;
4834 for (vector < Attribute * >::const_iterator i =
4836 i != this->sd->getAttributes ().end (); ++i) {
4838 if ((*i)->getName ().find(
"GridHeader")==0) {
4839 string temp_name = (*i)->getName();
4842 string str_num = temp_name.substr(10);
4843 stringstream ss_num(str_num);
4846 ss_num >> grid_index;
4848 if ( -1 == first_index)
4849 first_index = grid_index;
4851 float lat_start = 0.;
4852 float lon_start = 0.;
4859 HDFCFUtil::parser_trmm_v7_gridheader((*i)->getValue(),latsize,lonsize,
4860 lat_start,lon_start,
4861 lat_res, lon_res,
false);
4870 bool llname_found =
false;
4871 for (std::vector < SDField * >::iterator i =
4872 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4875 if(2 == (*i)->getRank()) {
4878 if ((*i)->newname !=(*i)->name) {
4880 string temp_field_full_path = (*i)->getNewName();
4881 size_t last_path_pos = temp_field_full_path.find_last_of(
'/');
4882 char str_index = temp_field_full_path[last_path_pos-1];
4883 if(grid_index ==(
int)(str_index -
'0')) {
4884 if(llname_found !=
true)
4885 llname_found = Obtain_TRMM_V7_latlon_name((*i),latsize,lonsize,latname,lonname);
4886 (*i)->newname = (*i)->name;
4890 else if (first_index == grid_index)
4891 (*i)->newname = (*i)->name;
4896 longitude->
name = lonname;
4897 longitude->
rank = 1;
4898 longitude->
type = DFNT_FLOAT32;
4899 longitude->fieldtype = 2;
4900 longitude->fieldref = grid_index;
4905 longitude->dims.push_back (dim);
4907 dim =
new Dimension (lonname, lonsize, 0);
4908 longitude->correcteddims.push_back (dim);
4909 file->sd->sdfields.push_back(longitude);
4912 latitude->
name = latname;
4914 latitude->
type = DFNT_FLOAT32;
4915 latitude->fieldtype = 1;
4916 latitude->fieldref = grid_index;
4919 dim =
new Dimension (latname, latsize, 0);
4920 latitude->dims.push_back (dim);
4922 dim =
new Dimension (latname, latsize, 0);
4923 latitude->correcteddims.push_back (dim);
4924 file->sd->sdfields.push_back(latitude);
4927 file->sd->nonmisscvdimnamelist.insert (latname);
4928 file->sd->nonmisscvdimnamelist.insert (lonname);
4945 std::string tempdimname1;
4946 std::string tempdimname2;
4947 std::string tempnewdimname1;
4948 std::string tempnewdimname2;
4949 std::string temppath;
4957 std::set < int32 > tempdimsizeset;
4958 std::map < int32, std::string > tempdimsizenamelist;
4959 std::map < int32, std::string >::iterator tempsizemapit;
4960 std::pair < std::set < int32 >::iterator,
bool > tempsetit;
4963 for (std::vector < SDField * >::const_iterator i =
4964 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4965 for (std::vector < Dimension * >::const_iterator j =
4966 (*i)->getCorrectedDimensions ().begin ();
4967 j != (*i)->getCorrectedDimensions ().end (); ++j) {
4968 if (((*j)->getName ()).find (
"fakeDim") == std::string::npos) {
4969 tempsetit = tempdimsizeset.insert ((*j)->getSize ());
4970 if (tempsetit.second ==
true)
4971 tempdimsizenamelist[(*j)->getSize ()] = (*j)->
getName ();
4976 for (std::vector < SDField * >::const_iterator i =
4977 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
4979 if ((*i)->getName () ==
"geolocation") {
4983 tempdimname1 = ((*i)->getDimensions ())[0]->getName ();
4984 tempdimsize1 = ((*i)->getDimensions ())[0]->getSize ();
4985 tempdimname2 = ((*i)->getDimensions ())[1]->getName ();
4986 tempdimsize2 = ((*i)->getDimensions ())[1]->getSize ();
4989 ((*i)->getCorrectedDimensions ())[0]->getName ();
4991 ((*i)->getCorrectedDimensions ())[1]->getName ();
4998 if(latitude ==
nullptr) {
5001 latitude->
name =
"latitude";
5003 latitude->fieldref = (*i)->fieldref;
5004 latitude->
type = (*i)->getType ();
5005 temppath = (*i)->newname.substr ((*i)->name.size ());
5007 latitude->fieldtype = 1;
5008 latitude->rootfieldname =
"geolocation";
5012 latitude->dims.push_back (dim);
5014 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
5015 latitude->dims.push_back (dim);
5017 dim =
new Dimension (tempnewdimname1, tempdimsize1, 0);
5018 latitude->correcteddims.push_back (dim);
5020 dim =
new Dimension (tempnewdimname2, tempdimsize2, 0);
5021 latitude->correcteddims.push_back (dim);
5024 if(longitude ==
nullptr) {
5026 longitude->
name =
"longitude";
5027 longitude->
rank = 2;
5028 longitude->fieldref = (*i)->fieldref;
5029 longitude->
type = (*i)->getType ();
5031 longitude->fieldtype = 2;
5032 longitude->rootfieldname =
"geolocation";
5035 longitude->dims.push_back (dim);
5036 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
5037 longitude->dims.push_back (dim);
5039 dim =
new Dimension (tempnewdimname1, tempdimsize1, 0);
5040 longitude->correcteddims.push_back (dim);
5042 dim =
new Dimension (tempnewdimname2, tempdimsize2, 0);
5043 longitude->correcteddims.push_back (dim);
5051 for (std::vector < Dimension * >::const_iterator k =
5052 (*i)->getCorrectedDimensions ().begin ();
5053 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5054 size_t fakeDimpos = ((*k)->getName ()).find (
"fakeDim");
5056 if (fakeDimpos != std::string::npos) {
5058 tempdimsizenamelist.find ((*k)->getSize ());
5059 if (tempsizemapit != tempdimsizenamelist.end ())
5060 (*k)->name = tempdimsizenamelist[(*k)->getSize ()];
5066 file->sd->sdfields.push_back (latitude);
5067 file->sd->sdfields.push_back (longitude);
5072 std::vector < SDField * >::iterator toeraseit;
5073 for (std::vector < SDField * >::iterator i = file->sd->sdfields.begin ();
5074 i != file->sd->sdfields.end (); ++i) {
5075 if ((*i)->getName () ==
"geolocation") {
5082 file->sd->sdfields.erase (toeraseit);
5083 if (origeo !=
nullptr)
5087 file->sd->nonmisscvdimnamelist.insert (tempnewdimname1);
5088 file->sd->nonmisscvdimnamelist.insert (tempnewdimname2);
5098 std::string tempnewdimname1, tempnewdimname2;
5102 std::string temppath;
5107 for (std::vector < SDField * >::const_iterator i =
5108 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
5110 for (std::vector < Dimension * >::const_iterator k =
5111 (*i)->getDimensions ().begin ();
5112 k != (*i)->getDimensions ().end (); ++k) {
5115 if ((((*k)->getName ()).find (
"fakeDim")) == std::string::npos) {
5117 temppath = (*i)->newname.substr ((*i)->name.size ());
5120 if ((*k)->getSize () == 1440 && (*k)->getType () == 0) {
5122 if(longitude ==
nullptr) {
5124 longitude->
name =
"longitude";
5125 longitude->
rank = 1;
5126 longitude->
type = DFNT_FLOAT32;
5127 longitude->fieldtype = 2;
5131 new Dimension ((*k)->getName (), (*k)->getSize (), 0);
5132 longitude->dims.push_back (dim);
5133 tempnewdimname2 = (*k)->getName ();
5136 new Dimension ((*k)->getName (), (*k)->getSize (), 0);
5137 longitude->correcteddims.push_back (dim);
5142 if ((*k)->getSize () == 400 && (*k)->getType () == 0) {
5144 if(latitude ==
nullptr) {
5146 latitude->
name =
"latitude";
5148 latitude->
type = DFNT_FLOAT32;
5149 latitude->fieldtype = 1;
5152 new Dimension ((*k)->getName (), (*k)->getSize (), 0);
5153 latitude->dims.push_back (dim);
5154 tempnewdimname1 = (*k)->getName ();
5162 new Dimension ((*k)->getName (), (*k)->getSize (), 0);
5163 latitude->correcteddims.push_back (dim);
5169 if (latflag == 1 && lonflag == 1)
5173 if (latflag == 1 && lonflag == 1)
5182 if (latflag != 1 || lonflag != 1) {
5183 if(latitude !=
nullptr)
5185 if(longitude !=
nullptr)
5187 throw5 (
"Either latitude or longitude doesn't exist.",
"lat. flag= ",
5188 latflag,
"lon. flag= ", lonflag);
5190 file->sd->sdfields.push_back (latitude);
5191 file->sd->sdfields.push_back (longitude);
5195 file->sd->nonmisscvdimnamelist.insert (tempnewdimname1);
5196 file->sd->nonmisscvdimnamelist.insert (tempnewdimname2);
5205 std::string tempnewdimname1;
5206 std::string tempnewdimname2;
5207 bool latflag =
false;
5208 bool lonflag =
false;
5214 for (std::vector < SDField * >::const_iterator i =
5215 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
5217 for (std::vector < Dimension * >::const_iterator k =
5218 (*i)->getDimensions ().begin ();
5219 k != (*i)->getDimensions ().end (); ++k) {
5220 if ((((*k)->getName ()).find (
"latitude")) == 0)
5221 (*k)->name =
"fakeDim1";
5222 if ((((*k)->getName()).find (
"longitude")) == 0)
5223 (*k)->name =
"fakeDim2";
5229 for (std::vector < Dimension * >::const_iterator k =
5230 (*i)->getCorrectedDimensions ().begin ();
5231 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5232 if ((((*k)->getName ()).find (
"latitude")) == 0)
5233 (*k)->name =
"fakeDim1";
5234 if ((((*k)->getName()).find (
"longitude")) == 0)
5235 (*k)->name =
"fakeDim2";
5240 for (std::vector < SDField * >::const_iterator i =
5241 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
5244 for (std::vector < Dimension * >::const_iterator k =
5245 (*i)->getDimensions ().begin ();
5246 k != (*i)->getDimensions ().end (); ++k) {
5254 if ((*k)->getSize () == 360 && (*k)->getType () == 0) {
5256 if(longitude ==
nullptr) {
5258 longitude->
name =
"longitude";
5259 longitude->
rank = 1;
5260 longitude->
type = DFNT_FLOAT32;
5261 longitude->fieldtype = 2;
5266 longitude->dims.push_back (dim);
5267 tempnewdimname2 = longitude->
name;
5271 longitude->correcteddims.push_back (dim);
5276 if ((*k)->getSize () == 180 && (*k)->getType () == 0) {
5278 if(latitude ==
nullptr) {
5280 latitude->
name =
"latitude";
5282 latitude->
type = DFNT_FLOAT32;
5283 latitude->fieldtype = 1;
5288 latitude->dims.push_back (dim);
5289 tempnewdimname1 = latitude->
getName ();
5298 latitude->correcteddims.push_back (dim);
5304 if (latflag ==
true && lonflag ==
true)
5308 if (latflag ==
true && lonflag ==
true)
5317 if (latflag !=
true || lonflag !=
true) {
5318 if(latitude !=
nullptr)
5320 if(longitude !=
nullptr)
5322 throw5 (
"Either latitude or longitude doesn't exist.",
"lat. flag= ",
5323 latflag,
"lon. flag= ", lonflag);
5327 for (std::vector < SDField * >::const_iterator i =
5328 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
5331 for (std::vector < Dimension * >::const_iterator k =
5332 (*i)->getDimensions ().begin ();
5333 k != (*i)->getDimensions ().end (); ++k) {
5335 if ((*k)->getSize () == 360 )
5336 (*k)->name = longitude->
name;
5338 if ((*k)->getSize () == 180 )
5339 (*k)->name = latitude->
name;
5343 for (std::vector < Dimension * >::const_iterator k =
5344 (*i)->getCorrectedDimensions ().begin ();
5345 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5347 if ((*k)->getSize () == 360 )
5348 (*k)->name = longitude->
name;
5350 if ((*k)->getSize () == 180 )
5351 (*k)->name = latitude->
name;
5359 file->sd->sdfields.push_back (latitude);
5360 file->sd->sdfields.push_back (longitude);
5365 file->sd->nonmisscvdimnamelist.insert (tempnewdimname1);
5366 file->sd->nonmisscvdimnamelist.insert (tempnewdimname2);
5376 std::string tempnewdimname1;
5377 std::string tempnewdimname2;
5378 std::string tempnewdimname3;
5379 bool latflag =
false;
5380 bool lonflag =
false;
5381 bool heiflag =
false;
5389 for (std::vector < SDField * >::const_iterator i =
5390 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
5393 for (std::vector < Dimension * >::const_iterator k =
5394 (*i)->getDimensions ().begin ();
5395 k != (*i)->getDimensions ().end (); ++k) {
5403 if ((*k)->getSize () == 720 && (*k)->getType () == 0) {
5406 if(longitude ==
nullptr) {
5408 longitude->
name =
"longitude";
5409 longitude->
rank = 1;
5410 longitude->
type = DFNT_FLOAT32;
5411 longitude->fieldtype = 2;
5416 longitude->dims.push_back (dim);
5417 tempnewdimname2 = longitude->
name;
5421 longitude->correcteddims.push_back (dim);
5426 if ((*k)->getSize () == 148 && (*k)->getType () == 0) {
5428 if(latitude ==
nullptr) {
5430 latitude->
name =
"latitude";
5432 latitude->
type = DFNT_FLOAT32;
5433 latitude->fieldtype = 1;
5438 latitude->dims.push_back (dim);
5439 tempnewdimname1 = latitude->
getName ();
5448 latitude->correcteddims.push_back (dim);
5453 if ((*k)->getSize () == 19 && (*k)->getType () == 0) {
5455 if(height ==
nullptr) {
5457 height->
name =
"height";
5459 height->
type = DFNT_FLOAT32;
5460 height->fieldtype = 6;
5465 height->dims.push_back (dim);
5466 tempnewdimname3 = height->
getName ();
5475 height->correcteddims.push_back (dim);
5483 if (latflag ==
true && lonflag ==
true)
5493 if (latflag !=
true || lonflag !=
true) {
5494 if(latitude !=
nullptr)
5496 if(longitude !=
nullptr)
5498 throw5 (
"Either latitude or longitude doesn't exist.",
"lat. flag= ",
5499 latflag,
"lon. flag= ", lonflag);
5502 if(height!=
nullptr && heiflag !=
true) {
5504 throw1(
"Height is allocated but the flag is not true");
5508 file->sd->sdfields.push_back (latitude);
5509 file->sd->sdfields.push_back (longitude);
5511 if(height!=
nullptr) {
5513 if(heiflag !=
true) {
5515 throw1(
"Height is allocated but the flag is not true");
5518 file->sd->sdfields.push_back (height);
5519 file->sd->nonmisscvdimnamelist.insert (tempnewdimname3);
5524 file->sd->nonmisscvdimnamelist.insert (tempnewdimname1);
5525 file->sd->nonmisscvdimnamelist.insert (tempnewdimname2);
5534 int pixels_per_scan_line = 0;
5536 std::string pixels_per_scan_line_name =
"Pixels per Scan Line";
5537 std::string number_pixels_control_points =
"Number of Pixel Control Points";
5538 std::string tempnewdimname1, tempnewdimname2;
5543 for (std::vector < Attribute * >::const_iterator i =
5546 if ((*i)->getName () == pixels_per_scan_line_name) {
5547 int *attrvalueptr = (
int *) (&((*i)->getValue ()[0]));
5548 pixels_per_scan_line = *attrvalueptr;
5553 if ( 0 == pixels_per_scan_line)
5554 throw1(
"The attribute 'Pixels per Scan Line' doesn't exist");
5559 int tempcountllflag = 0;
5561 for (std::vector < SDField * >::const_iterator i =
5562 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
5564 if ((*i)->getName () ==
"longitude" || (*i)->getName () ==
"latitude") {
5565 if ((*i)->getName () ==
"longitude")
5566 (*i)->fieldtype = 2;
5567 if ((*i)->getName () ==
"latitude")
5568 (*i)->fieldtype = 1;
5571 if ((*i)->getRank () != 2)
5572 throw3 (
"The lat/lon rank must be 2", (*i)->getName (),
5574 for (std::vector < Dimension * >::const_iterator k =
5575 (*i)->getDimensions ().begin ();
5576 k != (*i)->getDimensions ().end (); ++k) {
5577 if ((*k)->getName () == number_pixels_control_points) {
5578 (*k)->name = pixels_per_scan_line_name;
5579 (*k)->dimsize = pixels_per_scan_line;
5584 for (std::vector < Dimension * >::const_iterator k =
5585 (*i)->getCorrectedDimensions ().begin ();
5586 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5587 if ((*k)->getName ().find (number_pixels_control_points) !=
5588 std::string::npos) {
5589 (*k)->name = pixels_per_scan_line_name;
5590 (*k)->dimsize = pixels_per_scan_line;
5591 if (tempcountllflag == 1)
5592 tempnewdimname2 = (*k)->name;
5595 if (tempcountllflag == 1)
5596 tempnewdimname1 = (*k)->name;
5600 if (tempcountllflag == 2)
5607 file->sd->nonmisscvdimnamelist.insert (tempnewdimname1);
5608 file->sd->nonmisscvdimnamelist.insert (tempnewdimname2);
5620 std::string num_lat_name =
"Number of Lines";
5621 std::string num_lon_name =
"Number of Columns";
5627 int tempcountllflag = 0;
5629 for (std::vector < Attribute * >::const_iterator i =
5633 if ((*i)->getName () == num_lon_name) {
5636 int *attrvalue = (
int *) (&((*i)->getValue ()[0]));
5638 num_lon = *attrvalue;
5642 if ((*i)->getName () == num_lat_name) {
5644 int *attrvalue = (
int *) (&((*i)->getValue ()[0]));
5646 num_lat = *attrvalue;
5649 if (tempcountllflag == 2)
5655 if(longitude ==
nullptr)
5656 throw1(
"Allocate memory for longitude failed .");
5658 longitude->
name =
"longitude";
5659 longitude->
rank = 1;
5660 longitude->
type = DFNT_FLOAT32;
5661 longitude->fieldtype = 2;
5667 throw3(
"The size of the dimension of the longitude ",longitude->
name,
" is 0.");
5671 if(dim ==
nullptr) {
5673 throw1(
"Allocate memory for dim failed .");
5678 longitude->dims.push_back (dim);
5682 dim =
new Dimension (num_lon_name, num_lon, 0);
5683 if(dim ==
nullptr) {
5685 throw1(
"Allocate memory for dim failed .");
5688 longitude->correcteddims.push_back (dim);
5692 if(latitude ==
nullptr) {
5694 throw1(
"Allocate memory for dim failed .");
5696 latitude->
name =
"latitude";
5698 latitude->
type = DFNT_FLOAT32;
5699 latitude->fieldtype = 1;
5706 throw3(
"The size of the dimension of the latitude ",latitude->
name,
" is 0.");
5710 dim =
new Dimension (num_lat_name, num_lat, 0);
5711 if( dim ==
nullptr) {
5714 throw1(
"Allocate memory for dim failed .");
5717 if(latitude !=
nullptr)
5718 latitude->dims.push_back (dim);
5722 dim =
new Dimension (num_lat_name, num_lat, 0);
5723 if(dim ==
nullptr) {
5726 throw1(
"Allocate memory for dim failed .");
5729 latitude->correcteddims.push_back (dim);
5732 for (std::vector < SDField * >::const_iterator i =
5733 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
5734 if ((*i)->getRank () != 2) {
5739 throw3 (
"The lat/lon rank must be 2", (*i)->getName (),
5742 for (std::vector < Dimension * >::const_iterator k =
5743 (*i)->getDimensions ().begin ();
5744 k != (*i)->getDimensions ().end (); ++k) {
5745 if ((((*k)->getName ()).find (
"fakeDim")) != std::string::npos) {
5746 if ((*k)->getSize () == num_lon)
5747 (*k)->name = num_lon_name;
5748 if ((*k)->getSize () == num_lat)
5749 (*k)->name = num_lat_name;
5752 for (std::vector < Dimension * >::const_iterator k =
5753 (*i)->getCorrectedDimensions ().begin ();
5754 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5755 if ((((*k)->getName ()).find (
"fakeDim")) != std::string::npos) {
5756 if ((*k)->getSize () == num_lon)
5757 (*k)->name = num_lon_name;
5758 if ((*k)->getSize () == num_lat)
5759 (*k)->name = num_lat_name;
5763 file->sd->sdfields.push_back (latitude);
5764 file->sd->sdfields.push_back (longitude);
5767 file->sd->nonmisscvdimnamelist.insert (num_lat_name);
5768 file->sd->nonmisscvdimnamelist.insert (num_lon_name);
5779 bool colatflag =
false;
5780 bool lonflag =
false;
5782 std::string tempnewdimname1;
5783 std::string tempnewdimname2;
5784 std::string tempcvarname1;
5785 std::string tempcvarname2;
5789 std::vector < SDField * >::iterator beerasedit;
5793 for (std::vector < SDField * >::iterator i = file->sd->sdfields.begin ();
5794 i != file->sd->sdfields.end (); ) {
5797 if (((*i)->getName ()).find (
"Colatitude") != std::string::npos) {
5799 if ((*i)->getRank () != 2)
5800 throw3 (
"The lat/lon rank must be 2", (*i)->getName (),
5802 int dimsize0 = (*i)->getDimensions ()[0]->getSize ();
5803 int dimsize1 = (*i)->getDimensions ()[1]->getSize ();
5808 if (dimsize0 < dimsize1) {
5809 tempnewdimname1 = (*i)->getDimensions ()[0]->getName ();
5810 tempnewdimname2 = (*i)->getDimensions ()[1]->getName ();
5813 tempnewdimname1 = (*i)->getDimensions ()[1]->getName ();
5814 tempnewdimname2 = (*i)->getDimensions ()[0]->getName ();
5819 (*i)->fieldtype = 1;
5820 tempcvarname1 = (*i)->getName ();
5826 i = file->sd->sdfields.erase (i);
5834 else if (((*i)->getName ()).find (
"Longitude") != std::string::npos) {
5837 (*i)->fieldtype = 2;
5838 tempcvarname2 = (*i)->getName ();
5843 i = file->sd->sdfields.erase (i);
5855 file->sd->nonmisscvdimnamelist.insert (tempnewdimname1);
5856 file->sd->nonmisscvdimnamelist.insert (tempnewdimname2);
5866 std::string tempdimname1;
5867 std::string tempdimname2;
5868 int tempdimsize1 = 0;
5869 int tempdimsize2 = 0;
5870 std::string tempcvarname1;
5871 std::string tempcvarname2;
5872 std::string temppath;
5873 std::set < std::string > tempdimnameset;
5874 std::pair < std::set < std::string >::iterator,
bool > tempsetit;
5877 bool cvflag =
false;
5882 for (std::vector < SDField * >::iterator i = file->sd->sdfields.begin ();
5883 i != file->sd->sdfields.end (); ) {
5884 std::string tempfieldname = (*i)->getName ();
5885 if (tempfieldname.find (
"Colatitude") != std::string::npos) {
5887 for (std::vector < Dimension * >::const_iterator j =
5888 (*i)->getDimensions ().begin ();
5889 j != (*i)->getDimensions ().end (); ++j) {
5890 if (((*j)->getName ()).find (
"regional colat") !=
5891 std::string::npos) {
5892 tempsetit = tempdimnameset.insert ((*j)->getName ());
5893 if (tempsetit.second ==
true) {
5894 tempdimname1 = (*j)->getName ();
5895 tempdimsize1 = (*j)->getSize ();
5896 (*i)->fieldtype = 1;
5906 for (std::vector < Dimension * >::const_iterator j =
5907 (*i)->getDimensions ().begin ();
5908 j != (*i)->getDimensions ().end (); ++j)
5910 for (std::vector < Dimension * >::const_iterator j =
5911 (*i)->getCorrectedDimensions ().begin ();
5912 j != (*i)->getCorrectedDimensions ().end (); ++j)
5914 (*i)->dims.clear ();
5915 (*i)->correcteddims.clear ();
5918 new Dimension (tempdimname1, tempdimsize1, 0);
5919 (*i)->dims.push_back (dim);
5920 dim =
new Dimension (tempdimname1, tempdimsize1, 0);
5921 (*i)->correcteddims.push_back (dim);
5922 file->sd->nonmisscvdimnamelist.insert (tempdimname1);
5928 i = file->sd->sdfields.erase (i);
5937 else if (tempfieldname.find (
"Longitude") != std::string::npos) {
5938 for (std::vector < Dimension * >::const_iterator j =
5939 (*i)->getDimensions ().begin ();
5940 j != (*i)->getDimensions ().end (); ++j) {
5941 if (((*j)->getName ()).find (
"regional long") !=
5942 std::string::npos) {
5943 tempsetit = tempdimnameset.insert ((*j)->getName ());
5944 if (tempsetit.second ==
true) {
5945 tempdimname2 = (*j)->getName ();
5946 tempdimsize2 = (*j)->getSize ();
5947 (*i)->fieldtype = 2;
5956 for (std::vector < Dimension * >::const_iterator j =
5957 (*i)->getDimensions ().begin ();
5958 j != (*i)->getDimensions ().end (); ++j) {
5961 for (std::vector < Dimension * >::const_iterator j =
5962 (*i)->getCorrectedDimensions ().begin ();
5963 j != (*i)->getCorrectedDimensions ().end (); ++j) {
5966 (*i)->dims.clear ();
5967 (*i)->correcteddims.clear ();
5970 new Dimension (tempdimname2, tempdimsize2, 0);
5971 (*i)->dims.push_back (dim);
5972 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
5973 (*i)->correcteddims.push_back (dim);
5975 file->sd->nonmisscvdimnamelist.insert (tempdimname2);
5981 i = file->sd->sdfields.erase (i);
6009 std::string tempdimname1 =
"1.0 deg. regional colat. zones";
6010 std::string tempdimname2 =
"1.0 deg. regional long. zones";
6011 std::string tempdimname3 =
"1.0 deg. zonal colat. zones";
6012 std::string tempdimname4 =
"1.0 deg. zonal long. zones";
6013 int tempdimsize1 = 180;
6014 int tempdimsize2 = 360;
6015 int tempdimsize3 = 180;
6016 int tempdimsize4 = 1;
6018 std::string tempnewdimname1;
6019 std::string tempnewdimname2;
6020 std::string tempcvarname1;
6021 std::string tempcvarname2;
6028 latitude->
name =
"latitude";
6030 latitude->
type = DFNT_FLOAT32;
6031 latitude->fieldtype = 1;
6038 latitude->dims.push_back (dim);
6040 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
6041 latitude->dims.push_back (dim);
6043 dim =
new Dimension (tempdimname1, tempdimsize1, 0);
6044 latitude->correcteddims.push_back (dim);
6046 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
6047 latitude->correcteddims.push_back (dim);
6048 file->sd->sdfields.push_back (latitude);
6052 longitude->
name =
"longitude";
6053 longitude->
rank = 2;
6054 longitude->
type = DFNT_FLOAT32;
6055 longitude->fieldtype = 2;
6060 dim =
new Dimension (tempdimname1, tempdimsize1, 0);
6061 longitude->dims.push_back (dim);
6063 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
6064 longitude->dims.push_back (dim);
6066 dim =
new Dimension (tempdimname1, tempdimsize1, 0);
6067 longitude->correcteddims.push_back (dim);
6069 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
6070 longitude->correcteddims.push_back (dim);
6071 file->sd->sdfields.push_back (longitude);
6075 if (file->sptype == CER_SRB) {
6079 latitudez->
name =
"latitudez";
6080 latitudez->
rank = 1;
6081 latitudez->
type = DFNT_FLOAT32;
6082 latitudez->fieldtype = 1;
6085 dim =
new Dimension (tempdimname3, tempdimsize3, 0);
6086 latitudez->dims.push_back (dim);
6088 dim =
new Dimension (tempdimname3, tempdimsize3, 0);
6089 latitudez->correcteddims.push_back (dim);
6090 file->sd->sdfields.push_back (latitudez);
6093 longitudez->
name =
"longitudez";
6094 longitudez->
rank = 1;
6095 longitudez->
type = DFNT_FLOAT32;
6096 longitudez->fieldtype = 2;
6099 dim =
new Dimension (tempdimname4, tempdimsize4, 0);
6100 longitudez->dims.push_back (dim);
6102 dim =
new Dimension (tempdimname4, tempdimsize4, 0);
6103 longitudez->correcteddims.push_back (dim);
6104 file->sd->sdfields.push_back (longitudez);
6107 if (file->sptype == CER_SRB) {
6108 file->sd->nonmisscvdimnamelist.insert (tempdimname3);
6109 file->sd->nonmisscvdimnamelist.insert (tempdimname4);
6112 file->sd->nonmisscvdimnamelist.insert (tempdimname1);
6113 file->sd->nonmisscvdimnamelist.insert (tempdimname2);
6115 if(file->sptype == CER_CDAY) {
6117 string odddimname1=
"1.0 deg. regional Colat. zones";
6118 string odddimname2 =
"1.0 deg. regional Long. zones";
6121 for (std::vector < SDField * >::const_iterator i =
6122 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
6123 for (std::vector < Dimension * >::const_iterator j =
6124 (*i)->getDimensions ().begin ();
6125 j != (*i)->getDimensions ().end (); ++j) {
6126 if (odddimname1 == (*j)->name)
6127 (*j)->name = tempdimname1;
6128 if (odddimname2 == (*j)->name)
6129 (*j)->name = tempdimname2;
6131 for (std::vector < Dimension * >::const_iterator j =
6132 (*i)->getCorrectedDimensions ().begin ();
6133 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6134 if (odddimname1 == (*j)->name)
6135 (*j)->name = tempdimname1;
6136 if (odddimname2 == (*j)->name)
6137 (*j)->name = tempdimname2;
6151 std::string tempdimname3 =
"1.0 deg. zonal colat. zones";
6152 std::string tempdimname4 =
"1.0 deg. zonal long. zones";
6153 int tempdimsize3 = 180;
6154 int tempdimsize4 = 1;
6159 latitudez->
name =
"latitudez";
6160 latitudez->
rank = 1;
6161 latitudez->
type = DFNT_FLOAT32;
6162 latitudez->fieldtype = 1;
6167 latitudez->dims.push_back (dim);
6169 dim =
new Dimension (tempdimname3, tempdimsize3, 0);
6170 latitudez->correcteddims.push_back (dim);
6172 file->sd->sdfields.push_back (latitudez);
6175 longitudez->
name =
"longitudez";
6176 longitudez->
rank = 1;
6177 longitudez->
type = DFNT_FLOAT32;
6178 longitudez->fieldtype = 2;
6181 dim =
new Dimension (tempdimname4, tempdimsize4, 0);
6182 longitudez->dims.push_back (dim);
6184 dim =
new Dimension (tempdimname4, tempdimsize4, 0);
6185 longitudez->correcteddims.push_back (dim);
6187 file->sd->sdfields.push_back (longitudez);
6188 file->sd->nonmisscvdimnamelist.insert (tempdimname3);
6189 file->sd->nonmisscvdimnamelist.insert (tempdimname4);
6202 std::set < std::string > tempfulldimnamelist;
6203 std::pair < std::set < std::string >::iterator,
bool > ret;
6205 std::map < int, std::string > tempsizedimnamelist;
6209 for (std::vector < SDField * >::const_iterator i =
6210 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
6211 if ((*i)->getName () ==
"Latitude")
6212 (*i)->fieldtype = 1;
6213 if ((*i)->getName () ==
"Longitude") {
6214 (*i)->fieldtype = 2;
6219 for (std::vector < Dimension * >::const_iterator j =
6220 (*i)->getCorrectedDimensions ().begin ();
6221 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6222 tempsizedimnamelist[(*j)->getSize ()] = (*j)->getName ();
6223 file->sd->nonmisscvdimnamelist.insert ((*j)->getName ());
6228 for (std::vector < SDField * >::const_iterator i =
6229 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
6230 for (std::vector < Dimension * >::const_iterator j =
6231 (*i)->getCorrectedDimensions ().begin ();
6232 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6236 if ((*i)->fieldtype == 0) {
6237 if ((tempsizedimnamelist.find ((*j)->getSize ())) !=
6238 tempsizedimnamelist.end ())
6239 (*j)->name = tempsizedimnamelist[(*j)->getSize ()];
6254 std::set < std::string > tempfulldimnamelist;
6255 std::pair < std::set < std::string >::iterator,
bool > ret;
6265 bool merra_is_eos2 =
false;
6266 size_t found_forward_slash = file->path.find_last_of(
"/");
6267 if ((found_forward_slash != string::npos) &&
6268 (((file->path).substr(found_forward_slash+1).compare(0,5,
"MERRA"))==0)){
6270 for (std::vector < Attribute * >::const_iterator i =
6275 if(((*i)->getName().compare(0, 14,
"StructMetadata" )== 0) ||
6276 ((*i)->getName().compare(0, 14,
"structmetadata" )== 0)) {
6277 merra_is_eos2 =
true;
6284 if(
true == merra_is_eos2) {
6285 vector <string> noneos_newnamelist;
6288 for (std::vector < SDField * >::const_iterator i =
6289 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
6290 (*i)->special_product_fullpath = (*i)->newname;
6292 string EOSGRIDstring=
":EOSGRID";
6293 size_t found = ((*i)->name).rfind(EOSGRIDstring);
6295 if (found !=string::npos && (((*i)->name).size() == (found + EOSGRIDstring.size()))) {
6297 (*i)->newname = (*i)->name.substr(0,found);
6298 noneos_newnamelist.push_back((*i)->newname);
6301 (*i)->newname = (*i)->name;
6308 for (std::vector < SDField * >::const_iterator i =
6309 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
6311 for(vector<string>::const_iterator j =
6312 noneos_newnamelist.begin(); j !=noneos_newnamelist.end();++j) {
6314 if ((*i)->newname == (*j) && (*i)->name == (*j)) {
6316 (*i)->newname = (*i)->newname +
"_EOS";
6323 map<string,string> dimname_to_newdimname;
6324 for (std::vector < SDField * >::const_iterator i =
6325 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
6326 for (std::vector < Dimension * >::const_iterator j =
6327 (*i)->getCorrectedDimensions ().begin ();
6328 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6330 if ((*j)->getType () != 0) {
6331 if ((*i)->name == (*j)->getName () && (*i)->getRank () == 1){
6332 (*i)->fieldtype = 3;
6333 (*i)->is_dim_scale =
true;
6334 (*j)->name = (*i)->newname;
6339 file->sd->nonmisscvdimnamelist.insert ((*j)->name);
6345 map<string,string>::iterator itmap;
6346 for (std::vector < SDField * >::const_iterator i =
6347 file->sd->sdfields.begin (); i != file->sd->sdfields.end (); ++i) {
6349 if (0 == (*i)->fieldtype) {
6350 for (std::vector < Dimension * >::const_iterator j =
6351 (*i)->getCorrectedDimensions ().begin ();
6352 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6353 itmap = dimname_to_newdimname.find((*j)->name);
6354 if (itmap == dimname_to_newdimname.end())
6355 throw2(
"Cannot find the corresponding new dim. name for dim. name ",(*j)->name);
6357 (*j)->name = (*itmap).second;
6365 for (std::vector < SDField * >::const_iterator i =
6366 file->sd->sdfields.begin (); i != file->sd->sdfields.end () && (
false == this->OTHERHDF_Has_Dim_NoScale_Field); ++i) {
6367 for (std::vector < Dimension * >::const_iterator j =
6368 (*i)->getCorrectedDimensions ().begin ();
6369 j != (*i)->getCorrectedDimensions ().end () && (
false == this->OTHERHDF_Has_Dim_NoScale_Field); ++j) {
6371 if ((*j)->getType () != 0) {
6372 if ((*i)->name == (*j)->getName () && (*i)->getRank () == 1)
6373 (*i)->fieldtype = 3;
6374 file->sd->nonmisscvdimnamelist.insert ((*j)->getName ());
6377 this->OTHERHDF_Has_Dim_NoScale_Field =
true;
6385 if (
true == this->OTHERHDF_Has_Dim_NoScale_Field)
6386 file->sd->nonmisscvdimnamelist.clear();
Representing one attribute in grid or swath.
int32 rank
The rank of this field.
std::vector< Attribute * > attrs
The attributes of this field.
std::string newname
The CF full path(special characters replaced by underscores) of this field.
int32 type
The datatype of this field.
std::string name
The original name of this field.
const std::string & getName() const
Get the name of this field.
static File * Read(const char *path, int32 sdid, int32 fileid)
Retrieve SDS and Vdata information from the HDF4 file.
void handle_sds_final_dim_names()
Create the final CF-compliant dimension name list for each field.
void PrepareTRMML3M_V7()
Special method to prepare TRMM multiple grid Level 3 geolocation fields(latitude,longitude,...
void handle_sds_coords(bool &COARDFLAG, std::string &lldimname1, std::string &lldimname2)
Create "coordinates", "units" CF attributes.
void handle_vdata()
Handle Vdata.
void handle_sds_missing_fields()
Add the missing coordinate variables based on the corrected dimension name list.
void PrepareTRMML3S_V7()
Special method to prepare TRMM single grid Level 3 geolocation fields(latitude,longitude,...
void CheckSDType()
This method will check if the HDF4 file is one of TRMM or OBPG products we supported.
void ReadVgattrs(int32 vgroup_id, const char *fullpath)
Obtain vgroup attributes.
void PrepareTRMML2_V7()
Latitude and longitude are stored in different fields. Need to separate.
void Obtain_TRMML3S_V7_latlon_size(int &latsize, int &lonsize)
void Obtain_TRMML3S_V7_latlon_size(int &latsize, int&lonsize) throw(Exception);
void PrepareTRMML3C_V6()
Special method to prepare TRMM Level 3 CSH latitude,longitude and Height information.
static File * Read_Hybrid(const char *path, int32 sdid, int32 fileid)
void handle_sds_fakedim_names()
void PrepareOBPGL3()
Special method to prepare OBPG Level 3 latitude and longitude information. The latitude and longitude...
void ReadHybridNonLoneVdatas(File *)
void obtain_vdata_path(int32 file_id, char *full_path, int32 pobj_ref)
The internal function used to obtain the path for hybrid non-lone vdata.
void handle_sds_names(bool &COARDFLAG, std::string &lldimname1, std::string &lldimname2)
Create the final CF-compliant field name list.
void PrepareOTHERHDF()
We still provide a hook for other HDF data product although no CF compliant is followed.
void ReadLoneVdatas(File *)
Handle non-attribute lone vdatas.
void PrepareTRMML3A_V6()
Special method to prepare TRMM Level 3A46 latitude and longitude information.
void PrepareTRMML3B_V6()
Special method to prepare TRMM Level 3B latitude and longitude information.
void InsertOrigFieldPath_ReadVgVdata()
The full path of SDS and Vdata will be obtained.
void PrepareOBPGL2()
Special method to prepare OBPG Level 2 latitude and longitude information. The latitude and longitude...
void create_sds_dim_name_list()
Create the new dimension name set and the dimension name to size map.
void obtain_path(int32 file_id, int32 sd_id, char *full_path, int32 pobj_ref)
The internal function used by InsertOrigFieldPath_ReadVgVdata.
void PrepareCERZAVG()
Special method to prepare CERES Zonal Average latitude and longitude information.
void PrepareTRMML2_V6()
Latitude and longitude are stored in one array(geolocation). Need to separate.
const std::string & getPath() const
Obtain the path of the file.
One instance of this class represents one SDS object.
This class retrieves all SDS objects and SD file attributes.
const std::vector< Attribute * > & getAttributes() const
Public interface to obtain the SD(file) attributes.
static SD * Read_Hybrid(int32 sdfileid, int32 hfileid)
Read the information of all hybrid SDS objects from the HDF4 file.
const std::vector< SDField * > & getFields() const
Redundant member function.
static SD * Read(int32 sdfileid, int32 hfileid)
Read the information of all SDS objects from the HDF4 file.
void obtain_noneos2_sds_path(int32, char *, int32)
Obtain SDS path, this is like a clone of obtain_path in File class, except the Vdata and some minor p...
This class retrieves all information of one Vdata.
bool getTreatAsAttrFlag() const
const std::vector< VDField * > & getFields() const
Obtain Vdata fields.
void ReadAttributes(int32 vdata_id)
Retrieve all attributes of this Vdata.
static VDATA * Read(int32 vdata_id, int32 obj_ref)
Retrieve all information of this Vdata.
One instance of this class represents one Vdata field.
void ReadAttributes(int32 vdata_id, int32 fieldindex)
Read vdata field attributes.
static bool insert_map(std::map< std::string, std::string > &m, std::string key, std::string val)
static void Handle_NameClashing(std::vector< std::string > &newobjnamelist)
General routines to handle name clashings.
static std::string get_CF_string(std::string s)
Change special characters to "_".