EMM_Array.hpp

Go to the documentation of this file.

#ifndef EMM_Array_HPP
#define EMM_Array_HPP

#include "CORE_Time.h"
#include "CORE_Out.h"
#include "EMM_Exception.h"


template<class T>
tBoolean EMM_Array<T>::saveToFile(const tString& fileName) const {
   ofstream f(fileName.c_str(),ios::out);
   
   if (f) {
       CORE_Time time;
       f << "# file generated at "<<time.toString("DD/MM/YYYY-HHhMM")<<"\n";
       f << "# save a steady field \n";
       f << "#N is the number of points\n";
       f << "#values : the values of the array. One value by line\n";
       tUIndex n=CORE_Array<T>::getSize();
       f <<n<<"\n";

       //save to stream
       saveToStream(f,1);
     
   
       //free the file pointer
       f.close();
   } else {
       throw EMM_Exception("EMM_Array::saveToFile("+fileName+")","impossible to open file for saving");
       return false;
   }
   return true;
}


template<class T>
tBoolean EMM_Array<T>::saveToStream(ofstream& f,const tUSInt& dim) const {
    tUIndex n=CORE_Array<T>::getSize();
    tUIndex i,p=n/dim;
    tUSInt j;
    
    const T *vs=&(*this)[0];
    //read all the points
    for (i=0;i<p;i++) {
        //copy dim values per line
        for (j=0;j<dim;j++) { 
            f << CORE_String::toString(*vs)<<"\t";   
            vs++;
        }
        f<<"\n";
    }
    return true;
}

template<class T>
tBoolean EMM_Array<T>::saveToStream(ofstream& f,const vector<tUSInt>& dims,const vector<const EMM_Array<T>*>& indics) {

    tUIndex nIndics=indics.size();
    //verify the size of dims equals to size of indics
    if (dims.size()!=indics.size()) return false;
    
    //verify the packs number are the same
    //packs number
    tUIndex nPacks=0;
    //pointers to indicator
    
    vector<const T*> arrays(nIndics);
    typename vector<const T* >::iterator iterA=arrays.begin();
    
    //iterator on indicators
    typename vector<const EMM_Array<T>*>::const_iterator iterI=indics.begin();
    
    //iterator on dimension of packs
    typename vector<tUSInt>::const_iterator iterD=dims.begin();
    
    while (iterI!=indics.end()) {
        //set the pointer
        *iterA=&(*(*iterI))[0];

        if (nPacks==0) {
            //compute the numbe rof packs
            nPacks=(*iterI)->getSize()/(*iterD);
        } else {
            //the number of packs must be the same for all indicators
            if ((*iterI)->getSize()/(*iterD)<nPacks) return false;
        }
        //next iter
        iterI++;
        iterD++;
        iterA++;
    }


    //write the arrays
    tUIndex i;
    tUSInt j;
    for (i=0;i<nPacks;i++) {
        //write the indicators by packed of size (*iterD)
        iterD=dims.begin();
        for (iterA=arrays.begin();iterA!=arrays.end();iterA++) {
            for (j=0;j<(*iterD);j++)  {
                //write the values of the indicator
                f << CORE_String::toString((*(*iterA)))<<"\t";
                //next values of indicator
                (*iterA)++;
            }//loop on size of pack
            //next packs number of array 
            iterD++;
        }//loop on indicators
        f<<"\n";
    }//end loop on pack
    return true;
}

template<class T>
tBoolean EMM_Array<T>::loadFromFile(const tString& fileName) {
   ifstream f(fileName.c_str(),ios::in);
   
   if (f) {
       // number of line
       tUInteger numLine=0;
       tUInteger maxLines=CORE_Object::getMaxUInt();
       
       //for reading a line
       tUSInt len=1024;
       char line[len];
       
       //for analysing a line
       SP::CORE_String tokenizer=CORE_String::New();
       
       //number of tokens per line
       tUInteger nTokens;
       
       //index of comment char
       tUIndex iComment;

       
       tUIndex nPoints=0;

       
       tUInteger nEmptyLines=0,nMaxEmptyLines=10;
       
       while (!f.eof() && (numLine<maxLines) && (nEmptyLines<nMaxEmptyLines) ) {
           //read the line
           f.getline(line,len);
           numLine++;
       
           //analyse the line
           tokenizer->setString(line);
           
           //ignore comment part
           iComment=tokenizer->getString().find("#");
           if (iComment!=tString::npos) {
               
               //comment line
               if (iComment==0) continue;
               
               //ignore all chars after #
               tokenizer->setString(tokenizer->getString().substr(0,iComment));
           }
           
           //erase blanks before and after line
           tokenizer->trim();
           
           //anaylyse all the tokens of the line
           tokenizer->tokenize();
           
           //get the number of token
           nTokens=tokenizer->getTokensNumber();
           if (nTokens==0) {
               nEmptyLines++;
               
           } else {
               nEmptyLines=0;
               if ((nPoints==0) && (nTokens>=1)) {
                   //read the number of points
                   nPoints=CORE_Integer::parseInt(tokenizer->nextToken());
                   CORE_Array<T>::setSize(nPoints);
                   
                   //load the data from stream
                   if (nPoints>0) loadFromStream(f,1);
                   
               }
           }

         
           
       }//reading next line
           
      
   
       //free the file pointer
       f.close();
       if (nEmptyLines>=nMaxEmptyLines) {
           throw EMM_Exception("EMM_Array::loadFromFile("+fileName+")"," too many empty lines detected "+
                               CORE_Integer::toString(nEmptyLines)+ "max empty lines is "+CORE_Integer::toString(nMaxEmptyLines) );
           return false;
       }
   } else {
       throw EMM_Exception("EMM_Array::loadFromFile("+fileName+")","impossible to open file");
       return false;
   }
   return true;
}

