EMMH_HysteresisFile.hpp

Go to the documentation of this file.

#include "EMMH_HysteresisFile.h"

template<class T>
tBoolean EMMH_HysteresisFile::load(const tString& fileName,
                                   EMM_RealArray* Hext,
                                   EMM_Array<T>* M,
                                   tUIndex& n,
                                   tUSInt& dim,
                                   tUInteger& iData,
                                   tUInteger& iHCycle,
                                   tUSInt& s) const {


    //return velue of the method
    tBoolean succeeds=true;

    //init the last 1/2 cycle read index
    iHCycle=0;
    
    //init the first index of the data of the half cycle c to compute
    iData=0;

    //index of the data
    tUInteger i=0;
    
    
    //open the hysteresis file
    ifstream fileHst(fileName.c_str(),ios::in);

    //number of steps of Hext
    n=0;

    //indicates if the current data is found
    tBoolean isCurrentDataFound=false;
    
    if (fileHst) {
        
        //number of lines
        tUInteger numLine=0;
        
        // for reading line
        tUInteger len=2048;
        char line[len];
        
        // for analysing line
        tUIndex nTokens=0;
        tString token;
        SP::CORE_String tokenizer=CORE_String::New();

        //dimension of M
        tUSInt k;

      
        //iterator on Hext
        tReal *Hi=null;
        
        //iterator on M
        T *Mi=null;
        
        //memory distance between 2 1/2 cycles for M
        tUInteger ldM=0;
        
        //current 1/2 cycles read in a line 
        tUInteger nHCycles;
    
        //max number of 1/2 cycles 
        tUInteger nMaxHCycles;
        
        tBoolean isFirstHCyclesNumberRead=false;

        

        // data step for saving magnetism file
        i=0;
        
        do {
            //current line
            numLine++;
            // read line 
            fileHst.getline(line,len);

            //analyse the line
            tokenizer->setString(line);
            tokenizer->tokenize(": , \t");
            nTokens=tokenizer->getTokensCount();

            //empty line
            if (nTokens==0) continue;

            //read the first token
            token=tokenizer->nextToken();

            //comment line
            if (token.find("#")==0) continue;
            

            //read the type of M
            if ( (nTokens==4) && (n==0) ) {
               
                //read the number of data per 1/2 cycle
                n=CORE_Integer::parseInt(token);

                //read the dim of M
                dim=CORE_Integer::parseInt(tokenizer->nextToken());

                //read the maximum number of half cycles
                nMaxHCycles=CORE_Integer::parseInt(tokenizer->nextToken());
                //init the current data
                iHCycle=0;
                iData=0;

                //read the step for saving the equilibrium magnetism field
                s=CORE_Integer::parseInt(tokenizer->nextToken());
                
                //set the size of H
                if (Hext!=null) {
                    Hext->setSize(3*n);
                    Hi=&(*Hext)[0];
                }

                //set the size of M
                if (M!=null) {
                    M->setSize(dim*n*nMaxHCycles);
                
                    //memory size between point at (i,iCycle) and point at (i-dim,iCycle+1)
                    ldM=(n-1)*dim;
                } else {
                    ldM=0;
                }
                
            } else {//read current line
                if ((dim==0) || (n==0)) {
                    cout << "error in reading the hysteresis file: M type can not be read or no data found \n";
                    succeeds=false;
                } 
                
               
                if (succeeds) {
                    if (nTokens>=3) {
                        //read H ext
                        if (Hext!=null) {
                            (*Hi)=CORE_Real::parseReal(token);
                            Hi++;
                            for (k=0;k<2;k++) {
                                token=tokenizer->nextToken();
                                (*Hi)=CORE_Real::parseReal(token);
                                Hi++;
                            }   
                        } else {
                            tokenizer->nextToken();
                            tokenizer->nextToken();
                        }
                        nTokens-=3;
                        
                        //read M at step s for all 1/2 cycles
                        //index=d+dim*(i+n*iHCycle)
                        Mi=null;
                        if (M!=null) {
                            //verify number of tokens is ok
                            if (nTokens/dim>nMaxHCycles) throw EMM_Exception("emicrom/hysteresis",
                                                                             "EMMH_HysteresisFile::load()",
                                                                             "number of cycles ("+CORE_Integer::toString(nTokens/dim)+") is greater than this indicated in header:"+CORE_Integer::toString(nMaxHCycles));
                            Mi=&(*M)[dim*i];
                            nHCycles=0;
                            while (nTokens>=dim) {
                                nHCycles++;
                                
                                for (k=0;k<dim;k++) {                              
                                    token=tokenizer->nextToken();
                                    CORE_String::parse(token,*Mi);
                                    Mi++;
                                
                                }
                                nTokens-=dim;   
                                Mi+=ldM;
                            }//end loop on reading data for each data step
                        } else {
                            nHCycles=nTokens/dim;
                        }
                        //nHCycle is the number of half cycles read
                        
                      
                        //set the first number of half cycles computed
                        if (!isFirstHCyclesNumberRead){
                            if (nHCycles==0) {
                                //no cycles
                                iHCycle=0;
                                isCurrentDataFound=true;
                            } else {
                                iHCycle=nHCycles-1;
                            }
                            isFirstHCyclesNumberRead=true;
                        } else if ( (!isCurrentDataFound) && (nHCycles<iHCycle+1)  )  {
                            //increment half cycle
                            iData=i;
                            isCurrentDataFound=true;;
                            
                        } else if ((!isCurrentDataFound) && (nHCycles>iHCycle+1)) {
                            //decrement half cycle
                            iData=i-1;
                            //half cycle to compute
                            iHCycle=nHCycles-1;
                            isCurrentDataFound=true;
                        }
                        
                      
                        
                        //next step
                        i++;
                        
                    }  else {//end nTokends>=3
                        cout << "error in reading the hysteresis file:not enough data to read Hext \n";
                        succeeds=false;
                    }
                }//end succeeds condition
                
            }//end reding current line
            //stop if any of those conditions are fullfilled:
            // - any error occurs
            // - all the data has been read
            // - end of file
            // - max num lines reached
        } while ( (succeeds) &&
                  ((n==0) || ( (n>0) && (i<n)) ) &&
                  ((Hext!=null) || !isCurrentDataFound)  &&
                  (!fileHst.eof()) && (numLine<MAX_LINES) );

        //close the file
        fileHst.close();
    } else {
        cout << "error in opening the file "<<fileName<<"\n";
        succeeds=false;
    }


    if (!isCurrentDataFound) {
        //all the data for the last half cycles has been computed
        //set the next data to first data of next half cycle
        iHCycle++;
        if (iHCycle%2==0) iData=0;
        else iData=n-1;
    } 
    
    return succeeds;
}

