Changeset 124

Timestamp:

10/01/10 11:32:41 (14 years ago)

Author:

hozdoba

Message:

Commit pour sauvegarde - diverses corrections de bogues et améliorations du code.

Location:

XMLIO_V2/dev/dev_rv/src/XMLIO

Files:

• NetCDF4_data_output.hpp (modified) (1 diff)
• NetCDF4_data_treatment.hpp (modified) (1 diff)
• abstract_calendar.hpp (modified) (4 diffs)
• abstract_data_treatment.hpp (modified) (7 diffs)
• attribut_registrar.hpp (modified) (1 diff)
• c_interface.cpp (modified) (2 diffs)
• calendar_utils.hpp (modified) (1 diff)
• context.hpp (modified) (2 diffs)
• date.hpp (modified) (2 diffs)
• field.hpp (modified) (3 diffs)
• field_attribut.hpp (modified) (1 diff)
• field_gridrefsolver.hpp (modified) (1 diff)
• field_operation.hpp (modified) (2 diffs)
• file.hpp (modified) (5 diffs)
• grid.hpp (modified) (7 diffs)
• object_template.hpp (modified) (4 diffs)
• xmlio.hpp (modified) (5 diffs)

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

@@ -150 +150 @@
             for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
             {
-               const CField* field = (*it);
+               CField* field = (*it);
                const CField* bfield = (*it)->getBaseObject();
 
                lonlat = !field->getGrid()->_hasAxis();
+
                if (field->operation.hasValue())
-                  if (string(field->operation).compare("once") == 0) wtime = false;
+               { // Si une opération sur le champ est définie ...
+                  if (field->operation.getId().compare("once") == 0)
+                  {
+                     wtime = false;
+                     field->freq_op.setValue(NoneDu);
+                  }
+               }
+               else
+               { // Si aucune opération sur le champ n'est définie ...
+                  FieldOperation ope("inst");
+                  field->operation.setValue(ope);
+               }
+
+               // Si la fréquence d'opération n'est pas définie, on l'initialise à 0s.
+               // Une fréquence à 0s signifie que l'opération se fera à chaque écriture de données depuis la simulation.
+               if (!field->freq_op.hasValue())
+                  field->freq_op.setValue(NoneDu);
+               ((FieldOperation)field->operation).setFreqOp(Duration(field->freq_op));
+
 
                tvar = ncFloat;

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

@@ -8 +8 @@
       public :
 
-         NetCDF4DataTreatment(Context* const _ctxt) : AbstractDataTreatment(_ctxt)
+         NetCDF4DataTreatment(Context* const _ctxt = Context::GetCurrentContext()) : AbstractDataTreatment(_ctxt, *_ctxt->getCalendar())
          { /* Ne rien faire de plus */ }
+
+         virtual void createDataOutput(void)
+         {
+            for (unsigned int i = 0; i < enabledFiles.size(); i++)
+            {
+               // Initialisation des instances de sortie de données.
+               enabledFiles[i]->initializeDataOutput(new NetCDF4DataOutput(enabledFiles[i]));
+               // Ouverture des fichiers et création des entêtes.
+               enabledFiles[i]->getDataOutput()->createFileAndHeader();
+            }
+         }
 
          virtual ~NetCDF4DataTreatment()

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

@@ -20 +20 @@
          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); }
+
+         Date& update(void);
 
          virtual int getYearTotalLength(const Date& d) const { return (365 * 86400); } // Retourne la durée d'une année en seconde.
@@ -49 +57 @@
          { string value = getMonthName(_mi); value.resize(3); return (value); }
 
-         const Date& getInitDate(void) const { return(initDate); }
-         Date& getCurrentDate(void) { return(currentDate); }
-
          virtual ~AbstractCalendar()
          {/* Ne rien faire de plus */}
@@ -57 +62 @@
       protected :
 
-         AbstractCalendar() : AbstractObject(), initDate(*this), currentDate(initDate)
+         AbstractCalendar()
+            : AbstractObject(), initDate(*this), currentDate(initDate), tempo(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)
+            : AbstractObject(_id), initDate(*this, yr, mth, d, hr, min, sec), currentDate(initDate), tempo(Hour)
          {/* Ne rien faire de plus */}
 
          AbstractCalendar(const string& _id, const string& dateStr)