template<class T>
tBoolean EMM_Array<T>::loadFromStream(ifstream& f,const tUSInt& dim) {
    tUIndex n=CORE_Array<T>::getSize();

    //number of packs
    tUIndex i,p=n/dim;
    tUSInt j;
    T *vs=&(*this)[0];
    //read all the points
    for (i=0;i<p;i++) {
        //read the values by pack of size dim
        for (j=0;j<dim;j++) {
            if (f.eof()) {
                throw EMM_Exception("EMM_Array<T>::loadFromStream(f,dim)",
                                    "unexpected end of file for reading pack "+CORE_Integer::toString(i)+" of size "+CORE_Integer::toString(dim));
            }
            f >> (*vs);   
            if (isnan(*vs)) {
                throw EMM_Exception("EMM_Array<T>::loadFromStream(...)",
                                    "nan error in reading file at line "+CORE_Integer::toString(i));
            }    
            vs++;
        } //end loop on j
       
    }//end loop on i
   
    return true;
}
template<class T>
tBoolean EMM_Array<T>::loadFromStream(ifstream& f,const vector<tUSInt>& dims,const vector<EMM_Array<T>* >& arrays) const {
  
  
    
    //number of arrays to load
    tUIndex nArrays=arrays.size();
    
    //dims'size & arrays'size must be same
    if (dims.size()!=arrays.size()) return false;
    

    //vector of pointers of arrays
    vector<T*> Parrays(nArrays);
    typename vector<T* >::iterator iterP=Parrays.begin();
    
    //arrays interator
    typename vector<EMM_Array<T>*>::const_iterator iterA=arrays.begin();
    
    //dim iterator
    typename vector<tUSInt>::const_iterator iterD=dims.begin();

    //fill the pointer arrays
    // get the size of the pointers
    tUIndex size=0;
    while (iterA!=arrays.end()) {
        //set the pointer of indicators
        *iterP=&(*(*iterA))[0];
        //compute the size of arrays: size*dim=array.size()
        if (size==0) {
            //initialize it
            size=(*iterA)->getSize()/(*iterD);
        } else {
            //the size must be the same for each array to load
            if ((*iterA)->getSize()/(*iterD)<size) {
                CORE_Object::out().println(CORE_Out::ERROR_MSG,
                                           "error in reading aim file: the size of arrays to read is not compatible");
                return false;
            }
        }
        
        //next iter
        iterA++;
        iterD++;
        iterP++;
    }

    
    //read the arrays
    tUIndex i;
    tUSInt j,dim;
    tString token;
    tBoolean jumpLine=false;
    for (i=0;i<size;i++) {
       
        
        //loop on arrays
        iterD=dims.begin();
        iterP=Parrays.begin();
        while (iterP!=Parrays.end()) {
            dim=(*iterD);//dimension of the array
            T* &values=(*iterP);//values of the array
            
            for (j=0;j<dim;j++)  {
                //write the values of the indicator
                if (f.eof()) {
                    throw EMM_Exception("EMM_Array<T>::loadFromStream(...)",
                                        "unexpected end of file for reading pack "+CORE_Integer::toString(i)+" of size "+CORE_Integer::toString((*iterD)));
                }
                f >> token;
                if (CORE_String::isDigit(token[0])) {
                    (*values)=CORE_Real::parseReal(token);
                    //next values of arrays
                    values++;
                } else {
                    jumpLine=true;
                    break;
                }
                
            }
            if (jumpLine) break;
            //next array 
            iterD++;
            iterP++;
        }
        if (jumpLine) {
            size++;
            jumpLine=false;
        }
    }
    return true;
}


#endif