Changeset 127

Timestamp:

10/07/10 16:17:04 (14 years ago)

Author:

hozdoba

Message:

suite du précédent commit

Location:

XMLIO_V2/dev/dev_rv/src/XMLIO

Files:

• NetCDF4_data_output.hpp (modified) (11 diffs)
• abstract_calendar.hpp (modified) (3 diffs)
• attribut.hpp (modified) (1 diff)
• c_interface.cpp (modified) (2 diffs)
• calendar.hpp (modified) (6 diffs)
• calendar_utils.hpp (modified) (1 diff)
• data_treatment.hpp (modified) (2 diffs)
• date.hpp (modified) (4 diffs)
• declare_attribut.hpp (modified) (2 diffs)
• declare_group.hpp (modified) (1 diff)
• domain_attribut.hpp (modified) (3 diffs)
• field_operation.hpp (modified) (2 diffs)
• file.hpp (modified) (7 diffs)
• grid.hpp (modified) (5 diffs)
• group_template.hpp (modified) (1 diff)
• main.f90 (modified) (1 diff)
• xml_node.hpp (modified) (2 diffs)
• xml_parser.hpp (modified) (2 diffs)
• xmlio.hpp (modified) (2 diffs)

XMLIO_V2/dev/dev_rv/src/XMLIO/NetCDF4_data_output.hpp

@@ -6 +6 @@
 namespace XMLIOSERVER
 {
+
+   static const char* TimeName = "time";
+
    class NetCDF4DataOutput : public AbstractDataOutput
    {
@@ -74 +77 @@
          }
 
-         void writeCoords(const string& id, const Array<float, 1>& cdata)
+         void writeCoords(const string& id, const Array<double, 1>& cdata)
          {
             NcVar *cVar = dataFile->get_var(id.c_str());
@@ -115 +118 @@
             // Ajout de la dimension temporelle non limitée.
             if (withTime)
-               if (NULL == dataFile->add_dim("time"))
+               if (NULL == dataFile->add_dim(TimeName))
                   throw XMLIOUndefinedValueException("Impossible d'ajouter la dimension temporelle !");
          }
@@ -139 +142 @@
                if (!(latVar = dataFile->add_var(latid.c_str(), ncFloat, dataFile->get_dim(latid.c_str()))))
                   throw XMLIOUndefinedValueException("Impossible d'ajouter la variable de latitude !");
+
                if (!(lonVar = dataFile->add_var(lonid.c_str(), ncFloat, dataFile->get_dim(lonid.c_str()))))
                   throw XMLIOUndefinedValueException("Impossible d'ajouter la variable de longitude !");
@@ -147 +151 @@
                hm["units"]         = "degrees_north";
                hm["long_name"]     = "Latitude" ;
-               addStringAttributesToVar(latVar, hm);
+               this->addStringAttributesToVar(latVar, hm);
                hm.clear();
 
@@ -155 +159 @@
                hm["units"]          = "degrees_east";
                hm["long_name"]      = "Longitude" ;
-               addStringAttributesToVar(lonVar, hm);
-               hm.clear();
+               this->addStringAttributesToVar(lonVar, hm);
+               hm.clear();
+
+               if ((*itt)->yvalue.hasValue())
+                  this->writeCoords(lonid, (*itt)->xvalue);
+               else throw XMLIOUndefinedValueException("Les coordonnées de longitude (xvalue) ne sont pas définies pour le domaine \""+domid+"\".");
+
+               if ((*itt)->xvalue.hasValue())
+                  this->writeCoords(latid, (*itt)->yvalue);
+               else throw XMLIOUndefinedValueException("Les coordonnées de latitude (yvalue) ne sont pas définies pour le domaine \""+domid+"\".");
             }
 
@@ -171 +183 @@
                if ((*it)->long_name.hasValue())    hm["long_name"]     = (*it)->long_name ;
                if ((*it)->unit.hasValue())         hm["units"]         = (*it)->unit;
-               addStringAttributesToVar(othvar, hm);
-               hm.clear();
+               this->addStringAttributesToVar(othvar, hm);
+               hm.clear();
+
+               if ((*it)->value.hasValue())
+                  this->writeCoords(axisid, (*it)->value);
+               else throw XMLIOUndefinedValueException("Les coordonnées de l'axe \""+axisid+"\" (value) ne sont pas définies.");
             }
          }
@@ -228 +244 @@
                   {
                      if (!(var = dataFile->add_var(fieldid.c_str(), tvar,
-                        dataFile->get_dim("time"), dataFile->get_dim(latid.c_str()), dataFile->get_dim(lonid.c_str()))))
+                        dataFile->get_dim(TimeName), dataFile->get_dim(latid.c_str()), dataFile->get_dim(lonid.c_str()))))
                         throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
                   }