-            : AbstractObject(_id), initDate(Date::FromString(dateStr, *this)), currentDate(initDate)
+            : AbstractObject(_id), initDate(Date::FromString(dateStr, *this)), currentDate(initDate), tempo(Hour)
          {/* Ne rien faire de plus */}
 
@@ -72 +78 @@
          const Date initDate;
          Date currentDate;
+         Duration tempo;
 
    }; // class AbstractCalendar

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

@@ -11 +11 @@
          { return (currentContext); }
 
-         const std::vector<CFile*> getEnabledFiles(void) const
+         const std::vector<CFile*>& getEnabledFiles(void) const
          { return (enabledFiles); }
 
@@ -22 +22 @@
          void printEnabledFilesId(std::ostream& out = std::clog) const
          {
-            out << "Liste des fichiers à sortir dans le contexte analysé nommé \"" << currentContext->getId() << "\"" << std::endl;
-            std::vector<std::string> __vect; getEnabledFilesId(__vect);
+            out << "Liste des fichiers à sortir dans le contexte analysé nommé \""
+                << currentContext->getId() << "\"" << std::endl;
+
+            std::vector<std::string> __vect;
+            this->getEnabledFilesId(__vect);
+
             for (unsigned int i = 0; i < __vect.size(); i++)
                out << __vect[i] << "|";
             out << "fin" << std::endl;
          }
+
+         template <class T>
+            bool writeData(const std::string& id, const T& arr)
+         {
+            const CField* const field_entry = CField::GetObject(id);
+            const vector<CField*>& vectRef = field_entry->getVectRefObject();
+
+            std::vector<CField*>::const_iterator it;
+            for (it = vectRef.begin(); it != vectRef.end(); it++ )
+            {
+               if ((*it)->isStorable(currentContext->getCalendar()->getCurrentDate()))
+               { // Stockage des données dans l'instance CField si nécessaire.
+                  Array<double, 1> data_uni;
+                  (*it)->getGrid()->storeField(arr, data_uni);
+                  (*it)->storeData(data_uni, currentContext->getCalendar()->getCurrentDate());
+               }
+            }
+
+            return (false);
+         }
+         virtual void createDataOutput(void) = 0;
 
          virtual ~AbstractDataTreatment()
@@ -34 +59 @@
       protected :
 
-         AbstractDataTreatment(Context* const _ctxt) : currentContext(_ctxt), enabledFiles()
+         AbstractDataTreatment(Context* const _ctxt, const AbstractCalendar& cal) : enabledFiles(), currentContext(_ctxt)
          {
             //std::cout << "(Message temporaire) Résolution des héritages ..." << std::endl;
@@ -46 +71 @@
             // Recherche des champs à sortir (enable à true + niveau de sortie correct) pour chaque fichier précédemment listé.
             //std::cout << "(Message temporaire) Recherche des champs à sortir ..." << std::endl;
-            findAllEnabledFields();
+            findAllEnabledFields(cal.getInitDate());
 
             // Résolution des références de grilles pour chacun des champs.
@@ -55 +80 @@
          }
 
+         std::vector<CFile*> enabledFiles; // Liste des fichiers à créer dans un context donné.
+
       private :
 
-         void findAllEnabledFields(void)// <- ajouter attribut par défault ici.
+         void findAllEnabledFields(const Date& iniDate)// <- ajouter attribut par défault ici.
          {
             for (unsigned int i = 0; i < enabledFiles.size(); i++)
-               enabledFiles[i]->findEnabledFields();
+               enabledFiles[i]->findEnabledFields(iniDate);
          }
 
