37 #include "HDFCFUtil.h"
40 #include "HDF4RequestHandler.h"
42 const char *_BACK_SLASH=
"/";
44 using namespace HDFSP;
47 #define ERR_LOC1(x) #x
48 #define ERR_LOC2(x) ERR_LOC1(x)
49 #define ERR_LOC __FILE__ " : " ERR_LOC2(__LINE__)
51 template <
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) {
121 if (this->fileid != -1) {
123 for (vector < VDATA * >::const_iterator i = this->vds.begin ();
124 i != this->vds.end (); ++i) {
128 for (vector < AttrContainer * >::const_iterator i = this->vg_attrs.begin ();
129 i != this->vg_attrs.end (); ++i) {
144 std::for_each (this->vdfields.begin (), this->vdfields.end (),
148 std::for_each (this->attrs.begin (), this->attrs.end (), delete_elem ());
155 std::for_each (this->attrs.begin (), this->attrs.end (), delete_elem ());
158 std::for_each (this->sdfields.begin (), this->sdfields.end (),
167 std::for_each (this->dims.begin (), this->dims.end (), delete_elem ());
170 std::for_each (this->correcteddims.begin (), this->correcteddims.end (),
174 std::for_each (this->dims_info.begin (), this->dims_info.end (), delete_elem ());
189 std::for_each (this->attrs.begin (), this->attrs.end (), delete_elem ());
193 AttrContainer::~AttrContainer()
195 std::for_each (this->attrs.begin (), this->attrs.end (), delete_elem ());
214 SDstart (
const_cast < char *
>(file->
path.c_str ()),
215 DFACC_READ)) == -1) {
217 throw2 (
"SDstart", path);
226 file->fileid = myfileid;
230 int32 status = Vstart (file->fileid);
231 if (status == FAIL) {
233 throw2 (
"Cannot start vdata/vgroup interface", path);
239 file->
sd =
SD::Read (file->sdfd, file->fileid);
263 throw1(
"Memory allocation for file class failed. ");
270 SDstart (
const_cast < char *
>(file->
path.c_str ()),
271 DFACC_READ)) == -1) {
273 throw2 (
"SDstart", path);
282 file->fileid = myfileid;
285 int status = Vstart (file->fileid);
286 if (status == FAIL) {
288 throw2 (
"Cannot start vdata/vgroup interface", path);
320 int status = Vstart (file->fileid);
322 throw2 (
"Cannot start vdata/vgroup interface", path);
326 int num_lone_vdata = VSlone (file->fileid, NULL, 0);
328 if (num_lone_vdata == FAIL)
329 throw2 (
"Fail to obtain lone vdata number", path);
335 char vdata_class[VSNAMELENMAX];
336 char vdata_name[VSNAMELENMAX];
338 if (num_lone_vdata > 0) {
340 vector<int32>ref_array;
341 ref_array.resize(num_lone_vdata);
343 if (VSlone (file->fileid, &ref_array[0], num_lone_vdata) == FAIL) {
344 throw2 (
"cannot obtain lone vdata reference arrays", path);
347 for (
int i = 0; i < num_lone_vdata; i++) {
351 vdata_id = VSattach (file->fileid, ref_array[i],
"r");
352 if (vdata_id == FAIL) {
353 throw2 (
"Fail to attach Vdata", path);
355 status = VSgetclass (vdata_id, vdata_class);
356 if (status == FAIL) {
358 throw2 (
"Fail to obtain Vdata class", path);
361 if (VSgetname (vdata_id, vdata_name) == FAIL) {
363 throw3 (
"Fail to obtain Vdata name", path, vdata_name);
368 if (VSisattr (vdata_id) == TRUE
369 || !strncmp (vdata_class, _HDF_CHK_TBL_CLASS,
370 strlen (_HDF_CHK_TBL_CLASS))
371 || !strncmp (vdata_class, _HDF_SDSVAR, strlen (_HDF_SDSVAR))
372 || !strncmp (vdata_class, _HDF_CRDVAR, strlen (_HDF_CRDVAR))
373 || !strncmp (vdata_class, DIM_VALS, strlen (DIM_VALS))
374 || !strncmp (vdata_class, DIM_VALS01, strlen (DIM_VALS01))
375 || !strncmp (vdata_class, RIGATTRCLASS, strlen (RIGATTRCLASS))
376 || !strncmp (vdata_name, RIGATTRNAME, strlen (RIGATTRNAME))) {
378 status = VSdetach (vdata_id);
379 if (status == FAIL) {
380 throw3 (
"VSdetach failed ",
"Vdata name ", vdata_name);
385 VDATA*vdataobj = NULL;
399 for (std::vector < VDField * >::const_iterator it_vdf =
401 it_vdf != vdataobj->
getFields ().end (); it_vdf++) {
406 "vdata_" + vdataobj->
newname +
"_vdf_" +
415 file->vds.push_back (vdataobj);
429 (vdata_name, CERE_META_NAME, strlen (CERE_META_NAME))) {
431 char *fieldname = NULL;
434 int num_field = VFnfields (vdata_id);
435 if (num_field == FAIL) {
437 throw3 (
"number of fields at Vdata ", vdata_name,
" is -1");
441 for (
int j = 0; j < num_field; j++) {
443 fieldname = VFfieldname (vdata_id, j);
444 if (fieldname == NULL) {
446 throw5 (
"vdata ", vdata_name,
" field index ", j,
447 " field name is NULL.");
451 else if (!strcmp (fieldname, CERE_META_FIELD_NAME)) {
453 int32 fieldsize = -1;
457 fieldsize = VFfieldesize (vdata_id, j);
458 if (fieldsize == FAIL) {
460 throw5 (
"vdata ", vdata_name,
" field ",fieldname,
" size is wrong.");
464 nelms = VSelts (vdata_id);
467 throw5 (
"vdata ", vdata_name,
468 " number of field record ", nelms,
" is wrong.");
472 bool data_buf_err =
false;
473 bool VS_fun_err =
false;
476 char *databuf = (
char *) malloc (fieldsize * nelms);
477 if (databuf == NULL) {
478 err_msg = string(ERR_LOC) +
"No enough memory to allocate buffer.";
484 if (VSseek (vdata_id, 0) == FAIL) {
485 err_msg = string(ERR_LOC) +
"VSseek failed";
491 if (VSsetfields (vdata_id, CERE_META_FIELD_NAME) == FAIL) {
492 err_msg =
"VSsetfields failed";
498 if (VSread(vdata_id, (uint8 *) databuf, 1,FULL_INTERLACE)
500 err_msg =
"VSread failed";
506 if (!strncmp(databuf, CER_AVG_NAME,strlen (CER_AVG_NAME)))
507 file->sptype = CER_AVG;
509 (databuf, CER_ES4_NAME,strlen(CER_ES4_NAME)))
510 file->sptype = CER_ES4;
512 (databuf, CER_CDAY_NAME,strlen (CER_CDAY_NAME)))
513 file->sptype = CER_CDAY;
515 (databuf, CER_CGEO_NAME,strlen (CER_CGEO_NAME)))
516 file->sptype = CER_CGEO;
518 (databuf, CER_SRB_NAME,strlen (CER_SRB_NAME)))
519 file->sptype = CER_SRB;
521 (databuf, CER_SYN_NAME,strlen (CER_SYN_NAME)))
522 file->sptype = CER_SYN;
524 (databuf, CER_ZAVG_NAME,
525 strlen (CER_ZAVG_NAME)))
526 file->sptype = CER_ZAVG;
529 if(data_buf_err ==
true || VS_fun_err ==
true) {
531 if(data_buf_err ==
true)
535 throw5(
"vdata ",vdata_name,
"field ",
536 CERE_META_FIELD_NAME,err_msg);
558 int32 vgroup_id = -1;
566 int32 lone_vg_number = 0;
567 int32 num_of_lones = -1;
568 int32 num_gobjects = 0;
573 char vdata_name[VSNAMELENMAX];
574 char vdata_class[VSNAMELENMAX];
575 char vgroup_name[VGNAMELENMAX*4];
576 char vgroup_class[VGNAMELENMAX*4];
579 char *full_path = NULL;
582 char *cfull_path = NULL;
585 file_id = file->fileid;
590 status = Vstart (file_id);
592 throw2 (
"Cannot start vdata/vgroup interface", path);
598 num_of_lones = Vlone (file_id, NULL, 0);
599 if (num_of_lones == FAIL)
600 throw3 (
"Fail to obtain lone vgroup number",
"file id is", file_id);
603 if (num_of_lones > 0) {
609 vector<int32>ref_array;
610 ref_array.resize(num_of_lones);
614 num_of_lones = Vlone (file_id, &ref_array[0], num_of_lones);
615 if (num_of_lones == FAIL) {
616 throw3 (
"Cannot obtain lone vgroup reference arrays ",
617 "file id is ", file_id);
621 for (lone_vg_number = 0; lone_vg_number < num_of_lones;
625 vgroup_id = Vattach (file_id, ref_array[lone_vg_number],
"r");
626 if (vgroup_id == FAIL) {
627 throw3 (
"Vattach failed ",
"Reference number is ",
628 ref_array[lone_vg_number]);
632 status = Vgetname (vgroup_id, vgroup_name);
633 if (status == FAIL) {
635 throw3 (
"Vgetname failed ",
"vgroup_id is ", vgroup_id);
639 status = Vgetclass (vgroup_id, vgroup_class);
640 if (status == FAIL) {
642 throw3 (
"Vgetclass failed ",
"vgroup_name is ", vgroup_name);
646 if (strcmp (vgroup_class, _HDF_ATTRIBUTE) == 0
647 || strcmp (vgroup_class, _HDF_VARIABLE) == 0
648 || strcmp (vgroup_class, _HDF_DIMENSION) == 0
649 || strcmp (vgroup_class, _HDF_UDIMENSION) == 0
650 || strcmp (vgroup_class, _HDF_CDF) == 0
651 || strcmp (vgroup_class, GR_NAME) == 0
652 || strcmp (vgroup_class, RI_NAME) == 0) {
658 num_gobjects = Vntagrefs (vgroup_id);
659 if (num_gobjects < 0) {
661 throw3 (
"Vntagrefs failed ",
"vgroup_name is ", vgroup_name);
666 bool VS_or_mem_err =
false;
672 full_path = (
char *) malloc (MAX_FULL_PATH_LEN);
673 if (full_path == NULL) {
674 err_msg =
"No enough memory to allocate the buffer for full_path.";
675 VS_or_mem_err =
true;
682 memset(full_path,
'\0',MAX_FULL_PATH_LEN);
685 strncpy (full_path,_BACK_SLASH,strlen(_BACK_SLASH));
686 strncat(full_path,vgroup_name,strlen(vgroup_name));
687 strncat(full_path,_BACK_SLASH,strlen(_BACK_SLASH));
690 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
691 if (cfull_path == NULL) {
694 err_msg =
"No enough memory to allocate the buffer for cfull_path.";
695 VS_or_mem_err =
true;
701 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
702 strncpy(cfull_path,full_path,strlen(full_path));
706 for (
int i = 0; i < num_gobjects; i++) {
709 if (Vgettagref (vgroup_id, i, &obj_tag, &obj_ref) == FAIL) {
710 err_msg =
"Vgettagref failed";
711 VS_or_mem_err =
true;
722 if (Visvg (vgroup_id, obj_ref) == TRUE) {
723 strncpy(full_path,cfull_path,strlen(cfull_path)+1);
724 full_path[strlen(cfull_path)]=
'\0';
725 obtain_vdata_path (file_id, full_path, obj_ref);
729 else if (Visvs (vgroup_id, obj_ref)) {
732 vdata_id = VSattach (file_id, obj_ref,
"r");
733 if (vdata_id == FAIL) {
734 err_msg =
"VSattach failed";
735 VS_or_mem_err =
true;
740 status = VSgetname (vdata_id, vdata_name);
741 if (status == FAIL) {
742 err_msg =
"VSgetname failed";
743 VS_or_mem_err =
true;
748 status = VSgetclass (vdata_id, vdata_class);
749 if (status == FAIL) {
750 err_msg =
"VSgetclass failed";
751 VS_or_mem_err =
true;
756 if (VSisattr (vdata_id) == TRUE
757 || !strncmp (vdata_class, _HDF_CHK_TBL_CLASS,
758 strlen (_HDF_CHK_TBL_CLASS))
759 || !strncmp (vdata_class, _HDF_SDSVAR,
760 strlen (_HDF_SDSVAR))
761 || !strncmp (vdata_class, _HDF_CRDVAR,
762 strlen (_HDF_CRDVAR))
763 || !strncmp (vdata_class, DIM_VALS, strlen (DIM_VALS))
764 || !strncmp (vdata_class, DIM_VALS01,
766 || !strncmp (vdata_class, RIGATTRCLASS,
767 strlen (RIGATTRCLASS))
768 || !strncmp (vdata_name, RIGATTRNAME,
769 strlen (RIGATTRNAME))) {
771 status = VSdetach (vdata_id);
772 if (status == FAIL) {
773 err_msg =
"VSdetach failed in the if block to ignore the HDF4 internal attributes.";
774 VS_or_mem_err =
true;
782 VDATA *vdataobj = NULL;
794 if(full_path != NULL)
800 for (std::vector <VDField * >::const_iterator it_vdf =
809 "vdata" + vdataobj->
newname +
"_vdf_" + (*it_vdf)->name;
821 this->vds.push_back (vdataobj);
823 status = VSdetach (vdata_id);
824 if (status == FAIL) {
825 err_msg =
"VSdetach failed in the user-defined vdata block";
826 VS_or_mem_err =
true;
837 if(full_path != NULL)
839 if(cfull_path != NULL)
842 status = Vdetach (vgroup_id);
843 if (status == FAIL) {
844 throw3 (
"Vdetach failed ",
"vgroup_name is ", vgroup_name);
846 if(
true == VS_or_mem_err)
847 throw3(err_msg,
"vgroup_name is ",vgroup_name);
864 File::Check_update_special(
const string& grid_name)
throw(
Exception) {
866 set<string> dimnameset;
867 set<SDField*> fldset;
880 FullXDim= FullXDim+grid_name;
881 FullYDim =FullYDim+grid_name;
883 for (vector < SDField * >::const_iterator i =
884 this->sd->getFields ().begin ();
885 i != this->sd->getFields ().end (); ++i) {
887 for (vector < Dimension * >::const_iterator k =
888 (*i)->getDimensions ().begin ();
889 k != (*i)->getDimensions ().end (); ++k) {
890 if((*k)->getName() !=FullXDim && (*k)->getName()!=FullYDim)
891 dimnameset.insert((*k)->getName());
894 if (1==(*i)->getRank())
903 if (fldset.size() < (dimnameset.size()+2))
906 int total_num_dims = 0;
907 size_t grid_name_size = grid_name.size();
908 string reduced_dimname;
910 for(set<SDField*>::const_iterator j =
911 fldset.begin(); j!=fldset.end(); ++ j) {
913 size_t dim_size = ((*j)->getDimensions())[0]->getName().size();
914 if( dim_size > grid_name_size){
915 reduced_dimname = ((*j)->getDimensions())[0]->getName().substr(0,dim_size-grid_name_size-1);
916 if ((*j)->getName() == reduced_dimname)
921 if((
size_t)total_num_dims != (dimnameset.size()+2))
925 for (vector < SDField * >::const_iterator i =
926 this->sd->getFields ().begin ();
927 i != this->sd->getFields ().end (); ++i) {
929 for (vector < Dimension * >::const_iterator k =
930 (*i)->getDimensions ().begin ();
931 k != (*i)->getDimensions ().end (); ++k) {
933 size_t dim_size = (*k)->getName().size();
934 if( dim_size > grid_name_size){
935 reduced_dimname = (*k)->getName().substr(0,dim_size-grid_name_size-1);
936 (*k)->name = reduced_dimname;
945 for(std::set<SDField*>::const_iterator j =
946 fldset.begin(); j!=fldset.end(); ++ j) {
948 if ((*j)->getName() == ((*j)->getDimensions())[0]->getName()) {
950 if(
"XDim" == (*j)->getName()){
951 std::string tempunits =
"degrees_east";
952 (*j)->setUnits (tempunits);
956 else if(
"YDim" == (*j)->getName()){
957 std::string tempunits =
"degrees_north";
958 (*j)->setUnits (tempunits);
962 else if(
"Pressure_Level" == (*j)->getName()) {
963 std::string tempunits =
"hPa";
964 (*j)->setUnits (tempunits);
968 std::string tempunits =
"level";
969 (*j)->setUnits (tempunits);
987 File::Check_if_special(
const string& grid_name)
throw(
Exception) {
990 bool xdim_is_lon =
false;
991 bool ydim_is_lat =
false;
992 bool pre_unit_hpa =
true;
993 for (vector < SDField * >::const_iterator i =
994 this->sd->getFields ().begin ();
995 i != this->sd->getFields ().end (); ++i) {
996 if (1==(*i)->getRank()) {
997 if(1 == ((*i)->fieldtype)) {
998 if(
"YDim" == (*j)->getName()
1007 File::Handle_AIRS_L23() throw(
Exception) {
1011 bool airs_l3 =
true;
1012 if(basename(file->
path).find(
".L2.")!=string::npos)
1016 set<string> scaled_dname_set;
1019 set<string> non_scaled_dname_set;
1020 pair<set<string>::iterator,
bool> ret;
1023 map<string,int> non_scaled_dname_to_size;
1027 for (std::vector < SDField * >::const_iterator i =
1030 string tempname = (*i)->name;
1031 size_t found_colon = tempname.find_first_of(
':');
1032 if(found_colon!=string::npos)
1033 (*i)->newname = tempname.substr(0,found_colon);
1035 for (vector < Dimension * >::const_iterator k =
1036 (*i)->getDimensions ().begin ();
1037 k != (*i)->getDimensions ().end (); ++k) {
1039 tempname = (*k)->name;
1040 found_colon = tempname.find_first_of(
':');
1041 if(found_colon!=string::npos)
1042 (*k)->name = tempname.substr(0,found_colon);
1044 if(0==(*k)->getType()) {
1045 ret = non_scaled_dname_set.insert((*k)->name);
1046 if (
true == ret.second)
1047 non_scaled_dname_to_size[(*k)->name] = (*k)->dimsize;
1050 scaled_dname_set.insert((*k)->name);
1057 for(set<string>::const_iterator sdim_it = scaled_dname_set.begin();
1058 sdim_it !=scaled_dname_set.end();
1060 cerr<<
"scaled dim. name "<<*sdim_it <<endl;
1072 if(
true == airs_l3) {
1073 set<string>scaled_dname_set_marker = scaled_dname_set;
1082 for (std::vector < SDField * >::iterator i =
1084 if(1 == (*i)->getRank()) {
1085 if(scaled_dname_set.find((*i)->getNewName())!=scaled_dname_set.end()) {
1086 if(scaled_dname_set_marker.find((*i)->getNewName())!=scaled_dname_set_marker.end()) {
1087 scaled_dname_set_marker.erase((*i)->getNewName());
1101 else if( 2 == (*i)->getRank()) {
1102 if (
"Latitude" == (*i)->getNewName() ||
"Longitude" == (*i)->getNewName()) {
1116 for(set<string>::const_iterator sdim_it = scaled_dname_set.begin();
1117 sdim_it !=scaled_dname_set.end();
1119 cerr<<
"new scaled dim. name "<<*sdim_it <<endl;
1127 set<string>final_non_scaled_dname_set;
1128 for(set<string>::const_iterator non_sdim_it = non_scaled_dname_set.begin();
1129 non_sdim_it !=non_scaled_dname_set.end();
1132 if(scaled_dname_set.find(*non_sdim_it)==scaled_dname_set.end())
1133 final_non_scaled_dname_set.insert(*non_sdim_it);
1137 for(set<string>::const_iterator non_sdim_it = final_non_scaled_dname_set.begin();
1138 non_sdim_it !=final_non_scaled_dname_set.end();
1145 missingfield->
type = DFNT_INT32;
1146 missingfield->
name = *non_sdim_it;
1147 missingfield->
newname = *non_sdim_it;
1148 missingfield->
rank = 1;
1149 missingfield->fieldtype = 4;
1150 missingfield->setUnits(
"level");
1151 Dimension *dim =
new Dimension (*non_sdim_it,non_scaled_dname_to_size[*non_sdim_it] , 0);
1153 missingfield->dims.push_back (dim);
1160 if(
true == airs_l3) {
1161 for (std::vector < SDField * >::const_iterator i =
1164 if(1 ==(*i)->getRank()){
1165 if (
"XDim" == (*i)->newname)
1166 (*i)->newname =
"Longitude";
1167 else if (
"YDim" == (*i)->newname)
1168 (*i)->newname =
"Latitude";
1171 for (vector < Dimension * >::const_iterator k =
1172 (*i)->getDimensions ().begin ();
1173 k != (*i)->getDimensions ().end (); ++k) {
1174 if(
"XDim" == (*k)->name)
1175 (*k)->name =
"Longitude";
1176 else if (
"YDim" == (*k)->name)
1177 (*k)->name =
"Latitude";
1184 if(
false == airs_l3) {
1186 bool change_lat_unit =
false;
1187 bool change_lon_unit =
false;
1188 string ll_dimname1 =
"";
1189 string ll_dimname2 =
"";
1193 for (std::vector < SDField * >::const_iterator i =
1196 if(2 == (*i)->getRank()) {
1197 if(
"Latitude" == (*i)->newname){
1198 (*i)->fieldtype = 1;
1199 change_lat_unit =
true;
1200 string tempunits =
"degrees_north";
1201 (*i)->setUnits(tempunits);
1202 ll_dimname1 = (*i)->getDimensions()[0]->getName();
1203 ll_dimname2 = (*i)->getDimensions()[1]->getName();
1206 else if(
"Longitude" == (*i)->newname) {
1207 (*i)->fieldtype = 2;
1208 change_lon_unit =
true;
1209 string tempunits =
"degrees_east";
1210 (*i)->setUnits(tempunits);
1212 if((
true == change_lat_unit) && (
true == change_lon_unit))
1218 string tempcoordinates =
"";
1219 string tempfieldname =
"";
1222 for (std::vector < SDField * >::const_iterator i =
1226 bool dimscale_var =
false;
1227 dimscale_var = ((*i)->rank == 1) & (((*i)->newname) == ((*i)->getDimensions()[0]->getName()));
1229 if((0 ==(*i)->fieldtype) && (
false == dimscale_var)) {
1232 tempcoordinates =
"";
1236 bool has_lldim1 =
false;
1237 bool has_lldim2 =
false;
1238 for (std::vector < Dimension * >::const_iterator j =
1239 (*i)->getDimensions ().begin ();
1240 j != (*i)->getDimensions ().end (); ++j) {
1241 if((*j)->name == ll_dimname1)
1243 else if ((*j)->name == ll_dimname2)
1245 if((
true == has_lldim1) && (
true == has_lldim2))
1251 if((
true == has_lldim1) && (
true == has_lldim2)) {
1252 for (std::vector < Dimension * >::const_iterator j =
1253 (*i)->getDimensions ().begin ();
1254 j != (*i)->getDimensions ().end (); ++j) {
1255 if((*j)->name == ll_dimname1)
1256 tempfieldname =
"Latitude";
1257 else if ((*j)->name == ll_dimname2)
1258 tempfieldname =
"Longitude";
1260 tempfieldname = (*j)->name;
1263 tempcoordinates = tempfieldname;
1265 tempcoordinates = tempcoordinates +
" " + tempfieldname;
1270 for (std::vector < Dimension * >::const_iterator j =
1271 (*i)->getDimensions ().begin ();
1272 j != (*i)->getDimensions ().end (); ++j) {
1274 tempcoordinates = (*j)->name;
1276 tempcoordinates = tempcoordinates +
" " + (*j)->name;
1281 (*i)->setCoordinates (tempcoordinates);
1299 if (this->sptype == OTHERHDF) {
1301 int trmm_multi_gridflag = 0;
1302 int trmm_single_gridflag = 0;
1303 int trmm_swathflag = 0;
1305 for (std::vector < Attribute * >::const_iterator i =
1306 this->sd->getAttributes ().begin ();
1307 i != this->sd->getAttributes ().end (); ++i) {
1308 if ((*i)->getName () ==
"FileHeader") {
1309 trmm_multi_gridflag++;
1310 trmm_single_gridflag++;
1313 if ((*i)->getName () ==
"FileInfo") {
1314 trmm_multi_gridflag++;
1315 trmm_single_gridflag++;
1318 if ((*i)->getName () ==
"SwathHeader")
1321 if ((*i)->getName () ==
"GridHeader")
1322 trmm_single_gridflag++;
1324 else if (((*i)->getName ().find (
"GridHeader") == 0) &&
1325 (((*i)->getName()).size() >10))
1326 trmm_multi_gridflag++;
1331 if(3 == trmm_single_gridflag)
1332 this->sptype = TRMML3S_V7;
1333 else if(3 == trmm_swathflag)
1334 this->sptype = TRMML2_V7;
1335 else if(trmm_multi_gridflag >3)
1336 this->sptype = TRMML3M_V7;
1342 if (this->sptype == OTHERHDF) {
1344 int metadataflag = 0;
1346 for (std::vector < Attribute * >::const_iterator i =
1347 this->sd->getAttributes ().begin ();
1348 i != this->sd->getAttributes ().end (); ++i) {
1349 if ((*i)->getName () ==
"CoreMetadata.0")
1351 if ((*i)->getName () ==
"ArchiveMetadata.0")
1353 if ((*i)->getName () ==
"StructMetadata.0")
1355 if ((*i)->getName ().find (
"SubsettingMethod") !=
1364 if (metadataflag == 4)
1365 this->sptype = MODISARNSS;
1369 if (metadataflag == 2) {
1371 for (std::vector < SDField * >::const_iterator i =
1372 this->sd->getFields ().begin ();
1373 i != this->sd->getFields ().end (); ++i) {
1374 if (((*i)->getName () ==
"geolocation")
1375 && (*i)->getNewName ().find (
"DATA_GRANULE") !=
1377 && (*i)->getNewName ().find (
"SwathData") !=
1378 std::string::npos && (*i)->getRank () == 3) {
1379 this->sptype = TRMML2_V6;
1392 if (this->sptype == OTHERHDF) {
1393 for (std::vector < SDField * >::const_iterator i =
1394 this->sd->getFields ().begin ();
1395 i != this->sd->getFields ().end (); ++i) {
1396 if ((*i)->getNewName ().find (
"DATA_GRANULE") !=
1397 std::string::npos) {
1398 bool l3b_v6_lonflag =
false;
1399 bool l3b_v6_latflag =
false;
1400 for (std::vector < Dimension * >::const_iterator k =
1401 (*i)->getDimensions ().begin ();
1402 k != (*i)->getDimensions ().end (); ++k) {
1403 if ((*k)->getSize () == 1440)
1404 l3b_v6_lonflag =
true;
1406 if ((*k)->getSize () == 400)
1407 l3b_v6_latflag =
true;
1409 if (l3b_v6_lonflag ==
true && l3b_v6_latflag ==
true) {
1410 this->sptype = TRMML3B_V6;
1415 bool l3a_v6_latflag =
false;
1416 bool l3a_v6_lonflag =
false;
1418 bool l3c_v6_lonflag =
false;
1419 bool l3c_v6_latflag =
false;
1421 if ((*i)->getRank()>2) {
1422 for (std::vector < Dimension * >::const_iterator k =
1423 (*i)->getDimensions ().begin ();
1424 k != (*i)->getDimensions ().end (); ++k) {
1425 if ((*k)->getSize () == 360)
1426 l3a_v6_lonflag =
true;
1428 if ((*k)->getSize () == 180)
1429 l3a_v6_latflag =
true;
1431 if ((*k)->getSize () == 720)
1432 l3c_v6_lonflag =
true;
1434 if ((*k)->getSize () == 148)
1435 l3c_v6_latflag =
true;
1440 if (
true == l3a_v6_latflag &&
true == l3a_v6_lonflag) {
1441 this->sptype = TRMML3A_V6;
1445 if (
true == l3c_v6_latflag &&
true == l3c_v6_lonflag) {
1446 this->sptype = TRMML3C_V6;
1457 if(this->sptype == TRMML3A_V6)
1458 cerr<<
"3A46 products "<<endl;
1459 if(this->sptype == TRMML3C_V6)
1460 cerr<<
"CSH products "<<endl;
1472 if (this->sptype == OTHERHDF) {
1475 int modisal2flag = 0;
1478 int modistl2flag = 0;
1484 int seawifsl2flag = 0;
1490 int modisal3mflag = 0;
1493 int modistl3mflag = 0;
1496 int octsl3mflag = 0;
1499 int seawifsl3mflag = 0;
1502 int czcsl3mflag = 0;
1507 for (std::vector < Attribute * >::const_iterator i =
1508 this->sd->getAttributes ().begin ();
1509 i != this->sd->getAttributes ().end (); ++i) {
1510 if ((*i)->getName () ==
"Product Name") {
1512 std::string attrvalue ((*i)->getValue ().begin (),
1513 (*i)->getValue ().end ());
1514 if ((attrvalue.find_first_of (
'A', 0) == 0)
1515 && (attrvalue.find (
".L2", 0) != std::string::npos))
1517 else if ((attrvalue.find_first_of (
'A', 0) == 0)
1518 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1520 else if ((attrvalue.find_first_of (
'T', 0) == 0)
1521 && (attrvalue.find (
".L2", 0) != std::string::npos))
1523 else if ((attrvalue.find_first_of (
'T', 0) == 0)
1524 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1526 else if ((attrvalue.find_first_of (
'O', 0) == 0)
1527 && (attrvalue.find (
".L2", 0) != std::string::npos))
1529 else if ((attrvalue.find_first_of (
'O', 0) == 0)
1530 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1532 else if ((attrvalue.find_first_of (
'S', 0) == 0)
1533 && (attrvalue.find (
".L2", 0) != std::string::npos))
1535 else if ((attrvalue.find_first_of (
'S', 0) == 0)
1536 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1538 else if ((attrvalue.find_first_of (
'C', 0) == 0)
1539 && ((attrvalue.find (
".L2", 0) != std::string::npos)
1541 (attrvalue.find (
".L1A", 0) != std::string::npos)))
1543 else if ((attrvalue.find_first_of (
'C', 0) == 0)
1544 && (attrvalue.find (
".L3m", 0) != std::string::npos))
1548 if ((*i)->getName () ==
"Sensor Name") {
1550 std::string attrvalue ((*i)->getValue ().begin (),
1551 (*i)->getValue ().end ());
1552 if (attrvalue.find (
"MODISA", 0) != std::string::npos) {
1556 else if (attrvalue.find (
"MODIST", 0) != std::string::npos) {
1560 else if (attrvalue.find (
"OCTS", 0) != std::string::npos) {
1564 else if (attrvalue.find (
"SeaWiFS", 0) != std::string::npos) {
1568 else if (attrvalue.find (
"CZCS", 0) != std::string::npos) {
1575 if ((modisal2flag == 2) || (modisal3mflag == 2)
1576 || (modistl2flag == 2) || (modistl3mflag == 2)
1577 || (octsl2flag == 2) || (octsl3mflag == 2)
1578 || (seawifsl2flag == 2) || (seawifsl3mflag == 2)
1579 || (czcsl2flag == 2) || (czcsl3mflag == 2))
1585 if ((modisal2flag == 2) || (modistl2flag == 2) ||
1586 (octsl2flag == 2) || (seawifsl2flag == 2) || (czcsl2flag == 2))
1587 this->sptype = OBPGL2;
1589 if ((modisal3mflag == 2) ||
1590 (modistl3mflag == 2) || (octsl3mflag == 2) ||
1591 (seawifsl3mflag == 2) || (czcsl3mflag == 2))
1592 this->sptype = OBPGL3;
1610 int32 n_sd_attrs = 0;
1619 int32 dim_sizes[H4_MAX_VAR_DIMS];
1622 int32 n_sds_attrs = 0;
1628 char sds_name[H4_MAX_NC_NAME];
1631 char dim_name[H4_MAX_NC_NAME];
1634 char attr_name[H4_MAX_NC_NAME];
1650 int32 attr_value_count = 0;
1653 SD* sd =
new SD (sdfd, fileid);
1656 if (SDfileinfo (sdfd, &n_sds, &n_sd_attrs) == FAIL) {
1658 throw2 (
"SDfileinfo failed ", sdfd);
1662 for (sds_index = 0; sds_index < n_sds; sds_index++) {
1668 sds_id = SDselect (sdfd, sds_index);
1669 if (sds_id == FAIL) {
1673 SDendaccess (sds_id);
1674 throw3 (
"SDselect Failed ",
"SDS index ", sds_index);
1678 sds_ref = SDidtoref (sds_id);
1679 if (sds_ref == FAIL) {
1682 SDendaccess (sds_id);
1683 throw3 (
"Cannot obtain SDS reference number",
" SDS ID is ",
1688 status = SDgetinfo (sds_id, sds_name, &field->
rank, dim_sizes,
1689 &field->
type, &n_sds_attrs);
1690 if (status == FAIL) {
1693 SDendaccess (sds_id);
1694 throw2 (
"SDgetinfo failed ", sds_name);
1698 string tempname (sds_name);
1699 field->
name = tempname;
1701 field->fieldref = sds_ref;
1706 bool dim_no_dimscale =
false;
1707 vector <int> dimids;
1709 dimids.assign(field->
rank,0);
1712 vector <int>num_dim_attrs;
1714 num_dim_attrs.assign(field->
rank,0);
1717 for (
int dimindex = 0; dimindex < field->
rank; dimindex++) {
1720 int dimid = SDgetdimid (sds_id, dimindex);
1721 if (dimid == FAIL) {
1724 SDendaccess (sds_id);
1725 throw5 (
"SDgetdimid failed ",
"SDS name ", sds_name,
1726 "dim index= ", dimindex);
1730 int temp_num_dim_attrs = 0;
1732 SDdiminfo (dimid, dim_name, &dim_size, &dim_type,
1733 (int32*)&temp_num_dim_attrs);
1734 if (status == FAIL) {
1737 SDendaccess (sds_id);
1738 throw5 (
"SDdiminfo failed ",
"SDS name ", sds_name,
1739 "dim index= ", dimindex);
1742 num_dim_attrs[dimindex] = temp_num_dim_attrs;
1761 string dim_name_str (dim_name);
1766 new Dimension (dim_name_str, dim_sizes[dimindex], dim_type);
1769 field->dims.push_back (dim);
1773 dimids[dimindex] = dimid;
1774 if (0 == dim_type) {
1775 if (
false == dim_no_dimscale)
1776 dim_no_dimscale =
true;
1777 if ((dim_name_str == field->
name) && (1 == field->
rank))
1778 field->is_noscale_dim =
true;
1785 if(
true == dim_no_dimscale) {
1787 for (
int dimindex = 0; dimindex < field->
rank; dimindex++) {
1789 string dim_name_str = (field->dims)[dimindex]->name;
1792 stringstream out_index;
1793 out_index << dimindex;
1794 index_str = out_index.str();
1795 dim_info->name =
"_dim_" + index_str;
1799 bool dimname_flag =
false;
1801 int32 dummy_type = 0;
1802 int32 dummy_value_count = 0;
1805 for (
int attrindex = 0; attrindex < num_dim_attrs[dimindex]; attrindex++) {
1807 status = SDattrinfo(dimids[dimindex],attrindex,attr_name,
1808 &dummy_type,&dummy_value_count);
1809 if (status == FAIL) {
1812 SDendaccess (sds_id);
1813 throw3 (
"SDattrinfo failed ",
"SDS name ", sds_name);
1816 string tempname2(attr_name);
1817 if (
"name"==tempname2) {
1818 dimname_flag =
true;
1824 for (
int attrindex = 0; attrindex < num_dim_attrs[dimindex]; attrindex++) {
1827 status = SDattrinfo(dimids[dimindex],attrindex,attr_name,
1828 &attr->type,&attr_value_count);
1829 if (status == FAIL) {
1832 SDendaccess (sds_id);
1833 throw3 (
"SDattrinfo failed ",
"SDS name ", sds_name);
1835 string tempname3 (attr_name);
1836 attr->name = tempname3;
1839 attr->newname = tempname3;
1840 attr->count = attr_value_count;
1841 attr->value.resize (attr_value_count * DFKNTsize (attr->type));
1842 if (SDreadattr (dimids[dimindex], attrindex, &attr->value[0]) == -1) {
1845 SDendaccess (sds_id);
1846 throw5 (
"read SDS attribute failed ",
"Field name ",
1847 field->
name,
" Attribute name ", attr->name);
1850 dim_info->attrs.push_back (attr);
1856 if (
false == dimname_flag) {
1859 attr->name =
"name";
1860 attr->newname =
"name";
1861 attr->type = DFNT_CHAR;
1862 attr->count = dim_name_str.size();
1863 attr->value.resize(attr->count);
1864 copy(dim_name_str.begin(),dim_name_str.end(),attr->value.begin());
1865 dim_info->attrs.push_back(attr);
1868 field->dims_info.push_back(dim_info);
1873 for (
int attrindex = 0; attrindex < n_sds_attrs; attrindex++) {
1876 SDattrinfo (sds_id, attrindex, attr_name, &attr->type,
1879 if (status == FAIL) {
1883 SDendaccess (sds_id);
1884 throw3 (
"SDattrinfo failed ",
"SDS name ", sds_name);
1888 string tempname4 (attr_name);
1889 attr->name = tempname4;
1892 attr->newname = tempname4;
1893 attr->count = attr_value_count;
1894 attr->value.resize (attr_value_count * DFKNTsize (attr->type));
1895 if (SDreadattr (sds_id, attrindex, &attr->value[0]) == -1) {
1896 string temp_field_name = field->
name;
1897 string temp_attr_name = attr->name;
1901 SDendaccess (sds_id);
1902 throw5 (
"read SDS attribute failed ",
"Field name ",
1903 temp_field_name,
" Attribute name ", temp_attr_name);
1905 field->
attrs.push_back (attr);
1908 SDendaccess (sds_id);
1913 for (
int attrindex = 0; attrindex < n_sd_attrs; attrindex++) {
1916 status = SDattrinfo (sdfd, attrindex, attr_name, &attr->type,
1918 if (status == FAIL) {
1921 throw3 (
"SDattrinfo failed ",
"SD id ", sdfd);
1924 std::string tempname5 (attr_name);
1925 attr->name = tempname5;
1929 attr->newname = tempname5;
1930 attr->count = attr_value_count;
1931 attr->value.resize (attr_value_count * DFKNTsize (attr->type));
1932 if (SDreadattr (sdfd, attrindex, &attr->value[0]) == -1) {
1935 throw3 (
"Cannot read SD attribute",
" Attribute name ",
1938 sd->
attrs.push_back (attr);
1958 int32 n_sd_attrs = 0;
1964 int extra_sds_index = 0;
1970 int32 dim_sizes[H4_MAX_VAR_DIMS];
1973 int32 n_sds_attrs = 0;
1979 char sds_name[H4_MAX_NC_NAME];
1982 char dim_name[H4_MAX_NC_NAME];
1985 char attr_name[H4_MAX_NC_NAME];
1998 int32 num_dim_attrs = 0;
2001 int32 attr_value_count = 0;
2005 int32 vgroup_id = 0;
2008 int32 lone_vg_number = 0;
2011 int32 num_of_lones = -1;
2013 int32 num_gobjects = 0;
2024 char vgroup_name[VGNAMELENMAX*4];
2025 char vgroup_class[VGNAMELENMAX*4];
2030 char *full_path = NULL;
2034 char *cfull_path = NULL;
2038 SD *sd =
new SD (sdfd, fileid);
2041 if (SDfileinfo (sdfd, &n_sds, &n_sd_attrs) == FAIL) {
2044 throw2 (
"SDfileinfo failed ", sdfd);
2049 for (sds_index = 0; sds_index < n_sds; sds_index++) {
2050 sds_id = SDselect (sdfd, sds_index);
2052 if (sds_id == FAIL) {
2057 SDendaccess (sds_id);
2058 throw3 (
"SDselect Failed ",
"SDS index ", sds_index);
2061 sds_ref = SDidtoref (sds_id);
2062 if (sds_ref == FAIL) {
2065 SDendaccess (sds_id);
2066 throw3 (
"Cannot obtain SDS reference number",
" SDS ID is ",
2070 SDendaccess(sds_id);
2079 num_of_lones = Vlone (fileid, NULL, 0);
2080 if (num_of_lones == FAIL){
2083 throw3 (
"Fail to obtain lone vgroup number",
"file id is", fileid);
2087 if (num_of_lones > 0) {
2091 vector<int32>ref_array;
2092 ref_array.resize(num_of_lones);
2096 num_of_lones = Vlone (fileid, &ref_array[0], num_of_lones);
2097 if (num_of_lones == FAIL) {
2100 throw3 (
"Cannot obtain lone vgroup reference arrays ",
2101 "file id is ", fileid);
2105 for (lone_vg_number = 0; lone_vg_number < num_of_lones;
2109 vgroup_id = Vattach (fileid, ref_array[lone_vg_number],
"r");
2110 if (vgroup_id == FAIL) {
2113 throw3 (
"Vattach failed ",
"Reference number is ",
2114 ref_array[lone_vg_number]);
2117 status = Vgetname (vgroup_id, vgroup_name);
2118 if (status == FAIL) {
2121 Vdetach (vgroup_id);
2122 throw3 (
"Vgetname failed ",
"vgroup_id is ", vgroup_id);
2125 status = Vgetclass (vgroup_id, vgroup_class);
2126 if (status == FAIL) {
2129 Vdetach (vgroup_id);
2130 throw3 (
"Vgetclass failed ",
"vgroup_name is ", vgroup_name);
2134 if (strcmp (vgroup_class, _HDF_ATTRIBUTE) == 0
2135 || strcmp (vgroup_class, _HDF_VARIABLE) == 0
2136 || strcmp (vgroup_class, _HDF_DIMENSION) == 0
2137 || strcmp (vgroup_class, _HDF_UDIMENSION) == 0
2138 || strcmp (vgroup_class, _HDF_CDF) == 0
2139 || strcmp (vgroup_class, GR_NAME) == 0
2140 || strcmp (vgroup_class, RI_NAME) == 0) {
2141 Vdetach (vgroup_id);
2146 num_gobjects = Vntagrefs (vgroup_id);
2147 if (num_gobjects < 0) {
2150 Vdetach (vgroup_id);
2151 throw3 (
"Vntagrefs failed ",
"vgroup_name is ", vgroup_name);
2164 full_path = (
char *) malloc (MAX_FULL_PATH_LEN);
2165 if (full_path == NULL) {
2168 Vdetach (vgroup_id);
2170 throw1 (
"No enough memory to allocate the buffer.");
2173 memset(full_path,
'\0',MAX_FULL_PATH_LEN);
2174 strncpy(full_path,_BACK_SLASH,strlen(_BACK_SLASH));
2175 strncat(full_path, vgroup_name,strlen(vgroup_name));
2177 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
2178 if (cfull_path == NULL) {
2181 Vdetach (vgroup_id);
2182 if(full_path != NULL)
2185 throw1 (
"No enough memory to allocate the buffer.");
2188 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
2189 strncpy (cfull_path, full_path,strlen(full_path));
2192 for (i = 0; i < num_gobjects; i++) {
2195 if (Vgettagref (vgroup_id, i, &obj_tag, &obj_ref) == FAIL) {
2198 Vdetach (vgroup_id);
2199 if(full_path != NULL)
2201 if(cfull_path != NULL)
2203 throw5 (
"Vgettagref failed ",
"vgroup_name is ",
2204 vgroup_name,
" reference number is ", obj_ref);
2208 if (Visvg (vgroup_id, obj_ref) == TRUE) {
2209 strncpy(full_path,cfull_path,strlen(cfull_path)+1);
2210 full_path[strlen(cfull_path)]=
'\0';
2215 else if (obj_tag == DFTAG_NDG || obj_tag == DFTAG_SDG
2216 || obj_tag == DFTAG_SD) {
2222 string temp_str = string(full_path);
2223 if((temp_str.find(
"Data Fields") != std::string::npos)||
2224 (temp_str.find(
"Geolocation Fields") != std::string::npos))
2236 status = Vdetach (vgroup_id);
2238 if (status == FAIL) {
2241 throw3 (
"Vdetach failed ",
"vgroup_name is ", vgroup_name);
2248 for(std::list<int32>::iterator sds_ref_it = sd->
sds_ref_list.begin();
2251 extra_sds_index = SDreftoindex(sdfd,*sds_ref_it);
2252 if(extra_sds_index == FAIL) {
2254 throw3(
"SDreftoindex Failed ",
"SDS reference number ", *sds_ref_it);
2258 sds_id = SDselect (sdfd, extra_sds_index);
2259 if (sds_id == FAIL) {
2263 SDendaccess (sds_id);
2264 throw3 (
"SDselect Failed ",
"SDS index ", extra_sds_index);
2268 status = SDgetinfo (sds_id, sds_name, &field->
rank, dim_sizes,
2269 &field->
type, &n_sds_attrs);
2270 if (status == FAIL) {
2273 SDendaccess (sds_id);
2274 throw2 (
"SDgetinfo failed ", sds_name);
2278 string tempname (sds_name);
2279 field->
name = tempname;
2281 field->
newname = tempname+
"_"+
"NONEOS";
2282 field->fieldref = *sds_ref_it;
2286 for (
int dimindex = 0; dimindex < field->
rank; dimindex++) {
2287 int dimid = SDgetdimid (sds_id, dimindex);
2288 if (dimid == FAIL) {
2291 SDendaccess (sds_id);
2292 throw5 (
"SDgetdimid failed ",
"SDS name ", sds_name,
2293 "dim index= ", dimindex);
2295 status = SDdiminfo (dimid, dim_name, &dim_size, &dim_type,
2298 if (status == FAIL) {
2301 SDendaccess (sds_id);
2302 throw5 (
"SDdiminfo failed ",
"SDS name ", sds_name,
2303 "dim index= ", dimindex);
2306 string dim_name_str (dim_name);
2311 new Dimension (dim_name_str, dim_sizes[dimindex], dim_type);
2313 field->dims.push_back (dim);
2333 new Dimension (cfdimname, dim_sizes[dimindex], dim_type);
2335 field->correcteddims.push_back (correcteddim);
2340 for (
int attrindex = 0; attrindex < n_sds_attrs; attrindex++) {
2344 status = SDattrinfo (sds_id, attrindex, attr_name, &attr->type,
2346 if (status == FAIL) {
2350 SDendaccess (sds_id);
2351 throw3 (
"SDattrinfo failed ",
"SDS name ", sds_name);
2354 string tempname (attr_name);
2355 attr->name = tempname;
2359 attr->newname = tempname;
2360 attr->count = attr_value_count;
2361 attr->value.resize (attr_value_count * DFKNTsize (attr->type));
2362 if (SDreadattr (sds_id, attrindex, &attr->value[0]) == -1) {
2366 SDendaccess (sds_id);
2367 throw5 (
"read SDS attribute failed ",
"Field name ",
2368 field->
name,
" Attribute name ", attr->name);
2370 field->
attrs.push_back (attr);
2372 SDendaccess (sds_id);
2385 int32 fieldsize = 0;
2388 int32 fieldtype = 0;
2391 int32 fieldorder = 0;
2394 char *fieldname = NULL;
2398 char vdata_name[VSNAMELENMAX];
2400 VDATA *vdata =
new VDATA (vdata_id, obj_ref);
2402 vdata->
vdref = obj_ref;
2404 if (VSQueryname (vdata_id, vdata_name) == FAIL){
2406 throw3 (
"VSQueryname failed ",
"vdata id is ", vdata_id);
2409 string vdatanamestr (vdata_name);
2411 vdata->
name = vdatanamestr;
2413 int32 num_field = VFnfields (vdata_id);
2415 if (num_field == -1){
2417 throw3 (
"For vdata, VFnfields failed. ",
"vdata name is ",
2421 int32 num_record = VSelts (vdata_id);
2423 if (num_record == -1) {
2425 throw3 (
"For vdata, VSelts failed. ",
"vdata name is ", vdata->
name);
2433 string check_vdata_to_attr_key=
"H4.EnableVdata_to_Attr";
2434 bool turn_on_vdata_to_attr_key =
false;
2436 turn_on_vdata_to_attr_key = HDFCFUtil::check_beskeys(check_vdata_to_attr_key);
2444 if (num_record <= 10 &&
true == HDF4RequestHandler::get_enable_vdata_attr())
2450 for (
int i = 0; i < num_field; i++) {
2457 throw1(
"Memory allocation for field class failed.");
2460 fieldsize = VFfieldesize (vdata_id, i);
2461 if (fieldsize == FAIL) {
2462 string temp_vdata_name = vdata->
name;
2465 throw5 (
"For vdata field, VFfieldsize failed. ",
"vdata name is ",
2466 temp_vdata_name,
" index is ", i);
2469 fieldname = VFfieldname (vdata_id, i);
2470 if (fieldname == NULL) {
2471 string temp_vdata_name = vdata->
name;
2474 throw5 (
"For vdata field, VFfieldname failed. ",
"vdata name is ",
2475 temp_vdata_name,
" index is ", i);
2478 fieldtype = VFfieldtype (vdata_id, i);
2479 if (fieldtype == FAIL) {
2480 string temp_vdata_name = vdata->
name;
2483 throw5 (
"For vdata field, VFfieldtype failed. ",
"vdata name is ",
2484 temp_vdata_name,
" index is ", i);
2487 fieldorder = VFfieldorder (vdata_id, i);
2488 if (fieldorder == FAIL) {
2489 string temp_vdata_name = vdata->
name;
2492 throw5 (
"For vdata field, VFfieldtype failed. ",
"vdata name is ",
2493 temp_vdata_name,
" index is ", i);
2496 if(fieldname !=NULL)
2497 field->
name = fieldname;
2499 field->
type = fieldtype;
2500 field->order = fieldorder;
2501 field->size = fieldsize;
2503 field->numrec = num_record;
2510 field->value.resize (num_record * fieldsize);
2511 if (VSseek (vdata_id, 0) == FAIL) {
2516 throw5 (
"vdata ", vdata_name,
"field ", fieldname,
2520 if (VSsetfields (vdata_id, fieldname) == FAIL) {
2525 throw3 (
"vdata field ", fieldname,
" VSsetfields failed.");
2529 (vdata_id, (uint8 *) & field->value[0], num_record,
2530 FULL_INTERLACE) == FAIL){
2535 throw3 (
"vdata field ", fieldname,
" VSread failed.");
2574 char attr_name[H4_MAX_NC_NAME];
2586 nattrs = VSfnattrs (vdata_id, _HDF_VDATA);
2591 throw3 (
"VSfnattrs failed ",
"vdata id is ", vdata_id);
2597 for (
int i = 0; i < nattrs; i++) {
2601 status = VSattrinfo (vdata_id, _HDF_VDATA, i, attr_name,
2602 &attr->type, &attr->count, &attrsize);
2603 if (status == FAIL) {
2605 throw5 (
"VSattrinfo failed ",
"vdata id is ", vdata_id,
2606 " attr index is ", i);
2610 string tempname(attr_name);
2612 attr->name = tempname;
2614 attr->value.resize (attrsize);
2616 if (VSgetattr (vdata_id, _HDF_VDATA, i, &attr->value[0]) == FAIL) {
2618 throw5 (
"VSgetattr failed ",
"vdata id is ", vdata_id,
2619 " attr index is ", i);
2621 attrs.push_back (attr);
2636 char attr_name[H4_MAX_NC_NAME];
2648 nattrs = VSfnattrs (vdata_id, fieldindex);
2653 throw5 (
"VSfnattrs failed ",
"vdata id is ", vdata_id,
2654 "Field index is ", fieldindex);
2660 for (
int i = 0; i < nattrs; i++) {
2664 status = VSattrinfo (vdata_id, fieldindex, i, attr_name,
2665 &attr->type, &attr->count, &attrsize);
2667 if (status == FAIL) {
2669 throw5 (
"VSattrinfo failed ",
"vdata field index ",
2670 fieldindex,
" attr index is ", i);
2674 string tempname(attr_name);
2675 attr->name = tempname;
2680 attr->value.resize (attrsize);
2681 if (VSgetattr (vdata_id, fieldindex, i, &attr->value[0]) == FAIL) {
2683 throw5 (
"VSgetattr failed ",
"vdata field index is ",
2684 fieldindex,
" attr index is ", i);
2686 attrs.push_back (attr);
2697 char attr_name[H4_MAX_NC_NAME];
2700 intn n_attrs = Vnattrs(vgroup_id);
2702 throw1(
"Vnattrs failed");
2705 string temp_container_name(fullpath);
2709 for(
int attr_index = 0; attr_index <n_attrs; attr_index++) {
2712 int32 value_size_32 = 0;
2713 status_n = Vattrinfo(vgroup_id, (intn)attr_index, attr_name, &attr->type,
2714 &attr->count, &value_size_32);
2715 if(status_n == FAIL) {
2717 throw1(
"Vattrinfo failed.");
2719 int value_size = value_size_32;
2721 string tempname (attr_name);
2723 attr->name = tempname;
2725 attr->newname = tempname;
2726 attr->value.resize (value_size);
2728 status_n = Vgetattr(vgroup_id,(intn)attr_index,&attr->value[0]);
2729 if(status_n == FAIL) {
2732 throw3(
"Vgetattr failed. ",
"The attribute name is ",attr->name);
2734 vg_attr->attrs.push_back(attr);
2739 vg_attrs.push_back(vg_attr);
2759 int32 vgroup_id = 0;
2765 int32 lone_vg_number = 0;
2768 int32 num_of_lones = -1;
2771 int32 num_gobjects = 0;
2781 char vdata_name[VSNAMELENMAX];
2784 char vdata_class[VSNAMELENMAX];
2787 char vgroup_name[VGNAMELENMAX*4];
2790 char vgroup_class[VGNAMELENMAX*4];
2793 char *full_path = NULL;
2796 char *cfull_path = NULL;
2801 file_id = this->fileid;
2807 num_of_lones = Vlone (file_id, NULL, 0);
2808 if (num_of_lones == FAIL)
2809 throw3 (
"Fail to obtain lone vgroup number",
"file id is", file_id);
2812 if (num_of_lones > 0) {
2816 vector<int32>ref_array;
2817 ref_array.resize(num_of_lones);
2821 num_of_lones = Vlone (file_id, &ref_array[0], num_of_lones);
2822 if (num_of_lones == FAIL) {
2823 throw3 (
"Cannot obtain lone vgroup reference arrays ",
2824 "file id is ", file_id);
2828 for (lone_vg_number = 0; lone_vg_number < num_of_lones;
2832 vgroup_id = Vattach (file_id, ref_array[lone_vg_number],
"r");
2833 if (vgroup_id == FAIL) {
2834 throw3 (
"Vattach failed ",
"Reference number is ",
2835 ref_array[lone_vg_number]);
2838 status = Vgetname (vgroup_id, vgroup_name);
2839 if (status == FAIL) {
2840 Vdetach (vgroup_id);
2841 throw3 (
"Vgetname failed ",
"vgroup_id is ", vgroup_id);
2844 status = Vgetclass (vgroup_id, vgroup_class);
2845 if (status == FAIL) {
2846 Vdetach (vgroup_id);
2847 throw3 (
"Vgetclass failed ",
"vgroup_name is ", vgroup_name);
2851 if (strcmp (vgroup_class, _HDF_ATTRIBUTE) == 0
2852 || strcmp (vgroup_class, _HDF_VARIABLE) == 0
2853 || strcmp (vgroup_class, _HDF_DIMENSION) == 0
2854 || strcmp (vgroup_class, _HDF_UDIMENSION) == 0
2855 || strcmp (vgroup_class, _HDF_CDF) == 0
2856 || strcmp (vgroup_class, GR_NAME) == 0
2857 || strcmp (vgroup_class, RI_NAME) == 0) {
2862 num_gobjects = Vntagrefs (vgroup_id);
2863 if (num_gobjects < 0) {
2864 Vdetach (vgroup_id);
2865 throw3 (
"Vntagrefs failed ",
"vgroup_name is ", vgroup_name);
2873 full_path = (
char *) malloc (MAX_FULL_PATH_LEN);
2874 if (full_path == NULL) {
2875 Vdetach (vgroup_id);
2877 throw1 (
"No enough memory to allocate the buffer.");
2880 memset(full_path,
'\0',MAX_FULL_PATH_LEN);
2881 strncpy (full_path,_BACK_SLASH,strlen(_BACK_SLASH));
2882 strncat(full_path,vgroup_name,strlen(vgroup_name));
2885 ReadVgattrs(vgroup_id,full_path);
2889 Vdetach (vgroup_id);
2891 throw1 (
"ReadVgattrs failed ");
2893 strncat(full_path,_BACK_SLASH,strlen(_BACK_SLASH));
2895 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
2896 if (cfull_path == NULL) {
2897 Vdetach (vgroup_id);
2900 throw1 (
"No enough memory to allocate the buffer.");
2903 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
2904 strncpy (cfull_path, full_path,strlen(full_path));
2908 for (
int i = 0; i < num_gobjects; i++) {
2909 if (Vgettagref (vgroup_id, i, &obj_tag, &obj_ref) == FAIL) {
2910 Vdetach (vgroup_id);
2913 throw5 (
"Vgettagref failed ",
"vgroup_name is ",
2914 vgroup_name,
" reference number is ", obj_ref);
2918 if (Visvg (vgroup_id, obj_ref) == TRUE) {
2919 strncpy (full_path, cfull_path,strlen(cfull_path)+1);
2920 full_path[strlen(cfull_path)]=
'\0';
2921 obtain_path (file_id, sd_id, full_path, obj_ref);
2924 else if (Visvs (vgroup_id, obj_ref)) {
2926 vdata_id = VSattach (file_id, obj_ref,
"r");
2927 if (vdata_id == FAIL) {
2928 Vdetach (vgroup_id);
2931 throw5 (
"VSattach failed ",
"vgroup_name is ",
2932 vgroup_name,
" reference number is ",
2935 status = VSgetname (vdata_id, vdata_name);
2936 if (status == FAIL) {
2937 Vdetach (vgroup_id);
2940 throw5 (
"VSgetclass failed ",
"vgroup_name is ",
2941 vgroup_name,
" reference number is ",
2945 status = VSgetclass (vdata_id, vdata_class);
2946 if (status == FAIL) {
2947 Vdetach (vgroup_id);
2950 throw5 (
"VSgetclass failed ",
"vgroup_name is ",
2951 vgroup_name,
" reference number is ",
2964 if (VSisattr (vdata_id) == TRUE
2965 || !strncmp (vdata_class, _HDF_CHK_TBL_CLASS,
2966 strlen (_HDF_CHK_TBL_CLASS))
2967 || !strncmp (vdata_class, _HDF_SDSVAR,
2968 strlen (_HDF_SDSVAR))
2969 || !strncmp (vdata_class, _HDF_CRDVAR,
2970 strlen (_HDF_CRDVAR))
2971 || !strncmp (vdata_class, DIM_VALS, strlen (DIM_VALS))
2972 || !strncmp (vdata_class, DIM_VALS01,
2973 strlen (DIM_VALS01))
2974 || !strncmp (vdata_class, RIGATTRCLASS,
2975 strlen (RIGATTRCLASS))
2976 || !strncmp (vdata_name, RIGATTRNAME,
2977 strlen (RIGATTRNAME))) {
2979 status = VSdetach (vdata_id);
2980 if (status == FAIL) {
2981 Vdetach (vgroup_id);
2984 throw3 (
"VSdetach failed ",
2985 "Vdata is under vgroup ", vgroup_name);
2991 VDATA*vdataobj = NULL;
2999 Vdetach (vgroup_id);
3009 for (std::vector <VDField * >::const_iterator it_vdf =
3011 it_vdf != vdataobj->
getFields ().end ();
3017 (*it_vdf)->newname =
3018 "vdata" + vdataobj->
newname +
"_vdf_" + (*it_vdf)->name;
3028 this->vds.push_back (vdataobj);
3030 status = VSdetach (vdata_id);
3031 if (status == FAIL) {
3032 Vdetach (vgroup_id);
3035 throw3 (
"VSdetach failed ",
3036 "Vdata is under vgroup ", vgroup_name);
3042 else if (obj_tag == DFTAG_NDG || obj_tag == DFTAG_SDG
3043 || obj_tag == DFTAG_SD) {
3046 if (this->sd->refindexlist.find (obj_ref) !=
3047 sd->refindexlist.end ()) {
3051 if(full_path != NULL) {
3052 this->sd->sdfields[this->sd->refindexlist[obj_ref]]->newname =
3054 this->sd->sdfields[this->sd->refindexlist[obj_ref]]->name;
3058 Vdetach (vgroup_id);
3061 throw3 (
"SDS with the reference number ", obj_ref,
3072 status = Vdetach (vgroup_id);
3073 if (status == FAIL) {
3074 throw3 (
"Vdetach failed ",
"vgroup_name is ", vgroup_name);
3090 int32 vgroup_pid = -1;
3099 int num_gobjects = 0;
3107 char cvgroup_name[VGNAMELENMAX*4];
3110 char vdata_name[VSNAMELENMAX];
3113 char vdata_class[VSNAMELENMAX];
3116 int32 vdata_id = -1;
3125 char *cfull_path = NULL;
3127 bool unexpected_fail =
false;
3130 vgroup_pid = Vattach (file_id, pobj_ref,
"r");
3131 if (vgroup_pid == FAIL)
3132 throw3 (
"Vattach failed ",
"Object reference number is ", pobj_ref);
3135 if (Vgetname (vgroup_pid, cvgroup_name) == FAIL) {
3136 Vdetach (vgroup_pid);
3137 throw3 (
"Vgetname failed ",
"Object reference number is ", pobj_ref);
3139 num_gobjects = Vntagrefs (vgroup_pid);
3140 if (num_gobjects < 0) {
3141 Vdetach (vgroup_pid);
3142 throw3 (
"Vntagrefs failed ",
"Object reference number is ", pobj_ref);
3153 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
3154 if (cfull_path == NULL)
3155 throw1 (
"No enough memory to allocate the buffer");
3157 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
3159 strncpy(cfull_path,full_path,strlen(full_path));
3160 strncat(cfull_path,cvgroup_name,strlen(cvgroup_name));
3162 ReadVgattrs(vgroup_pid,cfull_path);
3166 Vdetach (vgroup_pid);
3168 throw1 (
"ReadVgattrs failed ");
3171 strncat(cfull_path,_BACK_SLASH,strlen(_BACK_SLASH));
3177 for (i = 0; i < num_gobjects; i++) {
3179 if (Vgettagref (vgroup_pid, i, &obj_tag, &obj_ref) == FAIL) {
3180 unexpected_fail =
true;
3181 err_msg = string(ERR_LOC) +
" Vgettagref failed. ";
3185 if (Visvg (vgroup_pid, obj_ref) == TRUE) {
3186 strncpy(full_path,cfull_path,strlen(cfull_path)+1);
3187 full_path[strlen(cfull_path)]=
'\0';
3188 obtain_path (file_id, sd_id, full_path, obj_ref);
3190 else if (Visvs (vgroup_pid, obj_ref)) {
3192 vdata_id = VSattach (file_id, obj_ref,
"r");
3193 if (vdata_id == FAIL) {
3194 unexpected_fail =
true;
3195 err_msg = string(ERR_LOC) +
" VSattach failed. ";
3199 status = VSQueryname (vdata_id, vdata_name);
3200 if (status == FAIL) {
3201 unexpected_fail =
true;
3202 err_msg = string(ERR_LOC) +
" VSQueryname failed. ";
3206 status = VSgetclass (vdata_id, vdata_class);
3207 if (status == FAIL) {
3208 unexpected_fail =
true;
3209 err_msg = string(ERR_LOC) +
" VSgetclass failed. ";
3213 if (VSisattr (vdata_id) != TRUE) {
3215 (vdata_class, _HDF_CHK_TBL_CLASS,
3216 strlen (_HDF_CHK_TBL_CLASS))) {
3218 VDATA *vdataobj = NULL;
3226 Vdetach (vgroup_pid);
3236 for (std::vector <VDField * >::const_iterator it_vdf =
3238 it_vdf != vdataobj->
getFields ().end ();
3243 (*it_vdf)->newname =
3244 "vdata" + vdataobj->
newname +
"_vdf_" +
3252 this->vds.push_back (vdataobj);
3255 status = VSdetach (vdata_id);
3256 if (status == FAIL) {
3257 unexpected_fail =
true;
3258 err_msg = string(ERR_LOC) +
" VSdetach failed. ";
3262 else if (obj_tag == DFTAG_NDG || obj_tag == DFTAG_SDG
3263 || obj_tag == DFTAG_SD) {
3264 if (this->sd->refindexlist.find (obj_ref) !=
3265 this->sd->refindexlist.end ())
3266 this->sd->sdfields[this->sd->refindexlist[obj_ref]]->newname =
3268 cfull_path + this->sd->sdfields[this->sd->refindexlist[obj_ref]]->name;
3270 unexpected_fail =
true;
3271 stringstream temp_ss;
3273 err_msg = string(ERR_LOC) +
"SDS with the reference number"
3274 + temp_ss.str() +
" is not found.";
3283 if(vdata_id != -1) {
3284 status = VSdetach(vdata_id);
3285 if (status == FAIL) {
3286 Vdetach(vgroup_pid);
3287 string err_msg2 =
"In the cleanup " + string(ERR_LOC) +
" VSdetached failed. ";
3288 err_msg = err_msg + err_msg2;
3291 else if(
true == unexpected_fail)
3296 if(vgroup_pid != -1) {
3297 status = Vdetach(vgroup_pid);
3298 if (status == FAIL) {
3299 string err_msg2 =
"In the cleanup " + string(ERR_LOC) +
" VSdetached failed. ";
3300 err_msg = err_msg + err_msg2;
3303 else if(
true == unexpected_fail)
3320 int32 vgroup_cid = -1;
3323 int num_gobjects = 0;
3328 char cvgroup_name[VGNAMELENMAX*4];
3332 char *cfull_path = NULL;
3334 bool unexpected_fail =
false;
3336 vgroup_cid = Vattach (file_id, pobj_ref,
"r");
3337 if (vgroup_cid == FAIL)
3338 throw3 (
"Vattach failed ",
"Object reference number is ", pobj_ref);
3340 if (Vgetname (vgroup_cid, cvgroup_name) == FAIL) {
3341 Vdetach (vgroup_cid);
3342 throw3 (
"Vgetname failed ",
"Object reference number is ", pobj_ref);
3344 num_gobjects = Vntagrefs (vgroup_cid);
3345 if (num_gobjects < 0) {
3346 Vdetach (vgroup_cid);
3347 throw3 (
"Vntagrefs failed ",
"Object reference number is ", pobj_ref);
3359 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
3360 if (cfull_path == NULL)
3361 throw1 (
"No enough memory to allocate the buffer");
3363 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
3367 strncpy(cfull_path,full_path,strlen(full_path));
3368 strncat(cfull_path,cvgroup_name,strlen(cvgroup_name));
3369 strncat(cfull_path,_BACK_SLASH,strlen(_BACK_SLASH));
3373 for (i = 0; i < num_gobjects; i++) {
3375 if (Vgettagref (vgroup_cid, i, &obj_tag, &obj_ref) == FAIL) {
3376 unexpected_fail =
true;
3377 err_msg = string(ERR_LOC) +
" Vgettagref failed. ";
3381 if (Visvg (vgroup_cid, obj_ref) == TRUE) {
3382 strncpy (full_path, cfull_path,strlen(cfull_path)+1);
3383 full_path[strlen(cfull_path)]=
'\0';
3384 obtain_noneos2_sds_path (file_id, full_path, obj_ref);
3386 else if (obj_tag == DFTAG_NDG || obj_tag == DFTAG_SDG
3387 || obj_tag == DFTAG_SD) {
3393 string temp_str = string(cfull_path);
3394 if((temp_str.find(
"Data Fields") != std::string::npos)||
3395 (temp_str.find(
"Geolocation Fields") != std::string::npos))
3396 sds_ref_list.remove(obj_ref);
3402 if(vgroup_cid != -1) {
3403 status = Vdetach(vgroup_cid);
3404 if (status == FAIL) {
3405 string err_msg2 =
"In the cleanup " + string(ERR_LOC) +
" Vdetached failed. ";
3406 err_msg = err_msg + err_msg2;
3409 else if(
true == unexpected_fail)
3427 int32 vgroup_cid = -1;
3430 int num_gobjects = -1;
3435 char cvgroup_name[VGNAMELENMAX*4];
3436 char vdata_name[VSNAMELENMAX];
3437 char vdata_class[VSNAMELENMAX];
3438 int32 vdata_id = -1;
3441 char *cfull_path = NULL;
3444 bool unexpected_fail =
false;
3455 cfull_path = (
char *) malloc (MAX_FULL_PATH_LEN);
3456 if (cfull_path == NULL)
3457 throw1 (
"No enough memory to allocate the buffer");
3459 memset(cfull_path,
'\0',MAX_FULL_PATH_LEN);
3461 vgroup_cid = Vattach (file_id, pobj_ref,
"r");
3462 if (vgroup_cid == FAIL) {
3463 unexpected_fail =
true;
3464 err_msg = string(ERR_LOC)+
"Vattach failed";
3469 if (Vgetname (vgroup_cid, cvgroup_name) == FAIL) {
3470 unexpected_fail =
true;
3471 err_msg = string(ERR_LOC)+
"Vgetname failed";
3474 num_gobjects = Vntagrefs (vgroup_cid);
3475 if (num_gobjects < 0) {
3476 unexpected_fail =
true;
3477 err_msg = string(ERR_LOC)+
"Vntagrefs failed";
3481 strncpy(cfull_path,full_path,strlen(full_path));
3482 strncat(cfull_path,cvgroup_name,strlen(cvgroup_name));
3483 strncat(cfull_path,_BACK_SLASH,strlen(_BACK_SLASH));
3487 temp_str = string(cfull_path);
3489 if (temp_str.find(
"Geolocation Fields") != string::npos) {
3490 if(
false == this->EOS2Swathflag)
3491 this->EOS2Swathflag =
true;
3494 for (i = 0; i < num_gobjects; i++) {
3496 if (Vgettagref (vgroup_cid, i, &obj_tag, &obj_ref) == FAIL) {
3497 unexpected_fail =
true;
3498 err_msg = string(ERR_LOC)+
"Vgettagref failed";
3502 if (Visvg (vgroup_cid, obj_ref) == TRUE) {
3503 strncpy(full_path,cfull_path,strlen(cfull_path)+1);
3504 full_path[strlen(cfull_path)] =
'\0';
3505 obtain_vdata_path (file_id, full_path, obj_ref);
3507 else if (Visvs (vgroup_cid, obj_ref)) {
3509 vdata_id = VSattach (file_id, obj_ref,
"r");
3510 if (vdata_id == FAIL) {
3511 unexpected_fail =
true;
3512 err_msg = string(ERR_LOC)+
"VSattach failed";
3516 status = VSQueryname (vdata_id, vdata_name);
3517 if (status == FAIL) {
3518 unexpected_fail =
true;
3519 err_msg = string(ERR_LOC)+
"VSQueryname failed";
3523 status = VSgetclass (vdata_id, vdata_class);
3524 if (status == FAIL) {
3525 unexpected_fail =
true;
3526 err_msg = string(ERR_LOC)+
"VSgetclass failed";
3531 string temp_str2 = string(cfull_path);
3541 bool ignore_eos2_geo_vdata =
false;
3542 bool ignore_eos2_data_vdata =
false;
3543 if (temp_str2.find(
"Geolocation Fields") != string::npos) {
3544 ignore_eos2_geo_vdata =
true;
3548 if (temp_str2.find(
"Data Fields") != string::npos) {
3549 if (
true == this->EOS2Swathflag)
3550 ignore_eos2_data_vdata =
true;
3552 if ((
true == ignore_eos2_data_vdata)
3553 ||(
true == ignore_eos2_geo_vdata)
3554 || VSisattr (vdata_id) == TRUE
3555 || !strncmp (vdata_class, _HDF_CHK_TBL_CLASS,
3556 strlen (_HDF_CHK_TBL_CLASS))
3557 || !strncmp (vdata_class, _HDF_SDSVAR,
3558 strlen (_HDF_SDSVAR))
3559 || !strncmp (vdata_class, _HDF_CRDVAR,
3560 strlen (_HDF_CRDVAR))
3561 || !strncmp (vdata_class, DIM_VALS, strlen (DIM_VALS))
3562 || !strncmp (vdata_class, DIM_VALS01,
3563 strlen (DIM_VALS01))
3564 || !strncmp (vdata_class, RIGATTRCLASS,
3565 strlen (RIGATTRCLASS))
3566 || !strncmp (vdata_name, RIGATTRNAME,
3567 strlen (RIGATTRNAME))) {
3569 status = VSdetach (vdata_id);
3570 if (status == FAIL) {
3571 unexpected_fail =
true;
3572 err_msg = string(ERR_LOC)+
"VSdetach failed";
3578 VDATA *vdataobj = NULL;
3585 Vdetach (vgroup_cid);
3594 for (std::vector <VDField * >::const_iterator it_vdf =
3596 it_vdf != vdataobj->
getFields ().end ();
3601 (*it_vdf)->newname =
3602 "vdata" + vdataobj->
newname +
"_vdf_" +
3610 this->vds.push_back (vdataobj);
3611 status = VSdetach (vdata_id);
3612 if (status == FAIL) {
3613 unexpected_fail =
true;
3614 err_msg = string(ERR_LOC)+
"VSdetach failed";
3624 if(vgroup_cid != -1) {
3625 status = Vdetach(vgroup_cid);
3626 if (status == FAIL) {
3627 string err_msg2 =
"In the cleanup " + string(ERR_LOC) +
" Vdetached failed. ";
3628 err_msg = err_msg + err_msg2;
3629 throw3(err_msg,
"vgroup name is ",cvgroup_name);
3631 else if(
true == unexpected_fail)
3632 throw3(err_msg,
"vgroup name is ",cvgroup_name);
3656 std::string tempdimname;
3657 std::pair < std::set < std::string >::iterator,
bool > ret;
3658 std::string temppath;
3659 std::set < int32 > fakedimsizeset;
3660 std::pair < std::set < int32 >::iterator,
bool > fakedimsizeit;
3661 std::map < int32, std::string > fakedimsizenamelist;
3662 std::map < int32, std::string >::iterator fakedimsizenamelistit;
3664 for (std::vector < SDField * >::const_iterator i =
3667 for (std::vector < Dimension * >::const_iterator j =
3668 (*i)->getDimensions ().begin ();
3669 j != (*i)->getDimensions ().end (); ++j) {
3672 if (file->sptype != OTHERHDF)
3673 tempdimname = (*j)->getName ();
3675 tempdimname = (*j)->getName () + temppath;
3678 new Dimension (tempdimname, (*j)->getSize (),
3680 (*i)->correcteddims.push_back (dim);
3681 if (tempdimname.find (
"fakeDim") != std::string::npos) {
3682 fakedimsizeit = fakedimsizeset.insert ((*j)->getSize ());
3683 if (fakedimsizeit.second ==
true) {
3684 fakedimsizenamelist[(*j)->getSize ()] = (*j)->getName ();
3694 if (file->sptype != OTHERHDF) {
3695 for (std::vector < SDField * >::const_iterator i =
3697 for (std::vector < Dimension * >::const_iterator j =
3698 (*i)->getCorrectedDimensions ().begin ();
3699 j != (*i)->getCorrectedDimensions ().end (); ++j) {
3700 if ((*j)->getName ().find (
"fakeDim") != std::string::npos) {
3701 if (fakedimsizenamelist.find ((*j)->getSize ()) !=
3702 fakedimsizenamelist.end ()) {
3703 (*j)->name = fakedimsizenamelist[(*j)->getSize ()];
3706 throw5 (
"The fakeDim name ", (*j)->getName (),
3707 "with the size", (*j)->getSize (),
3708 "does not in the fakedimsize list");
3721 for (std::vector < SDField * >::const_iterator i =
3723 for (std::vector < Dimension * >::const_iterator j =
3724 (*i)->getCorrectedDimensions ().begin ();
3725 j != (*i)->getCorrectedDimensions ().end (); ++j) {
3726 std::pair < std::set < std::string >::iterator,
bool > ret;
3730 if (ret.second ==
true) {
3748 for (std::map < std::string, int32 >::const_iterator i =
3759 missingfield->
type = DFNT_INT32;
3760 missingfield->
name = (*i).first;
3761 missingfield->
newname = (*i).first;
3762 missingfield->
rank = 1;
3763 missingfield->fieldtype = 4;
3766 missingfield->dims.push_back (dim);
3767 dim =
new Dimension ((*i).first, (*i).second, 0);
3768 missingfield->correcteddims.push_back (dim);
3784 vector<string>tempfulldimnamelist;
3785 for (std::set < std::string >::const_iterator i =
3793 int total_dcounter = 0;
3794 for (std::set < std::string >::const_iterator i =
3802 std::map < std::string, std::string >::iterator tempmapit;
3803 for (std::vector < SDField * >::const_iterator i =
3805 for (std::vector < Dimension * >::const_iterator j =
3806 (*i)->getCorrectedDimensions ().begin ();
3807 j != (*i)->getCorrectedDimensions ().end (); ++j) {
3810 (*j)->name = tempmapit->second;
3812 throw5 (
"This dimension with the name ", (*j)->name,
3813 "and the field name ", (*i)->name,
3814 " is not found in the dimension list.");
3838 string check_ceres_short_name_key=
"H4.EnableCERESMERRAShortName";
3839 bool turn_on_ceres_short_name_key=
false;
3841 turn_on_ceres_short_name_key = HDFCFUtil::check_beskeys(check_ceres_short_name_key);
3845 if (
true == HDF4RequestHandler::get_enable_ceres_merra_short_name() && (file->sptype == CER_ES4 || file->sptype == CER_SRB
3846 || file->sptype == CER_CDAY || file->sptype == CER_CGEO
3847 || file->sptype == CER_SYN || file->sptype == CER_ZAVG
3848 || file->sptype == CER_AVG)) {
3850 for (
unsigned int i = 0; i < file->
sd->
sdfields.size (); ++i) {
3857 vector<string>sd_data_fieldnamelist;
3858 vector<string>sd_latlon_fieldnamelist;
3859 vector<string>sd_nollcv_fieldnamelist;
3861 set<string>sd_fieldnamelist;
3863 for (std::vector < SDField * >::const_iterator i =
3865 if ((*i)->fieldtype ==0)
3867 else if ((*i)->fieldtype == 1 || (*i)->fieldtype == 2)
3880 int total_data_counter = 0;
3881 int total_latlon_counter = 0;
3882 int total_nollcv_counter = 0;
3889 std::map < std::string, std::string >::iterator tempmapit;
3892 for (std::vector < SDField * >::const_iterator i =
3908 if ((*i)->fieldtype != 0) {
3909 if ((*i)->fieldtype == 1 || (*i)->fieldtype == 2) {
3911 (*i)->newname = sd_latlon_fieldnamelist[total_latlon_counter];
3912 total_latlon_counter++;
3914 if ((*i)->getRank () > 2)
3915 throw3 (
"the lat/lon rank should NOT be greater than 2",
3916 (*i)->name, (*i)->getRank ());
3917 else if ((*i)->getRank () == 2) {
3918 for (std::vector < Dimension * >::const_iterator j =
3919 (*i)->getCorrectedDimensions ().begin ();
3920 j != (*i)->getCorrectedDimensions ().end (); ++j) {
3927 if (lldimname1 ==
"")
3928 lldimname1 =(*j)->name;
3930 lldimname2 = (*j)->name;
3941 (*i)->getCorrectedDimensions ()[0]->getName ();
3949 (*i)->newname = sd_data_fieldnamelist[total_data_counter];
3950 total_data_counter++;
3955 for (std::vector < SDField * >::const_iterator i =
3972 if ((*i)->fieldtype != 0) {
3973 if ((*i)->fieldtype != 1 && (*i)->fieldtype != 2) {
3976 (*i)->newname = sd_nollcv_fieldnamelist[total_nollcv_counter];
3977 total_nollcv_counter++;
3979 if ((*i)->getRank () > 1)
3980 throw3 (
"The lat/lon rank should be 1", (*i)->name,
3987 if (COARDFLAG || file->sptype == OTHERHDF)
3989 (*i)->getCorrectedDimensions ()[0]->getName ();
3993 (*i)->getCorrectedDimensions ()[0]->getName ();
3997 (*i)->newname = (*i)->getCorrectedDimensions ()[0]->getName ();
4014 std::map < std::string, std::string >::iterator tempmapit;
4017 std::string tempcoordinates;
4018 std::string tempfieldname;
4019 for (std::vector < SDField * >::const_iterator i =
4021 if ((*i)->fieldtype == 0) {
4023 tempcoordinates =
"";
4026 for (std::vector < Dimension * >::const_iterator j =
4027 (*i)->getCorrectedDimensions ().begin ();
4028 j != (*i)->getCorrectedDimensions ().end (); ++j) {
4029 tempmapit = (file->
sd->
dimcvarlist).find ((*j)->getName ());
4031 tempfieldname = tempmapit->second;
4033 throw3 (
"The dimension with the name ", (*j)->getName (),
4034 "must have corresponding coordinate variables.");
4036 tempcoordinates = tempfieldname;
4038 tempcoordinates = tempcoordinates +
" " + tempfieldname;
4041 (*i)->setCoordinates (tempcoordinates);
4045 if ((*i)->fieldtype == 1) {
4046 std::string tempunits =
"degrees_north";
4047 (*i)->setUnits (tempunits);
4050 if ((*i)->fieldtype == 2) {
4051 std::string tempunits =
"degrees_east";
4052 (*i)->setUnits (tempunits);
4056 if (((*i)->fieldtype == 3) || ((*i)->fieldtype == 4)) {
4057 std::string tempunits =
"level";
4058 (*i)->setUnits (tempunits);
4066 if (
false == COARDFLAG) {
4067 for (std::vector < SDField * >::const_iterator i =
4069 if ((*i)->fieldtype == 0) {
4070 bool has_lldim1 =
false;
4071 bool has_lldim2 =
false;
4072 for (std::vector < Dimension * >::const_iterator j =
4073 (*i)->getCorrectedDimensions ().begin ();
4074 j != (*i)->getCorrectedDimensions ().end (); ++j) {
4075 if(lldimname1 == (*j)->name)
4077 else if(lldimname2 == (*j)->name)
4082 if (has_lldim1^has_lldim2)
4083 (*i)->coordinates =
"";
4104 string check_disable_vdata_nameclashing_key=
"H4.DisableVdataNameclashingCheck";
4105 bool turn_on_disable_vdata_nameclashing_key =
false;
4107 turn_on_disable_vdata_nameclashing_key = HDFCFUtil::check_beskeys(check_disable_vdata_nameclashing_key);
4112 if (
false == HDF4RequestHandler::get_disable_vdata_nameclashing_check()) {
4114 vector<string> tempvdatafieldnamelist;
4116 for (std::vector < VDATA * >::const_iterator i = file->
vds.begin ();
4117 i != file->
vds.end (); ++i) {
4118 for (std::vector < VDField * >::const_iterator j =
4119 (*i)->getFields ().begin (); j != (*i)->getFields ().end ();
4121 tempvdatafieldnamelist.push_back((*j)->newname);
4126 int total_vfd_counter = 0;
4128 for (std::vector < VDATA * >::const_iterator i = file->
vds.begin ();
4129 i != file->
vds.end (); ++i) {
4130 for (std::vector < VDField * >::const_iterator j =
4131 (*i)->getFields ().begin (); j != (*i)->getFields ().end ();
4133 (*j)->newname = tempvdatafieldnamelist[total_vfd_counter];
4134 total_vfd_counter++;
4158 if (file->sptype != OTHERHDF) {
4160 for (std::vector < SDField * >::const_iterator i =
4162 for (vector<AttrContainer *>::iterator j = (*i)->dims_info.begin();
4163 j!= (*i)->dims_info.end(); ) {
4165 j = (*i)->dims_info.erase(j);
4168 if ((*i)->dims_info.size() != 0)
4169 throw1(
"Not totally erase the dimension container ");
4176 handle_sds_fakedim_names();
4179 switch (file->sptype) {
4274 throw3 (
"No such SP datatype ",
"sptype is ", sptype);
4281 create_sds_dim_name_list();
4284 handle_sds_missing_fields();
4287 handle_sds_final_dim_names();
4289 bool COARDFLAG =
false;
4295 handle_sds_names(COARDFLAG, lldimname1, lldimname2);
4298 handle_sds_coords(COARDFLAG, lldimname1,lldimname2);
4307 for (std::vector < Attribute * >::const_iterator i =
4308 this->sd->getAttributes ().begin ();
4309 i != this->sd->getAttributes ().end (); ++i) {
4311 if ((*i)->getName () ==
"GridHeader") {
4312 float lat_start = 0.;
4313 float lon_start = 0.;
4317 HDFCFUtil::parser_trmm_v7_gridheader((*i)->getValue(),latsize,lonsize,
4318 lat_start,lon_start,
4319 lat_res,lon_res,
false);
4330 bool File:: Obtain_TRMM_V7_latlon_name(
const SDField* sdfield,
const int latsize,
4331 const int lonsize,
string& latname,
string& lonname)
throw(
Exception) {
4336 int latname_index = -1;
4337 int lonname_index = -1;
4338 for (
int temp_index = 0; temp_index <sdfield->getRank(); ++temp_index) {
4339 if(-1==latname_index && sdfield->getCorrectedDimensions()[temp_index]->getSize() == latsize) {
4340 latname_index = temp_index;
4342 latname = sdfield->getCorrectedDimensions()[temp_index]->getName();
4344 else if (-1 == lonname_index && sdfield->getCorrectedDimensions()[temp_index]->getSize() == lonsize) {
4345 lonname_index = temp_index;
4347 lonname = sdfield->getCorrectedDimensions()[temp_index]->getName();
4351 return (latname_index + lonname_index == 1);
4360 std::string tempdimname1;
4361 std::string tempdimname2;
4362 std::string tempnewdimname1;
4363 std::string tempnewdimname2;
4364 std::string temppath;
4371 std::set < int32 > tempdimsizeset;
4372 std::map < int32, std::string > tempdimsizenamelist;
4373 std::map < int32, std::string >::iterator tempsizemapit;
4374 std::pair < std::set < int32 >::iterator,
bool > tempsetit;
4377 for (std::vector < SDField * >::const_iterator i =
4379 for (std::vector < Dimension * >::const_iterator j =
4380 (*i)->getCorrectedDimensions ().begin ();
4381 j != (*i)->getCorrectedDimensions ().end (); ++j) {
4382 if (((*j)->getName ()).find (
"fakeDim") == std::string::npos) {
4383 tempsetit = tempdimsizeset.insert ((*j)->getSize ());
4384 if (tempsetit.second ==
true)
4385 tempdimsizenamelist[(*j)->getSize ()] = (*j)->getName ();
4391 for (std::vector < SDField * >::const_iterator i =
4394 string temp_name = (*i)->newname.substr(1) ;
4395 size_t temp_pos = temp_name.find_first_of(
'/');
4396 if (temp_pos !=string::npos)
4397 (*i)->newname = temp_name.substr(temp_pos+1);
4402 for (std::vector < SDField * >::const_iterator i =
4405 if((*i)->getName() ==
"Latitude") {
4406 if((*i)->getRank() ==2) {
4409 ((*i)->getCorrectedDimensions ())[0]->getName ();
4411 ((*i)->getCorrectedDimensions ())[1]->getName ();
4414 (*i)->fieldtype = 1;
4417 else if ((*i)->getName() ==
"Longitude") {
4418 (*i)->fieldtype = 2;
4425 for (std::vector < Dimension * >::const_iterator k =
4426 (*i)->getCorrectedDimensions ().begin ();
4427 k != (*i)->getCorrectedDimensions ().end (); ++k) {
4428 size_t fakeDimpos = ((*k)->getName ()).find (
"fakeDim");
4430 if (fakeDimpos != std::string::npos) {
4432 tempdimsizenamelist.find ((*k)->getSize ());
4433 if (tempsizemapit != tempdimsizenamelist.end ())
4434 (*k)->name = tempdimsizenamelist[(*k)->getSize ()];
4442 if(tempnewdimname1.empty()!=
true)
4445 if(tempnewdimname2.empty()!=
true)
4448 string base_filename;
4449 size_t last_slash_pos = file->
getPath().find_last_of(
"/");
4450 if(last_slash_pos != string::npos)
4451 base_filename = file->
getPath().substr(last_slash_pos+1);
4452 if(
""==base_filename)
4453 base_filename = file->
getPath();
4456 if(base_filename.find(
"2A12")!=string::npos) {
4458 string nlayer_name =
"nlayer";
4460 for (vector < SDField * >::iterator i =
4463 bool has_nlayer =
false;
4465 for (vector < Dimension * >::const_iterator k =
4466 (*i)->getDimensions ().begin ();
4467 k != (*i)->getDimensions ().end (); ++k) {
4469 if((*k)->getSize() == 28 && (*k)->name == nlayer_name) {
4472 nlayer->
name = nlayer_name;
4474 nlayer->
type = DFNT_FLOAT32;
4475 nlayer->fieldtype = 6;
4480 nlayer->dims.push_back(dim);
4483 nlayer->correcteddims.push_back(dim);
4491 if(
true == has_nlayer)
4507 for (std::vector < SDField * >::iterator i =
4511 if((*i)->name ==
"InputFileNames") {
4515 else if((*i)->name ==
"InputAlgorithmVersions") {
4519 else if((*i)->name ==
"InputGenerationDateTimes") {
4524 (*i)->newname = (*i)->name;
4531 string nlayer_name =
"nlayer";
4533 for (vector < SDField * >::iterator i =
4536 bool has_nlayer =
false;
4538 for (vector < Dimension * >::const_iterator k =
4539 (*i)->getDimensions ().begin ();
4540 k != (*i)->getDimensions ().end (); ++k) {
4542 if((*k)->getSize() == 28 && (*k)->name == nlayer_name) {
4545 nlayer->
name = nlayer_name;
4547 nlayer->
type = DFNT_FLOAT32;
4548 nlayer->fieldtype = 6;
4553 nlayer->dims.push_back(dim);
4556 nlayer->correcteddims.push_back(dim);
4564 if(
true == has_nlayer)
4576 Obtain_TRMML3S_V7_latlon_size(latsize,lonsize);
4583 bool llname_found =
false;
4584 for (std::vector < SDField * >::iterator i =
4587 if(2 == (*i)->getRank()) {
4589 llname_found = Obtain_TRMM_V7_latlon_name((*i),latsize,lonsize,latname,lonname);
4590 if (
true == llname_found)
4600 longitude->
name = lonname;
4601 longitude->
rank = 1;
4602 longitude->
type = DFNT_FLOAT32;
4603 longitude->fieldtype = 2;
4608 longitude->dims.push_back (dim);
4610 dim =
new Dimension (lonname, lonsize, 0);
4611 longitude->correcteddims.push_back (dim);
4615 latitude->
name = latname;
4617 latitude->
type = DFNT_FLOAT32;
4618 latitude->fieldtype = 1;
4621 dim =
new Dimension (latname, latsize, 0);
4622 latitude->dims.push_back (dim);
4624 dim =
new Dimension (latname, latsize, 0);
4625 latitude->correcteddims.push_back (dim);
4635 string base_filename;
4636 if(path.find_last_of(
"/") != string::npos)
4637 base_filename = path.substr(path.find_last_of(
"/")+1);
4638 if(base_filename.find(
"3A26")!=string::npos) {
4640 bool ZOflag =
false;
4641 bool SRTflag =
false;
4642 bool HBflag =
false;
4643 string nthrsh_base_name =
"nthrsh";
4644 string nthrsh_zo_name =
"nthrshZO";
4645 string nthrsh_hb_name =
"nthrshHB";
4646 string nthrsh_srt_name =
"nthrshSRT";
4652 for (vector < SDField * >::iterator i =
4655 if(ZOflag !=
true) {
4656 if((*i)->name.find(
"Order")!=string::npos) {
4657 for (vector < Dimension * >::const_iterator k =
4658 (*i)->getDimensions ().begin ();
4659 k != (*i)->getDimensions ().end (); ++k) {
4661 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4662 if(nthrsh_zo == NULL) {
4664 nthrsh_zo->
name = nthrsh_zo_name;
4665 nthrsh_zo->
rank = 1;
4666 nthrsh_zo->
type = DFNT_FLOAT32;
4667 nthrsh_zo->fieldtype = 6;
4672 nthrsh_zo->dims.push_back(dim);
4675 nthrsh_zo->correcteddims.push_back(dim);
4686 else if(SRTflag !=
true) {
4687 if((*i)->name.find(
"2A25")!=string::npos) {
4689 for (vector < Dimension * >::const_iterator k =
4690 (*i)->getDimensions ().begin ();
4691 k != (*i)->getDimensions ().end (); ++k) {
4693 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4694 if(nthrsh_srt == NULL) {
4696 nthrsh_srt->
name = nthrsh_srt_name;
4697 nthrsh_srt->
rank = 1;
4698 nthrsh_srt->
type = DFNT_FLOAT32;
4699 nthrsh_srt->fieldtype = 6;
4704 nthrsh_srt->dims.push_back(dim);
4707 nthrsh_srt->correcteddims.push_back(dim);
4716 else if(HBflag !=
true) {
4717 if((*i)->name.find(
"hb")!=string::npos || (*i)->name.find(
"HB")!=string::npos) {
4719 for (vector < Dimension * >::const_iterator k =
4720 (*i)->getDimensions ().begin ();
4721 k != (*i)->getDimensions ().end (); ++k) {
4723 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4725 if(nthrsh_hb == NULL) {
4727 nthrsh_hb->
name = nthrsh_hb_name;
4728 nthrsh_hb->
rank = 1;
4729 nthrsh_hb->
type = DFNT_FLOAT32;
4730 nthrsh_hb->fieldtype = 6;
4735 nthrsh_hb->dims.push_back(dim);
4738 nthrsh_hb->correcteddims.push_back(dim);
4749 for (vector < SDField * >::iterator i =
4752 if((*i)->name.find(
"Order")!=string::npos && ZOflag ==
true) {
4753 for (vector < Dimension * >::const_iterator k =
4754 (*i)->getDimensions ().begin ();
4755 k != (*i)->getDimensions ().end (); ++k) {
4757 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4758 (*k)->name = nthrsh_zo_name;
4763 for (std::vector < Dimension * >::const_iterator k =
4764 (*i)->getCorrectedDimensions ().begin ();
4765 k != (*i)->getCorrectedDimensions ().end (); ++k) {
4766 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4767 (*k)->name = nthrsh_zo_name;
4774 else if(((*i)->name.find(
"hb")!=string::npos || (*i)->name.find(
"HB")!=string::npos)&& HBflag ==
true) {
4775 for (vector < Dimension * >::const_iterator k =
4776 (*i)->getDimensions ().begin ();
4777 k != (*i)->getDimensions ().end (); ++k) {
4779 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4780 (*k)->name = nthrsh_hb_name;
4785 for (std::vector < Dimension * >::const_iterator k =
4786 (*i)->getCorrectedDimensions ().begin ();
4787 k != (*i)->getCorrectedDimensions ().end (); ++k) {
4788 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4789 (*k)->name = nthrsh_hb_name;
4795 else if(((*i)->name.find(
"2A25")!=string::npos) && SRTflag ==
true) {
4796 for (vector < Dimension * >::const_iterator k =
4797 (*i)->getDimensions ().begin ();
4798 k != (*i)->getDimensions ().end (); ++k) {
4800 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4801 (*k)->name = nthrsh_srt_name;
4806 for (std::vector < Dimension * >::const_iterator k =
4807 (*i)->getCorrectedDimensions ().begin ();
4808 k != (*i)->getCorrectedDimensions ().end (); ++k) {
4809 if((*k)->getSize() == 6 && (*k)->name == nthrsh_base_name) {
4810 (*k)->name = nthrsh_srt_name;
4820 if(nthrsh_zo !=NULL) {
4825 if(nthrsh_hb !=NULL) {
4830 if(nthrsh_srt !=NULL) {
4843 for (std::vector < SDField * >::iterator i =
4846 if((*i)->name ==
"InputFileNames") {
4851 else if((*i)->name ==
"InputAlgorithmVersions") {
4856 else if((*i)->name ==
"InputGenerationDateTimes") {
4869 NOTE
for programming:
4870 1. Outer loop: loop global attribute
for GridHeader?. Retrieve ? as a number
for index.
4871 1.5. Obtain the lat/lon sizes
for this grid.
4872 The following steps are to retrieve lat/lon names
for this grid.
4873 2. Inner loop: Then loop through the field
4874 3. Check the field rank,
4875 3.1
if the rank is not 2, (
if the index is the first index, change the newname to name )
4878 3.2.1 Retrieve the index from the field
new name(retrieve last path Grid1 then retrieve 1)
4879 3.2.2 If the index from the field is the same as that from the GridHeader,
continue checking
4880 the lat/lon name
for this grid as the single grid.
4881 change the newname to name.
4888 int first_index = -1;
4889 for (vector < Attribute * >::const_iterator i =
4890 this->sd->getAttributes ().begin ();
4891 i != this->sd->getAttributes ().end (); ++i) {
4893 if ((*i)->getName ().find(
"GridHeader")==0) {
4894 string temp_name = (*i)->getName();
4897 string str_num = temp_name.substr(10);
4898 stringstream ss_num(str_num);
4901 ss_num >> grid_index;
4903 if ( -1 == first_index)
4904 first_index = grid_index;
4906 float lat_start = 0.;
4907 float lon_start = 0.;
4914 HDFCFUtil::parser_trmm_v7_gridheader((*i)->getValue(),latsize,lonsize,
4915 lat_start,lon_start,
4916 lat_res, lon_res,
false);
4925 bool llname_found =
false;
4926 for (std::vector < SDField * >::iterator i =
4930 if(2 == (*i)->getRank()) {
4933 if ((*i)->newname !=(*i)->name) {
4935 string temp_field_full_path = (*i)->getNewName();
4936 size_t last_path_pos = temp_field_full_path.find_last_of(
'/');
4937 char str_index = temp_field_full_path[last_path_pos-1];
4938 if(grid_index ==(
int)(str_index -
'0')) {
4939 if(llname_found !=
true)
4940 llname_found = Obtain_TRMM_V7_latlon_name((*i),latsize,lonsize,latname,lonname);
4941 (*i)->newname = (*i)->name;
4945 else if (first_index == grid_index)
4946 (*i)->newname = (*i)->name;
4951 longitude->
name = lonname;
4952 longitude->
rank = 1;
4953 longitude->
type = DFNT_FLOAT32;
4954 longitude->fieldtype = 2;
4955 longitude->fieldref = grid_index;
4960 longitude->dims.push_back (dim);
4962 dim =
new Dimension (lonname, lonsize, 0);
4963 longitude->correcteddims.push_back (dim);
4967 latitude->
name = latname;
4969 latitude->
type = DFNT_FLOAT32;
4970 latitude->fieldtype = 1;
4971 latitude->fieldref = grid_index;
4974 dim =
new Dimension (latname, latsize, 0);
4975 latitude->dims.push_back (dim);
4977 dim =
new Dimension (latname, latsize, 0);
4978 latitude->correcteddims.push_back (dim);
5000 std::string tempdimname1;
5001 std::string tempdimname2;
5002 std::string tempnewdimname1;
5003 std::string tempnewdimname2;
5004 std::string temppath;
5012 std::set < int32 > tempdimsizeset;
5013 std::map < int32, std::string > tempdimsizenamelist;
5014 std::map < int32, std::string >::iterator tempsizemapit;
5015 std::pair < std::set < int32 >::iterator,
bool > tempsetit;
5018 for (std::vector < SDField * >::const_iterator i =
5020 for (std::vector < Dimension * >::const_iterator j =
5021 (*i)->getCorrectedDimensions ().begin ();
5022 j != (*i)->getCorrectedDimensions ().end (); ++j) {
5023 if (((*j)->getName ()).find (
"fakeDim") == std::string::npos) {
5024 tempsetit = tempdimsizeset.insert ((*j)->getSize ());
5025 if (tempsetit.second ==
true)
5026 tempdimsizenamelist[(*j)->getSize ()] = (*j)->getName ();
5031 for (std::vector < SDField * >::const_iterator i =
5034 if ((*i)->getName () ==
"geolocation") {
5038 tempdimname1 = ((*i)->getDimensions ())[0]->getName ();
5039 tempdimsize1 = ((*i)->getDimensions ())[0]->getSize ();
5040 tempdimname2 = ((*i)->getDimensions ())[1]->getName ();
5041 tempdimsize2 = ((*i)->getDimensions ())[1]->getSize ();
5044 ((*i)->getCorrectedDimensions ())[0]->getName ();
5046 ((*i)->getCorrectedDimensions ())[1]->getName ();
5053 if(latitude == NULL) {
5056 latitude->
name =
"latitude";
5058 latitude->fieldref = (*i)->fieldref;
5059 latitude->
type = (*i)->getType ();
5060 temppath = (*i)->newname.substr ((*i)->name.size ());
5062 latitude->fieldtype = 1;
5063 latitude->rootfieldname =
"geolocation";
5067 latitude->dims.push_back (dim);
5069 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
5070 latitude->dims.push_back (dim);
5072 dim =
new Dimension (tempnewdimname1, tempdimsize1, 0);
5073 latitude->correcteddims.push_back (dim);
5075 dim =
new Dimension (tempnewdimname2, tempdimsize2, 0);
5076 latitude->correcteddims.push_back (dim);
5079 if(longitude == NULL) {
5081 longitude->
name =
"longitude";
5082 longitude->
rank = 2;
5083 longitude->fieldref = (*i)->fieldref;
5084 longitude->
type = (*i)->getType ();
5086 longitude->fieldtype = 2;
5087 longitude->rootfieldname =
"geolocation";
5090 longitude->dims.push_back (dim);
5091 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
5092 longitude->dims.push_back (dim);
5094 dim =
new Dimension (tempnewdimname1, tempdimsize1, 0);
5095 longitude->correcteddims.push_back (dim);
5097 dim =
new Dimension (tempnewdimname2, tempdimsize2, 0);
5098 longitude->correcteddims.push_back (dim);
5106 for (std::vector < Dimension * >::const_iterator k =
5107 (*i)->getCorrectedDimensions ().begin ();
5108 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5109 size_t fakeDimpos = ((*k)->getName ()).find (
"fakeDim");
5111 if (fakeDimpos != std::string::npos) {
5113 tempdimsizenamelist.find ((*k)->getSize ());
5114 if (tempsizemapit != tempdimsizenamelist.end ())
5115 (*k)->name = tempdimsizenamelist[(*k)->getSize ()];
5127 std::vector < SDField * >::iterator toeraseit;
5128 for (std::vector < SDField * >::iterator i = file->
sd->
sdfields.begin ();
5130 if ((*i)->getName () ==
"geolocation") {
5153 std::string tempnewdimname1, tempnewdimname2;
5157 std::string temppath;
5162 for (std::vector < SDField * >::const_iterator i =
5165 for (std::vector < Dimension * >::const_iterator k =
5166 (*i)->getDimensions ().begin ();
5167 k != (*i)->getDimensions ().end (); ++k) {
5170 if ((((*k)->getName ()).find (
"fakeDim")) == std::string::npos) {
5172 temppath = (*i)->newname.substr ((*i)->name.size ());
5175 if ((*k)->getSize () == 1440 && (*k)->getType () == 0) {
5177 if(longitude == NULL) {
5179 longitude->
name =
"longitude";
5180 longitude->
rank = 1;
5181 longitude->
type = DFNT_FLOAT32;
5182 longitude->fieldtype = 2;
5186 new Dimension ((*k)->getName (), (*k)->getSize (), 0);
5187 longitude->dims.push_back (dim);
5188 tempnewdimname2 = (*k)->getName ();
5191 new Dimension ((*k)->getName (), (*k)->getSize (), 0);
5192 longitude->correcteddims.push_back (dim);
5197 if ((*k)->getSize () == 400 && (*k)->getType () == 0) {
5199 if(latitude == NULL) {
5201 latitude->
name =
"latitude";
5203 latitude->
type = DFNT_FLOAT32;
5204 latitude->fieldtype = 1;
5207 new Dimension ((*k)->getName (), (*k)->getSize (), 0);
5208 latitude->dims.push_back (dim);
5209 tempnewdimname1 = (*k)->getName ();
5217 new Dimension ((*k)->getName (), (*k)->getSize (), 0);
5218 latitude->correcteddims.push_back (dim);
5224 if (latflag == 1 && lonflag == 1)
5228 if (latflag == 1 && lonflag == 1)
5237 if (latflag != 1 || lonflag != 1) {
5238 if(latitude != NULL)
5240 if(longitude != NULL)
5242 throw5 (
"Either latitude or longitude doesn't exist.",
"lat. flag= ",
5243 latflag,
"lon. flag= ", lonflag);
5260 std::string tempnewdimname1;
5261 std::string tempnewdimname2;
5262 bool latflag =
false;
5263 bool lonflag =
false;
5269 for (std::vector < SDField * >::const_iterator i =
5272 for (std::vector < Dimension * >::const_iterator k =
5273 (*i)->getDimensions ().begin ();
5274 k != (*i)->getDimensions ().end (); ++k) {
5275 if ((((*k)->getName ()).find (
"latitude")) == 0)
5276 (*k)->name =
"fakeDim1";
5277 if ((((*k)->getName()).find (
"longitude")) == 0)
5278 (*k)->name =
"fakeDim2";
5284 for (std::vector < Dimension * >::const_iterator k =
5285 (*i)->getCorrectedDimensions ().begin ();
5286 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5287 if ((((*k)->getName ()).find (
"latitude")) == 0)
5288 (*k)->name =
"fakeDim1";
5289 if ((((*k)->getName()).find (
"longitude")) == 0)
5290 (*k)->name =
"fakeDim2";
5295 for (std::vector < SDField * >::const_iterator i =
5299 for (std::vector < Dimension * >::const_iterator k =
5300 (*i)->getDimensions ().begin ();
5301 k != (*i)->getDimensions ().end (); ++k) {
5309 if ((*k)->getSize () == 360 && (*k)->getType () == 0) {
5311 if(longitude == NULL) {
5313 longitude->
name =
"longitude";
5314 longitude->
rank = 1;
5315 longitude->
type = DFNT_FLOAT32;
5316 longitude->fieldtype = 2;
5321 longitude->dims.push_back (dim);
5322 tempnewdimname2 = longitude->
name;
5326 longitude->correcteddims.push_back (dim);
5331 if ((*k)->getSize () == 180 && (*k)->getType () == 0) {
5333 if(latitude == NULL) {
5335 latitude->
name =
"latitude";
5337 latitude->
type = DFNT_FLOAT32;
5338 latitude->fieldtype = 1;
5343 latitude->dims.push_back (dim);
5344 tempnewdimname1 = latitude->
getName ();
5353 latitude->correcteddims.push_back (dim);
5359 if (latflag ==
true && lonflag ==
true)
5363 if (latflag ==
true && lonflag ==
true)
5372 if (latflag !=
true || lonflag !=
true) {
5373 if(latitude != NULL)
5375 if(longitude != NULL)
5377 throw5 (
"Either latitude or longitude doesn't exist.",
"lat. flag= ",
5378 latflag,
"lon. flag= ", lonflag);
5382 for (std::vector < SDField * >::const_iterator i =
5386 for (std::vector < Dimension * >::const_iterator k =
5387 (*i)->getDimensions ().begin ();
5388 k != (*i)->getDimensions ().end (); ++k) {
5390 if ((*k)->getSize () == 360 )
5391 (*k)->name = longitude->
name;
5393 if ((*k)->getSize () == 180 )
5394 (*k)->name = latitude->
name;
5398 for (std::vector < Dimension * >::const_iterator k =
5399 (*i)->getCorrectedDimensions ().begin ();
5400 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5402 if ((*k)->getSize () == 360 )
5403 (*k)->name = longitude->
name;
5405 if ((*k)->getSize () == 180 )
5406 (*k)->name = latitude->
name;
5431 std::string tempnewdimname1;
5432 std::string tempnewdimname2;
5433 std::string tempnewdimname3;
5434 bool latflag =
false;
5435 bool lonflag =
false;
5436 bool heiflag =
false;
5444 for (std::vector < SDField * >::const_iterator i =
5448 for (std::vector < Dimension * >::const_iterator k =
5449 (*i)->getDimensions ().begin ();
5450 k != (*i)->getDimensions ().end (); ++k) {
5458 if ((*k)->getSize () == 720 && (*k)->getType () == 0) {
5461 if(longitude == NULL) {
5463 longitude->
name =
"longitude";
5464 longitude->
rank = 1;
5465 longitude->
type = DFNT_FLOAT32;
5466 longitude->fieldtype = 2;
5471 longitude->dims.push_back (dim);
5472 tempnewdimname2 = longitude->
name;
5476 longitude->correcteddims.push_back (dim);
5481 if ((*k)->getSize () == 148 && (*k)->getType () == 0) {
5483 if(latitude == NULL) {
5485 latitude->
name =
"latitude";
5487 latitude->
type = DFNT_FLOAT32;
5488 latitude->fieldtype = 1;
5493 latitude->dims.push_back (dim);
5494 tempnewdimname1 = latitude->
getName ();
5503 latitude->correcteddims.push_back (dim);
5508 if ((*k)->getSize () == 19 && (*k)->getType () == 0) {
5510 if(height == NULL) {
5512 height->
name =
"height";
5514 height->
type = DFNT_FLOAT32;
5515 height->fieldtype = 6;
5520 height->dims.push_back (dim);
5521 tempnewdimname3 = height->
getName ();
5530 height->correcteddims.push_back (dim);
5538 if (latflag ==
true && lonflag ==
true)
5548 if (latflag !=
true || lonflag !=
true) {
5549 if(latitude != NULL)
5551 if(longitude != NULL)
5553 throw5 (
"Either latitude or longitude doesn't exist.",
"lat. flag= ",
5554 latflag,
"lon. flag= ", lonflag);
5557 if(height!=NULL && heiflag !=
true) {
5559 throw1(
"Height is allocated but the flag is not true");
5568 if(heiflag !=
true) {
5570 throw1(
"Height is allocated but the flag is not true");
5589 int pixels_per_scan_line = 0;
5591 std::string pixels_per_scan_line_name =
"Pixels per Scan Line";
5592 std::string number_pixels_control_points =
"Number of Pixel Control Points";
5593 std::string tempnewdimname1, tempnewdimname2;
5598 for (std::vector < Attribute * >::const_iterator i =
5601 if ((*i)->getName () == pixels_per_scan_line_name) {
5602 int *attrvalueptr = (
int *) (&((*i)->getValue ()[0]));
5603 pixels_per_scan_line = *attrvalueptr;
5608 if ( 0 == pixels_per_scan_line)
5609 throw1(
"The attribute 'Pixels per Scan Line' doesn't exist");
5614 int tempcountllflag = 0;
5616 for (std::vector < SDField * >::const_iterator i =
5619 if ((*i)->getName () ==
"longitude" || (*i)->getName () ==
"latitude") {
5620 if ((*i)->getName () ==
"longitude")
5621 (*i)->fieldtype = 2;
5622 if ((*i)->getName () ==
"latitude")
5623 (*i)->fieldtype = 1;
5626 if ((*i)->getRank () != 2)
5627 throw3 (
"The lat/lon rank must be 2", (*i)->getName (),
5629 for (std::vector < Dimension * >::const_iterator k =
5630 (*i)->getDimensions ().begin ();
5631 k != (*i)->getDimensions ().end (); ++k) {
5632 if ((*k)->getName () == number_pixels_control_points) {
5633 (*k)->name = pixels_per_scan_line_name;
5634 (*k)->dimsize = pixels_per_scan_line;
5639 for (std::vector < Dimension * >::const_iterator k =
5640 (*i)->getCorrectedDimensions ().begin ();
5641 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5642 if ((*k)->getName ().find (number_pixels_control_points) !=
5643 std::string::npos) {
5644 (*k)->name = pixels_per_scan_line_name;
5645 (*k)->dimsize = pixels_per_scan_line;
5646 if (tempcountllflag == 1)
5647 tempnewdimname2 = (*k)->name;
5650 if (tempcountllflag == 1)
5651 tempnewdimname1 = (*k)->name;
5655 if (tempcountllflag == 2)
5675 std::string num_lat_name =
"Number of Lines";
5676 std::string num_lon_name =
"Number of Columns";
5682 int tempcountllflag = 0;
5684 for (std::vector < Attribute * >::const_iterator i =
5688 if ((*i)->getName () == num_lon_name) {
5691 int *attrvalue = (
int *) (&((*i)->getValue ()[0]));
5693 num_lon = *attrvalue;
5697 if ((*i)->getName () == num_lat_name) {
5699 int *attrvalue = (
int *) (&((*i)->getValue ()[0]));
5701 num_lat = *attrvalue;
5704 if (tempcountllflag == 2)
5710 if(longitude == NULL)
5711 throw1(
"Allocate memory for longitude failed .");
5713 longitude->
name =
"longitude";
5714 longitude->
rank = 1;
5715 longitude->
type = DFNT_FLOAT32;
5716 longitude->fieldtype = 2;
5722 throw3(
"The size of the dimension of the longitude ",longitude->
name,
" is 0.");
5728 throw1(
"Allocate memory for dim failed .");
5733 longitude->dims.push_back (dim);
5737 dim =
new Dimension (num_lon_name, num_lon, 0);
5740 throw1(
"Allocate memory for dim failed .");
5743 longitude->correcteddims.push_back (dim);
5747 if(latitude == NULL) {
5749 throw1(
"Allocate memory for dim failed .");
5751 latitude->
name =
"latitude";
5753 latitude->
type = DFNT_FLOAT32;
5754 latitude->fieldtype = 1;
5761 throw3(
"The size of the dimension of the latitude ",latitude->
name,
" is 0.");
5765 dim =
new Dimension (num_lat_name, num_lat, 0);
5769 throw1(
"Allocate memory for dim failed .");
5772 if(latitude != NULL)
5773 latitude->dims.push_back (dim);
5777 dim =
new Dimension (num_lat_name, num_lat, 0);
5781 throw1(
"Allocate memory for dim failed .");
5784 latitude->correcteddims.push_back (dim);
5787 for (std::vector < SDField * >::const_iterator i =
5789 if ((*i)->getRank () != 2) {
5794 throw3 (
"The lat/lon rank must be 2", (*i)->getName (),
5797 for (std::vector < Dimension * >::const_iterator k =
5798 (*i)->getDimensions ().begin ();
5799 k != (*i)->getDimensions ().end (); ++k) {
5800 if ((((*k)->getName ()).find (
"fakeDim")) != std::string::npos) {
5801 if ((*k)->getSize () == num_lon)
5802 (*k)->name = num_lon_name;
5803 if ((*k)->getSize () == num_lat)
5804 (*k)->name = num_lat_name;
5807 for (std::vector < Dimension * >::const_iterator k =
5808 (*i)->getCorrectedDimensions ().begin ();
5809 k != (*i)->getCorrectedDimensions ().end (); ++k) {
5810 if ((((*k)->getName ()).find (
"fakeDim")) != std::string::npos) {
5811 if ((*k)->getSize () == num_lon)
5812 (*k)->name = num_lon_name;
5813 if ((*k)->getSize () == num_lat)
5814 (*k)->name = num_lat_name;
5834 bool colatflag =
false;
5835 bool lonflag =
false;
5837 std::string tempnewdimname1;
5838 std::string tempnewdimname2;
5839 std::string tempcvarname1;
5840 std::string tempcvarname2;
5844 std::vector < SDField * >::iterator beerasedit;
5848 for (std::vector < SDField * >::iterator i = file->
sd->
sdfields.begin ();
5852 if (((*i)->getName ()).find (
"Colatitude") != std::string::npos) {
5854 if ((*i)->getRank () != 2)
5855 throw3 (
"The lat/lon rank must be 2", (*i)->getName (),
5857 int dimsize0 = (*i)->getDimensions ()[0]->getSize ();
5858 int dimsize1 = (*i)->getDimensions ()[1]->getSize ();
5863 if (dimsize0 < dimsize1) {
5864 tempnewdimname1 = (*i)->getDimensions ()[0]->getName ();
5865 tempnewdimname2 = (*i)->getDimensions ()[1]->getName ();
5868 tempnewdimname1 = (*i)->getDimensions ()[1]->getName ();
5869 tempnewdimname2 = (*i)->getDimensions ()[0]->getName ();
5874 (*i)->fieldtype = 1;
5875 tempcvarname1 = (*i)->getName ();
5889 else if (((*i)->getName ()).find (
"Longitude") != std::string::npos) {
5892 (*i)->fieldtype = 2;
5893 tempcvarname2 = (*i)->getName ();
5921 std::string tempdimname1;
5922 std::string tempdimname2;
5923 int tempdimsize1 = 0;
5924 int tempdimsize2 = 0;
5925 std::string tempcvarname1;
5926 std::string tempcvarname2;
5927 std::string temppath;
5928 std::set < std::string > tempdimnameset;
5929 std::pair < std::set < std::string >::iterator,
bool > tempsetit;
5932 bool cvflag =
false;
5937 for (std::vector < SDField * >::iterator i = file->
sd->
sdfields.begin ();
5939 std::string tempfieldname = (*i)->getName ();
5940 if (tempfieldname.find (
"Colatitude") != std::string::npos) {
5942 for (std::vector < Dimension * >::const_iterator j =
5943 (*i)->getDimensions ().begin ();
5944 j != (*i)->getDimensions ().end (); ++j) {
5945 if (((*j)->getName ()).find (
"regional colat") !=
5946 std::string::npos) {
5947 tempsetit = tempdimnameset.insert ((*j)->getName ());
5948 if (tempsetit.second ==
true) {
5949 tempdimname1 = (*j)->getName ();
5950 tempdimsize1 = (*j)->getSize ();
5951 (*i)->fieldtype = 1;
5961 for (std::vector < Dimension * >::const_iterator j =
5962 (*i)->getDimensions ().begin ();
5963 j != (*i)->getDimensions ().end (); ++j)
5965 for (std::vector < Dimension * >::const_iterator j =
5966 (*i)->getCorrectedDimensions ().begin ();
5967 j != (*i)->getCorrectedDimensions ().end (); ++j)
5969 (*i)->dims.clear ();
5970 (*i)->correcteddims.clear ();
5973 new Dimension (tempdimname1, tempdimsize1, 0);
5974 (*i)->dims.push_back (dim);
5975 dim =
new Dimension (tempdimname1, tempdimsize1, 0);
5976 (*i)->correcteddims.push_back (dim);
5992 else if (tempfieldname.find (
"Longitude") != std::string::npos) {
5993 for (std::vector < Dimension * >::const_iterator j =
5994 (*i)->getDimensions ().begin ();
5995 j != (*i)->getDimensions ().end (); ++j) {
5996 if (((*j)->getName ()).find (
"regional long") !=
5997 std::string::npos) {
5998 tempsetit = tempdimnameset.insert ((*j)->getName ());
5999 if (tempsetit.second ==
true) {
6000 tempdimname2 = (*j)->getName ();
6001 tempdimsize2 = (*j)->getSize ();
6002 (*i)->fieldtype = 2;
6011 for (std::vector < Dimension * >::const_iterator j =
6012 (*i)->getDimensions ().begin ();
6013 j != (*i)->getDimensions ().end (); ++j) {
6016 for (std::vector < Dimension * >::const_iterator j =
6017 (*i)->getCorrectedDimensions ().begin ();
6018 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6021 (*i)->dims.clear ();
6022 (*i)->correcteddims.clear ();
6025 new Dimension (tempdimname2, tempdimsize2, 0);
6026 (*i)->dims.push_back (dim);
6027 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
6028 (*i)->correcteddims.push_back (dim);
6064 std::string tempdimname1 =
"1.0 deg. regional colat. zones";
6065 std::string tempdimname2 =
"1.0 deg. regional long. zones";
6066 std::string tempdimname3 =
"1.0 deg. zonal colat. zones";
6067 std::string tempdimname4 =
"1.0 deg. zonal long. zones";
6068 int tempdimsize1 = 180;
6069 int tempdimsize2 = 360;
6070 int tempdimsize3 = 180;
6071 int tempdimsize4 = 1;
6073 std::string tempnewdimname1;
6074 std::string tempnewdimname2;
6075 std::string tempcvarname1;
6076 std::string tempcvarname2;
6083 latitude->
name =
"latitude";
6085 latitude->
type = DFNT_FLOAT32;
6086 latitude->fieldtype = 1;
6093 latitude->dims.push_back (dim);
6095 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
6096 latitude->dims.push_back (dim);
6098 dim =
new Dimension (tempdimname1, tempdimsize1, 0);
6099 latitude->correcteddims.push_back (dim);
6101 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
6102 latitude->correcteddims.push_back (dim);
6107 longitude->
name =
"longitude";
6108 longitude->
rank = 2;
6109 longitude->
type = DFNT_FLOAT32;
6110 longitude->fieldtype = 2;
6115 dim =
new Dimension (tempdimname1, tempdimsize1, 0);
6116 longitude->dims.push_back (dim);
6118 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
6119 longitude->dims.push_back (dim);
6121 dim =
new Dimension (tempdimname1, tempdimsize1, 0);
6122 longitude->correcteddims.push_back (dim);
6124 dim =
new Dimension (tempdimname2, tempdimsize2, 0);
6125 longitude->correcteddims.push_back (dim);
6130 if (file->sptype == CER_SRB) {
6134 latitudez->
name =
"latitudez";
6135 latitudez->
rank = 1;
6136 latitudez->
type = DFNT_FLOAT32;
6137 latitudez->fieldtype = 1;
6140 dim =
new Dimension (tempdimname3, tempdimsize3, 0);
6141 latitudez->dims.push_back (dim);
6143 dim =
new Dimension (tempdimname3, tempdimsize3, 0);
6144 latitudez->correcteddims.push_back (dim);
6148 longitudez->
name =
"longitudez";
6149 longitudez->
rank = 1;
6150 longitudez->
type = DFNT_FLOAT32;
6151 longitudez->fieldtype = 2;
6154 dim =
new Dimension (tempdimname4, tempdimsize4, 0);
6155 longitudez->dims.push_back (dim);
6157 dim =
new Dimension (tempdimname4, tempdimsize4, 0);
6158 longitudez->correcteddims.push_back (dim);
6162 if (file->sptype == CER_SRB) {
6170 if(file->sptype == CER_CDAY) {
6172 string odddimname1=
"1.0 deg. regional Colat. zones";
6173 string odddimname2 =
"1.0 deg. regional Long. zones";
6176 for (std::vector < SDField * >::const_iterator i =
6178 for (std::vector < Dimension * >::const_iterator j =
6179 (*i)->getDimensions ().begin ();
6180 j != (*i)->getDimensions ().end (); ++j) {
6181 if (odddimname1 == (*j)->name)
6182 (*j)->name = tempdimname1;
6183 if (odddimname2 == (*j)->name)
6184 (*j)->name = tempdimname2;
6186 for (std::vector < Dimension * >::const_iterator j =
6187 (*i)->getCorrectedDimensions ().begin ();
6188 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6189 if (odddimname1 == (*j)->name)
6190 (*j)->name = tempdimname1;
6191 if (odddimname2 == (*j)->name)
6192 (*j)->name = tempdimname2;
6206 std::string tempdimname3 =
"1.0 deg. zonal colat. zones";
6207 std::string tempdimname4 =
"1.0 deg. zonal long. zones";
6208 int tempdimsize3 = 180;
6209 int tempdimsize4 = 1;
6214 latitudez->
name =
"latitudez";
6215 latitudez->
rank = 1;
6216 latitudez->
type = DFNT_FLOAT32;
6217 latitudez->fieldtype = 1;
6222 latitudez->dims.push_back (dim);
6224 dim =
new Dimension (tempdimname3, tempdimsize3, 0);
6225 latitudez->correcteddims.push_back (dim);
6230 longitudez->
name =
"longitudez";
6231 longitudez->
rank = 1;
6232 longitudez->
type = DFNT_FLOAT32;
6233 longitudez->fieldtype = 2;
6236 dim =
new Dimension (tempdimname4, tempdimsize4, 0);
6237 longitudez->dims.push_back (dim);
6239 dim =
new Dimension (tempdimname4, tempdimsize4, 0);
6240 longitudez->correcteddims.push_back (dim);
6257 std::set < std::string > tempfulldimnamelist;
6258 std::pair < std::set < std::string >::iterator,
bool > ret;
6260 std::map < int, std::string > tempsizedimnamelist;
6264 for (std::vector < SDField * >::const_iterator i =
6266 if ((*i)->getName () ==
"Latitude")
6267 (*i)->fieldtype = 1;
6268 if ((*i)->getName () ==
"Longitude") {
6269 (*i)->fieldtype = 2;
6274 for (std::vector < Dimension * >::const_iterator j =
6275 (*i)->getCorrectedDimensions ().begin ();
6276 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6277 tempsizedimnamelist[(*j)->getSize ()] = (*j)->getName ();
6283 for (std::vector < SDField * >::const_iterator i =
6285 for (std::vector < Dimension * >::const_iterator j =
6286 (*i)->getCorrectedDimensions ().begin ();
6287 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6291 if ((*i)->fieldtype == 0) {
6292 if ((tempsizedimnamelist.find ((*j)->getSize ())) !=
6293 tempsizedimnamelist.end ())
6294 (*j)->name = tempsizedimnamelist[(*j)->getSize ()];
6309 std::set < std::string > tempfulldimnamelist;
6310 std::pair < std::set < std::string >::iterator,
bool > ret;
6320 bool merra_is_eos2 =
false;
6321 size_t found_forward_slash = file->
path.find_last_of(
"/");
6322 if ((found_forward_slash != string::npos) &&
6323 (((file->
path).substr(found_forward_slash+1).compare(0,5,
"MERRA"))==0)){
6325 for (std::vector < Attribute * >::const_iterator i =
6330 if(((*i)->getName().compare(0, 14,
"StructMetadata" )== 0) ||
6331 ((*i)->getName().compare(0, 14,
"structmetadata" )== 0)) {
6332 merra_is_eos2 =
true;
6339 if(
true == merra_is_eos2) {
6340 vector <string> noneos_newnamelist;
6343 for (std::vector < SDField * >::const_iterator i =
6345 (*i)->special_product_fullpath = (*i)->newname;
6347 string EOSGRIDstring=
":EOSGRID";
6348 size_t found = ((*i)->name).rfind(EOSGRIDstring);
6350 if (found !=string::npos && (((*i)->name).size() == (found + EOSGRIDstring.size()))) {
6352 (*i)->newname = (*i)->name.substr(0,found);
6353 noneos_newnamelist.push_back((*i)->newname);
6356 (*i)->newname = (*i)->name;
6363 for (std::vector < SDField * >::const_iterator i =
6366 for(vector<string>::const_iterator j =
6367 noneos_newnamelist.begin(); j !=noneos_newnamelist.end();++j) {
6369 if ((*i)->newname == (*j) && (*i)->name == (*j)) {
6371 (*i)->newname = (*i)->newname +
"_EOS";
6378 map<string,string> dimname_to_newdimname;
6379 for (std::vector < SDField * >::const_iterator i =
6381 for (std::vector < Dimension * >::const_iterator j =
6382 (*i)->getCorrectedDimensions ().begin ();
6383 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6385 if ((*j)->getType () != 0) {
6386 if ((*i)->name == (*j)->getName () && (*i)->getRank () == 1){
6387 (*i)->fieldtype = 3;
6388 (*i)->is_dim_scale =
true;
6389 (*j)->name = (*i)->newname;
6400 map<string,string>::iterator itmap;
6401 for (std::vector < SDField * >::const_iterator i =
6404 if (0 == (*i)->fieldtype) {
6405 for (std::vector < Dimension * >::const_iterator j =
6406 (*i)->getCorrectedDimensions ().begin ();
6407 j != (*i)->getCorrectedDimensions ().end (); ++j) {
6408 itmap = dimname_to_newdimname.find((*j)->name);
6409 if (itmap == dimname_to_newdimname.end())
6410 throw2(
"Cannot find the corresponding new dim. name for dim. name ",(*j)->name);
6412 (*j)->name = (*itmap).second;
6420 for (std::vector < SDField * >::const_iterator i =
6421 file->
sd->
sdfields.begin (); i != file->
sd->
sdfields.end () && (
false == this->OTHERHDF_Has_Dim_NoScale_Field); ++i) {
6422 for (std::vector < Dimension * >::const_iterator j =
6423 (*i)->getCorrectedDimensions ().begin ();
6424 j != (*i)->getCorrectedDimensions ().end () && (
false == this->OTHERHDF_Has_Dim_NoScale_Field); ++j) {
6426 if ((*j)->getType () != 0) {
6427 if ((*i)->name == (*j)->getName () && (*i)->getRank () == 1)
6428 (*i)->fieldtype = 3;
6432 this->OTHERHDF_Has_Dim_NoScale_Field =
true;
6440 if (
true == this->OTHERHDF_Has_Dim_NoScale_Field)