FFrResultContainer.H

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 SAP SE
//
// SPDX-License-Identifier: Apache-2.0
//
// This file is part of FEDEM - https://openfedem.org
 
#ifndef FFR_RESULT_CONTAINER_H
#define FFR_RESULT_CONTAINER_H
 
#include <string>
#include <vector>
#include <map>
#include <set>
 
#include "FFrLib/FFrVariable.H"
#include "FFrLib/FFrItemGroup.H"
#include "FFaLib/FFaOS/FFaIO.H"
 
class FFrExtractor;
class FFrVariableReference;
 
 
typedef std::map<double,int>       FFrTimeMap;
typedef std::vector<FFrEntryBase*> FFrEntrySet;
 
struct FFrCreatorData
{
  std::map<int,FFrVariable*>  variables;
  std::map<int,FFrItemGroup*> itemGroups;
  FFrEntrySet&  topLevelEntries;
  VariableSet*  extractorVariables;
  ItemGroupSet* extractorIGs;
  std::set<std::string>* dict;
 
  FFrCreatorData(FFrEntrySet& tl, VariableSet* vars, ItemGroupSet* itgs,
                 std::set<std::string>* tdic) : topLevelEntries(tl)
  {
    extractorVariables = vars;
    extractorIGs       = itgs;
    dict               = tdic;
  }
};
 
 
class FFrResultContainer
{
public:
  FFrResultContainer(FFrExtractor* extractor, const std::string& fileName);
  ~FFrResultContainer();
 
  FFrResultContainer(const FFrResultContainer&) = delete;
  FFrResultContainer& operator=(const FFrResultContainer&) = delete;
 
  enum Status {
    FFR_CONTAINER_INVALID = 1,
    FFR_NO_FILE_FOUND,
    FFR_TEXT_FILE,
    FFR_TEXT_PRESENT,
    FFR_NEW_TEXT,
    FFR_HEADER_INCOMPLETE,
    FFR_HEADER_COMPLETE,
    FFR_DATA_CLOSED,
    FFR_DATA_PRESENT,
    FFR_NEW_DATA
  };
 
  Status close();
 
  Status updateContainerStatus();
 
  Status getContainerStatus() const { return myStatus; }
  bool isHeaderComplete() const { return myStatus >= FFR_HEADER_COMPLETE; }
 
  const std::string& getFileName() const { return myFileName; }
  unsigned int getDate() const { return myDate; }
 
  int getStepsInFile() const { return myPhysicalTimeMap.size(); }
  int getStepSize() const { return timeStepSize; }
  FT_int getHeaderSize() const { return myHeaderSize; }
 
  void printInfo() const;
 
  const FFrEntrySet& topLevel() const { return myTopLevelEntries; }
  const FFrTimeMap& getPhysicalTime() const { return myPhysicalTimeMap; }
 
  int positionAtKey(double key, bool getNextHigher = false);
  bool isPositioned() const { return myPositionedTimeStep > 0; }
  void resetPositioning();
 
 
  int readPositionedTimestepData(const double* values, int nvals,
                 int bitPos, int cellBits, int repeats)
  {
    return this->actualRead((void*)values,nvals,bitPos,cellBits,repeats);
  }
 
  int readPositionedTimestepData(const float* values, int nvals,
                 int bitPos, int cellBits, int repeats)
  {
    return this->actualRead((void*)values,nvals,bitPos,cellBits,repeats);
  }
 
  int readPositionedTimestepData(const int* values, int nvals,
                 int bitPos, int cellBits, int repeats)
  {
    return this->actualRead((void*)values,nvals,bitPos,cellBits,repeats);
  }
 
 
  enum PositionStatus {
    FFR_NOT_SET,
    FFR_BEFORE_START,
    FFR_INSIDE,
    FFR_AFTER_END
  };
 
  PositionStatus getPositioningStatus() const { return myWantedKeyStatus; }
  double getCurrentKey() const { return this->getKey(0); }
  double getFirstKey() const { return this->getKey(1); }
  double getLastKey() const { return this->getKey(2); }
 
  double getDistanceFromPosKey(bool usePositionedKey = false) const;
  bool getDistanceToNextKey(double& dist);
 
  void collectGarbage(FFrEntryBase* entry);
 
  void enablePreRead(bool f) { if (!(iAmPreReading = f)) this->clearPreRead(); }
  bool isPreReadEnabled() const { return iAmPreReading; }
  void clearPreRead();
 
protected:
  void printSizeParameters(FT_int fileSize) const;
 
  bool readFileHeader();
  FFrStatus readVariables(FILE* fp, FFrCreatorData& cd,
                          bool dataBlocks = false);
 
  bool buildAndResolveHierarchy();
  bool readTimeStepInformation();
  bool readText();
  bool reopenForDataAccess();
  void fillPreRead();
  double getKey(int flag) const;
  int actualRead(void* var, int nvals, int bitPos, int cellBits, int repeats);
 
private:
  FFrVariableReference* myPhysTimeRef; 
 
  // data info
  bool    swapBytes;    
  int     timeStepSize; 
  FT_int  myHeaderSize; 
  FILE*   myFile;       
  FT_FILE myDataFile;   
  Status  myStatus;     
 
  // header info
  std::string  myFileName; 
  std::string  myModule;   
  unsigned int myDate;     
 
  // extractor info
  FFrExtractor*  myExtractor;       
  FFrEntrySet    myTopLevelEntries; 
  FFrEntrySet    myGarbage;         
 
  // information for pre-positioning of the container
  int myPositionedTimeStep; 
  int myLastReadEndPos;     
 
  FFrTimeMap           myPhysicalTimeMap; 
  FFrTimeMap::iterator myCurrentIndexIt;  
 
  double         myWantedKey;       
  PositionStatus myWantedKeyStatus; 
 
  bool iAmLazyPositioned; 
  bool iAmPreReading;     
 
  char* myPreRead;         
  int   myPreReadTimeStep; 
};
 
#endif