@@ -82 +109 @@
          {
             const std::vector<CFile*>& allFiles = CFile::GetCurrentListObject().getVector();
+
             for (unsigned int i = 0; i < allFiles.size(); i++)
                if (allFiles[i]->enabled.hasValue()) // Si l'attribut 'enabled' est défini.
                   if ((bool)allFiles[i]->enabled) // Si l'attribut 'enabled' est fixé à vrai.
                      enabledFiles.push_back ( allFiles[i] );
+
             if (enabledFiles.size() == 0)
                WARNING("Aucun fichier ne va être sorti dans le contexte nommé \"" + currentContext->getId() + "\" !");
@@ -91 +120 @@
 
          Context* const currentContext;
-         std::vector<CFile*> enabledFiles; // Liste des fichiers à créer dans un context donné.
 
    }; //class AbstractDataTreatment

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

@@ -24 +24 @@
          friend ostream& operator<< (ostream& out, const AttributRegistrar& c)
          {
-            for(unsigned int i = 0; i < c.attrList.getVectorSize(); i++) out << *c.attrList.getVector()[i];
+            for(unsigned int i = 0; i < c.attrList.getVectorSize(); i++)
+               if (c.attrList.getVector()[i]->hasValue())
+                  out << *c.attrList.getVector()[i];
             return (out);
          }

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

@@ -23 +23 @@
    try
    {
-      Array<double, 3> arr(3, 3, 3) ; // Les données.
+      Array<double, 3> arr(100, 100, 20) ; // Les données(les arguments en fonction des dimensions).
       string file("/local/XMLIOSERVER_DEV/dev_rv/test/iodef_simple_test.xml"); // Le fichier de définition.
       ifstream istr( file.c_str() , ifstream::in );
@@ -38 +38 @@
       std::cout << " * ----------- Début du traitement ----------- * " << std::endl;
 
-      //Affichage de la date initiale (pour vérification).
-      std::cout << *Context::GetObject("context1")->getCalendar() << std::endl;
+      {
+         // On crée une instance de traitement de données dans le format NetCDF4.
+         AbstractDataTreatment *dtreat = new NetCDF4DataTreatment();
+         dtreat->createDataOutput();
 
-      // On crée une instance de traitement de données dans le format NetCDF4.
-      AbstractDataTreatment *dtreat = new NetCDF4DataTreatment(Context::GetObject("context1"));
+         // Récupération du calendrier assossié au context courant et initialisation des delais d'écriture.
+         AbstractCalendar* calendar = dtreat->getCurrentContext()->getCalendar();
+         calendar->setTempo(1*Hour);
 
-      NetCDF4DataOutput dop(CFile::GetObject("fichier1"));
-      dop.createFileAndHeader();
+         //Affichage de la date initiale (pour vérification).
+         std::cout << *calendar << std::endl;
 
-      for(int tcourant = 0, tfinal = 9; tcourant <= tfinal; tcourant++)
-      {
-         // Mise à jour de la date.
+         for(int tcourant = 0, tfinal = 9; tcourant <= tfinal; tcourant++)
+         { /***************************** BOUCLE DE CALCUL *****************************/
 
+            // Mise à jour de la date.
+            calendar->update();
 
-         // Mise à jour des données.
-         updateDataTest<Array<double, 3>::iterator>(arr.begin(), arr.end());
+            std::cout << "> Itération de calcul " << tcourant << ",  " << *calendar << std::endl;
 
-         // Ecriture des données.
-         // dtreat->writeData("Premier_champ", arr);
+            // Mise à jour des données.
+            updateDataTest<Array<double, 3>::iterator>(arr.begin(), arr.end());
 
+            // Ecriture des données.
+            dtreat->writeData<Array<double, 3> >("champ1", arr);
+
+         }
+
+         // On écrit l'arborescence résultante du traitement sur la sortie de log.
+         Context::ShowTree(std::clog);
+
+         delete dtreat;
       }
-
-      // On écrit l'arborescence résultante du traitement sur la sortie de log.
-      //Context::ShowTree(std::clog);
-
-      delete dtreat;
 
    }

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

@@ -190 +190 @@
    bool operator!=(const Date& dt0, const Date& dt1) { return !(dt1 == dt0); }
    bool operator> (const Date& dt0, const Date& dt1) { return (dt1 < dt0); }
-   bool operator>=(const Date& dt0, const Date& dt1) { return ((dt1 > dt0) || (dt1 == dt0)); }
-   bool operator<=(const Date& dt0, const Date& dt1) { return ((dt1 < dt0) || (dt1 == dt0)); }
+   bool operator>=(const Date& dt0, const Date& dt1) { return ((dt0 > dt1) || (dt1 == dt0)); }
+   bool operator<=(const Date& dt0, const Date& dt1) { return ((dt0 < dt1) || (dt1 == dt0)); }
+
+   Date& AbstractCalendar::update(void)
+   { return (getCurrentDate() = getCurrentDate() + tempo); }
 
 } // namespace XMLIOSERVER

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