@@ -234 +250 @@
                   {
                      if (!(var = dataFile->add_var(fieldid.c_str(), tvar,
-                        dataFile->get_dim("time"), dataFile->get_dim(axisid.c_str()),
+                        dataFile->get_dim(TimeName), dataFile->get_dim(axisid.c_str()),
                         dataFile->get_dim(latid.c_str()), dataFile->get_dim(lonid.c_str()))))
                         throw XMLIOUndefinedValueException("Impossible d'ajouter le champ "+ field->getId() +" !");
@@ -258 +274 @@
                if (field->long_name.hasValue())    hm["long_name"]     = field->long_name ;
                if (field->unit.hasValue())         hm["units"]         = field->unit;
-               addStringAttributesToVar(var, hm);
+               this->addStringAttributesToVar(var, hm);
                hm.clear();
             }
@@ -265 +281 @@
       private :
 
-         void addStringAttributesToVar(NcVar * var, const Poco::HashMap<string, string>& attr)
+         void addStringAttributesToVar(NcVar * const var, const Poco::HashMap<string, string>& attr)
          {
             Poco::HashMap<string, string>::ConstIterator it;

XMLIO_V2/dev/dev_rv/src/XMLIO/abstract_calendar.hpp

@@ -12 +12 @@
       public :
 
-         virtual int getMonthLength(const Date& d) const
-         { // Retourne la durée du mois en jour.
-            static const int NoLeapMonthLength[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
-            return (NoLeapMonthLength[d.getMonth()-1]);
+         friend std::ostream& operator<<(std::ostream& out, AbstractCalendar& c)
+         {
+            out <<   "[type: "   << c.getId()
+                << ", start: "   << c.getInitDate()
+                << ", current: " << c.getCurrentDate() << "]";
+            return (out);
          }
-
-         friend std::ostream& operator<<(std::ostream& out, AbstractCalendar& c)
-         { out << "[type: " << c.getId() << ", start: " << c.getInitDate() << ", current: " << c.getCurrentDate() << "]"; return (out); }
 
          const Date& getInitDate(void) const { return(initDate); }
          Date& getCurrentDate(void) { return(currentDate); }
 
-         void setTempo(const Duration& dr) { tempo = dr; }
-         Duration getTempo(void) const { return (tempo); }
+         void setTimeStep(const Duration& dr) { timestep = dr; }
+         const Duration& getTimeStep(void) const { return (timestep); }
 
          Date& update(void);
+
+      public : /* virtual */
+
+         virtual int getMonthLength(const Date& d) const
+         { // Retourne la durée du mois en jour.
+            static const int NoLeapMonthLength[] =
+               {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+            return (NoLeapMonthLength[d.getMonth()-1]);
+         }
 
          virtual int getYearTotalLength(const Date& d) const { return (365 * 86400); } // Retourne la durée d'une année en seconde.
@@ -63 +71 @@
 
          AbstractCalendar(void)
-            : AbstractObject(), initDate(*this), currentDate(initDate), tempo(Hour)
+            : AbstractObject(), initDate(*this), currentDate(initDate), timestep(Hour)
          { /* Ne rien faire de plus */ }
 
          AbstractCalendar(const string& _id,
                           int yr = 0, int mth = 1, int d = 1, int hr = 0, int min = 0 , int sec = 0)
-            : AbstractObject(_id), initDate(*this, yr, mth, d, hr, min, sec), currentDate(initDate), tempo(Hour)
+            : AbstractObject(_id),
+              initDate(*this, yr, mth, d, hr, min, sec), currentDate(initDate), timestep(Hour)
          { /* Ne rien faire de plus */ }
 
          AbstractCalendar(const string& _id, const string& dateStr)
-            : AbstractObject(_id), initDate(Date::FromString(dateStr, *this)), currentDate(initDate), tempo(Hour)
+            : AbstractObject(_id),
+              initDate(Date::FromString(dateStr, *this)), currentDate(initDate), timestep(Hour)
          { /* Ne rien faire de plus */ }
 
@@ -79 +89 @@
          const Date initDate;
          Date currentDate;
-         Duration tempo;
+         Duration timestep;
 
    }; // class AbstractCalendar

XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp

@@ -86 +86 @@
    { _hasValue = true ; value.resize(val.shape()); value = val ; }
 
+#define PRINT_ARRAY(type)                                             \
+   template <>                                                        \
+      ostream& Attribut<Array<type, 1> >::print(ostream & _out) const \
+   {                                                                  \
+      if (_hasValue) _out << " " << getName() << "=\"" << value(0);   \
+      _out << "..." << value(value.size()-1); _out << "\"" ;          \
+      return (_out) ;                                                 \
+   }
+
 #define SET_ARRAY_TYPE(type) \
-   SET_ARRAY_DIM(type,1)     \
-   SET_ARRAY_DIM(type,2)     \
-   SET_ARRAY_DIM(type,3)     \
-   SET_ARRAY_DIM(type,4)
+   PRINT_ARRAY(type)         \
+   SET_ARRAY_DIM(type, 1)    \
+   SET_ARRAY_DIM(type, 2)    \
+   SET_ARRAY_DIM(type, 3)    \
+   SET_ARRAY_DIM(type, 4)
 
    SET_ARRAY_TYPE(double)
+   SET_ARRAY_TYPE(float)
    SET_ARRAY_TYPE(int)
    SET_ARRAY_TYPE(bool)
 
-   template <>
-      ostream& Attribut<Array<double,1> >::print(ostream & o) const
-   {
-      if (_hasValue) o << " " << getName() << "=\"" << value(0);
-      /*for (int i = 1; i < value.size(); i++)
-      { o << "," << value(i); }*/
-      o << value(0) << "..." << value(value.size()-1);
-      o << "\"" ;
-      return (o) ;
-   }
+#undef SET_ARRAY_DIM
+#undef SET_ARRAY_TYPE
+#undef PRINT_ARRAY
 
    template <>
-      void Attribut<Array<double,1> >::setFromString(const std::string& _str)
+      void Attribut<Array<double, 1> >::setFromString(const std::string& _str)
    {
       istringstream iss(_str) ;

XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp

@@ -45 +45 @@
          // Récupération du calendrier assossié au context courant et initialisation des delais d'écriture.
          AbstractCalendar* calendar = dtreat.getCurrentContext()->getCalendar();
-         calendar->setTempo(1 * Hour);
+         calendar->setTimeStep(1 * Hour);
 
          // Affichage de la date initiale (pour vérification).
@@ -67 +67 @@
          }
 
+         std::cout << std::endl << " * ----------- Affichage de l'arborescence ----------- * " << std::endl << std::endl;
+
          // On écrit l'arborescence résultante du traitement sur la sortie de log.
-         //Context::ShowTree(std::clog);
+         Context::ShowTree(std::clog);
+         std::cout << std::endl;
       }
 

XMLIO_V2/dev/dev_rv/src/XMLIO/calendar.hpp

@@ -7 +7 @@
    {
       public :
+
          JulianCalendar() : AbstractCalendar("Julian")
          {/* Ne rien faire de plus */}
          JulianCalendar(const string& _dateStr) : AbstractCalendar("Julian", _dateStr)
          {/* Ne rien faire de plus */}
+
+      public : /* virtual */
 
          virtual int getYearTotalLength(const Date& _d) const
@@ -33 +36 @@
    {
       public :
+
          GregorianCalendar() : AbstractCalendar("Gregorian")
          {/* Ne rien faire de plus */}
          GregorianCalendar(const string& dateStr) : AbstractCalendar("Gregorian", dateStr)
          {/* Ne rien faire de plus */}
+
+      public : /* virtual */
 
          virtual int getYearTotalLength(const Date& d) const
@@ -48 +54 @@
             if (d.getMonth() == 2)
             { // Traitement du cas particulier en Février.
-               if ((d.getYear() % 4 == 0) && (d.getYear() % 100 != 0 || d.getYear() % 400 == 0))
+               if ((d.getYear() % 4   == 0) &&
+                  ((d.getYear() % 100 != 0) ||
+                   (d.getYear() % 400 == 0) ))
                   return (29);
                return (28);
@@ -63 +71 @@
    {
       public :
+
          NoLeapCalendar() : AbstractCalendar("NoLeap")
          {/* Ne rien faire de plus */}
@@ -76 +85 @@
    {
       public :
+
          AllLeapCalendar() : AbstractCalendar("AllLeap")
          {/* Ne rien faire de plus */}
          AllLeapCalendar(const string& dateStr) : AbstractCalendar("AllLeap", dateStr)
          {/* Ne rien faire de plus */}
+
+      public : /* virtual */
 
          virtual int getMonthLength(const Date& d) const
@@ -94 +106 @@
    {
       public :
+
          D360Calendar() : AbstractCalendar("D360")
          {/* Ne rien faire de plus */}
          D360Calendar(const string& dateStr) : AbstractCalendar("D360", dateStr)
          {/* Ne rien faire de plus */}
+
+      public : /* virtual */
 
          virtual int getYearTotalLength(const Date& d) const { return (360 * 86400); }

XMLIO_V2/dev/dev_rv/src/XMLIO/calendar_utils.hpp

@@ -194 +194 @@
 
    Date& AbstractCalendar::update(void)
-   { return (getCurrentDate() = getCurrentDate() + tempo); }
+   { return (getCurrentDate() = getCurrentDate() + timestep); }
 
 } // namespace XMLIOSERVER

XMLIO_V2/dev/dev_rv/src/XMLIO/data_treatment.hpp

@@ -13 +13 @@
          { this->doTreatment(cal); }
 
-         const Context* getCurrentContext(void) const { return (currentContext); }
-         const std::vector<CFile*>& getEnabledFiles(void) const { return (enabledFiles); }
+         const Context*             getCurrentContext(void) const { return (currentContext); }
+         const std::vector<CFile*>& getEnabledFiles  (void) const { return (enabledFiles); }
 
          void getEnabledFilesId(std::vector<std::string>& _vect) const
@@ -74 +74 @@
          }
 
-         ~DataTreatment()
+         ~DataTreatment(void)
          { /* Ne rien faire de plus */ }
 

XMLIO_V2/dev/dev_rv/src/XMLIO/date.hpp

@@ -8 +8 @@
       public :
 
-         Date(const AbstractCalendar& cal, int yr = 0, int mth = 1, int d = 1, int hr = 0, int min = 0 , int sec = 0) : relCalendar(cal)
-            , year(yr), month(mth), day(d), hour(hr), minute(min), second(sec)
+         Date(const AbstractCalendar& cal,
+              int yr = 0, int mth = 1, int d = 1, int hr = 0, int min = 0 , int sec = 0)
+                  : relCalendar(cal)
+                  , year(yr), month(mth), day(d), hour(hr), minute(min), second(sec)
          {
-            if(!checkDate())
+            if(!this->checkDate())
                WARNING("La date initialisée a été modifiée car elle était incorrecte par rapport au calendrier souhaité.");
          }
@@ -18 +20 @@
             , year(d.year), month(d.month), day(d.day), hour(d.hour), minute(d.minute), second(d.second)
          {
-            if(!checkDate())
+            if(!this->checkDate())
                WARNING("La date initialisée a été modifiée car elle était incorrecte par rapport au calendrier souhaité.");
          }
@@ -50 +52 @@
          }
 
-         static Date FromString(const string& str, const AbstractCalendar& cal);
-
          /// Divers accesseurs.
-         int getYear  (void) const { return (year); }
-         int getMonth (void) const { return (month); }
-         int getDay   (void) const { return (day); }
-         int getHour  (void) const { return (hour); }
+         int getYear  (void) const { return (year  ); }
+         int getMonth (void) const { return (month ); }
+         int getDay   (void) const { return (day   ); }
+         int getHour  (void) const { return (hour  ); }
          int getMinute(void) const { return (minute); }
          int getSecond(void) const { return (second); }
@@ -70 +70 @@
          }
 
-
-
          const AbstractCalendar& getRelCalendar(void) const { return (relCalendar); }
 
          ~Date()
          {/* Ne rien faire de plus */}
+
+      public : /* static */
+
+         static Date FromString(const string& str, const AbstractCalendar& cal);
 
       private :

XMLIO_V2/dev/dev_rv/src/XMLIO/declare_attribut.hpp

@@ -18 +18 @@
          Attr_##att_name(const att_type& _value) : Attribut<att_type>(_value)       \
          { /* Ne rien faire de plus */ }                                            \
-         Attr_##att_name(const Attr_##att_name & att) : Attribut<att_type>(att)     \
+         Attr_##att_name(const Attr_##att_name& _att) : Attribut<att_type>(_att)    \
          { /* Ne rien faire de plus */ }                                            \
                                                                                     \
@@ -33 +33 @@
    void setAttr##att_name(const att_type& _newattr) { att_name.setValue(_newattr); }\
    void set_##att_name   (const att_type& _newattr) { att_name.setValue(_newattr); }\
+                                                                                    \
    Attr_##att_name att_name
 

XMLIO_V2/dev/dev_rv/src/XMLIO/declare_group.hpp

@@ -21 +21 @@
             { _parse<child_type##Group>(_node, _withAttr); }               \
                                                                            \
-            virtual ~child_type##Group(void){}                             \
+            virtual ~child_type##Group(void)                               \
+            { /* Ne rien faire de plus */ }                                \
       };                                                                   \
                                                                            \

XMLIO_V2/dev/dev_rv/src/XMLIO/domain_attribut.hpp

@@ -16 +16 @@
          DECLARE_ATTR(ni_glo        , int) ;
          DECLARE_ATTR(nj_glo        , int) ;
+
          DECLARE_ATTR(ibegin        , int) ;
          DECLARE_ATTR(iend          , int) ;
          DECLARE_ATTR(ni            , int) ;
+
          DECLARE_ATTR(jbegin        , int) ;
          DECLARE_ATTR(jend          , int) ;
          DECLARE_ATTR(nj            , int) ;
+
          DECLARE_ATTR(mask          , Array(bool, 2)) ;
 
@@ -29 +32 @@
          DECLARE_ATTR(data_ibegin   , int) ;
          DECLARE_ATTR(data_jbegin   , int) ;
+
          DECLARE_ATTR(data_n_index  , int) ;
          DECLARE_ATTR(data_i_index  , Array(int, 1)) ;
          DECLARE_ATTR(data_j_index  , Array(int, 1)) ;
+
+         DECLARE_ATTR(xvalue        , Array(double, 1)) ;
+         DECLARE_ATTR(yvalue        , Array(double, 1)) ;
 
          DomainAttribut(void) : AttributRegistrar()
@@ -61 +68 @@
             RegisterAttribut(&data_i_index) ;
             RegisterAttribut(&data_j_index) ;
+
+            RegisterAttribut(&xvalue) ;
+            RegisterAttribut(&yvalue) ;
          }
 

XMLIO_V2/dev/dev_rv/src/XMLIO/field_operation.hpp

@@ -9 +9 @@
       public :
 
-         FieldOperation(const string& _id = string("inst"), const Duration& _dr = Hour)
+         FieldOperation(const string& _id = string("inst"), const Duration& _dr = NoneDu)
             : AbstractObject(_id), freqOp(_dr)
          { /* Ne rien faire de plus */ }
@@ -22 +22 @@
          void setFreqOp(const Duration& _dr) { freqOp = _dr; }
 
-         //void getOutputField(const Array<double, 1>& inField, Array<double, 1>& outField) const
+      public : /* virtual */
 
-         //void getStoreField(const Array<double, 1>& inField, Array<double, 1>& outField) const
-
-         virtual ~FieldOperation()
+         virtual ~FieldOperation(void)
          { /* Ne rien faire de plus */ }
-
 
       protected :

XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp

@@ -16 +16 @@
          {/* Ne rien faire de plus */}
 
-         static string GetName(void) { return ("file"); }
-         static string GetDefName(void)  { return (CFile::GetName()); }
-
-         virtual void parse (XMLNode& _node)
-         {
-            string name = _node.getElementName();
-            THashAttributes attributes;
-
-            /// PARSING GESTION DES ATTRIBUTS ///
-            _node.getAttributes(attributes);
-            this->setAttributes(attributes);
-            attributes.clear();
-
-            /// PARSING POUR GESION DES ENFANTS ///
-            if (_node.goToChildElement() and hasId())
-            { // Si la définition du fichier intégre des champs et si le fichier est identifié.
-               _node.goToParentElement();
-               vfieldGroup = CreateInstanceAndParse<FieldGroup>(_node, getId().c_str(), false );
-            }
-         }
-
          AbstractDataOutput* getDataOutput(void) const { return (output); }
          void initializeDataOutput(AbstractDataOutput* _output)
@@ -50 +29 @@
          {
             std::set<const CGrid*> sgrid;
-            const std::vector<CField*> enabledFields = getEnabledFields();
+            const std::vector<CField*> enabledFields = this->getEnabledFields();
             std::vector<CField*>::const_iterator it;
 
@@ -59 +38 @@
          }
 
+         const std::set<const FieldOperation*> getEnabledOperation(void) const
+         {
+            std::set<const FieldOperation*> sope;
+            const std::vector<CField*> enabledFields = this->getEnabledFields();
+            std::vector<CField*>::const_iterator it;
+
+            for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
+               if ((*it)->operation.hasValue())
+                  sope.insert((FieldOperation*)&(*it)->operation);
+
+            return (sope);
+         }
+
          const std::set<const CDomain*> getEnabledDomains(void) const
          {
-            const std::set<const CGrid*> sgrid = getEnabledGrids();
+            const std::set<const CGrid*> sgrid = this->getEnabledGrids();
             std::set<const CDomain*> sdomain;
 
@@ -74 +66 @@
          const std::set<const CAxis*> getEnabledAxis(void) const
          {
-            const std::set<const CGrid*> sgrid = getEnabledGrids();
+            const std::set<const CGrid*> sgrid = this->getEnabledGrids();
             std::set<const CAxis*> saxis;
 
@@ -84 +76 @@
             return (saxis);
          }
-
-         virtual bool hasChild(void) const { return (vfieldGroup != NULL); }
-         virtual void printChild(ostream& out) const { out << *vfieldGroup << std::endl; }
-
-         virtual void resolveDescInheritance(const AttributRegistrar* const _parent = 0)
-         { addAttributes(*_parent); if(vfieldGroup != NULL) vfieldGroup->resolveDescInheritance(); }
 
          void resolveFieldRefInheritance(void)
@@ -144 +130 @@
          }
 
+      public : /* virtual */
+
+         virtual void parse (XMLNode& _node)
+         {
+            string name = _node.getElementName();
+            THashAttributes attributes;
+
+            /// PARSING GESTION DES ATTRIBUTS ///
+            _node.getAttributes(attributes);
+            this->setAttributes(attributes);
+            attributes.clear();
+
+            /// PARSING POUR GESION DES ENFANTS ///
+            if (_node.goToChildElement() and hasId())
+            { // Si la définition du fichier intégre des champs et si le fichier est identifié.
+               _node.goToParentElement();
+               vfieldGroup = CreateInstanceAndParse<FieldGroup>(_node, getId().c_str(), false );
+            }
+         }
+
+         virtual bool hasChild(void) const { return (vfieldGroup != NULL); }
+         virtual void printChild(ostream& out) const { out << *vfieldGroup << std::endl; }
+
+         virtual void resolveDescInheritance(const AttributRegistrar* const _parent = 0)
+         { addAttributes(*_parent); if(vfieldGroup != NULL) vfieldGroup->resolveDescInheritance(); }
+
          virtual  ~CFile(void)
          {
@@ -149 +161 @@
             if(output != NULL) delete output;
          }
+
+      public : /* static */
+
+         static string GetName(void) { return ("file"); }
+         static string GetDefName(void)  { return (CFile::GetName()); }
 
       private :

XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp

@@ -11 +11 @@
       public:
 
-         CGrid(void) : ObjectTemplate<CGrid>(), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
+         CGrid(void)
+            : ObjectTemplate<CGrid>(), GridAttribut(),
+              hasAxis(false), axis(NULL), domain(NULL)
          { /* Ne rien faire de plus */ }
 
-         CGrid(const string& _id) : ObjectTemplate<CGrid>(_id), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
+         CGrid(const string& _id)
+            : ObjectTemplate<CGrid>(_id), GridAttribut(),
+              hasAxis(false), axis(NULL), domain(NULL)
          { /* Ne rien faire de plus */ }
 
-         static string GetName(void) { return ("grid"); }
-         static string GetDefName(void)  { return (CGrid::GetName()); }
-
-         const CAxis* getRelAxis(void) const { return (axis); }
+         const CAxis*   getRelAxis  (void) const { return (axis); }
          const CDomain* getRelDomain(void) const { return (domain); }
 
-         const Array<int, 1>& getStoreIndex(void) { return (storeIndex); }
-         const Array<int, 1>& getOutIIndex(void) { return (out_i_index); }
-         const Array<int, 1>& getOutJIndex(void) { return (out_j_index); }
-         const Array<int, 1>& getOutLIndex(void) { return (out_l_index); }
-
-         inline void solveReference(void) ;
-         inline void solveDomainRef(void) ;
-         inline void solveAxisRef(void) ;
+         const Array<int, 1>& getStoreIndex(void) const { return (storeIndex); }
+         const Array<int, 1>& getOutIIndex(void)  const { return (out_i_index); }
+         const Array<int, 1>& getOutJIndex(void)  const { return (out_j_index); }
+         const Array<int, 1>& getOutLIndex(void)  const { return (out_l_index); }
+
+         void solveReference(void)
+         { this->solveDomainRef() ; this->solveAxisRef() ; this->computeIndex() ; }
+
+         void solveDomainRef(void)
+         {
+            if (domain_ref.hasValue())
+            {
+               if (CDomain::HasObject(domain_ref))
+               {
+                 domain = CDomain::GetObject(domain_ref) ;
+                 domain->check() ;
+               }
+               else ERROR("Référence au domaine incorrecte") ;
+            }
+            else ERROR("Domaine non défini") ;
+         }
+
+         void solveAxisRef(void)
+         {
+            if (axis_ref.hasValue())
+            {
+               hasAxis = true ;
+               if (CAxis::HasObject(axis_ref)) axis = CAxis::GetObject(axis_ref) ;
+               else ERROR("Référence a l'axe incorrecte") ;
+            }
+            else hasAxis = false ; // hasAxis est normalement déjà à false(?).
+         }
 
          inline void computeIndex(void);
@@ -36 +61 @@
          bool _hasAxis(void) const { return (hasAxis); }
 
-         inline void storeField(const Array<double, 1>& field, Array<double, 1>& stored) const;
-         inline void storeField(const Array<double, 2>& field, Array<double, 1>& stored) const;
-         inline void storeField(const Array<double, 3>& field, Array<double, 1>& stored) const;
-         inline void storeField(const double* const data, Array<double, 1>& stored) const;
-
-         inline void outputField(const Array<double,1>& stored, Array<double, 2>& outField) const;
-         inline void outputField(const Array<double,1>& stored, Array<double, 3>& outField) const;
-
-         inline static CGrid* CreateObject(const CDomain* const a_domain, const CAxis* const a_axis);
-         inline static CGrid* CreateObject(const CDomain* const a_domain);
+         template <class T>
+            void storeField(const T& field, Array<double, 1>& stored) const
+         { this->storeField_arr(field.dataFirst(), stored) ; }
+
+         template <class T>
+            inline void outputField(const Array<double, 1>& stored, T&) const;
+
+      public : /* virtual */
 
          virtual ~CGrid(void)
          { /* Ne rien faire de plus */ }
 
+      public : /* static */
+
+         static string GetName   (void) { return ("grid"); }
+         static string GetDefName(void) { return (CGrid::GetName()); }
+
+         static CGrid* CreateObject(const CDomain* const a_domain, const CAxis* const a_axis)
+         {
+            string new_id = string("___") + a_domain->getId() + string("_") + a_axis->getId() + string("__") ;
+            CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
+
+            grid->domain_ref = a_domain->getId() ;
+            grid->axis_ref   = a_axis  ->getId() ;
+
+            return (grid);
+         }
+
+         static CGrid* CreateObject(const CDomain* const a_domain)
+         {
+            string new_id = string("___") + a_domain->getId() + string("__") ;
+            CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
+            grid->domain_ref = a_domain->getId() ;
+
+            return (grid);
+         }
+
+      protected :
+
+         void storeField_arr(const double* const data, Array<double, 1>& stored) const
+         {
+            const int size = storeIndex.size() ;
+            stored.resize(shape(size)) ;
+            for(int i = 0; i < size; i++)
+               stored(i) = data[storeIndex(i)] ;
+         }
+
       private:
 
          bool hasAxis ;
 
-         CAxis* axis ;
-         CDomain* domain ;
+         CAxis   * axis ;
+         CDomain * domain ;
 
          Array<int, 1> storeIndex ;
@@ -64 +122 @@
    }; // class CGrid
 
-   CGrid* CGrid::CreateObject(const CDomain* const a_domain, const CAxis* const a_axis)
-   {
-      string new_id = string("___") + a_domain->getId() + string("_") + a_axis->getId() + string("__") ;
-      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
-
-      grid->domain_ref = a_domain->getId() ;
-      grid->axis_ref   = a_axis  ->getId() ;
-
-      return (grid);
-   }
-
-   CGrid* CGrid::CreateObject(const CDomain* const a_domain)
-   {
-      string new_id = string("___") + a_domain->getId() + string("__") ;
-      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
-
-      grid->domain_ref = a_domain->getId() ;
-
-      return (grid);
-   }
-
-   void CGrid::solveReference(void)
-   {
-
-      /**static bool isReferenceSolved = false;
-      if (isReferenceSolved)
-      {
-         std::cout << "C'est n'importe quoi, A modifierrrrrrrrrrr!!!!!!!!!!!!!!!!!!!!!" << std::endl;
-         return;
-      }*/
-
-      // Résolution de chacune des références et indexation.
-      solveDomainRef() ;
-      solveAxisRef() ;
-      computeIndex() ;
-
-      //isReferenceSolved = true ;
-   }
-
-   void CGrid::solveDomainRef(void)
-   {
-      if (domain_ref.hasValue())
-      {
-         if (CDomain::HasObject(domain_ref))
-         {
-           domain = CDomain::GetObject(domain_ref) ;
-           domain->check() ;
-         }
-         else ERROR("Référence au domaine incorrecte") ;
-      }
-      else ERROR("Domaine non défini") ;
-   }
-
-   void CGrid::solveAxisRef(void)
-   {
-      if (axis_ref.hasValue())
-      {
-         hasAxis = true ;
-         if (CAxis::HasObject(axis_ref)) axis = CAxis::GetObject(axis_ref) ;
-         else ERROR("Référence a l'axe incorrecte") ;
-      }
-      else hasAxis = false ; // hasAxis est normalement déjà à false(?).
-   }
-
    void CGrid::computeIndex(void)
    {
-
       int ni = domain->ni ;
       int nj = domain->nj ;
@@ -196 +189 @@
          }
       }
-
-      /** Pour tests
-
-      cout << "Out of CGrid::ComputeIndex" << endl ;
-
-      cout << "storeIndex : " << endl ;
-      cout << storeIndex << endl ;
-
-      cout << "out_i_index : " << endl ;
-      cout << out_i_index << endl ;
-
-      cout << "out_j_index : " << endl ;
-      cout << out_j_index << endl ;
-
-      cout << "out_l_index : " << endl ;
-      cout << out_l_index << endl ;
-
-      **/
-
    }
 
