BinaryFormat2.hxx

Go to the documentation of this file.

/*
  This file is part of MURE,
  Copyright (C) 2007-2021 MURE developers.
 
  MURE is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  MURE is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with MURE.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef _BINARYFORMAT2_
#define _BINARYFORMAT2_
 
#include <fstream>
using namespace std;
 
struct FileHeader
{
    FileHeader()
    {
        Version = 2;   
    }
    short Version;              
    float Time;                 
    float K;                    
    float Kerr;                 
    float Power;                    
    int NCells;                 
    void write(ofstream &out);  
    void read(ifstream &in, int version);   
};
 
struct CellHeader
{
    int CellNumber;     
    float Volume;       
    float Flux;         
    float FluxErr;      
    float Power;        
    float Burnup;       
    int NNucleusRecords;        
    void write(ofstream &out);  
    void read(ifstream &in, int version);   
};
 
struct NucleusRecord
{
    short Z;    
    short A;    
    short I;    
    float Mass; 
    float Proportion;           
    short NReactionRecords;     
    void write(ofstream &out);  
    void read(ifstream &in, int version);   
};
 
struct ReactionRecord
{
    short Code;     
    float Sigma;    
    float SigmaErr; 
    void write(ofstream &out);  
    void read(ifstream &in, int version = 1);   
};
//--------------------------------------------------------
//  Implementation of methods
//-------------------------------------------------------
void FileHeader::write(ofstream &out)
{
    out.write((char *) & Version, sizeof(Version));
    out.write((char *) & Time, sizeof(Time));
    out.write((char *) & K, sizeof(K));
    out.write((char *) & Kerr, sizeof(Kerr));
    out.write((char *) & Power, sizeof(Power));
    out.write((char *) & NCells, sizeof(NCells));
}
 
void FileHeader::read(ifstream &in, int version)
{
    in.read((char *) & Version, sizeof(Version));
    in.read((char *) & Time, sizeof(Time));
    in.read((char *) & K, sizeof(K));
    in.read((char *) & Kerr, sizeof(Kerr));
    if(version > 1)
        in.read((char *) & Power, sizeof(Power));
    in.read((char *) & NCells, sizeof(NCells));
}
 
void CellHeader::write(ofstream &out)
{
    out.write((char *) & CellNumber, sizeof(CellNumber));
    out.write((char *) & Volume, sizeof(Volume));
    out.write((char *) & Flux, sizeof(Flux));
    out.write((char *) & FluxErr, sizeof(FluxErr));
    out.write((char *) & Power, sizeof(Power));
    out.write((char *) & Burnup, sizeof(Burnup));
    out.write((char *) & NNucleusRecords, sizeof(NNucleusRecords));
}
 
void CellHeader::read(ifstream &in, int version)
{
    in.read((char *) & CellNumber, sizeof(CellNumber));
    in.read((char *) & Volume, sizeof(Volume));
    in.read((char *) & Flux, sizeof(Flux));
    in.read((char *) & FluxErr, sizeof(FluxErr));
    if ( version > 2 )
    {
        in.read((char *) & Power, sizeof(Power));
        in.read((char *) & Burnup, sizeof(Burnup));
    }
    else
    {
        Power = 0.;
        Burnup = 0.;
    }
 
    in.read((char *) & NNucleusRecords, sizeof(NNucleusRecords));
}
 
void NucleusRecord::write(ofstream &out)
{
    out.write((char *) & Z, sizeof(Z));
    out.write((char *) & A, sizeof(A));
    out.write((char *) & I, sizeof(I));
    out.write((char *) & Mass, sizeof(Mass));
    out.write((char *) & Proportion, sizeof(Proportion));
    out.write((char *) & NReactionRecords, sizeof(NReactionRecords));
}
 
void NucleusRecord::read(ifstream &in, int version)
{
    in.read((char *) & Z, sizeof(Z));
    in.read((char *) & A, sizeof(A));
    in.read((char *) & I, sizeof(I));
    in.read((char *) & Mass, sizeof(Mass));
    in.read((char *) & Proportion, sizeof(Proportion));
    in.read((char *) & NReactionRecords, sizeof(NReactionRecords));
}
 
void ReactionRecord::write(ofstream &out)
{
    out.write((char *) & Code, sizeof(Code));
    out.write((char *) & Sigma, sizeof(Sigma));
    out.write((char *) & SigmaErr, sizeof(SigmaErr));
}
 
void ReactionRecord::read(ifstream &in, int version)
{
    in.read((char *) & Code, sizeof(Code));
    in.read((char *) & Sigma, sizeof(Sigma));
    in.read((char *) & SigmaErr, sizeof(SigmaErr));
}
 
 
#endif