template<class T>
tBoolean EMMH_HysteresisFile::save(const tString& fileName,
                                   const tString& comment,
                                   const EMM_RealArray& Hext,
                                   const EMM_Array<T>& M,
                                   const tUSInt& dim,
                                   const tUInteger& iData,
                                   const tUInteger& iHCycle,
                                   const tUSInt& s) const {

    
    //interator on data
    tUIndex i,n=Hext.getSize();
    
    //number of data
    n/=dim;
    
    //cycles
    tUSInt c,nMaxHCycles;
    
    tUSInt d;
  
    //compute max number of  H Cycles
    nMaxHCycles=(M.getSize()/(n*dim));

    //memory size between point at (i,iCycle) and point at (i-dim,iCycle+1)
    tUIndex ldM=(n-1)*dim;

    //open the hysteresis file
    ofstream fileHst(fileName.c_str(),ios::out);
    if (fileHst) {
        fileHst << "# hysteresis file modified by e-microm"<<endl;
        fileHst << comment <<endl;
        fileHst << "# N: number of data per half cycle"<<endl;
        fileHst << "# D : dimension of the field per data"<<endl;
        fileHst << "# nHCycles : number of half cycles"<<endl;
        fileHst << "# S : steps number for saving equilibrium magnetism"<<endl;
        fileHst<< n<<"\t"<<dim<<"\t"<<nMaxHCycles<<"\t"<<s<<endl;
        fileHst << "# Hext : M^0_x M^0_y M^0_z M^1_x M^1_y M^1_z ..."<<endl;
        //iterator on H
        const tReal *Hi=&Hext[0];
        //iterator on M
        const T *Mci,*Mi=&M[0];
        for (i=0;i<n;i++) {
            //print Hext
            for (d=0;d<3;d++) {
                fileHst<<(*Hi)<<"\t";
                Hi++;
            }
            fileHst<<":\t";
            
            Mci=Mi;
            //save for all data value for half-cycle in [0,iHCycle[
            for (c=0;c<iHCycle;c++) {
                for (d=0;d<dim;d++) {
                    fileHst<<(*Mci)<<"\t";
                    Mci++;
                }
                Mci+=ldM;
            }
            //for last cycle iHCycle
            //save all data in [0,iData] if iHycle is pair
            //save all adat in [iData,n[ if iHcycle is impair
            if (iHCycle%2==0) {
                if (i<=iData) {
                    for (d=0;d<dim;d++) {
                        fileHst<<(*Mci)<<"\t";
                        Mci++;
                    }
                }
            } else {
                if (i>=iData) {
                    for (d=0;d<dim;d++) {
                        fileHst<<(*Mci)<<"\t";
                        Mci++;
                    }
                }
            }
            
            
            //all cycles with data  saved
            fileHst<<"\n";
            
            Mi+=dim;
        }
        
    } else {
        cout << "impossible to open the hysteresis file "<<fileName<<"\n";
        return false;
    }
    return true;
}