@@ -52 +52 @@
             }
          }
+
+         static Context* GetCurrentContext(void)
+         { return (Context::GetObject(Context::GetCurrentContextId())); }
 
          static void SetCurrentContext(const string& id)
@@ -150 +153 @@
          DomainDefinition * getDomainDefinition(void) const { return (this->domainDef); }
 
-         void updateCurrentDate(const Duration* const dr = NULL)
-         {
-            static Duration dur = Hour;
-            if (dr != NULL) dur = *dr;
-            Date newCurrentDate = ccalendar->getCurrentDate() + dur;
-            ccalendar->getCurrentDate() = newCurrentDate;
-         }
-
          AbstractCalendar * getCalendar(void) const { return (this->ccalendar ); }
          AbstractCalendar * setCalendar(const string& _calName, const string& _dateStr)

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

@@ -60 +60 @@
          int getSecond(void) const { return (second); }
 
+         void setYear  (int newyear)  { year  = newyear; }
          void setMonth (int newmonth) { month = newmonth; }
 
@@ -69 +70 @@
          }
 
-         void setYear  (int newyear)  { year  = newyear; }
+
 
          const AbstractCalendar& getRelCalendar(void) const { return (relCalendar); }

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

@@ -8 +8 @@
 {
    class CGrid; // CGRID = CDOMAINE + CAXIS
+   class CFile;
 
    class CField : public ObjectTemplate<CField>, public FieldAttribut
@@ -13 +14 @@
       public:
 
-         CField(void) : ObjectTemplate<CField>(), FieldAttribut(), grid(NULL)
+         CField(void) : ObjectTemplate<CField>(), FieldAttribut(), lastStored(NULL), grid(NULL), file(NULL)
          {/* Ne rien faire de plus */}
-         CField(const string& _id) : ObjectTemplate<CField>(_id), FieldAttribut(), grid(NULL), foper(NULL)
+         CField(const string& _id) : ObjectTemplate<CField>(_id), FieldAttribut(), lastStored(NULL), grid(NULL), file(NULL)
          {/* Ne rien faire de plus */}
 
          static string GetName(void) { return ("field"); }
 
-         inline void SolveGridRef(void) ;
+         inline void solveGridRef(void) ;
 
          const CGrid* getGrid(void) const { return (grid); }
          const Array<double, 1>& getData(void) const { return (data); }
-         const FieldOperation* getFieldOperation(void) const { return (foper); }
+
+         void initLastStoredDate(const Date& _newlastStored)
+         { if(lastStored == NULL) lastStored = new Date(_newlastStored); };
+
+         bool isStorable(const Date& currDate)
+         {
+            if (lastStored == NULL) return (false);
+            if (freq_op.hasValue())
+               return (currDate >= (*lastStored + (Duration)freq_op));
+            return (true);
+         }
+
+         void storeData(const Array<double, 1> & arr, const Date& currDate)
+         {
+            *lastStored = currDate;
+            data.resize(shape(arr.size())) ;
+            data = arr;
+         }
+
+         const CFile* getRelFile(void) const { return (file); }
+         void setRelFile(CFile* _file) { file = _file; }
 
          virtual CField* getReference(void) const
@@ -36 +57 @@
 
          virtual ~CField(void)
-         { /* Ne rien faire de plus */ }
+         { if(lastStored !=  NULL) delete lastStored; }
 
       private :
 
+         Date* lastStored;
+
          CGrid* grid ;
-         FieldOperation* foper;
-         Array<double, 1> data;
+         CFile* file;
+
+         Array<double, 1>  data;
 
    }; // class CField

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

