Ignore:
Timestamp:
01/23/19 10:31:44 (5 years ago)
Author:
yushan
Message:

dev on ADA. add flag switch _usingEP/_usingMPI

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/branch_openmp/src/io/netCdfInterface.cpp

    r1555 r1642  
    2222int CNetCdfInterface::create(const StdString& fileName, int cMode, int& ncId) 
    2323{ 
    24   int status; 
    25   #pragma omp critical (_netcdf) 
    26   { 
    27     info(100)<<"start nc_create"<<std::endl; 
    28     status = nc_create(fileName.c_str(), cMode, &ncId); 
    29     info(100)<<"end nc_create"<<std::endl; 
    30   } 
     24  int status = nc_create(fileName.c_str(), cMode, &ncId); 
    3125  if (NC_NOERR != status) 
    3226  { 
    … …  
    5347\return Status code 
    5448*/ 
    55 int CNetCdfInterface::createPar(const StdString& fileName, int cMode, MPI_Comm comm, MPI_Info info, int& ncId) 
    56 { 
    57   int status = xios::nc_create_par(fileName.c_str(), cMode, comm, to_mpi_info(MPI_INFO_NULL), &ncId); 
    58  
     49int CNetCdfInterface::createPar(const StdString& fileName, int cMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId) 
     50{ 
     51  #ifdef _usingMPI 
     52  int status = xios::nc_create_par(fileName.c_str(), cMode, comm, info, &ncId); 
     53  #elif _usingEP 
     54  int status = xios::nc_create_par(fileName.c_str(), cMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId); 
     55  #endif 
    5956  if (NC_NOERR != status) 
    6057  { 
    … …  
    8178int CNetCdfInterface::open(const StdString& fileName, int oMode, int& ncId) 
    8279{ 
    83   int status; 
    84   #pragma omp critical (_netcdf) 
    85   { 
    86     info(100)<<"start nc_open"<<std::endl; 
    87     status = nc_open(fileName.c_str(), oMode, &ncId); 
    88     info(100)<<"end nc_open"<<std::endl; 
    89   } 
     80  int status = nc_open(fileName.c_str(), oMode, &ncId); 
    9081  if (NC_NOERR != status) 
    9182  { 
    … …  
    113104\return Status code 
    114105*/ 
    115 int CNetCdfInterface::openPar(const StdString& fileName, int oMode, MPI_Comm comm, MPI_Info info, int& ncId) 
    116 { 
    117   int status = xios::nc_open_par(fileName.c_str(), oMode, comm, to_mpi_info(MPI_INFO_NULL), &ncId); 
    118    
     106int CNetCdfInterface::openPar(const StdString& fileName, int oMode, ep_lib::MPI_Comm comm, ep_lib::MPI_Info info, int& ncId) 
     107{ 
     108  #ifdef _usingMPI 
     109  int status = xios::nc_open_par(fileName.c_str(), oMode, comm, info, &ncId); 
     110  #elif _usingEP 
     111  int status = xios::nc_open_par(fileName.c_str(), oMode, to_mpi_comm(comm->mpi_comm), to_mpi_info(info), &ncId); 
     112  #endif 
    119113  if (NC_NOERR != status) 
    120114  { 
    … …  
    139133int CNetCdfInterface::close(int ncId) 
    140134{ 
    141   int status = NC_NOERR; 
    142   #pragma omp critical (_netcdf) 
    143   { 
    144     info(100)<<"start nc_close"<<std::endl; 
    145     status = nc_close(ncId); 
    146     info(100)<<"end nc_close"<<std::endl; 
    147   } 
    148        
     135  int status = nc_close(ncId); 
    149136  if (NC_NOERR != status) 
    150137  { 
    … …  
    168155int CNetCdfInterface::reDef(int ncId) 
    169156{ 
    170   int status; 
    171   #pragma omp critical (_netcdf) 
    172   { 
    173     info(100)<<"start nc_reDef"<<std::endl; 
    174     status = nc_redef(ncId); 
    175     info(100)<<"end nc_reDef"<<std::endl; 
    176   } 
    177    
     157  int status = nc_redef(ncId); 
    178158  if (NC_NOERR != status) 
    179159  { 
    … …  
    197177int CNetCdfInterface::endDef(int ncId) 
    198178{ 
    199   int status; 
    200   #pragma omp critical (_netcdf) 
    201   { 
    202     info(100)<<"start nc_enddef"<<std::endl; 
    203     status = nc_enddef(ncId); 
    204     info(100)<<"end nc_enddef"<<std::endl; 
    205   } 
     179  int status = nc_enddef(ncId); 
    206180  if (NC_NOERR != status) 
    207181  { 
    … …  
    228202int CNetCdfInterface::inqNcId(int ncid, const StdString& grpName, int& grpId) 
    229203{ 
    230   int status; 
    231   #pragma omp critical (_netcdf) 
    232   { 
    233     info(100)<<"start nc_inq_ncid"<<std::endl; 
    234     status = nc_inq_ncid(ncid, grpName.c_str(), &grpId); 
    235     info(100)<<"end nc_inq_ncid"<<std::endl; 
    236   } 
    237    
     204  int status = nc_inq_ncid(ncid, grpName.c_str(), &grpId); 
    238205  if (NC_NOERR != status) 
    239206  { 
    … …  
    261228int CNetCdfInterface::inqVarId(int ncid, const StdString& varName, int& varId) 
    262229{ 
    263   int status; 
    264   #pragma omp critical (_netcdf) 
    265   { 
    266     info(100)<<"start nc_inq_varid"<<std::endl; 
    267     status = nc_inq_varid(ncid, varName.c_str(), &varId); 
    268     info(100)<<"end nc_inq_varid"<<std::endl; 
    269   } 
     230  int status = nc_inq_varid(ncid, varName.c_str(), &varId); 
    270231  if (NC_NOERR != status) 
    271232  { 
    … …  
    292253int CNetCdfInterface::inqDimId(int ncid, const StdString& dimName, int& dimId) 
    293254{ 
    294   int status; 
    295   #pragma omp critical (_netcdf) 
    296   { 
    297     info(100)<<"start nc_inq_dimid"<<std::endl; 
    298     status = nc_inq_dimid(ncid, dimName.c_str(), &dimId); 
    299     info(100)<<"end nc_inq_dimid"<<std::endl; 
    300   } 
    301    
     255  int status = nc_inq_dimid(ncid, dimName.c_str(), &dimId); 
    302256  if (NC_NOERR != status) 
    303257  { 
    … …  
    325279{ 
    326280  char varNameBuff[NC_MAX_NAME + 1]; 
    327   int status; 
    328   #pragma omp critical (_netcdf) 
    329   { 
    330     info(100)<<"start nc_inq_varname"<<std::endl; 
    331     status = nc_inq_varname(ncid, varId, varNameBuff); 
    332     info(100)<<"end nc_inq_varname"<<std::endl; 
    333   } 
     281  int status = nc_inq_varname(ncid, varId, varNameBuff); 
    334282  if (NC_NOERR != status) 
    335283  { 
    … …  
    355303int CNetCdfInterface::inqUnLimDim(int ncid, int& dimId) 
    356304{ 
    357   int status; 
    358   #pragma omp critical (_netcdf) 
    359   { 
    360     info(100)<<"start nc_inq_unlimdim"<<std::endl; 
    361     status = nc_inq_unlimdim(ncid, &dimId); 
    362     info(100)<<"end nc_inq_unlimdim"<<std::endl; 
    363   } 
     305  int status = nc_inq_unlimdim(ncid, &dimId); 
    364306  if (NC_NOERR != status) 
    365307  { 
    … …  
    387329{ 
    388330  char fullNameIn[NC_MAX_NAME + 1]; 
    389   int status; 
    390   #pragma omp critical (_netcdf) 
    391   { 
    392     info(100)<<"start nc_inq_dimname"<<std::endl; 
    393     status = nc_inq_dimname(ncid, dimId, fullNameIn); 
    394     info(100)<<"end nc_inq_dimname"<<std::endl; 
    395   } 
     331  int status = nc_inq_dimname(ncid, dimId, fullNameIn); 
    396332  if (NC_NOERR != status) 
    397333  { 
    … …  
    418354int CNetCdfInterface::inqDimLen(int ncid, int dimId, StdSize& dimLen) 
    419355{ 
    420   int status; 
    421   #pragma omp critical (_netcdf) 
    422   { 
    423     info(100)<<"start nc_inq_dimlen"<<std::endl; 
    424     status = nc_inq_dimlen(ncid, dimId, &dimLen); 
    425     info(100)<<"end nc_inq_dimlen"<<std::endl; 
    426   } 
     356  int status = nc_inq_dimlen(ncid, dimId, &dimLen); 
    427357  if (NC_NOERR != status) 
    428358  { 
    … …  
    449379int CNetCdfInterface::inqVarNDims(int ncid, int varId, int& nDims) 
    450380{ 
    451   int status; 
    452   #pragma omp critical (_netcdf) 
    453   { 
    454     info(100)<<"start nc_inq_varndims"<<std::endl; 
    455     status = nc_inq_varndims(ncid, varId, &nDims); 
    456     info(100)<<"end nc_inq_varndims"<<std::endl; 
    457   } 
     381  int status = nc_inq_varndims(ncid, varId, &nDims); 
    458382  if (NC_NOERR != status) 
    459383  { 
    … …  
    480404int CNetCdfInterface::inqVarDimId(int ncid, int varId, int* dimIds) 
    481405{ 
    482   int status; 
    483   #pragma omp critical (_netcdf) 
    484   { 
    485     info(100)<<"start nc_inq_vardimid"<<std::endl; 
    486     status = nc_inq_vardimid(ncid, varId, dimIds); 
    487     info(100)<<"end nc_inq_vardimid"<<std::endl; 
    488   } 
     406  int status = nc_inq_vardimid(ncid, varId, dimIds); 
    489407  if (NC_NOERR != status) 
    490408  { 
    … …  
    512430int CNetCdfInterface::inqDimIds(int ncid, int& nDims, int* dimIds, int includeParents) 
    513431{ 
    514   int status; 
    515   #pragma omp critical (_netcdf) 
    516   { 
    517     info(100)<<"start nc_inq_dimids"<<std::endl; 
    518     status = nc_inq_dimids(ncid, &nDims, dimIds, includeParents); 
    519     info(100)<<"end nc_inq_dimids"<<std::endl; 
    520   } 
     432  int status = nc_inq_dimids(ncid, &nDims, dimIds, includeParents); 
    521433  if (NC_NOERR != status) 
    522434  { 
    … …  
    545457  StdSize strlen = 0; 
    546458  std::vector<char> buff; 
    547   int status; 
    548   #pragma omp critical (_netcdf) 
    549   { 
    550     info(100)<<"start nc_inq_grpname_full"<<std::endl; 
    551     status = nc_inq_grpname_full(ncid, &strlen, NULL); 
    552     info(100)<<"end nc_inq_grpname_full"<<std::endl; 
    553    
    554     if (NC_NOERR == status) 
    555     { 
    556       buff.resize(strlen + 1); 
    557       status = nc_inq_grpname_full(ncid, NULL, &buff[0]); 
    558     } 
    559     info(100)<<"start nc_inq_grpname_full"<<std::endl; 
    560   } 
     459  int status = nc_inq_grpname_full(ncid, &strlen, NULL); 
     460  if (NC_NOERR == status) 
     461  { 
     462    buff.resize(strlen + 1); 
     463    status = nc_inq_grpname_full(ncid, NULL, &buff[0]); 
     464  } 
     465 
    561466  if (NC_NOERR != status) 
    562467  { 
    … …  
    585490int CNetCdfInterface::inqGrpIds(int ncid, int& numgrps, int* ncids) 
    586491{ 
    587   int status; 
    588   #pragma omp critical (_netcdf) 
    589   { 
    590     info(100)<<"start nc_inq_grps"<<std::endl; 
    591     status = nc_inq_grps(ncid, &numgrps, ncids); 
    592     info(100)<<"end nc_inq_grps"<<std::endl; 
    593   } 
     492  int status = nc_inq_grps(ncid, &numgrps, ncids); 
    594493  if (NC_NOERR != status) 
    595494  { 
    … …  
    616515int CNetCdfInterface::inqVarIds(int ncid, int& nvars, int* varids) 
    617516{ 
    618   int status; 
    619   #pragma omp critical (_netcdf) 
    620   { 
    621     info(100)<<"start nc_inq_varids"<<std::endl; 
    622     status = nc_inq_varids(ncid, &nvars, varids); 
    623     info(100)<<"end nc_inq_varids"<<std::endl; 
    624   } 
     517  int status = nc_inq_varids(ncid, &nvars, varids); 
    625518  if (NC_NOERR != status) 
    626519  { 
    … …  
    649542int CNetCdfInterface::inqAtt(int ncid, int varid, const StdString& name, nc_type& type, size_t& len) 
    650543{ 
    651   int status; 
    652   #pragma omp critical (_netcdf) 
    653   { 
    654     info(100)<<"start nc_inq_att"<<std::endl; 
    655     status = nc_inq_att(ncid, varid, name.c_str(), &type, &len); 
    656     info(100)<<"end nc_inq_att"<<std::endl; 
    657   } 
    658    
     544  int status = nc_inq_att(ncid, varid, name.c_str(), &type, &len); 
    659545  if (NC_NOERR != status) 
    660546  { 
    … …  
    680566int CNetCdfInterface::inqNAtts(int ncid, int& ngatts) 
    681567{ 
    682   int status; 
    683   #pragma omp critical (_netcdf) 
    684   { 
    685     info(100)<<"start nc_inq_natts"<<std::endl; 
    686     status = nc_inq_natts(ncid, &ngatts); 
    687     info(100)<<"end nc_inq_natts"<<std::endl; 
    688   } 
     568  int status = nc_inq_natts(ncid, &ngatts); 
    689569  if (NC_NOERR != status) 
    690570  { 
    … …  
    711591int CNetCdfInterface::inqVarNAtts(int ncid, int varid, int& natts) 
    712592{ 
    713   int status; 
    714   #pragma omp critical (_netcdf) 
    715   { 
    716     info(100)<<"start nc_inq_varnatts"<<std::endl; 
    717     status = nc_inq_varnatts(ncid, varid, &natts); 
    718     info(100)<<"end nc_inq_varnatts"<<std::endl; 
    719   } 
     593  int status = nc_inq_varnatts(ncid, varid, &natts); 
    720594  if (NC_NOERR != status) 
    721595  { 
    … …  
    738612{ 
    739613  std::vector<char> attName(NC_MAX_NAME + 1,' '); 
    740   int status; 
    741   #pragma omp critical (_netcdf) 
    742   { 
    743     info(100)<<"start nc_inq_attname"<<std::endl; 
    744     status = nc_inq_attname(ncid, varid, attnum, &attName[0]); 
    745     info(100)<<"end nc_inq_attname"<<std::endl; 
    746   } 
     614  int status = nc_inq_attname(ncid, varid, attnum, &attName[0]); 
    747615  if (NC_NOERR != status) 
    748616  { 
    … …  
    775643int CNetCdfInterface::defGrp(int parentNcid, const StdString& grpName, int& grpId) 
    776644{ 
    777   int status; 
    778   #pragma omp critical (_netcdf) 
    779   { 
    780     info(100)<<"start nc_def_grp"<<std::endl; 
    781     status = nc_def_grp(parentNcid, grpName.c_str(), &grpId); 
    782     info(100)<<"end nc_def_grp"<<std::endl; 
    783   } 
     645  int status = nc_def_grp(parentNcid, grpName.c_str(), &grpId); 
    784646  if (NC_NOERR != status) 
    785647  { 
    … …  
    806668int CNetCdfInterface::defDim(int ncid, const StdString& dimName, StdSize dimLen, int& dimId) 
    807669{ 
    808   int status; 
    809   #pragma omp critical (_netcdf) 
    810   { 
    811     info(100)<<"start nc_def_dim"<<std::endl; 
    812     status = nc_def_dim(ncid, dimName.c_str(), dimLen, &dimId); 
    813     info(100)<<"end nc_def_dim"<<std::endl; 
    814   } 
     670  int status = nc_def_dim(ncid, dimName.c_str(), dimLen, &dimId); 
    815671  if (NC_NOERR != status) 
    816672  { 
    … …  
    843699                             int nDims, const int dimIds[], int& varId) 
    844700{ 
    845   int status; 
    846   #pragma omp critical (_netcdf) 
    847   { 
    848     info(100)<<"start nc_def_var"<<std::endl; 
    849     status = nc_def_var(ncid, varName.c_str(), xtype, nDims, dimIds, &varId); 
    850     info(100)<<"end nc_def_var"<<std::endl; 
    851   } 
     701  int status = nc_def_var(ncid, varName.c_str(), xtype, nDims, dimIds, &varId); 
    852702  if (NC_NOERR != status) 
    853703  { 
    … …  
    878728int CNetCdfInterface::defVarChunking(int ncid, int varId, int storage, StdSize chunkSize[]) 
    879729{ 
    880   int status; 
    881   #pragma omp critical (_netcdf) 
    882   { 
    883     info(100)<<"start nc_def_var_chunking"<<std::endl; 
    884     status = nc_def_var_chunking(ncid, varId, storage, chunkSize); 
    885     info(100)<<"end nc_def_var_chunking"<<std::endl; 
    886   } 
     730  int status = nc_def_var_chunking(ncid, varId, storage, chunkSize); 
    887731  if (NC_NOERR != status) 
    888732  { 
    … …  
    912756   
    913757  if (compressionLevel == 0) return NC_NOERR ; 
    914   int status; 
    915   #pragma omp critical (_netcdf) 
    916   { 
    917     info(100)<<"start nc_def_var_deflate"<<std::endl; 
    918     status = nc_def_var_deflate(ncid, varId, (compressionLevel > 0), (compressionLevel > 0), compressionLevel); 
    919     info(100)<<"end nc_def_var_deflate"<<std::endl; 
    920   } 
     758  int status = nc_def_var_deflate(ncid, varId, (compressionLevel > 0), (compressionLevel > 0), compressionLevel); 
    921759  if (NC_NOERR != status) 
    922760  { 
    … …  
    944782{ 
    945783  int old_fill_mode; 
    946   int status; 
    947   #pragma omp critical (_netcdf) 
    948   { 
    949     info(100)<<"start nc_set_fill"<<std::endl; 
    950     status = nc_set_fill(ncid, fill ? NC_FILL: NC_NOFILL, &old_fill_mode); 
    951     info(100)<<"end nc_set_fill"<<std::endl; 
    952   } 
     784  int status = nc_set_fill(ncid, fill ? NC_FILL: NC_NOFILL, &old_fill_mode); 
    953785  if (NC_NOERR != status) 
    954786  { 
    … …  
    977809int CNetCdfInterface::defVarFill(int ncid, int varId, int noFill, void* fillValue) 
    978810{ 
    979   int status; 
    980   #pragma omp critical (_netcdf) 
    981   { 
    982     info(100)<<"start nc_def_var_fill"<<std::endl; 
    983     status = nc_def_var_fill(ncid, varId, noFill, fillValue); 
    984     info(100)<<"end nc_def_var_fill"<<std::endl; 
    985   } 
     811  int status = nc_def_var_fill(ncid, varId, noFill, fillValue); 
    986812  if (NC_NOERR != status) 
    987813  { 
    … …  
    1011837int CNetCdfInterface::varParAccess(int ncid, int varId, int access) 
    1012838{ 
    1013   int status; 
    1014   #pragma omp critical (_netcdf) 
    1015   { 
    1016     info(100)<<"start nc_var_par_access"<<std::endl; 
    1017     status = nc_var_par_access(ncid, varId, access); 
    1018     info(100)<<"end nc_var_par_access"<<std::endl; 
    1019   } 
     839  int status = nc_var_par_access(ncid, varId, access); 
    1020840  if (NC_NOERR != status) 
    1021841  { 
    … …  
    1040860int CNetCdfInterface::sync(int ncid) 
    1041861{ 
    1042   int status; 
    1043   #pragma omp critical (_netcdf) 
    1044   { 
    1045     info(100)<<"start nc_sync"<<std::endl; 
    1046     status = nc_sync(ncid); 
    1047     info(100)<<"end nc_sync"<<std::endl; 
    1048   } 
     862  int status = nc_sync(ncid); 
    1049863  if (NC_NOERR != status) 
    1050864  { 
    … …  
    1066880int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, double* data) 
    1067881{ 
    1068   int status; 
    1069   #pragma omp critical (_netcdf) 
    1070   { 
    1071     info(100)<<"start nc_get_att_double"<<std::endl; 
    1072     status = nc_get_att_double(ncid, varid, attrName, data); 
    1073     info(100)<<"end nc_get_att_double"<<std::endl; 
    1074   } 
    1075   return status; 
     882  return nc_get_att_double(ncid, varid, attrName, data); 
    1076883} 
    1077884 
    … …  
    1079886int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, float* data) 
    1080887{ 
    1081   int status; 
    1082   #pragma omp critical (_netcdf) 
    1083   { 
    1084     info(100)<<"start nc_get_att_float"<<std::endl; 
    1085     status = nc_get_att_float(ncid, varid, attrName, data); 
    1086     info(100)<<"end nc_get_att_float"<<std::endl; 
    1087   } 
    1088   return status; 
     888  return nc_get_att_float(ncid, varid, attrName, data); 
    1089889} 
    1090890 
    … …  
    1092892int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, int* data) 
    1093893{ 
    1094   int status; 
    1095   #pragma omp critical (_netcdf) 
    1096   { 
    1097     info(100)<<"start nc_get_att_int"<<std::endl; 
    1098     status = nc_get_att_int(ncid, varid, attrName, data); 
    1099     info(100)<<"end nc_get_att_int"<<std::endl; 
    1100   } 
    1101   return status;  
     894  return nc_get_att_int(ncid, varid, attrName, data); 
    1102895} 
    1103896 
    … …  
    1105898int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, long* data) 
    1106899{ 
    1107   int status; 
    1108   #pragma omp critical (_netcdf) 
    1109   { 
    1110     info(100)<<"start nc_get_att_long"<<std::endl; 
    1111     status = nc_get_att_long(ncid, varid, attrName, data); 
    1112     info(100)<<"end nc_get_att_long"<<std::endl; 
    1113   } 
    1114   return status; 
     900  return nc_get_att_long(ncid, varid, attrName, data); 
    1115901} 
    1116902 
    … …  
    1118904int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, short* data) 
    1119905{ 
    1120   int status; 
    1121   #pragma omp critical (_netcdf) 
    1122   { 
    1123     info(100)<<"start nc_get_att_short"<<std::endl; 
    1124     status = nc_get_att_short(ncid, varid, attrName, data); 
    1125     info(100)<<"end nc_get_att_short"<<std::endl; 
    1126   } 
    1127   return status; 
     906  return nc_get_att_short(ncid, varid, attrName, data); 
    1128907} 
    1129908 
    … …  
    1131910int CNetCdfInterface::ncGetAttType(int ncid, int varid, const char* attrName, char* data) 
    1132911{ 
    1133   int status; 
    1134   #pragma omp critical (_netcdf) 
    1135   { 
    1136     info(100)<<"start nc_get_att_text"<<std::endl; 
    1137     status = nc_get_att_text(ncid, varid, attrName, data); 
    1138     info(100)<<"end nc_get_att_text"<<std::endl; 
    1139   } 
    1140   return status; 
     912  return nc_get_att_text(ncid, varid, attrName, data); 
    1141913} 
    1142914 
    … …  
    1146918                                   StdSize numVal, const double* data) 
    1147919{ 
    1148   int status; 
    1149   #pragma omp critical (_netcdf) 
    1150   { 
    1151     info(100)<<"start nc_put_att_double"<<std::endl; 
    1152     status = nc_put_att_double(ncid, varid, attrName, NC_DOUBLE, numVal, data); 
    1153     info(100)<<"end nc_put_att_double"<<std::endl; 
    1154   } 
    1155   return status; 
     920  return nc_put_att_double(ncid, varid, attrName, NC_DOUBLE, numVal, data); 
    1156921} 
    1157922 
    … …  
    1160925                                   StdSize numVal, const float* data) 
    1161926{ 
    1162   int status; 
    1163   #pragma omp critical (_netcdf) 
    1164   { 
    1165     info(100)<<"start nc_put_att_float"<<std::endl; 
    1166     status = nc_put_att_float(ncid, varid, attrName, NC_FLOAT, numVal, data); 
    1167     info(100)<<"end nc_put_att_float"<<std::endl; 
    1168   } 
    1169   return status; 
     927  return nc_put_att_float(ncid, varid, attrName, NC_FLOAT, numVal, data); 
    1170928} 
    1171929 
    … …  
    1174932                                   StdSize numVal, const int* data) 
    1175933{ 
    1176   int status; 
    1177   #pragma omp critical (_netcdf) 
    1178   { 
    1179     info(100)<<"start nc_put_att_int"<<std::endl; 
    1180     status = nc_put_att_int(ncid, varid, attrName, NC_INT, numVal, data); 
    1181     info(100)<<"end nc_put_att_int"<<std::endl; 
    1182   } 
    1183   return status; 
     934  return nc_put_att_int(ncid, varid, attrName, NC_INT, numVal, data); 
    1184935} 
    1185936 
    … …  
    1188939                                   StdSize numVal, const long* data) 
    1189940{ 
    1190   int status; 
    1191   #pragma omp critical (_netcdf) 
    1192   { 
    1193     info(100)<<"start nc_put_att_long"<<std::endl; 
    1194     status = nc_put_att_long(ncid, varid, attrName, NC_LONG, numVal, data); 
    1195     info(100)<<"end nc_put_att_long"<<std::endl; 
    1196   } 
    1197   return status; 
     941  return nc_put_att_long(ncid, varid, attrName, NC_LONG, numVal, data); 
    1198942} 
    1199943 
    … …  
    1202946                                   StdSize numVal, const short* data) 
    1203947{ 
    1204   int status; 
    1205   #pragma omp critical (_netcdf) 
    1206   { 
    1207     info(100)<<"start nc_put_att_short"<<std::endl; 
    1208     status = nc_put_att_short(ncid, varid, attrName, NC_SHORT, numVal, data); 
    1209     info(100)<<"end nc_put_att_short"<<std::endl; 
    1210   } 
    1211   return status; 
     948  return nc_put_att_short(ncid, varid, attrName, NC_SHORT, numVal, data); 
    1212949} 
    1213950 
    … …  
    1216953                                   StdSize numVal, const char* data) 
    1217954{ 
    1218   int status; 
    1219   #pragma omp critical (_netcdf) 
    1220   { 
    1221     info(100)<<"start nc_put_att_text"<<std::endl; 
    1222     status = nc_put_att_text(ncid, varid, attrName, numVal, data); 
    1223     info(100)<<"end nc_put_att_text"<<std::endl; 
    1224   } 
    1225   return status; 
     955  return nc_put_att_text(ncid, varid, attrName, numVal, data); 
    1226956} 
    1227957 
    … …  
    1230960int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, double* data) 
    1231961{ 
    1232   int status; 
    1233   #pragma omp critical (_netcdf) 
    1234   { 
    1235     info(100)<<"start nc_get_vara_double"<<std::endl; 
    1236     status = nc_get_vara_double(ncid, varid, start, count, data); 
    1237     info(100)<<"end nc_get_vara_double"<<std::endl; 
    1238   } 
    1239   return status; 
     962  return nc_get_vara_double(ncid, varid, start, count, data); 
    1240963} 
    1241964 
    … …  
    1243966int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, float* data) 
    1244967{ 
    1245   int status; 
    1246   #pragma omp critical (_netcdf) 
    1247   { 
    1248     info(100)<<"start nc_get_vara_float"<<std::endl; 
    1249     status = nc_get_vara_float(ncid, varid, start, count, data); 
    1250     info(100)<<"end nc_get_vara_float"<<std::endl; 
    1251   } 
    1252   return status;  
     968  return nc_get_vara_float(ncid, varid, start, count, data); 
    1253969} 
    1254970 
    … …  
    1256972int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, int* data) 
    1257973{ 
    1258   int status; 
    1259   #pragma omp critical (_netcdf) 
    1260   { 
    1261     info(100)<<"start nc_get_vara_int"<<std::endl; 
    1262     status = nc_get_vara_int(ncid, varid, start, count, data); 
    1263     info(100)<<"end nc_get_vara_int"<<std::endl; 
    1264   } 
    1265   return status;  
     974  return nc_get_vara_int(ncid, varid, start, count, data); 
    1266975} 
    1267976 
    … …  
    1269978int CNetCdfInterface::ncGetVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, char* data) 
    1270979{ 
    1271   int status; 
    1272   #pragma omp critical (_netcdf) 
    1273   { 
    1274     info(100)<<"start nc_get_vara_text"<<std::endl; 
    1275     status = nc_get_vara_text(ncid, varid, start, count, data); 
    1276     info(100)<<"end nc_get_vara_text"<<std::endl; 
    1277   } 
    1278   return status; 
     980  return nc_get_vara_text(ncid, varid, start, count, data); 
    1279981} 
    1280982 
    … …  
    1283985int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const double* data) 
    1284986{ 
    1285   int status; 
    1286   #pragma omp critical (_netcdf) 
    1287   { 
    1288     info(100)<<"start nc_put_vara_double"<<std::endl; 
    1289     status = nc_put_vara_double(ncid, varid, start, count, data); 
    1290     info(100)<<"end nc_put_vara_double"<<std::endl; 
    1291   } 
    1292   return status; 
     987  return nc_put_vara_double(ncid, varid, start, count, data); 
    1293988} 
    1294989 
    … …  
    1296991int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const float* data) 
    1297992{ 
    1298   int status; 
    1299   #pragma omp critical (_netcdf) 
    1300   { 
    1301     info(100)<<"start nc_put_vara_float"<<std::endl; 
    1302     status = nc_put_vara_float(ncid, varid, start, count, data); 
    1303     info(100)<<"end nc_put_vara_float"<<std::endl; 
    1304   } 
    1305   return status; 
     993  return nc_put_vara_float(ncid, varid, start, count, data); 
    1306994} 
    1307995 
    … …  
    1309997int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const int* data) 
    1310998{ 
    1311   int status; 
    1312   #pragma omp critical (_netcdf) 
    1313   { 
    1314     info(100)<<"start nc_put_vara_int"<<std::endl; 
    1315     status = nc_put_vara_int(ncid, varid, start, count, data); 
    1316     info(100)<<"end nc_put_vara_int"<<std::endl; 
    1317   } 
    1318   return status; 
     999  return nc_put_vara_int(ncid, varid, start, count, data); 
    13191000} 
    13201001 
    … …  
    13221003int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const char* data) 
    13231004{ 
    1324   int status; 
    1325   #pragma omp critical (_netcdf) 
    1326   { 
    1327     info(100)<<"start nc_put_vara_text"<<std::endl; 
    1328     status = nc_put_vara_text(ncid, varid, start, count, data); 
    1329     info(100)<<"end nc_put_vara_text"<<std::endl; 
    1330   } 
    1331   return status; 
     1005  return nc_put_vara_text(ncid, varid, start, count, data); 
    13321006} 
    13331007 
    … …  
    13421016{ 
    13431017   int varId = 0; 
    1344    int status; 
    1345    #pragma omp critical (_netcdf) 
    1346    { 
    1347      info(100)<<"start isVarExisted"<<std::endl; 
    1348      status = nc_inq_varid(ncId, varName.c_str(), &varId); 
    1349      info(100)<<"end isVarExisted"<<std::endl; 
    1350    } 
    1351    return (NC_NOERR == status); 
     1018   return (NC_NOERR == (nc_inq_varid(ncId, varName.c_str(), &varId))); 
    13521019} 
    13531020 
    … …  
    13551022{ 
    13561023   int dimId = 0; 
    1357    int status; 
    1358    #pragma omp critical (_netcdf) 
    1359    { 
    1360      info(100)<<"start isDimExisted"<<std::endl; 
    1361      status = nc_inq_dimid(ncId, dimName.c_str(), &dimId); 
    1362      info(100)<<"end isDimExisted"<<std::endl; 
    1363    } 
    1364    return (NC_NOERR == status); 
     1024   return (NC_NOERR == (nc_inq_dimid(ncId, dimName.c_str(), &dimId))); 
    13651025} 
    13661026 
Note: See TracChangeset for help on using the changeset viewer.