template<class T>
tBoolean EMMH_HysteresisFile::append(const tString& inFileName,
                                     const EMM_Array<T>& M,
                                     const tUSInt& dim,
                                     const tUSInt& flowSize) const {
    
    
    tString outFileName=inFileName+"~";

    tUSInt k;
    
    tUInteger i0,c0;
    tUInteger i,c;
    tUInteger nHCycles;
    
    tUIndex n;
    tUSInt s;
    tUSInt dim0;
    
    //load the current hysteresis data to fill
    load(inFileName,null,(EMM_Array<T>*) null,n,dim0,i0,c0,s);
    
    if (dim0!=dim) {
        throw EMM_Exception("emicrom/hsyteresis",
                            "EMMH_HysteresisFile::append(...)",
                            "incompatible hysteresis file "+inFileName+" dimension are not the same "+CORE_Integer::toString(dim0)+" with the append one "+CORE_Integer::toString(dim));
        return false;
    }  

    //open the file for reading
    ifstream iFileHst(inFileName.c_str(),ios::in);
  
    //open the file for writing
    ofstream oFileHst(outFileName.c_str(),ios::out);

    
    // the index of the point is as follow:
    //index(i,c)=\sum_{k=0}^{k=c} u_k with u_0=i u_{2p}=2i+1 and u_{2p+1}=2*(n-1-i)+1 
    tUIndex index,index1,index0=i0;
    for (c=1;c<=c0;c++) {
        index0+=((c%2==1)?(2*(n-1-i0)+1):(2*i0+1));
    }
    index1=index0+flowSize;
    
    if (iFileHst && oFileHst) {
        
        //number of lines
        tUInteger numLine=0;
        
        // for reading line
        tUInteger len=2048;
        char line[len];
        
        // for analysing line
        tUIndex nTokens=0;
        tString token;
        SP::CORE_String tokenizer=CORE_String::New();


        //iterator on M
        const T *Mi;
        
        
        //data
        i=0;
        tBoolean hasDataBeenRead=false;
        
        do {
            //current line
            numLine++;
            
            // read line 
            iFileHst.getline(line,len);
            
            //analyse the line
            tokenizer->setString(line);
            tokenizer->tokenize(": , \t");
            nTokens=tokenizer->getTokensCount();

            //empty line
            if (nTokens==0) continue;

            //read the first token
            token=tokenizer->nextToken();

            //comment line
            if (token.find("#")==0) {
                oFileHst<<line<<"\n";
                continue;
            } 
            
            
            //read the type of M
            if ( (nTokens==4) && (!hasDataBeenRead) ) {
                //read the number of data per 1/2 cycle : ignored because already read
                //n=CORE_Integer::parseInt(token);

                //read the dim of M
                dim0=CORE_Integer::parseInt(tokenizer->nextToken());

                //read the maximum number of half cycles
                tUInteger nMaxHCycles=CORE_Integer::parseInt(tokenizer->nextToken());
                c=c0+(i0+flowSize)/n;
                if (c>nMaxHCycles) nMaxHCycles=c;

                //read the step for saving the equilibrium magnetism field
                //s=CORE_Integer::parseInt(tokenizer->nextToken());
                //update the data
                oFileHst<< n<<"\t"<<dim<<"\t"<<nMaxHCycles<<"\t"<<flowSize<<endl;
                hasDataBeenRead=true;
                continue; 
            } else {//read current line
                
                
                if (nTokens>=3) {
                    //read H ext
                    tokenizer->nextToken();
                    tokenizer->nextToken();
                    nTokens-=3;
                   
                    //compute the number of cycles of the line
                    nHCycles=nTokens/dim;

                    //write the cycles
                    oFileHst<<line;

                    //compute the index of the last data read
                    index=0;
                    if (nHCycles>0) {
                        //c=0
                        index+=i;
                        //c>0
                        for (c=1;c<nHCycles;c++) {
                            index+=((c%2==1)?(2*(n-1-i)+1):(2*i+1));
                        }
                    }
                    
                    //compute the index of the next data to write
                    c=nHCycles;
                    if (c==0) index+=i;
                    else index+=((c%2==1)?(2*(n-1-i)+1):(2*i+1));

                    
                    //fill the next datas
                    while ((index>=index0) && (index<index1)) {
                        Mi=&M[dim*(index-index0)];
                        for (k=0;k<dim;k++) {
                            oFileHst<<(*Mi)<<"\t";
                            Mi++;
                        }
                      
                        //index for the next cycle
                        c++;
                        index+=((c%2==1)?(2*(n-1-i)+1):(2*i+1));
                    }

                    //next data
                    oFileHst<<"\n";
                    i++;
                        
                        
                }//end data reading
                
            }//end reding current line
            //stop if anu of those conditions are fullfilled:
            // - all the data has been read
            // - all the data has been written
            // - end of file
            // - max num lines reached
        } while ( ((n==0) || ( (n>0) && (i<n)) )
                  && (!iFileHst.eof()) 
                  && (numLine<MAX_LINES) );

        //close the i/o files
        iFileHst.close();
        oFileHst.close();
       

    } else {
        cout << "impossible to open the hysteresis file "<<inFileName<<" for reading and "<<outFileName<<" for writing \n";
        return false;
        
    }

    
    
    //rename the file
    CORE_IO::mv(outFileName,inFileName);

    return true;


}