@@ -11 +11 @@
          DECLARE_ATTR(description, string) ;
          DECLARE_ATTR(unit, string) ;
-         DECLARE_ATTR(operation, string);
+         DECLARE_ATTR(operation, FieldOperation);
 
-         DECLARE_ATTR(freq_op, int) ;
+         DECLARE_ATTR(freq_op, Duration) ;
          DECLARE_ATTR(level, int) ;
          DECLARE_ATTR(prec, int) ;

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

@@ -4 +4 @@
 namespace XMLIOSERVER
 {
-   void CField::SolveGridRef(void)
+   void CField::solveGridRef(void)
    {
       CDomain* domain = NULL;

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

@@ -9 +9 @@
       public :
 
-         FieldOperation() : AbstractObject("Inst(X)")
+         FieldOperation(const string& _id = string("inst"), const Duration& _dr = Hour)
+            : AbstractObject(_id), freqOp(_dr)
          { /* Ne rien faire de plus */ }
 
-         FieldOperation(const string& _id) : AbstractObject(_id)
-         { /* Ne rien faire de plus */ }
+         friend std::ostream& operator<<(std::ostream& out, const FieldOperation& fo)
+         { out << fo.getId(); return (out); }
+
+         friend std::istream& operator>>(std::istream& in, FieldOperation& fo)
+         { string __id; in >> __id; fo.setId(__id); return (in); }
+
+         const Duration& getFreqOp(void) const { return (freqOp); }
+         void setFreqOp(const Duration& _dr) { freqOp = _dr; }
+
+         //void getOutputField(const Array<double, 1>& inField, Array<double, 1>& outField) const
+
+         //void getStoreField(const Array<double, 1>& inField, Array<double, 1>& outField) const
 
          virtual ~FieldOperation()
@@ -23 +34 @@
       private :
 
+         Duration freqOp;
+
 
    }; // class FieldOperation

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

@@ -36 +36 @@
          }
 
-         const AbstractDataOutput* getDataOutput(void) const { return (output); }
+         AbstractDataOutput* getDataOutput(void) const { return (output); }
          void initializeDataOutput(AbstractDataOutput* _output)
          {
@@ -96 +96 @@
          }
 
-         FieldGroup* getVirtualFieldGroup(void) { return (vfieldGroup); }
+         FieldGroup* getVirtualFieldGroup(void) const { return (vfieldGroup); }
 
-         void findEnabledFields(int default_outputlevel = 5, int default_level = 1, bool default_enabled = true )
+         void findEnabledFields(const Date& inidate, int default_outputlevel = 5, int default_level = 1, bool default_enabled = true )
          {
             const int _outputlevel = (output_level.hasValue()) ? (int)output_level : default_outputlevel;
@@ -128 +128 @@
                   { enabledFields.erase(it); continue; }
                }
+
+               // Le champ est finalement actif, on ajoute la référence au champ de base.
+               (*it)->getBaseObject()->addRefObject(*it);
+               (*it)->setRelFile(this);
+               (*it)->initLastStoredDate(inidate);
             }
          }
@@ -134 +139 @@
          {
             for (unsigned int i = 0; i < enabledFields.size(); i++)
-               enabledFields[i]->SolveGridRef();
+               enabledFields[i]->solveGridRef();
          }
 
@@ -147 +152 @@
          FieldGroup* vfieldGroup; // FieldGroup "virtuel"
          std::vector<CField*> enabledFields; // Liste des champs à sortie dans le fichier courant.
+
          AbstractDataOutput* output; // Gestion de la sortie des données.
 

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

@@ -30 +30 @@
          bool _hasAxis(void) const { return (hasAxis); }
 
-         inline void storeField(const Array<double, 1>& field, Array<double, 1>& stored);
-         inline void storeField(const Array<double, 2>& field, Array<double, 1>& stored);
-         inline void storeField(const Array<double, 3>& field, Array<double, 1>& stored);
-         inline void storeField(const double* const data, Array<double, 1>& stored);
-
-         inline void outputField(const Array<double,1>& stored, Array<double, 2>& outField);
-         inline void outputField(const Array<double,1>& stored, Array<double, 3>& outField);
+         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);
@@ -207 +207 @@
    }
 
