39#include <unordered_map>
41#include <libdap/InternalErr.h>
59#include "HDF5CFGeoCF1D.h"
60#include "HDF5CFGeoCFProj.h"
67using namespace HDF5CF;
72void gen_dap_onevar_dds(DDS &dds,
const HDF5CF::Var* var,
const hid_t file_id,
const string & filename)
75 BESDEBUG(
"h5",
"Coming to gen_dap_onevar_dds() "<<endl);
76 const vector<HDF5CF::Dimension *>& dims = var->
getDimensions();
81 DMR * dmr = HDF5RequestHandler::get_dmr_64bit_int();
85 D4Group* root_grp = dmr->root();
92 string error_message =
"Cannot allocate the HDF5CFInt64: " + error_message;
93 throw InternalErr(__FILE__, __LINE__, error_message);
95 sca_int64->set_is_dap4(
true);
96 map_cfh5_var_attrs_to_dap4_int64(var,sca_int64);
97 root_grp->add_var_nocopy(sca_int64);
100 else if(H5UINT64 == var->
getType()) {
106 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFInt64.");
108 sca_uint64->set_is_dap4(
true);
109 map_cfh5_var_attrs_to_dap4_int64(var,sca_uint64);
110 root_grp->add_var_nocopy(sca_uint64);
116 else if (H5FSTRING == var->
getType() || H5VSTRING == var->
getType()) {
122 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFStr.");
124 dds.add_var(sca_str);
136 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFByte.");
138 dds.add_var(sca_uchar);
150 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFInt16.");
152 dds.add_var(sca_int16);
162 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFUInt16.");
164 dds.add_var(sca_uint16);
174 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFInt32.");
176 dds.add_var(sca_int32);
186 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFUInt32.");
188 dds.add_var(sca_uint32);
198 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFFloat32.");
200 dds.add_var(sca_float32);
210 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFFloat64.");
212 dds.add_var(sca_float64);
218 throw InternalErr(__FILE__, __LINE__,
"unsupported data type.");
227 bool dap4_int64 =
false;
229 DMR * dmr = HDF5RequestHandler::get_dmr_64bit_int();
238 D4Group* root_grp = dmr->root();
239 BaseType *bt =
nullptr;
241 bt->transform_to_dap4(root_grp,root_grp);
246 BaseType *bt =
nullptr;
248 if(
true == dap4_int64) {
251 else if(var->
getType() == H5UINT64)
258#define HANDLE_CASE(tid,type) \
260 bt = new (type)(var->getNewName(),var->getFullPath()); \
270 HANDLE_CASE(H5FSTRING,
Str)
271 HANDLE_CASE(H5VSTRING,
Str)
273 throw InternalErr(__FILE__, __LINE__,
"unsupported data type.");
278 vector<size_t> dimsizes;
279 dimsizes.resize(var->
getRank());
280 for (
int i = 0; i < var->
getRank(); i++)
281 dimsizes[i] = (dims[i])->getSize();
290 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFStr.");
293 for (
auto it_d = dims.begin(); it_d != dims.end(); ++it_d) {
294 if (
"" == (*it_d)->getNewName())
295 ar->append_dim((*it_d)->getSize());
297 ar->append_dim((*it_d)->getSize(), (*it_d)->getNewName());
301 if(dap4_int64 ==
true) {
302 DMR * dmr = HDF5RequestHandler::get_dmr_64bit_int();
303 D4Group* root_grp = dmr->root();
305 BaseType* d4_var = ar->h5cfdims_transform_to_dap4_int64(root_grp);
307 map_cfh5_var_attrs_to_dap4_int64(var,d4_var);
308 root_grp->add_var_nocopy(d4_var);
325 return (((
"_FillValue" == attr->getNewName()) && (var->
getType() != attr->getType())) ?
true :
false);
332 BESDEBUG(
"h5",
"Coming to gen_dap_special_oneobj_das() "<<endl);
333 if (attr->getCount() != 1)
throw InternalErr(__FILE__, __LINE__,
"FillValue attribute can only have one element.");
335 H5DataType var_dtype = var->
getType();
336 if ((
true == HDF5RequestHandler::get_fillvalue_check())
337 && (
false == is_fvalue_valid(var_dtype, attr))) {
338 string msg =
"The attribute value is out of the range.\n";
339 msg +=
"The variable name: " + var->
getNewName() +
"\n";
340 msg +=
"The attribute name: " + attr->getNewName() +
"\n";
341 msg +=
"The error occurs inside the gen_dap_special_oneobj_das function in h5commoncfdap.cc.";
342 throw InternalErr(msg);
344 string print_rep = HDF5CFDAPUtil::print_attr(attr->getType(), 0, (
void*) (&(attr->getValue()[0])));
345 at->append_attr(attr->getNewName(), HDF5CFDAPUtil::print_type(var_dtype), print_rep);
352 BESDEBUG(
"h5",
"Coming to is_fvalue_valid() "<<endl);
353 bool ret_value =
true;
355 switch (attr->getType()) {
357 signed char final_fill_value = *((
signed char*) ((
void*) (&(attr->getValue()[0]))));
358 if ((var_dtype == H5UCHAR) && (final_fill_value<0))
364 short final_fill_value = *((
short*) ((
void*) (&(attr->getValue()[0]))));
365 if ((var_dtype == H5UCHAR) &&(final_fill_value > 255 || final_fill_value < 0))
369 else if ((var_dtype == H5UINT16) && (final_fill_value < 0))
374 unsigned short final_fill_value = *((
unsigned short*) ((
void*) (&(attr->getValue()[0]))));
375 if ((var_dtype == H5UCHAR) &&(final_fill_value > 255)) {
378 else if ((var_dtype == H5INT16) && (final_fill_value >32767)){
391 unsigned char final_fill_value = *((
unsigned char*)((
void*)(&(attr->getValue()[0]))));
392 if(var_dtype == H5CHAR) {
393 if(final_fill_value >127)
413 if (attr->getCount() != 1)
414 throw InternalErr(__FILE__,__LINE__,
"FillValue attribute can only have one element.");
416 H5DataType var_dtype = var->
getType();
421 unsigned char final_fill_value = *((
unsigned char*)((
void*)(&(attr->getValue()[0]))));
422 print_rep = HDF5CFDAPUtil::print_attr(var_dtype,0,(
void*)&final_fill_value);
429 short final_fill_value = *((
short*)((
void*)(&(attr->getValue()[0]))));
430 print_rep = HDF5CFDAPUtil::print_attr(var_dtype,0,(
void*)&final_fill_value);
435 short final_fill_value = *((
short*)((
void*)(&(attr->getValue()[0]))));
436 print_rep = HDF5CFDAPUtil::print_attr(var_dtype,0,(
void*)&final_fill_value);
441 unsigned short final_fill_value = *((
unsigned short*)((
void*)(&(attr->getValue()[0]))));
442 print_rep = HDF5CFDAPUtil::print_attr(var_dtype,0,(
void*)&final_fill_value);
448 int final_fill_value = *((
int*)((
void*)(&(attr->getValue()[0]))));
449 print_rep = HDF5CFDAPUtil::print_attr(var_dtype,0,(
void*)&final_fill_value);
454 unsigned int final_fill_value = *((
unsigned int*)((
void*)(&(attr->getValue()[0]))));
455 print_rep = HDF5CFDAPUtil::print_attr(var_dtype,0,(
void*)&final_fill_value);
460 float final_fill_value = *((
float*)((
void*)(&(attr->getValue()[0]))));
463 print_rep = HDF5CFDAPUtil::print_attr(var_dtype,0,(
void*)&final_fill_value);
468 double final_fill_value = *((
double*)((
void*)(&(attr->getValue()[0]))));
469 print_rep = HDF5CFDAPUtil::print_attr(var_dtype,0,(
void*)&final_fill_value);
473 throw InternalErr(__FILE__,__LINE__,
"unsupported data type.");
476 at->append_attr(attr->getNewName(), HDF5CFDAPUtil::print_type(var_dtype), print_rep);
484 BESDEBUG(
"h5",
"Coming to gen_dap_oneobj_das() "<<endl);
486 if (H5INT64 == attr->getType() || H5UINT64 == attr->getType()) {
491 else if ((H5FSTRING == attr->getType()) || (H5VSTRING == attr->getType())) {
496 if (
nullptr == var) {
500 size_t mem_dtype_size = (attr->getBufSize()) / (attr->getCount());
501 H5DataType mem_dtype = HDF5CFDAPUtil::get_mem_dtype(attr->getType(), mem_dtype_size);
503 for (
unsigned int loc = 0; loc < attr->getCount(); loc++) {
504 string print_rep = HDF5CFDAPUtil::print_attr(mem_dtype, loc, (
void*) &(attr->getValue()[0]));
505 at->append_attr(attr->getNewName(), HDF5CFDAPUtil::print_type(attr->getType()), print_rep);
517 bool special_attr_handling = need_special_attribute_handling(attr, var);
518 if (
true == special_attr_handling) {
519 gen_dap_special_oneobj_das(at, attr, var);
526 size_t mem_dtype_size = (attr->getBufSize()) / (attr->getCount());
527 H5DataType mem_dtype = HDF5CFDAPUtil::get_mem_dtype(attr->getType(), mem_dtype_size);
529 for (
unsigned int loc = 0; loc < attr->getCount(); loc++) {
530 string print_rep = HDF5CFDAPUtil::print_attr(mem_dtype, loc, (
void*) &(attr->getValue()[0]));
531 at->append_attr(attr->getNewName(), HDF5CFDAPUtil::print_type(attr->getType()), print_rep);
540void gen_dap_onevar_dmr(libdap::D4Group* d4_grp,
const HDF5CF::Var* var,
const hid_t file_id,
const string & filename) {
542 BESDEBUG(
"h5",
"Coming to gen_dap_onevar_dmr() "<<endl);
544 const vector<HDF5CF::Dimension *>& dims = var->
getDimensions();
552 sca_str->set_is_dap4(
true);
553 map_cfh5_var_attrs_to_dap4(var,sca_str);
557 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFStr.");
559 d4_grp->add_var_nocopy(sca_str);
568 sca_uchar->set_is_dap4(
true);
569 map_cfh5_var_attrs_to_dap4(var,sca_uchar);
573 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFByte.");
575 d4_grp->add_var_nocopy(sca_uchar);
582 sca_char->set_is_dap4(
true);
583 map_cfh5_var_attrs_to_dap4(var,sca_char);
587 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFByte.");
589 d4_grp->add_var_nocopy(sca_char);
597 sca_int16->set_is_dap4(
true);
598 map_cfh5_var_attrs_to_dap4(var,sca_int16);
603 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFInt16.");
605 d4_grp->add_var_nocopy(sca_int16);
612 sca_uint16->set_is_dap4(
true);
613 map_cfh5_var_attrs_to_dap4(var,sca_uint16);
617 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFUInt16.");
619 d4_grp->add_var_nocopy(sca_uint16);
626 sca_int32->set_is_dap4(
true);
627 map_cfh5_var_attrs_to_dap4(var,sca_int32);
631 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFInt32.");
633 d4_grp->add_var_nocopy(sca_int32);
640 sca_uint32->set_is_dap4(
true);
641 map_cfh5_var_attrs_to_dap4(var,sca_uint32);
645 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFUInt32.");
647 d4_grp->add_var_nocopy(sca_uint32);
654 sca_int64->set_is_dap4(
true);
655 map_cfh5_var_attrs_to_dap4(var,sca_int64);
659 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFInt64.");
661 d4_grp->add_var_nocopy(sca_int64);
668 sca_uint64->set_is_dap4(
true);
669 map_cfh5_var_attrs_to_dap4(var,sca_uint64);
673 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFUInt64.");
675 d4_grp->add_var_nocopy(sca_uint64);
682 sca_float32->set_is_dap4(
true);
683 map_cfh5_var_attrs_to_dap4(var,sca_float32);
687 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFFloat32.");
689 d4_grp->add_var_nocopy(sca_float32);
696 sca_float64->set_is_dap4(
true);
697 map_cfh5_var_attrs_to_dap4(var,sca_float64);
701 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFFloat64.");
703 d4_grp->add_var_nocopy(sca_float64);
707 throw InternalErr(__FILE__, __LINE__,
"unsupported data type.");
714 BaseType *bt =
nullptr;
717#define HANDLE_CASE(tid,type) \
719 bt = new (type)(var->getNewName(),var->getFullPath()); \
731 HANDLE_CASE(H5FSTRING,
Str)
732 HANDLE_CASE(H5VSTRING,
Str)
734 throw InternalErr(__FILE__, __LINE__,
"unsupported data type.");
738 vector<size_t> dimsizes;
739 dimsizes.resize(var->
getRank());
740 for (
int i = 0; i < var->
getRank(); i++)
741 dimsizes[i] = (dims[i])->getSize();
750 throw InternalErr(__FILE__, __LINE__,
"Cannot allocate the HDF5CFStr.");
753 for (
auto it_d = dims.begin(); it_d != dims.end(); ++it_d) {
754 if (
"" == (*it_d)->getNewName())
755 ar->append_dim((
int)((*it_d)->getSize()));
757 ar->append_dim((
int)((*it_d)->getSize()), (*it_d)->getNewName());
761 ar->set_is_dap4(
true);
762 BaseType* d4_var=ar->h5cfdims_transform_to_dap4(d4_grp);
763 map_cfh5_var_attrs_to_dap4(var,d4_var);
764 d4_grp->add_var_nocopy(d4_var);
793 BESDEBUG(
"h5",
"Coming to gen_dap_str_attr() " << endl);
794 const vector<size_t>& strsize = attr->getStrSize();
796 unsigned int temp_start_pos = 0;
797 for (
unsigned int loc = 0; loc < attr->getCount(); loc++) {
798 if (strsize[loc] != 0) {
799 string tempstring(attr->getValue().begin() + temp_start_pos, attr->getValue().begin() + temp_start_pos + strsize[loc]);
800 temp_start_pos += strsize[loc];
815 if ((attr->getNewName() !=
"origname") && (attr->getNewName() !=
"fullnamepath")
816 && (HDF5RequestHandler::get_escape_utf8_attr() || (
true == attr->getCsetType()))) {
819 at->append_attr(attr->getNewName(),
"String", tempstring);
829void add_cf_grid_cvs(DDS & dds, EOS5GridPCType cv_proj_code,
float cv_point_lower,
float cv_point_upper,
830 float cv_point_left,
float cv_point_right,
const vector<HDF5CF::Dimension*>& dims)
835 if (HE5_GCTP_SNSOID == cv_proj_code || HE5_GCTP_LAMAZ == cv_proj_code || HE5_GCTP_PS == cv_proj_code) {
838 string dim0name = dims[0]->getNewName();
839 auto dim0size = (
int)(dims[0]->getSize());
840 string dim1name = dims[1]->getNewName();
841 auto dim1size = (
int)(dims[1]->getSize());
844 BaseType *bt_dim0 =
nullptr;
845 BaseType *bt_dim1 =
nullptr;
856 ar_dim0 =
new HDF5CFGeoCF1D(HE5_GCTP_SNSOID, cv_point_upper, cv_point_lower, dim0size, dim0name, bt_dim0);
857 ar_dim0->append_dim(dim0size, dim0name);
859 ar_dim1 =
new HDF5CFGeoCF1D(HE5_GCTP_SNSOID, cv_point_left, cv_point_right, dim1size, dim1name, bt_dim1);
860 ar_dim1->append_dim(dim1size, dim1name);
861 dds.add_var(ar_dim0);
862 dds.add_var(ar_dim1);
866 if (bt_dim0)
delete bt_dim0;
867 if (bt_dim1)
delete bt_dim1;
868 if (ar_dim0)
delete ar_dim0;
869 if (ar_dim1)
delete ar_dim1;
870 throw InternalErr(__FILE__, __LINE__,
"Unable to allocate the HDFEOS2GeoCF1D instance.");
873 if (bt_dim0)
delete bt_dim0;
874 if (bt_dim1)
delete bt_dim1;
875 if (ar_dim0)
delete ar_dim0;
876 if (ar_dim1)
delete ar_dim1;
882void add_cf_grid_mapinfo_var(DDS & dds,
const EOS5GridPCType grid_proj_code,
const unsigned short g_suffix)
887 string cf_projection_base =
"eos_cf_projection";
890 if(HE5_GCTP_SNSOID == grid_proj_code) {
893 dummy_proj_cf =
new HDF5CFGeoCFProj(cf_projection_base, cf_projection_base);
894 dds.add_var(dummy_proj_cf);
898 stringstream t_suffix_ss;
899 t_suffix_ss << g_suffix;
900 string cf_projection_name = cf_projection_base +
"_" + t_suffix_ss.str();
901 dummy_proj_cf =
new HDF5CFGeoCFProj(cf_projection_name, cf_projection_name);
902 dds.add_var(dummy_proj_cf);
904 if (dummy_proj_cf)
delete dummy_proj_cf;
910void add_cf_grid_cv_attrs(DAS & das,
const vector<HDF5CF::Var*>& vars, EOS5GridPCType cv_proj_code,
911 float ,
float ,
float ,
float ,
912 const vector<HDF5CF::Dimension*>& dims,
const vector<double> &eos5_proj_params,
const unsigned short g_suffix)
914void add_cf_grid_cv_attrs(DAS & das,
const vector<HDF5CF::Var*>& vars, EOS5GridPCType cv_proj_code,
915 const vector<HDF5CF::Dimension*>& dims,
const vector<double> &eos5_proj_params,
const unsigned short g_suffix)
920 if (HE5_GCTP_SNSOID == cv_proj_code || HE5_GCTP_PS == cv_proj_code || HE5_GCTP_LAMAZ== cv_proj_code) {
922 string dim0name = (dims[0])->getNewName();
923 auto dim0size = (
int)(dims[0]->getSize());
924 string dim1name = (dims[1])->getNewName();
925 auto dim1size = (
int)(dims[1]->getSize());
928 AttrTable *at = das.get_table(dim0name);
930 at = das.add_table(dim0name,
new AttrTable);
931 at->append_attr(
"standard_name",
"String",
"projection_y_coordinate");
933 string long_name =
"y coordinate of projection ";
934 at->append_attr(
"long_name",
"String", long_name);
937 at->append_attr(
"units",
"string",
"meter");
939 at->append_attr(
"_CoordinateAxisType",
"string",
"GeoY");
941 at = das.get_table(dim1name);
942 if (!at) at = das.add_table(dim1name,
new AttrTable);
944 at->append_attr(
"standard_name",
"String",
"projection_x_coordinate");
946 long_name =
"x coordinate of projection ";
947 at->append_attr(
"long_name",
"String", long_name);
950 at->append_attr(
"units",
"string",
"meter");
953 at->append_attr(
"_CoordinateAxisType",
"string",
"GeoX");
956 string cf_projection_base =
"eos_cf_projection";
957 string cf_projection;
958 if(HE5_GCTP_SNSOID == cv_proj_code)
959 cf_projection = cf_projection_base;
961 stringstream t_suffix_ss;
962 t_suffix_ss << g_suffix;
963 cf_projection = cf_projection_base +
"_" + t_suffix_ss.str();
965 add_cf_projection_attrs(das,cv_proj_code,eos5_proj_params,cf_projection);
969 add_cf_grid_mapping_attr(das, vars, cf_projection, dim0name, dim0size, dim1name, dim1size);
976void add_cf_projection_attrs(DAS &das,EOS5GridPCType cv_proj_code,
const vector<double> &eos5_proj_params,
const string& cf_projection) {
978 AttrTable* at = das.get_table(cf_projection);
980 at = das.add_table(cf_projection,
new AttrTable);
982 if (HE5_GCTP_SNSOID == cv_proj_code) {
983 at->append_attr(
"grid_mapping_name",
"String",
"sinusoidal");
984 at->append_attr(
"longitude_of_central_meridian",
"Float64",
"0.0");
985 at->append_attr(
"earth_radius",
"Float64",
"6371007.181");
986 at->append_attr(
"_CoordinateAxisTypes",
"string",
"GeoX GeoY");
988 else if (HE5_GCTP_PS == cv_proj_code) {
994 double vert_lon_pole = HE5_EHconvAng(eos5_proj_params[4],HE5_HDFE_DMS_DEG);
997 double lat_true_scale = HE5_EHconvAng(eos5_proj_params[5],HE5_HDFE_DMS_DEG);
1000 double fe = eos5_proj_params[6];
1003 double fn = eos5_proj_params[7];
1005 at->append_attr(
"grid_mapping_name",
"String",
"polar_stereographic");
1007 ostringstream s_vert_lon_pole;
1008 s_vert_lon_pole << vert_lon_pole;
1012 at->append_attr(
"straight_vertical_longitude_from_pole",
"Float64", s_vert_lon_pole.str());
1013 ostringstream s_lat_true_scale;
1014 s_lat_true_scale << lat_true_scale;
1016 at->append_attr(
"standard_parallel",
"Float64", s_lat_true_scale.str());
1019 at->append_attr(
"false_easting",
"Float64",
"0.0");
1023 at->append_attr(
"false_easting",
"Float64",s_fe.str());
1028 at->append_attr(
"false_northing",
"Float64",
"0.0");
1032 at->append_attr(
"false_northing",
"Float64",s_fn.str());
1036 if(lat_true_scale >0)
1037 at->append_attr(
"latitude_of_projection_origin",
"Float64",
"+90.0");
1039 at->append_attr(
"latitude_of_projection_origin",
"Float64",
"-90.0");
1042 at->append_attr(
"_CoordinateAxisTypes",
"string",
"GeoX GeoY");
1049 else if(HE5_GCTP_LAMAZ == cv_proj_code) {
1050 double lon_proj_origin = HE5_EHconvAng(eos5_proj_params[4],HE5_HDFE_DMS_DEG);
1051 double lat_proj_origin = HE5_EHconvAng(eos5_proj_params[5],HE5_HDFE_DMS_DEG);
1052 double fe = eos5_proj_params[6];
1053 double fn = eos5_proj_params[7];
1055 at->append_attr(
"grid_mapping_name",
"String",
"lambert_azimuthal_equal_area");
1057 ostringstream s_lon_proj_origin;
1058 s_lon_proj_origin << lon_proj_origin;
1059 at->append_attr(
"longitude_of_projection_origin",
"Float64", s_lon_proj_origin.str());
1061 ostringstream s_lat_proj_origin;
1062 s_lat_proj_origin << lat_proj_origin;
1064 at->append_attr(
"latitude_of_projection_origin",
"Float64", s_lat_proj_origin.str());
1068 at->append_attr(
"false_easting",
"Float64",
"0.0");
1072 at->append_attr(
"false_easting",
"Float64",s_fe.str());
1077 at->append_attr(
"false_northing",
"Float64",
"0.0");
1081 at->append_attr(
"false_northing",
"Float64",s_fn.str());
1084 at->append_attr(
"_CoordinateAxisTypes",
"string",
"GeoX GeoY");
1095void add_cf_grid_mapping_attr(DAS &das,
const vector<HDF5CF::Var*>& vars,
const string& cf_projection,
1096 const string & dim0name, hsize_t dim0size,
const string &dim1name, hsize_t dim1size)
1100 cerr<<
"dim0name is "<<dim0name <<endl;
1101 cerr<<
"dim1name is "<<dim1name <<endl;
1102 cerr<<
"dim0size is "<<dim0size <<endl;
1103 cerr<<
"dim1size is "<<dim1size <<endl;
1107 for (
auto it_v = vars.begin(); it_v != vars.end(); ++it_v) {
1109 if ((*it_v)->getRank() > 1) {
1110 bool has_dim0 =
false;
1111 bool has_dim1 =
false;
1112 const vector<HDF5CF::Dimension*>& dims = (*it_v)->getDimensions();
1113 for (
auto j = dims.begin(); j != dims.end(); ++j) {
1114 if ((*j)->getNewName() == dim0name && (*j)->getSize() == dim0size)
1116 else if ((*j)->getNewName() == dim1name && (*j)->getSize() == dim1size)
1120 if (
true == has_dim0 &&
true == has_dim1) {
1121 AttrTable *at = das.get_table((*it_v)->getNewName());
1122 if (!at) at = das.add_table((*it_v)->getNewName(),
new AttrTable);
1125 at->append_attr(
"grid_mapping",
"String", cf_projection);
1133void add_ll_valid_range(AttrTable* at,
bool is_lat) {
1134 if(
true == is_lat) {
1135 at->append_attr(
"valid_min",
"Float64",
"-90.0");
1136 at->append_attr(
"valid_max",
"Float64",
"90.0");
1139 at->append_attr(
"valid_min",
"Float64",
"-180.0");
1140 at->append_attr(
"valid_max",
"Float64",
"180.0");
1146bool need_attr_values_for_dap4(
const HDF5CF::Var *var) {
1147 bool ret_value =
false;
1148 if((HDF5RequestHandler::get_dmr_64bit_int()!=
nullptr) &&
1156void map_cfh5_var_attrs_to_dap4_int64(
const HDF5CF::Var *var,BaseType* d4_var) {
1158 for (
auto it_ra = var->getAttributes().begin();
1159 it_ra != var->getAttributes().end(); ++it_ra) {
1162 size_t mem_dtype_size = ((*it_ra)->getBufSize()) / ((*it_ra)->getCount());
1163 H5DataType mem_dtype = HDF5CFDAPUtil::get_mem_dtype((*it_ra)->getType(), mem_dtype_size);
1165 string dap2_attrtype = HDF5CFDAPUtil::print_type(mem_dtype);
1167 auto d4_attr =
new D4Attribute((*it_ra)->getNewName(),dap4_attrtype);
1168 if(dap4_attrtype == attr_str_c) {
1169 if(
"coordinates" == (*it_ra)->getNewName()) {
1170 bool chg_coor_value =
false;
1171 if((
true == HDF5RequestHandler::get_enable_coord_attr_add_path())
1172 &&(
true == var->getCoorAttrAddPath()))
1173 chg_coor_value =
true;
1175 handle_coor_attr_for_int64_var((*it_ra),var->
getFullPath(),tempstring,chg_coor_value);
1176 d4_attr->add_value(tempstring);
1179 const vector<size_t>& strsize = (*it_ra)->getStrSize();
1180 unsigned int temp_start_pos = 0;
1181 for (
unsigned int loc = 0; loc < (*it_ra)->getCount(); loc++) {
1182 if (strsize[loc] != 0) {
1183 string tempstring((*it_ra)->getValue().begin() + temp_start_pos,
1184 (*it_ra)->getValue().begin() + temp_start_pos + strsize[loc]);
1185 temp_start_pos += strsize[loc];
1191 d4_attr->add_value(tempstring);
1198 for (
unsigned int loc = 0; loc < (*it_ra)->getCount(); loc++) {
1199 string print_rep = HDF5CFDAPUtil::print_attr(mem_dtype, loc, (
void*) &((*it_ra)->getValue()[0]));
1200 d4_attr->add_value(print_rep);
1203 d4_var->attributes()->add_attribute_nocopy(d4_attr);
1206 auto d4_attr =
new D4Attribute(
"origname",attr_str_c);
1207 d4_attr->add_value(var->
getName());
1208 d4_var->attributes()->add_attribute_nocopy(d4_attr);
1209 d4_attr =
new D4Attribute(
"fullnamepath",attr_str_c);
1211 d4_var->attributes()->add_attribute_nocopy(d4_attr);
1216void check_update_int64_attr(
const string & obj_name,
const HDF5CF::Attribute * attr) {
1217 if(attr->getType() == H5INT64 || attr->getType() == H5UINT64) {
1219 DMR * dmr = HDF5RequestHandler::get_dmr_64bit_int();
1220 if(dmr !=
nullptr) {
1221 string dap2_attrtype = HDF5CFDAPUtil::print_type(attr->getType());
1223 D4Attribute *d4_attr =
new D4Attribute(attr->getNewName(),dap4_attrtype);
1224 for (
unsigned int loc = 0; loc < attr->getCount(); loc++) {
1225 string print_rep = HDF5CFDAPUtil::print_attr(attr->getType(), loc, (
void*) &(attr->getValue()[0]));
1226 d4_attr->add_value(print_rep);
1228 D4Group * root_grp = dmr->root();
1229 D4Attribute *d4_hg_container;
1230 if(root_grp->attributes()->empty() ==
true){
1235 d4_hg_container =
new D4Attribute;
1236 d4_hg_container->set_name(
"HDF5_GLOBAL_integer_64");
1237 d4_hg_container->set_type(attr_container_c);
1238 root_grp->attributes()->add_attribute_nocopy(d4_hg_container);
1244 d4_hg_container = root_grp->attributes()->get(
"HDF5_GLOBAL_integer_64");
1245 if(obj_name !=
"") {
1246 string test_obj_name =
"HDF5_GLOBAL_integer_64."+obj_name;
1251 D4Attribute *d4_container = root_grp->attributes()->get(test_obj_name);
1257 if(d4_container ==
nullptr) {
1258 d4_container =
new D4Attribute;
1259 d4_container->set_name(obj_name);
1260 d4_container->set_type(attr_container_c);
1269 d4_container->attributes()->add_attribute_nocopy(d4_attr);
1274 if(d4_hg_container->attributes()->get(obj_name)==
nullptr)
1275 d4_hg_container->attributes()->add_attribute_nocopy(d4_container);
1279 d4_hg_container->attributes()->add_attribute_nocopy(d4_attr);
1286void handle_coor_attr_for_int64_var(
const HDF5CF::Attribute *attr,
const string &var_path,
string &tempstring,
bool chg_coor_value) {
1288 string tempstring2(attr->getValue().begin(),attr->getValue().end());
1289 if(
true == chg_coor_value) {
1291 vector<string>cvalue_vec;
1292 HDF5CFUtil::Split_helper(cvalue_vec,tempstring2,sep);
1293 for (
int i = 0; i<cvalue_vec.size();i++) {
1294 HDF5CFUtil::cha_co(cvalue_vec[i],var_path);
1295 string t_str = get_cf_string(cvalue_vec[i]);
1299 tempstring += sep+t_str;
1303 tempstring = tempstring2;
1309void map_cfh5_var_attrs_to_dap4(
const HDF5CF::Var *var,BaseType* d4_var) {
1311 for (
auto it_ra = var->getAttributes().begin();
1312 it_ra != var->getAttributes().end(); ++it_ra) {
1314 D4Attribute *d4_attr = gen_dap4_attr((*it_ra));
1315 d4_var->attributes()->add_attribute_nocopy(d4_attr);
1320void map_cfh5_grp_attr_to_dap4(libdap::D4Group *d4_grp,
const HDF5CF::Attribute *attr) {
1322 D4Attribute *d4_attr = gen_dap4_attr(attr);
1323 d4_grp->attributes()->add_attribute_nocopy(d4_attr);
1328void map_cfh5_attr_container_to_dap4(libdap::D4Attribute *d4_con,
const HDF5CF::Attribute *attr) {
1330 D4Attribute *d4_attr = gen_dap4_attr(attr);
1331 d4_con->attributes()->add_attribute_nocopy(d4_attr);
1338 D4AttributeType dap4_attrtype = HDF5CFDAPUtil::print_type_dap4(attr->getType());
1339 auto d4_attr =
new D4Attribute(attr->getNewName(),dap4_attrtype);
1340 if(dap4_attrtype == attr_str_c) {
1342 const vector<size_t>& strsize = attr->getStrSize();
1344 if(strsize.size() == 0)
1345 cerr <<
"vector string size is 0" << endl;
1346 for(
int i = 0; i<strsize.size(); i++)
1347 cerr <<
"attr size is "<<strsize[i] << endl;
1349 unsigned int temp_start_pos = 0;
1350 for (
unsigned int loc = 0; loc < attr->getCount(); loc++) {
1351 if (strsize[loc] != 0) {
1352 string tempstring(attr->getValue().begin() + temp_start_pos,
1353 attr->getValue().begin() + temp_start_pos + strsize[loc]);
1354 temp_start_pos += strsize[loc];
1355 if ((attr->getNewName() !=
"origname") && (attr->getNewName() !=
"fullnamepath")
1356 && (HDF5RequestHandler::get_escape_utf8_attr() || (
true == attr->getCsetType()))) {
1359 d4_attr->add_value(tempstring);
1365 cerr <<
"not a string type " << endl;
1367 for (
unsigned int loc = 0; loc < attr->getCount(); loc++) {
1368 string print_rep = HDF5CFDAPUtil::print_attr(attr->getType(), loc, (
void*) &(attr->getValue()[0]));
1369 d4_attr->add_value(print_rep);
1378void add_gm_oneproj_var_dap4_attrs(BaseType *var,EOS5GridPCType cv_proj_code,
const vector<double> &eos5_proj_params) {
1380 if (HE5_GCTP_SNSOID == cv_proj_code) {
1382 add_var_dap4_attr(var,
"grid_mapping_name",attr_str_c,
"sinusoidal");
1383 add_var_dap4_attr(var,
"longitude_of_central_meridian",attr_float64_c,
"0.0");
1384 add_var_dap4_attr(var,
"earth_radius", attr_float64_c,
"6371007.181");
1385 add_var_dap4_attr(var,
"_CoordinateAxisTypes", attr_str_c,
"GeoX GeoY");
1388 else if (HE5_GCTP_PS == cv_proj_code) {
1394 double vert_lon_pole = HE5_EHconvAng(eos5_proj_params[4],HE5_HDFE_DMS_DEG);
1397 double lat_true_scale = HE5_EHconvAng(eos5_proj_params[5],HE5_HDFE_DMS_DEG);
1400 double fe = eos5_proj_params[6];
1403 double fn = eos5_proj_params[7];
1405 add_var_dap4_attr(var,
"grid_mapping_name",attr_str_c,
"polar_stereographic");
1407 ostringstream s_vert_lon_pole;
1408 s_vert_lon_pole << vert_lon_pole;
1415 add_var_dap4_attr(var,
"straight_vertical_longitude_from_pole", attr_float64_c, s_vert_lon_pole.str());
1417 ostringstream s_lat_true_scale;
1418 s_lat_true_scale << lat_true_scale;
1419 add_var_dap4_attr(var,
"standard_parallel", attr_float64_c, s_lat_true_scale.str());
1422 add_var_dap4_attr(var,
"false_easting",attr_float64_c,
"0.0");
1426 add_var_dap4_attr(var,
"false_easting",attr_float64_c,s_fe.str());
1430 add_var_dap4_attr(var,
"false_northing",attr_float64_c,
"0.0");
1434 add_var_dap4_attr(var,
"false_northing",attr_float64_c,s_fn.str());
1437 if(lat_true_scale >0)
1438 add_var_dap4_attr(var,
"latitude_of_projection_origin",attr_float64_c,
"+90.0");
1440 add_var_dap4_attr(var,
"latitude_of_projection_origin",attr_float64_c,
"-90.0");
1442 add_var_dap4_attr(var,
"_CoordinateAxisTypes", attr_str_c,
"GeoX GeoY");
1449 else if(HE5_GCTP_LAMAZ == cv_proj_code) {
1451 double lon_proj_origin = HE5_EHconvAng(eos5_proj_params[4],HE5_HDFE_DMS_DEG);
1452 double lat_proj_origin = HE5_EHconvAng(eos5_proj_params[5],HE5_HDFE_DMS_DEG);
1453 double fe = eos5_proj_params[6];
1454 double fn = eos5_proj_params[7];
1456 add_var_dap4_attr(var,
"grid_mapping_name", attr_str_c,
"lambert_azimuthal_equal_area");
1458 ostringstream s_lon_proj_origin;
1459 s_lon_proj_origin << lon_proj_origin;
1460 add_var_dap4_attr(var,
"longitude_of_projection_origin", attr_float64_c, s_lon_proj_origin.str());
1462 ostringstream s_lat_proj_origin;
1463 s_lat_proj_origin << lat_proj_origin;
1465 add_var_dap4_attr(var,
"latitude_of_projection_origin", attr_float64_c, s_lat_proj_origin.str());
1468 add_var_dap4_attr(var,
"false_easting",attr_float64_c,
"0.0");
1472 add_var_dap4_attr(var,
"false_easting",attr_float64_c,s_fe.str());
1476 add_var_dap4_attr(var,
"false_northing",attr_float64_c,
"0.0");
1480 add_var_dap4_attr(var,
"false_northing",attr_float64_c,s_fn.str());
1483 add_var_dap4_attr(var,
"_CoordinateAxisTypes", attr_str_c,
"GeoX GeoY");
1489void add_cf_grid_cv_dap4_attrs(D4Group *d4_root,
const string& cf_projection,
1490 const vector<HDF5CF::Dimension*>& dims,
const vector<string> & cvar_name)
1493 string dim0name = (dims[0])->getNewName();
1494 hsize_t dim0size = dims[0]->getSize();
1495 string dim1name = (dims[1])->getNewName();
1496 hsize_t dim1size = dims[1]->getSize();
1499 Constructor::Vars_iter vi = d4_root->var_begin();
1500 Constructor::Vars_iter ve = d4_root->var_end();
1501 for (; vi != ve; vi++) {
1503 if((*vi)->is_vector_type() && (cvar_name.end() == find(cvar_name.begin(), cvar_name.end(),(*vi)->name()))) {
1504 auto t_a =
dynamic_cast<Array*
>(*vi);
1505 if(t_a->dimensions() >1) {
1506 Array::Dim_iter dim_i = t_a->dim_begin();
1507 Array::Dim_iter dim_e = t_a->dim_end();
1508 bool has_dim0 =
false;
1509 bool has_dim1 =
false;
1510 for(;dim_i !=dim_e;dim_i++) {
1511 if((*dim_i).name == dim0name && (*dim_i).size == dim0size)
1513 else if((*dim_i).name == dim1name && (*dim_i).size == dim1size)
1517 if(
true == has_dim0 &&
true == has_dim1)
1518 add_var_dap4_attr((*vi),
"grid_mapping",attr_str_c,cf_projection);
1527void add_gm_spcvs(libdap::D4Group *d4_root, EOS5GridPCType cv_proj_code,
float cv_point_lower,
float cv_point_upper,
1528 float cv_point_left,
float cv_point_right,
const std::vector<HDF5CF::Dimension*>& dims) {
1532 if (HE5_GCTP_SNSOID == cv_proj_code || HE5_GCTP_LAMAZ == cv_proj_code || HE5_GCTP_PS == cv_proj_code) {
1535 string dim0name = dims[0]->getNewName();
1536 auto dim0size = (
int)(dims[0]->getSize());
1537 string dim1name = dims[1]->getNewName();
1538 auto dim1size = (
int)(dims[1]->getSize());
1541 BaseType *bt_dim0 =
nullptr;
1542 BaseType *bt_dim1 =
nullptr;
1553 ar_dim0 =
new HDF5CFGeoCF1D(HE5_GCTP_SNSOID, cv_point_upper, cv_point_lower, dim0size, dim0name, bt_dim0);
1554 ar_dim0->append_dim(dim0size, dim0name);
1556 ar_dim0->set_is_dap4(
true);
1558 add_gm_spcvs_attrs(ar_dim0,
true);
1560 ar_dim1 =
new HDF5CFGeoCF1D(HE5_GCTP_SNSOID, cv_point_left, cv_point_right, dim1size, dim1name, bt_dim1);
1561 ar_dim1->append_dim(dim1size, dim1name);
1563 ar_dim1->set_is_dap4(
true);
1565 add_gm_spcvs_attrs(ar_dim1,
false);
1567 d4_root->add_var(ar_dim0);
1568 d4_root->add_var(ar_dim1);
1572 if (bt_dim0)
delete bt_dim0;
1573 if (bt_dim1)
delete bt_dim1;
1574 if (ar_dim0)
delete ar_dim0;
1575 if (ar_dim1)
delete ar_dim1;
1576 throw InternalErr(__FILE__, __LINE__,
"Unable to allocate the HDFEOS2GeoCF1D instance.");
1579 if (bt_dim0)
delete bt_dim0;
1580 if (bt_dim1)
delete bt_dim1;
1581 if (ar_dim0)
delete ar_dim0;
1582 if (ar_dim1)
delete ar_dim1;
1588void add_gm_spcvs_attrs(libdap::BaseType *var,
const bool is_dim0) {
1590 string standard_name;
1592 string COORAxisTypes;
1594 if (
true == is_dim0) {
1595 standard_name =
"projection_y_coordinate";
1596 long_name =
"y coordinate of projection ";
1597 COORAxisTypes =
"GeoY";
1600 standard_name =
"projection_x_coordinate";
1601 long_name =
"x coordinate of projection ";
1602 COORAxisTypes =
"GeoX";
1605 add_var_dap4_attr(var,
"standard_name", attr_str_c, standard_name);
1606 add_var_dap4_attr(var,
"long_name", attr_str_c, long_name);
1607 add_var_dap4_attr(var,
"units", attr_str_c,
"meter");
1608 add_var_dap4_attr(var,
"_CoordinateAxisType", attr_str_c, COORAxisTypes);
1613void add_grp_dap4_attr(D4Group *d4_grp,
const string& attr_name, D4AttributeType attr_type,
const string& attr_value){
1615 auto d4_attr =
new D4Attribute(attr_name,attr_type);
1616 d4_attr->add_value(attr_value);
1617 d4_grp->attributes()->add_attribute_nocopy(d4_attr);
1621void add_var_dap4_attr(BaseType *var,
const string& attr_name, D4AttributeType attr_type,
const string& attr_value){
1623 auto d4_attr =
new D4Attribute(attr_name,attr_type);
1624 d4_attr->add_value(attr_value);
1625 var->attributes()->add_attribute_nocopy(d4_attr);
1630void add_dap4_coverage(libdap::D4Group* d4_root,
const vector<string>& coord_var_names,
bool is_coard) {
1633 unordered_map<string, Array*> d4map_array_maps;
1636 vector<Array*> has_map_arrays;
1638 Constructor::Vars_iter vi = d4_root->var_begin();
1639 Constructor::Vars_iter ve = d4_root->var_end();
1641 for (; vi != ve; vi++) {
1646 if (libdap::dods_array_c == v->type()) {
1648 auto t_a =
static_cast<Array *
>(*vi);
1657 for (
auto it_cv = coord_var_names.begin(); it_cv !=coord_var_names.end();++it_cv) {
1658 if ((*it_cv) == v->name()) {
1660 d4map_array_maps.emplace(v->name(),t_a);
1666 if (is_cv ==
false) {
1667 has_map_arrays.emplace_back(t_a);
1674 for (
auto it_hm = has_map_arrays.begin(); it_hm != has_map_arrays.end(); ++it_hm) {
1676 Array::Dim_iter dim_i = (*it_hm)->dim_begin();
1677 Array::Dim_iter dim_e = (*it_hm)->dim_end();
1678 for (; dim_i != dim_e; dim_i++) {
1682 unordered_map<string, Array*>::const_iterator it_ma = d4map_array_maps.find(dim_i->name);
1683 if(it_ma != d4map_array_maps.end()) {
1684 auto d4_map =
new D4Map((it_ma->second)->FQN(), it_ma->second, *it_hm);
1685 (*it_hm)->maps()->add_map(d4_map);
1694 for (
auto it_hm = has_map_arrays.begin(); it_hm != has_map_arrays.end(); ++it_hm) {
1697 vector<string> coord_names;
1698 D4Attributes *d4_attrs = (*it_hm)->attributes();
1699 const D4Attribute *d4_attr = d4_attrs->find(
"coordinates");
1700 if (d4_attr !=
nullptr) {
1703 if(d4_attr->type() == attr_str_c && d4_attr->num_values() == 1) {
1704 string tempstring = d4_attr->value(0);
1706 HDF5CFUtil::Split_helper(coord_names,tempstring,sep);
1711 for(
auto it_c = coord_names.begin(); it_c != coord_names.end(); ++it_c) {
1713 unordered_map<string, Array*>::const_iterator it_ma = d4map_array_maps.find(*it_c);
1714 if(it_ma != d4map_array_maps.end()) {
1715 auto d4_map =
new D4Map((it_ma->second)->FQN(), it_ma->second, *it_hm);
1716 (*it_hm)->maps()->add_map(d4_map);
1727 for (
auto it_dm = d4map_array_maps.begin(); it_dm != d4map_array_maps.end(); ++it_dm)
1728 it_dm->second =
nullptr;
1738string get_cf_string(
string & s) {
1741 return get_cf_string_helper(s);
1745 return get_cf_string_helper(s);
1749string get_cf_string_helper(
string & s) {
1751 if (
"" == s)
return s;
1752 string insertString(1,
'_');
1755 if (
true == isdigit(s[0])) s.insert(0, insertString);
1757 for (
unsigned int i = 0; i < s.length(); i++)
1758 if ((
false == isalnum(s[i])) && (s[i] !=
'_')) s[i] =
'_';
This class includes the methods to read data array into DAP buffer from an HDF5 dataset for the CF op...
This class provides a way to map HDF5 byte to DAP byte for the CF option.
This class provides a way to map HDF5 float to DAP float for the CF option.
This class provides a way to map HDF5 64-bit floating-point(double) to DAP 64-bit floating-point for ...
This class provides a way to map HDF5 int16 to DAP int16 for the CF option.
This class provides a way to map HDF5 32-bit integer to DAP Int32 for the CF option.
This class provides a way to map HDF5 64-bit integer to DAP4 Int64 for the CF option.
This class provides a way to map HDF5 int8 to DAP int16 for the CF option.
This class provides a way to map HDF5 Str to DAP Str for the CF option.
This class provides a way to map HDF5 unsigned 16-bit integer to DAP uint16 for the CF option.
This class provides a way to map HDF5 unsigned 32-bit integer to DAP uint32 for the CF option.
This class provides a way to map HDF5 64-bit unsigned integer to DAP4 UInt64 for the CF option.
This file includes several helper functions for translating HDF5 to CF-compliant.
include the entry functions to execute the handlers
static string escattr(string s)
static D4AttributeType daptype_strrep_to_dap4_attrtype(const string &s)
This class represents one attribute.
This class represents one HDF5 dataset(CF variable)
float getCompRatio() const
Get the compression ratio of this dataset.
int getRank() const
Get the dimension rank of this variable.
const std::string & getFullPath() const
Get the full path of this variable.
const std::string & getName() const
Get the original name of this variable.
H5DataType getType() const
Get the data type of this variable(Not HDF5 datatype id)
const std::vector< Dimension * > & getDimensions() const
Get the list of the dimensions.
const std::string & getNewName() const
Get the new name of this variable.
Helper functions for generating DAS attributes and a function to check BES Key.
void gen_dap_str_attr(AttrTable *at, const HDF5CF::Attribute *attr)
Transfer string attributes to a DAP2 AttrTable.
Map and generate DDS and DAS for the CF option for generic HDF5 products.