-   void CGrid::storeField(const Array<double, 1>& field, Array<double, 1>& stored) const
-   {
-      storeField(field.dataFirst(), stored) ;
-      //cout<<"Stored 1"<<stored<<endl ;
-   }
-
-   void CGrid::storeField(const Array<double, 2>& field, Array<double, 1>& stored) const
-   {
-      storeField(field.dataFirst(), stored) ;
-      //cout<<"Stored 2"<<stored<<endl ;
-   }
-
-   void CGrid::storeField(const Array<double, 3>& field, Array<double, 1>& stored) const
-   {
-      storeField(field.dataFirst(), stored) ;
-      //cout<<"Stored 3"<<stored<<endl ;
-   }
-
-   void CGrid::storeField(const double* const data, Array<double, 1>& stored) const
-   {
-      int size = storeIndex.size() ;
-      //cout << "size " << size << endl ;
-
-      stored.resize(shape(size)) ;
-      //cout << "Stored " << stored << endl ;
-
-      for(int i = 0; i < size; i++) stored(i) = data[storeIndex(i)] ;
-      //cout << "Stored " << stored << endl ;
-   }
-
-   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 2>& outField) const
+   template<>
+      void CGrid::outputField(const Array<double, 1>& stored, Array<double, 2>& outField) const
    {
       for(int n = 0; n < storeIndex.size(); n++)
@@ -253 +198 @@
    }
 