-   void CGrid::storeField(const Array<double, 1>& field, Array<double, 1>& stored)
+   void CGrid::storeField(const Array<double, 1>& field, Array<double, 1>& stored) const
    {
       storeField(field.dataFirst(), stored) ;
@@ -213 +213 @@
    }
 
-   void CGrid::storeField(const Array<double, 2>& field, Array<double, 1>& stored)
+   void CGrid::storeField(const Array<double, 2>& field, Array<double, 1>& stored) const
    {
       storeField(field.dataFirst(), stored) ;
@@ -219 +219 @@
    }
 
-   void CGrid::storeField(const Array<double, 3>& field, Array<double, 1>& stored)
+   void CGrid::storeField(const Array<double, 3>& field, Array<double, 1>& stored) const
    {
       storeField(field.dataFirst(), stored) ;
@@ -225 +225 @@
    }
 
-   void CGrid::storeField(const double* const data, Array<double, 1>& stored)
+   void CGrid::storeField(const double* const data, Array<double, 1>& stored) const
    {
       int size = storeIndex.size() ;
@@ -237 +237 @@
    }
 
-   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 2>& outField)
+   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 2>& outField) const
    {
       for(int n = 0; n < storeIndex.size(); n++)
@@ -243 +243 @@
    }
 
-   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 3>& outField)
+   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/object_template.hpp

@@ -43 +43 @@
          string getName(void) const {return (T::GetName()); }
 
-         const T* getBaseObject(void) const { return (baseObject); }
+         T* getBaseObject(void) const { return (baseObject); }
 
          virtual T* getReference(void) const { return (NULL); }
+
+         const vector<T*>& getVectRefObject(void) const { return (refObject); }
+
+         bool hasRefObject(void) { return (!refObject.empty()); }
+
+         const T* addRefObject(T* obj)
+         { refObject.push_back (obj); return (obj); }
 
          virtual bool hasChild(void) const { return (false); }
@@ -78 +85 @@
             // Rien à faire.
          }
+
+      public : /* static */
 
          static T* CreateObject(const string& _id) throw (XMLIOUndefinedValueException)
@@ -119 +128 @@
       protected :
 
-         ObjectTemplate(void) : AbstractObject(), baseObject(NULL)
+         ObjectTemplate(void) : AbstractObject(), baseObject(NULL), refObject()
          {/* Ne rien faire de plus */}
-         ObjectTemplate(const string& _id) : AbstractObject(_id), baseObject(NULL)
+         ObjectTemplate(const string& _id) : AbstractObject(_id), baseObject(NULL), refObject()
          {/* Ne rien faire de plus */}
 
@@ -145 +154 @@
       private :
          T* baseObject;
+         vector<T*> refObject;
 
          static string CurrContext;

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

@@ -7 +7 @@
 #include <cmath>
 
+
+// Conteneurs.
 #include <vector>
 #include <set>
 
+//Flux.
 #include <iostream>
 #include <fstream>
@@ -54 +57 @@
 #include "object_template.hpp"
 
+// Traitement des opérations sur les champs
+#include "field_operation.hpp"
+
 // Gestion des attributs des objets.
 #include "grid_attribut.hpp"
@@ -60 +66 @@
 #include "field_attribut.hpp"
 #include "file_attribut.hpp"
-
-// Traitement des opérations sur les champs
-#include "field_operation.hpp"
 
 #include "group_template.hpp"
@@ -74 +77 @@
 #include "file.hpp"
 
-// Résolution des références aux grilles pour les champs.
-#include "field_gridrefsolver.hpp"
-
 //....
 #include "context.hpp"
 #include "xml_parser.hpp"
 
+// Résolution des références aux grilles pour les champs.
+#include "field_gridrefsolver.hpp"
 
 // Gestion de l'écriture des données NetCDF
@@ -89 +91 @@
 #include "NetCDF4_data_treatment.hpp"
 
+
+
 #endif // __XMLIO__