Ignore:
Timestamp:
07/05/16 15:59:02 (8 years ago)
Author:
mhnguyen
Message:

Adding a new type of element into grid: Scalar

+) Add a new node Scalar for xml
+) Make some change on writing scalar value
+) Reorganize some codes
+) Remove some redundant codes

Test
+) On Curie
+) All tests pass

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/io/nc4_data_output.cpp

    r881 r887  
    10141014     } 
    10151015 
     1016      void CNc4DataOutput::writeScalar_(CScalar* scalar) 
     1017      { 
     1018        if (scalar->IsWritten(this->filename)) return; 
     1019        scalar->checkAttributes(); 
     1020        int scalarSize = 1; 
     1021 
     1022        StdString scalaId = scalar->getScalarOutputName(); 
     1023        if (isWrittenAxis(scalaId)) return ; 
     1024        else setWrittenAxis(scalaId); 
     1025 
     1026        try 
     1027        { 
     1028          if (!scalar->value.isEmpty()) 
     1029          { 
     1030//            dims.push_back(scalaId); 
     1031            std::vector<StdString> dims; 
     1032            SuperClassWriter::addVariable(scalaId, NC_FLOAT, dims); 
     1033 
     1034            if (!scalar->name.isEmpty()) 
     1035              SuperClassWriter::addAttribute("name", scalar->name.getValue(), &scalaId); 
     1036 
     1037            if (!scalar->standard_name.isEmpty()) 
     1038              SuperClassWriter::addAttribute("standard_name", scalar->standard_name.getValue(), &scalaId); 
     1039 
     1040            if (!scalar->long_name.isEmpty()) 
     1041              SuperClassWriter::addAttribute("long_name", scalar->long_name.getValue(), &scalaId); 
     1042 
     1043            if (!scalar->unit.isEmpty()) 
     1044              SuperClassWriter::addAttribute("units", scalar->unit.getValue(), &scalaId); 
     1045 
     1046            SuperClassWriter::definition_end(); 
     1047 
     1048            switch (SuperClass::type) 
     1049            { 
     1050              case MULTI_FILE: 
     1051              { 
     1052                CArray<double,1> scalarValue(scalarSize); 
     1053                scalarValue(0) = scalar->value; 
     1054                SuperClassWriter::writeData(scalarValue, scalaId, isCollective, 0); 
     1055                SuperClassWriter::definition_start(); 
     1056 
     1057                break; 
     1058              } 
     1059              case ONE_FILE: 
     1060              { 
     1061                CArray<double,1> scalarValue(scalarSize); 
     1062                scalarValue(0) = scalar->value; 
     1063 
     1064                std::vector<StdSize> start(1); 
     1065                std::vector<StdSize> count(1); 
     1066                start[0] = 0; 
     1067                count[0] = 1; 
     1068                SuperClassWriter::writeData(scalarValue, scalaId, isCollective, 0, &start, &count); 
     1069                SuperClassWriter::definition_start(); 
     1070 
     1071                break; 
     1072              } 
     1073              default : 
     1074                ERROR("CNc4DataOutput::writeAxis_(CAxis* scalar)", 
     1075                      << "[ type = " << SuperClass::type << "]" 
     1076                      << " not implemented yet !"); 
     1077            } 
     1078          } 
     1079        } 
     1080        catch (CNetCdfException& e) 
     1081        { 
     1082          StdString msg("On writing the scalar : "); 
     1083          msg.append(scalaId); msg.append("\n"); 
     1084          msg.append("In the context : "); 
     1085          CContext* context = CContext::getCurrent() ; 
     1086          msg.append(context->getId()); msg.append("\n"); 
     1087          msg.append(e.what()); 
     1088          ERROR("CNc4DataOutput::writeScalar_(CScalar* scalar)", << msg); 
     1089        } 
     1090        scalar->addRelFile(this->filename); 
     1091     } 
     1092 
    10161093     //-------------------------------------------------------------- 
    10171094 
    … …  
    10221099       try 
    10231100       { 
    1024          CArray<bool,1> axisDomainOrder = grid->axis_domain_order; 
     1101         CArray<int,1> axisDomainOrder = grid->axis_domain_order; 
    10251102         std::vector<StdString> domainList = grid->getDomainList(); 
    10261103         std::vector<StdString> axisList   = grid->getAxisList(); 
    1027          int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0; 
     1104         std::vector<StdString> scalarList = grid->getScalarList(); 
     1105         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0, idxScalar = 0; 
    10281106 
    10291107         std::vector<StdString> dims; 
    … …  
    10421120           for (int i = numElement - 1; i >= 0; --i) 
    10431121           { 
    1044              if (axisDomainOrder(i)) 
     1122             if (2 == axisDomainOrder(i)) 
    10451123             { 
    10461124               CDomain* domain = CDomain::get(domainList[domainList.size() - idxDomain - 1]); 
    … …  
    10621140               ++idxDomain; 
    10631141             } 
    1064              else 
     1142             else if (1 == axisDomainOrder(i)) 
    10651143             { 
    10661144               CAxis* axis = CAxis::get(axisList[axisList.size() - idxAxis - 1]); 
    10671145               compress << axis->getAxisOutputName(); 
    10681146               ++idxAxis; 
     1147             } 
     1148             else 
     1149             { 
     1150               CScalar* scalar = CScalar::get(scalarList[scalarList.size() - idxScalar - 1]); 
     1151               compress << scalar->getScalarOutputName(); 
     1152               ++idxScalar; 
    10691153             } 
    10701154 
    … …  
    11151199             int firstGlobalIndex; 
    11161200 
    1117              if (axisDomainOrder(i)) 
     1201             if (2 == axisDomainOrder(i)) 
    11181202             { 
    11191203               CDomain* domain = CDomain::get(domainList[idxDomain]); 
    … …  
    11541238               ++idxDomain; 
    11551239             } 
    1156              else 
     1240             else if (1 == axisDomainOrder(i)) 
    11571241             { 
    11581242               CAxis* axis = CAxis::get(axisList[idxAxis]); 
    … …  
    11811265               setWrittenCompressedAxis(axisId); 
    11821266               ++idxAxis; 
     1267             } 
     1268             else 
     1269             { 
    11831270             } 
    11841271 
    … …  
    12631350          if (SuperClass::type==MULTI_FILE) return ; 
    12641351 
    1265          CArray<bool,1> axisDomainOrder = grid->axis_domain_order; 
    1266          int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0; 
     1352         CArray<int,1> axisDomainOrder = grid->axis_domain_order; 
     1353         int numElement = axisDomainOrder.numElements(), idxDomain = 0, idxAxis = 0, idxScalar = 0; 
    12671354         std::vector<StdString> domainList = grid->getDomainList(); 
    12681355         std::vector<StdString> axisList   = grid->getAxisList(); 
     1356         std::vector<StdString> scalarList = grid->getScalarList(); 
    12691357 
    12701358         StdString timeid  = getTimeCounterName(); 
    … …  
    12771365         for (int i = 0; i < numElement; ++i) 
    12781366         { 
    1279            if (axisDomainOrder(i)) 
     1367           if (2 == axisDomainOrder(i)) 
    12801368           { 
    12811369             CDomain* domain = CDomain::get(domainList[idxDomain]); 
    … …  
    13551443             ++idxDomain; 
    13561444           } 
    1357            else 
     1445           else if (1 == axisDomainOrder(i)) 
    13581446           { 
    13591447             CAxis* axis = CAxis::get(axisList[idxAxis]); 
    … …  
    13701458             dimCoordList.push_back(axisId); 
    13711459             ++idxAxis; 
     1460           } 
     1461           else // scalar 
     1462           { 
     1463             /* Do nothing here */ 
    13721464           } 
    13731465         } 
    … …  
    13821474*/ 
    13831475         StdString fieldid = field->getFieldOutputName(); 
    1384  
    1385 //         unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue(); 
    1386 //         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize); 
    1387 //          bool isCurvilinear = domain->isCurvilinear ; 
    13881476 
    13891477         nc_type type ; 
    … …  
    18391927                  else 
    18401928                  { 
    1841                     CArray<bool,1> axisDomainOrder = grid->axis_domain_order; 
     1929                    CArray<int,1> axisDomainOrder = grid->axis_domain_order; 
    18421930                    std::vector<StdString> domainList = grid->getDomainList(); 
    18431931                    std::vector<StdString> axisList   = grid->getAxisList(); 
    … …  
    18521940                    for (int i = numElement - 1; i >= 0; --i) 
    18531941                    { 
    1854                       if (axisDomainOrder(i)) 
     1942                      if (2 == axisDomainOrder(i)) 
    18551943                      { 
    18561944                        CDomain* domain = CDomain::get(domainList[idxDomain]); 
    … …  
    18761964                        --idxDomain; 
    18771965                      } 
    1878                       else 
     1966                      else if (1 == axisDomainOrder(i)) 
    18791967                      { 
    18801968                        CAxis* axis = CAxis::get(axisList[idxAxis]); 
    … …  
    19001988                { 
    19011989 
    1902                   CArray<bool,1> axisDomainOrder = grid->axis_domain_order; 
     1990                  CArray<int,1> axisDomainOrder = grid->axis_domain_order; 
    19031991                  std::vector<StdString> domainList = grid->getDomainList(); 
    19041992                  std::vector<StdString> axisList   = grid->getAxisList(); 
    … …  
    19122000                  for (int i = numElement - 1; i >= 0; --i) 
    19132001                  { 
    1914                     if (axisDomainOrder(i)) 
     2002                    if (2 == axisDomainOrder(i)) 
    19152003                    { 
    19162004                      CDomain* domain = CDomain::get(domainList[idxDomain]); 
    … …  
    19262014                      --idxDomain; 
    19272015                    } 
    1928                     else 
     2016                    else if (1 == axisDomainOrder(i)) 
    19292017                    { 
    19302018                      start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]); 
    19312019                      count.push_back(nZoomSizeServer[idx]); 
    19322020                      --idx; 
    1933                      } 
     2021                    } 
     2022                    else 
     2023                    { 
     2024                      if (1 == axisDomainOrder.numElements()) 
     2025                      { 
     2026                        start.push_back(0); 
     2027                        count.push_back(1); 
     2028                      } 
     2029                      --idx; 
     2030                    } 
    19342031                  } 
    19352032                } 
    … …  
    23222419      } 
    23232420 
     2421      bool CNc4DataOutput::isWrittenScalar(const std::string& scalarName) const 
     2422      { 
     2423        return (this->writtenScalar.find(scalarName) != this->writtenScalar.end()); 
     2424      } 
     2425 
    23242426      void CNc4DataOutput::setWrittenDomain(const std::string& domainName) 
    23252427      { 
    … …  
    23412443        this->writtenCompressedAxis.insert(axisName); 
    23422444      } 
     2445 
     2446      void CNc4DataOutput::setWrittenScalar(const std::string& scalarName) 
     2447      { 
     2448        this->writtenScalar.insert(scalarName); 
     2449      } 
    23432450} // namespace xios 
Note: See TracChangeset for help on using the changeset viewer.