-   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 3>& outField) const
+   template<>
+      void CGrid::outputField(const Array<double, 1>& stored, Array<double, 3>& outField) const
    {
       for(int n = 0; n < storeIndex.size(); n++)

XMLIO_V2/dev/dev_rv/src/XMLIO/group_template.hpp

@@ -90 +90 @@
       public : /* virtual */
 
-         virtual ~GroupTemplate()
+         virtual ~GroupTemplate(void)
          {
             for (unsigned int i = 0; i < childList.getVector().size(); i++)

XMLIO_V2/dev/dev_rv/src/XMLIO/main.f90

@@ -1 +1 @@
 PROGRAM main
-IMPLICIT NONE
+   IMPLICIT NONE
 
    CALL main_c

XMLIO_V2/dev/dev_rv/src/XMLIO/xml_node.hpp

@@ -108 +108 @@
 
             Poco::XML::Node * getCNode(void) const { return (this->cNode); }
+
             void setCNode(Poco::XML::Node * _otherNode) { this->cNode = _otherNode; }
 
@@ -129 +130 @@
             Poco::XML::Node* cNode;
 
-            string rootName;
+            std::string rootName;
 
       };// class XMLNode

XMLIO_V2/dev/dev_rv/src/XMLIO/xml_parser.hpp

@@ -31 +31 @@
                   { WARNING("Le context ne sera pas traité car il n'est pas identifié !"); continue; }
 
-                  if( Context::GetAllListObject().find(attributes["id"]) != Context::GetAllListObject().end())
+                  if( Context::GetAllListObject().find(attributes["id"]) !=
+                      Context::GetAllListObject().end())
                   { WARNING("Le context ne sera pas traité car il existe déjà un autre context possédant le même nom !"); continue; }
 
@@ -46 +47 @@
                } while (_node.goToNextElement());
             }
+
       }; // class XMLParser
    } // namespace XML

XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp

@@ -67 +67 @@
 #include "file_attribut.hpp"
 
+#undef DECLARE_ATTR
+
 #include "group_template.hpp"
 #include "declare_group.hpp"
@@ -76 +78 @@
 #include "grid.hpp"
 #include "file.hpp"
+
+#undef DECLARE_GROUP
 
 //....