DataFieldInfo.h

Go to the documentation of this file.

//===-- serialbox/core/frontend/stella/DataFieldInfo.h ------------------------------*- C++ -*-===//
//
//                                    S E R I A L B O X
//
// This file is distributed under terms of BSD license.
// See LICENSE.txt for more information
//
//===------------------------------------------------------------------------------------------===//
//
//===------------------------------------------------------------------------------------------===//

#ifndef SERIALBOX_CORE_FRONTEND_STELLA_DATAFIELDINFO_H
#define SERIALBOX_CORE_FRONTEND_STELLA_DATAFIELDINFO_H

#include "serialbox/core/frontend/stella/ForwardDecl.h"
#include "serialbox/core/frontend/stella/IJKBoundary.h"
#include "serialbox/core/frontend/stella/IJKSize.h"
#include "serialbox/core/frontend/stella/MetainfoSet.h"
#include "serialbox/core/frontend/stella/TypeName.h"

namespace serialbox {

namespace stella {

class DataFieldInfo {
public:
  DataFieldInfo();

  DataFieldInfo(const boost::shared_ptr<FieldMetainfoImpl>& fieldMetainfoImpl);

  DataFieldInfo(const DataFieldInfo& other);

  DataFieldInfo& operator=(const DataFieldInfo& other);

  template <typename TDataField>
  void Init(const TDataField& dataField) {
    Init(dataField, dataField.name());
  }

  template <typename TDataField>
  void Init(const TDataField& dataField, std::string name) {
    // Get the calculation domain
    IJKSize domain;
    domain.Init(dataField.calculationDomain().iSize(), dataField.calculationDomain().jSize(),
                dataField.calculationDomain().kSize());

    IJKSize size;
    size.Init(dataField.storage().allocatedSize().iSize(),
              dataField.storage().allocatedSize().jSize(),
              dataField.storage().allocatedSize().kSize());

    // Get the size of the halo
    IJKBoundary boundary;
    boundary.Init(dataField.boundary().iMinusOffset(), dataField.boundary().iPlusOffset(),
                  dataField.boundary().jMinusOffset(), dataField.boundary().jPlusOffset(),
                  dataField.boundary().kMinusOffset(), dataField.boundary().kPlusOffset());

    // Workaround for boundary() not returning what it should
    const bool haloInI = !(size.iSize() <= domain.iSize());
    const bool haloInJ = !(size.jSize() <= domain.jSize());
    const bool haloInK = !(size.kSize() <= domain.kSize());
    const int iMinus = haloInI ? -boundary.iMinusOffset() : 0;
    const int iPlus = haloInI ? boundary.iPlusOffset() : 0;
    const int jMinus = haloInJ ? -boundary.jMinusOffset() : 0;
    const int jPlus = haloInJ ? boundary.jPlusOffset() : 0;
    const int kMinus = haloInK ? -boundary.kMinusOffset() : 0;
    const int kPlus = haloInK ? boundary.kPlusOffset() : 0;

    // Delegate the initialization
    Init(name, type_name<typename TDataField::ValueType>(), sizeof(typename TDataField::ValueType),
         dataField.storage().rank(), size.iSize(), size.jSize(), size.kSize(), 1, iMinus, iPlus,
         jMinus, jPlus, kMinus, kPlus, 0, 0);
  }

  void Init(std::string name, std::string type, int bytesPerElement, int rank, int iSize, int jSize,
            int kSize, int lSize, int iMinusHalo, int iPlusHalo, int jMinusHalo, int jPlusHalo,
            int kMinusHalo, int kPlusHalo, int lMinusHalo, int lPlusHalo);

  const MetainfoSet& metainfo() const { return metainfo_; }

  std::string name() const;

  std::string type() const;

  int dataSize() const { return bytesPerElement() * iSize() * jSize() * kSize() * lSize(); }

  int bytesPerElement() const;

  int rank() const;

  int iSize() const;

  int jSize() const;

  int kSize() const;

  int lSize() const;

  int iMinusHaloSize() const;

  int iPlusHaloSize() const;

  int jMinusHaloSize() const;

  int jPlusHaloSize() const;

  int kMinusHaloSize() const;

  int kPlusHaloSize() const;

  int lMinusHaloSize() const;

  int lPlusHaloSize() const;

  int fieldLength() const { return bytesPerElement() * iSize() * jSize() * kSize() * lSize(); }

  IJKSize calculationDomain() const {
    IJKSize size;
    size.Init(iSize() - iMinusHaloSize() - iPlusHaloSize(),
              jSize() - jMinusHaloSize() - jPlusHaloSize(),
              kSize() - kMinusHaloSize() - kPlusHaloSize());
    return size;
  }

  IJKSize size() const {
    IJKSize size;
    size.Init(iSize(), jSize(), kSize());
    return size;
  }

  IJKBoundary boundary() const {
    IJKBoundary boundary;
    boundary.Init(-iMinusHaloSize(), iPlusHaloSize(), -jMinusHaloSize(), jPlusHaloSize(),
                  -kMinusHaloSize(), kPlusHaloSize());
    return boundary;
  }

  template <typename ValueType>
  void AddMetainfo(const std::string& key, const ValueType& value) {
    metainfo_.AddMetainfo(key, value);
  }

  bool operator==(const DataFieldInfo& other) const;

  inline bool operator!=(const DataFieldInfo& other) const { return !(*this == other); }

  std::string ToString() const;

  void setImpl(const boost::shared_ptr<FieldMetainfoImpl>& fieldMetainfoImpl);

  boost::shared_ptr<FieldMetainfoImpl>& getImpl();
  const boost::shared_ptr<FieldMetainfoImpl>& getImpl() const;

private:
  boost::shared_ptr<FieldMetainfoImpl> fieldMetainfoImpl_;
  MetainfoSet metainfo_; // Allow refrence access
};

} // namespace stella

} // namespace serialbox

#endif