Index¶

class AdditionalConfiguration

Subclassed by Nextsim::NetcdfMetadataConfiguration

Public Functions

virtual ~AdditionalConfiguration() = default

virtual std::stringstream read(const std::string &source) = 0

class AnotherImpl : public Test::ITest2

class ArgV

Public Functions

ArgV(std::vector<std::string> vs)

~ArgV()

char **operator()()

int argc()

Private Members

int nStrings

char **ppc

class AtmIn : public Nextsim::MiniModelComponent

Public Functions

inline AtmIn(ModelArrayStore &store)

inline void configure()

inline void setData(const std::vector<FloatType> &values)

Private Members

ModelArrayAccessor<H_ICE0, RW> hiceAccessor

ModelArrayAccessor<SW_IN, RW> swinAccessor

class BBMDynamics : public Nextsim::IDynamics, public Nextsim::Configured<BBMDynamics>

Public Types

enum [anonymous]

Values:

enumerator C_KEY

enumerator NU_KEY

enumerator YOUNG_KEY

enumerator P0_KEY

enumerator LAMBDA0_KEY

enumerator ALPHA_KEY

enumerator EXPPMAX_KEY

enumerator MU_KEY

enumerator NMAX_KEY

enumerator CLAB_KEY

enumerator NSTEPS_KEY

enumerator RHOI_KEY

enumerator RHOA_KEY

enumerator RHOO_KEY

enumerator CATM_KEY

enumerator COCEAN_KEY

enumerator FC_KEY

enumerator ANGLE_KEY

Public Functions

BBMDynamics()

inline virtual std::string getName() const override

virtual void prepareAdvection() override

virtual void update(const TimestepTime &tst) override

virtual void advectField(FloatType timestep, ModelArray &field, FloatType lowerLimit = -std::numeric_limits<FloatType>::infinity(), FloatType upperLimit = std::numeric_limits<FloatType>::infinity()) override

virtual void setData(const ModelState::DataMap&) override

virtual void configure() override

virtual ConfigMap getConfiguration() const override

Public Static Functions

static HelpMap &getHelpText(HelpMap &map, bool getAll)

static HelpMap &getHelpRecursive(HelpMap&, bool getAll)

Private Members

BBMParameters params

BBMDynamicsKernel<3> kernel

class Bounds

Public Functions

inline Bounds()

inline Bounds(Index i)

inline Bounds(Index i, Index j)

inline Bounds(Index i, Index j, Int step_in)

inline std::ostream &print(std::ostream &os) const

Public Members

Index start

Index stop

Int step

friend SliceIter

Public Static Attributes

static const size_t max = std::numeric_limits<size_t>::max()

class CheckingModelComponent : public Nextsim::ModelComponent

Subclassed by Nextsim::PrognosticData

Protected Functions

CheckingModelComponent() = default

inline void checkFields() const

inline void addChecks(const std::map<const std::string, ModelArrayAccessorBase<RO>> &fieldsToAdd)

Protected Attributes

bool checkFast = false

Protected Static Functions

static inline bool &checkAll()

Private Members

std::vector<FieldInfo> fieldsToCheck = {}

class Chrono

Public Types

typedef std::chrono::high_resolution_clock::time_point WallTimePoint

typedef std::chrono::high_resolution_clock::duration WallTimeDuration

typedef std::clock_t CpuTimePoint

typedef double CpuTimeDuration

Public Functions

inline Chrono()

~Chrono() = default

inline WallTimePoint wallHack() const

inline WallTimeDuration wallTime() const

inline void reset()

inline CpuTimePoint cpuHack() const

inline CpuTimeDuration cpuTime() const

inline int ticks() const

inline bool running() const

inline void start()

inline void stop()

inline void extraCpuTime(const CpuTimeDuration &extraTime)

inline void extraWallTime(const WallTimeDuration &extraTime)

inline void extraTicks(int extraTicks)

Private Functions

inline CpuTimeDuration cpuTimeSinceHack() const

inline WallTimeDuration wallTimeSinceHack() const

Private Members

WallTimePoint m_wallHack

WallTimeDuration m_wallTime

CpuTimePoint m_cpuHack

CpuTimeDuration m_cpuTime

int m_ticks

bool m_running

struct CommandLine

Public Members

int m_argc

char **m_argv

class CommandLineParser

Public Functions

CommandLineParser(int argc, char *argv[])

virtual ~CommandLineParser() = default

std::vector<std::string> getConfigFileNames()

inline std::string configHelp()

Public Static Attributes

static const std::string allModuleString = ConfigurationHelpPrinter::allStr

static const std::string availableModuleString = ConfigurationHelpPrinter::availStr

Private Functions

CommandLineParser() = default

Private Members

boost::program_options::variables_map m_arguments

std::vector<std::string> m_configFilenames

std::string m_configHelp

class CommonRestartMetadata

Public Static Functions

static netCDF::NcFile &writeStructureType(netCDF::NcFile &ncFile)

static netCDF::NcFile &writeRestartMetadata(netCDF::NcFile &ncFile)

static inline const std::string timeNodeName()

static inline const std::string formattedName()

static inline const std::string unformattedName()

static inline const std::string configurationNode()

static inline const std::string startTimeName()

static inline const std::string stopTimeName()

static inline const std::string stepLengthName()

static inline const std::string runLengthName()

static inline const std::string missingDataName()

class Config1

Public Functions

inline Config1()

inline void configure()

inline bool checkValue(int target)

Private Members

int value

class Config2 : public Nextsim::Configured<Config2>

Public Types

enum [anonymous]

Values:

enumerator VALUE_KEY

enumerator NAME_KEY

Public Functions

Config2()

inline int getValue()

inline std::string getName()

virtual void configure() override

Private Members

int value

std::string name

class Config3 : public Nextsim::Configured<Config3>

Public Types

enum [anonymous]

Values:

enumerator VALUE_KEY

enumerator WEIGHT_KEY

Public Functions

inline Config3()

inline int getValue()

inline double getWeight()

virtual void configure() override

Private Members

int value

double weight

class ConfigOutput : public Nextsim::IDiagnosticOutput, public Nextsim::Configured<ConfigOutput>

Public Types

enum [anonymous]

Values:

enumerator PERIOD_KEY

enumerator START_KEY

enumerator SNAPSHOT_KEY

enumerator FIELDNAMES_KEY

enumerator FILENAME_KEY

enumerator FILEPERIOD_KEY

Public Functions

ConfigOutput()

virtual ~ConfigOutput() = default

inline virtual void setFilenamePrefix(const std::string &filePrefix) override

virtual void setModelStart(const TimePoint &modelStart) override

virtual void outputState(const ModelState &state) override

inline virtual std::string getName() const override

inline virtual void setData(const ModelState::DataMap&) override

virtual void configure() override

Public Static Functions

static HelpMap &getHelpRecursive(HelpMap &map, bool getAll)

static HelpMap &getHelpText(HelpMap &map, bool getAll)

Private Members

std::string m_filePrefix

Duration outputPeriod

bool firstOutput

bool everyTS

bool outputAllTheFields

TimePoint lastOutput

std::set<std::string> fieldsForOutput

std::string currentFileName

std::set<std::string> internalFieldsForOutput

TimePoint lastFileChange

Duration fileChangePeriod

std::map<std::string, std::string> reverseExternalNames

bool snapshots

bool resetState

Private Static Attributes

static const std::string all = "ALL"

static const std::string defaultLastOutput = "0000-01-01T00:00:00Z"

class ConfigurationHelp

Public Types

enum class ConfigType

Values:

enumerator STRING

enumerator NUMERIC

enumerator INTEGER

enumerator MODULE

enumerator BOOLEAN

typedef std::list<ConfigurationHelp> OptionList

typedef std::map<std::string, OptionList> HelpMap

Public Members

std::string name

ConfigType type

std::vector<std::string> range

std::string defaultValue

std::string units

std::string text

Public Static Functions

template<typename T> static inline std::string toString(const T input, const int n = 6)

class ConfigurationHelpPrinter

Public Types

enum class Output

Values:

enumerator ANSI

enumerator MARKDOWN

typedef ConfigurationHelp::ConfigType ConfigType

Public Static Functions

static void setOutput(Output out)

static std::ostream &print(std::ostream &os, const ConfigurationHelp::HelpMap &map, const std::string &target)

static std::ostream &print(std::ostream &os, const ConfigurationHelp &help)

Public Static Attributes

static const std::string allStr = "all"

static const std::string availStr = "avail"

Protected Static Functions

static std::ostream &printString(std::ostream &os, const ConfigurationHelp &help)

static std::ostream &printNumeric(std::ostream &os, const ConfigurationHelp &help)

static std::ostream &printInteger(std::ostream &os, const ConfigurationHelp &help)

static std::ostream &printModule(std::ostream &os, const ConfigurationHelp &help)

static std::ostream &printBoolean(std::ostream &os, const ConfigurationHelp &help)

class Configurator

Public Functions

Configurator() = default

virtual ~Configurator() = default

Public Static Functions

static inline void addFile(const std::string &filename)

template<typename C> static inline void addFiles(const C &container)

static inline void addStream(std::unique_ptr<std::istream> pis)

template<typename C> static inline void addStreams(const C &container)

static void addSStream(const std::stringstream &sstream)

static inline void clearStreams()

static inline void clear()

static inline void setCommandLine(int argc, char *argv[])

static void getAdditionalConfiguration(const std::string &source)

static boost::program_options::variables_map parse(const boost::program_options::options_description &opt)

static void setAdditionalConfiguration(AdditionalConfiguration *pAC)

Private Static Functions

static inline std::vector<std::unique_ptr<std::istream>> &sources()

static inline CommandLine &commandLine()

static inline AdditionalConfiguration *&addConf()

template<typename C> class Configured : public Nextsim::ConfiguredBase

Public Types

typedef ConfigurationHelp::HelpMap HelpMap

using ConfigType = ConfigurationHelp::ConfigType

Public Functions

Configured() = default

virtual ~Configured() = default

virtual void configure() = 0

inline virtual ConfigMap getConfiguration() const

Public Static Functions

template<typename T> static void tryConfigure(T &ref)

template<typename T> static void tryConfigure(T *ptr)

template<typename T> static ConfigMap tryGetConfiguration(T &ref)

template<typename T> static ConfigMap tryGetConfiguration(T *ptr)

template<typename T> static inline T getConfiguration(const std::string &name, const T &defaultValue)

static HelpMap &getHelpText(HelpMap &map, bool getAll)

static HelpMap &getHelpRecursive(HelpMap &map, bool getAll)

static inline void clearConfigurationMap()

Protected Functions

template<typename T> inline void addOption(const std::string &name, const T &defaultValue)

template<typename T> inline T retrieveValue(const std::string &name)

Private Static Functions

template<typename T> static inline void addOption(const std::string &name, const T &defaultValue, boost::program_options::options_description &opt)

template<typename T> static inline T retrieveValue(const std::string &name, boost::program_options::options_description &opt)

Private Static Attributes

static std::map<std::string, boost::program_options::options_description> singleOptions

class ConfiguredBase

Subclassed by Nextsim::Configured< Config3 >, Nextsim::Configured< MissingData >, Nextsim::Configured< MEVPDynamics >, Nextsim::Configured< Model >, Nextsim::Configured< ConfigOutput >, Nextsim::Configured< BBMDynamics >, Nextsim::Configured< PrognosticData >, Nextsim::Configured< Config2 >, Nextsim::Configured< C >

Public Functions

virtual ~ConfiguredBase() = default

virtual void configure() = 0

virtual ConfigMap getConfiguration() const = 0

class ConfiguredModule

Public Functions

ConfiguredModule() = default

virtual ~ConfiguredModule() = default

Public Static Functions

static std::string getImpl(const std::string &interface)

static ConfigMap getAllModuleConfigurations()

static std::string addPrefix(const std::string &moduleName)

Public Static Attributes

static const std::string MODULE_PREFIX = "Modules"

class ConstModelArraySlice

Public Types

using Slice = ArraySlicer::Slice

using SliceIter = ArraySlicer::SliceIter

using iterator = MASIter

Public Functions

ConstModelArraySlice() = delete

inline ConstModelArraySlice(const ModelArray &ma, const Slice &sl)

inline operator const ModelArraySlice()

Private Members

Slice slice

const ModelArray &data

class Counterant : public Nextsim::Iterator::Iterant

Public Functions

inline virtual void init()

inline virtual void start(const TimePoint &startTime)

inline virtual void iterate(const TimestepTime &tst)

inline virtual void stop(const TimePoint &stopTime)

inline int getCount()

Public Members

int count

int startCount

int stopCount

class CouplEr

Public Functions

inline CouplEr(ModelArrayStore &bs)

inline void update()

Private Members

ModelArrayAccessor<Nextsim::sw_in, RW> swFluxAccessor

class CouplIn : public Nextsim::MiniModelComponent

Public Functions

inline CouplIn(ModelArrayStore &store)

inline void configure()

inline void setData()

inline void update()

Private Members

ModelArrayAccessor<H_ICE, RW> hiceAccessor

ModelArrayAccessor<SW_IN, RW> swinAccessor

CouplEr coupler

class DefaultImpl : public Test::ITest

class DefaultImpl_2 : public Test::ITest2

class DevStep : public Nextsim::IModelStep

Public Functions

DevStep()

virtual ~DevStep() = default

inline virtual void writeRestartFile(const std::string &filePath) override

inline virtual void setData(PrognosticData &pDat) override

void setRestartDetails(const Duration &restartPeriod, const std::string &fileName)

virtual void init() override

virtual void start(const TimePoint &startTime) override

virtual void iterate(const TimestepTime &dt) override

inline virtual void stop(const TimePoint &stopTime) override

Private Members

PrognosticData *pData

Duration m_restartPeriod

TimePoint lastOutput

std::string m_restartFileName

class DimensionMap

Public Functions

DimensionMap()

inline MultiDim &at(const Type &type)

inline const MultiDim &at(const Type &type) const

inline MultiDim &operator[](const Type &type)

inline MultiDim &operator[](Type &&type)

inline size_t size() const noexcept

void validate()

Private Members

std::map<Type, MultiDim> m_dimensions

struct DimensionSpec

Public Functions

inline void setLengths(size_t length)

inline bool operator==(const DimensionSpec &other)

Public Members

std::string name

std::string altName

size_t globalLength

size_t localLength

size_t start

class DummyDynamics : public Nextsim::IDynamics

Subclassed by Nextsim::PDTestDynamics

Public Functions

DummyDynamics() = default

inline virtual std::string getName() const override

inline virtual void update(const TimestepTime &tst) override

inline virtual void prepareAdvection() override

inline virtual void setData(const ModelState::DataMap &state) override

class Duration

Public Types

typedef SystemDuration Basis

Public Functions

inline Duration()

Duration(const std::string &str)

Duration(double seconds)

TimePoint operator+(const TimePoint &t) const

TimePoint operator-(const TimePoint &t) const

inline Duration &operator+=(const Duration &a)

inline Duration &operator-=(const Duration &a)

inline Duration &operator*=(double a)

inline Duration &operator/=(double a)

inline Duration operator+(const Duration &a) const

inline Duration operator-(const Duration &a) const

inline double seconds() const

std::istream &parse(std::istream &is)

inline Duration &parse(const std::string &str)

inline std::ostream &format(std::ostream &os) const

inline std::string format() const

Public Members

friend TimePoint

Private Functions

inline Duration(const Basis &d)

void setDurationSeconds(double)

Private Members

Basis m_d

Friends

friend Duration durationFromISO(const std::string&, int)

class Earl

Public Static Functions

static inline void incr()

template<typename E> class EnumWrapper

Public Types

typedef std::map<std::string, E> MapType

Public Functions

inline E operator()(const std::string &key)

inline operator E() const

Public Static Functions

static inline void setMap(const MapType &inMap)

Private Members

E value

Private Static Attributes

static MapType map

Friends

friend std::istream &operator>>(std::istream &is, EnumWrapper<E>&)

struct ExecutionSpaceDummy

struct ExtModelArray

Public Members

std::string name

ModelArray modelArray

struct ExtModelArrayFlagged

Public Functions

ExtModelArrayFlagged(const std::string &name, bool _isReadWrite, bool _isRegistered)

Public Members

bool isReadWrite

bool isRegistered

ExtModelArray extModelArray

class FieldAdvection

Public Static Functions

static ModelArray &advectField(ModelArray &field, const TimestepTime &tst, FloatType lowerLimit = -std::numeric_limits<FloatType>::infinity(), FloatType upperLimit = std::numeric_limits<FloatType>::infinity())

class FieldInfo

Public Functions

inline FieldInfo(std::string n, const ModelArrayAccessorBase<RO> &a)

Public Members

const std::string name

ModelArrayAccessorBase<RO> arrayRef

class FileCallbackCloser

Public Types

typedef std::function<void(const std::string&)> ClosingFn

Public Static Functions

static void onClose(ClosingFn fn)

static void close(const std::string &fileName)

static void clearAllClose()

Private Static Functions

static inline std::list<ClosingFn> &closingFns()

class FileHolder

Public Static Functions

static inline void open(const std::string &fileName)

static inline void close(const std::string &fileName)

static inline bool isOpen(const std::string &fileName)

Private Static Attributes

static std::map<std::string, std::ofstream> openFiles

class Finalizer

Public Types

using FnType = void()

using FinalFn = std::function<FnType>

Public Static Functions

static void registerFunc(const FinalFn &fn)

static bool registerUnique(const FinalFn &fn)

static bool contains(const FinalFn &fn)

static void finalize()

static size_t count()

Private Types

typedef std::list<FinalFn> FinalFnContainer

Private Static Functions

static FinalFnContainer &functions()

class FreeDriftDynamics : public Nextsim::IDynamics

Public Functions

inline FreeDriftDynamics()

inline virtual std::string getName() const override

inline virtual void update(const TimestepTime &tst) override

inline virtual void setData(const ModelState::DataMap &ms) override

inline virtual void advectField(FloatType timestep, ModelArray &field, FloatType lowerLimit = -std::numeric_limits<FloatType>::infinity(), FloatType upperLimit = std::numeric_limits<FloatType>::infinity()) override

inline virtual void prepareAdvection() override

Private Members

FreeDriftDynamicsKernel<3> kernel

DynamicsParameters params

template<typename Base> class FreezingPointImpl : public Base

Public Functions

inline FloatType operator()(FloatType sss) const override

inline void update(ModelArrayAuto &tf, const ConstModelArrayAuto &sss) const override

struct GridDimensions

Public Members

int nx

int ny

class Halo

Public Functions

inline Halo(ModelArray &ma)

template<int N> inline Halo(DGVectorHolder<N> &dgvh)

template<int N> inline Halo(DGVector<N> &dgv)

template<int N> inline Halo(CGVector<N> &cgv)

inline size_t getInnerSize()

template<typename S, typename T = S> inline void getInnerBlock(S &source, T &target)

template<typename S, typename T = S> inline void setInnerBlock(S &source, T &target)

template<typename T> inline void exchangeHalos(T &target)

Public Static Functions

static inline const bool isDimLateral(const ModelArray::Dimension dim)

Public Static Attributes

static const size_t haloWidth = 1

Private Types

using Slice = ArraySlicer::Slice

using SliceIter = ArraySlicer::SliceIter

using Edge = ModelMetadata::Edge

using Corner = ModelMetadata::Corner

using VBounds = ArraySlicer::Slice::VBounds

Private Functions

void setSpatialDims()

void initializeHaloMetadata()

void openMemoryWindow(size_t idx)

void closeMemoryWindow()

template<typename S> inline void populateSendBuffers(S &source)

Edge edgeFromSendPos(int sendPos, int fromRank)

void recvPositions(int &fromRank, size_t &count, size_t &disp, size_t &recvOffset, Edge edge, const size_t neighbourIndex, const size_t cell, bool isPeriodic)

void recvPositions(int &fromRank, size_t &count, size_t &disp, size_t &recvOffset, Corner corner, const size_t cell, bool isPeriodic)

void populateRecvBuffers()

template<typename T> inline void populateTarget(T &target)

void transposeCorners()

void sendBufferPositions(int &idx_a, int &idx_b, int &offset, const Edge edge)

template<typename S, typename T> inline void sourceToSendBuffer(const Edge edge, Eigen::Map<T> &buffer_map, Eigen::Map<S, 0, Eigen::InnerStride<Eigen::Dynamic>> &source_map)

void recvBufferPositions(int &idx_a, int &idx_b, int &offset, const Edge edge)

template<typename S, typename T> inline void recvBufferToTarget(const Edge edge, Eigen::Map<T> &buffer_map, Eigen::Map<S, 0, Eigen::InnerStride<Eigen::Dynamic>> &target_map)

template<typename S, typename T> inline void recvBufferToTarget(const Corner corner, Eigen::Map<T> &buffer_map, Eigen::Map<S, 0, Eigen::InnerStride<Eigen::Dynamic>> &target_map)

Private Members

const typedef ArraySlicer::SliceIter::MultiDim MultiDim

const MultiDim m_haloDims

size_t m_Nx

size_t m_Ny

size_t m_innerNx

size_t m_innerNy

size_t m_numHaloCells

size_t m_numComps

int nCells = 1

std::array<size_t, Edge::N_EDGE> m_edgeLengths

std::array<Edge, Edge::N_EDGE> edges = ModelMetadata::edges

std::array<Corner, Corner::N_CORNER> corners = ModelMetadata::corners

MPI_Win m_win

bool isVertex = false

bool isCG = false

size_t CGdegree = 0

size_t sendBufferSize = 0

size_t recvBufferSize = 0

std::vector<std::vector<FloatType>> send

std::vector<std::vector<FloatType>> recv

Private Static Functions

static inline bool isVertical(const Edge edge)

static inline bool isHorizontal(const Edge edge)

class HappyExcept : public std::runtime_error

class HappyTime : public std::exception

Public Functions

inline const char *what() const noexcept

class IceCalc : public Nextsim::MiniModelComponent

Public Functions

inline IceCalc(ModelArrayStore &store)

inline void configure()

inline void update(int tStep)

inline void getData(FloatType &dataOut)

Private Members

ModelArrayAccessor<H_ICE, RW> hiceAccessor

ModelArrayAccessor<H_ICE0> hice0Accessor

IceThermo thermo

class IceThermo : public Nextsim::MiniModelComponent

Public Functions

inline IceThermo(ModelArrayStore &store)

inline void update(int tStep)

Private Members

ModelArrayAccessor<H_ICE, RW> hiceAccessor

class IDiagnosticOutput : public Nextsim::ModelComponent

Subclassed by Nextsim::ConfigOutput, Nextsim::NoOutput, Nextsim::SimpleOutput

Public Functions

inline IDiagnosticOutput()

virtual ~IDiagnosticOutput() = default

virtual void setFilenamePrefix(const std::string &filePrefix) = 0

virtual void outputState(const ModelState &state) = 0

inline virtual void setData(const ModelState::DataMap &state)

inline virtual void setModelStart(const TimePoint &ModelStart)

Protected Attributes

const std::map<std::string, std::string> externalNames

class IDynamics : public Nextsim::ModelComponent

Subclassed by Nextsim::BBMDynamics, Nextsim::DummyDynamics, Nextsim::FreeDriftDynamics, Nextsim::MEVPDynamics

Public Functions

inline IDynamics()

inline IDynamics(bool usesDamageIn)

virtual ~IDynamics() = default

inline virtual ModelState getStatePrognostic() const override

inline virtual ModelState getStateDiagnostic() const override

inline virtual std::string getName() const override

inline virtual void setData(const ModelState::DataMap &ms) override

virtual void update(const TimestepTime &tst) = 0

inline virtual bool usesDamage() const

inline virtual void advectField(FloatType timestep, ModelArray &field, FloatType lowerLimit = -std::numeric_limits<FloatType>::infinity(), FloatType upperLimit = std::numeric_limits<FloatType>::infinity())

virtual void prepareAdvection() = 0

Protected Attributes

ModelArrayAccessor<Protected::ICE_U, RW> uiceAccessor

ModelArrayAccessor<Protected::ICE_V, RW> viceAccessor

ModelArrayAccessor<Protected::IO_STRESS_X, RW> tauxAccessor

ModelArrayAccessor<Protected::IO_STRESS_Y, RW> tauyAccessor

ModelArrayAccessor<Protected::SHEAR, RW> shearAccessor

ModelArrayAccessor<Protected::DIV, RW> divergenceAccessor

ModelArrayAccessor<Protected::SIGMAI, RW> sigmaIAccessor

ModelArrayAccessor<Protected::SIGMAII, RW> sigmaIIAccessor

ModelArrayAccessor<Shared::DAMAGE, RW> damageAccessor

ModelArrayAccessor<Protected::WIND_U> uwindAccessor

ModelArrayAccessor<Protected::WIND_V> vwindAccessor

ModelArrayAccessor<Protected::OCEAN_U> uoceanAccessor

ModelArrayAccessor<Protected::OCEAN_V> voceanAccessor

ModelArrayAccessor<Protected::SSH> sshAccessor

bool m_usesDamage

ModelArrayAccessor<Shared::H_ICE_DG, RW> hiceDGAccessor

ModelArrayAccessor<Shared::C_ICE_DG, RW> ciceDGAccessor

ModelArrayAccessor<Shared::H_SNOW_DG, RW> hsnowDGAccessor

Protected Static Functions

static inline bool checkSpherical(const ModelState::DataMap &ms)

class IFreezingPoint : public Nextsim::ModelComponent

Subclassed by Nextsim::LinearFreezingImpl, Nextsim::UnescoFreezingImpl

Public Functions

virtual ~IFreezingPoint() = default

inline virtual void setData(const ModelState::DataMap &state) override

virtual FloatType operator()(FloatType sss) const = 0

virtual void update(ModelArrayAuto &tf, const ConstModelArrayAuto &sss) const = 0

class IModelStep : public Nextsim::Iterator::Iterant

Subclassed by Nextsim::DevStep

Public Functions

IModelStep() = default

virtual ~IModelStep() = default

inline void setInitFile(const std::string &filePath)

virtual void writeRestartFile(const std::string &filePath) = 0

virtual void setData(PrognosticData &data) = 0

virtual void init() = 0

virtual void start(const TimePoint &startTime) = 0

virtual void iterate(const TimestepTime &dt) = 0

virtual void stop(const TimePoint &stopTime) = 0

Protected Attributes

std::string initialRestartFilePath

class Impl1 : public Test::ITest

class Impl2 : public Test::ITest

class ImplementationNames

Public Types

using Container = std::map<std::string, std::string>

Public Static Functions

static inline Container getAll()

static inline std::string get(const std::string &interface)

Private Types

using Fn = std::string (*)()

using InternalContainer = std::list<std::pair<Fn, Fn>>

Private Static Functions

static inline InternalContainer &getNames()

static inline void set(Fn intFunctionPtr, Fn impFunctionPtr)

Friends

friend class Module

class Index

Public Functions

inline Index()

inline Index(Int ii)

template<typename I> inline Index(I ii)

inline bool isAll() const

inline operator std::ptrdiff_t() const

inline std::ostream &print(std::ostream &os) const

Private Members

bool m_isAll

Int i

class IParaGridIO

Subclassed by Nextsim::ParaGridIO

Public Functions

inline IParaGridIO(ParametricGrid &grid)

virtual ~IParaGridIO() = default

virtual ModelState getModelState(const std::string &filePath) = 0

virtual void dumpModelState(const ModelState &state, const std::string &filePath) = 0

virtual ModelState readForcingTime(const std::set<std::string> &forcings, const TimePoint &time, const std::string &filePath) = 0

virtual void writeDiagnosticTime(const ModelState &state, const std::string &filePath) = 0

Protected Functions

IParaGridIO() = delete

Private Members

ParametricGrid &grid

class IRectGridIO

Subclassed by Nextsim::RectGridIO

Public Functions

inline IRectGridIO(RectangularGrid &grid)

virtual ~IRectGridIO() = default

virtual ModelState getModelState(const std::string &filePath) = 0

virtual void dumpModelState(const ModelState &state, const std::string &filePath, bool isRestart) const = 0

Protected Functions

IRectGridIO() = default

Private Members

RectangularGrid *grid

class IStructure

Subclassed by Nextsim::ParametricGrid, Nextsim::RectangularGrid

Public Functions

inline IStructure()

virtual ~IStructure() = default

virtual ModelState getModelState(const std::string &filePath) = 0

inline virtual const std::string &structureType() const

inline bool structureTypeCheck(const std::string &str) const

virtual void dumpModelState(const ModelState &state, const std::string &filePath, bool isRestart) const = 0

Public Static Functions

static inline const std::string structureNodeName()

Private Members

const std::string processedStructureName = "none"

class Iterant

Subclassed by Nextsim::Counterant, Nextsim::IModelStep

Public Functions

Iterant() = default

Iterant(const Iterant &copyFrom) = default

Iterant &operator=(const Iterant &copyFrom) = default

Iterant(Iterant&&) = default

Iterant &operator=(Iterant&&) = default

virtual ~Iterant() = default

virtual void init() = 0

virtual void start(const TimePoint &startTime) = 0

virtual void iterate(const TimestepTime &dt) = 0

virtual void stop(const TimePoint &stopTime) = 0

class Iterator

Public Types

typedef TimePoint::Clock Clock

Public Functions

Iterator() = delete

inline Iterator(Iterant &iterant)

void setStartStopStep(TimePoint startTime, TimePoint stopTime, Duration timestep)

void run()

Private Members

Iterant &iterant

TimePoint startTime

TimePoint stopTime

Duration timestep

class ITest: Subclassed by Test::DefaultImpl, Test::Impl1, Test::Impl2

class ITest2: Subclassed by Test::AnotherImpl, Test::DefaultImpl_2

template<bool Active> class KokkosTimer

Public Functions

inline KokkosTimer(const std::string &_name)

inline ~KokkosTimer()

inline void start()

inline void stop()

inline void print()

Private Members

std::string m_name

int m_count

double m_total

std::chrono::time_point<std::chrono::high_resolution_clock> m_start

class LinearFreezingImpl : public Nextsim::IFreezingPoint

Public Functions

inline virtual std::string getName() const override

inline KERNEL_IMPL_FUNCTION FloatType calculate (FloatType sss) const

class Logged

Public Types

enum class level

Values:

enumerator ALL

enumerator TRACE

enumerator DEBUG_LVL

enumerator INFO

enumerator NOTICE

enumerator WARNING

enumerator ERROR

enumerator CRITICAL

enumerator ALERT

enumerator EMERGENCY

enumerator NONE

Public Static Functions

static void configure()

static void log(const std::string &message, const level lvl = level::NOTICE)

static inline void trace(const std::string &message)

static inline void debug(const std::string &message)

static inline void info(const std::string &message)

static inline void notice(const std::string &message)

static inline void warning(const std::string &message)

static inline void error(const std::string &message)

static inline void critical(const std::string &message)

static inline void alert(const std::string &message)

static inline void emergency(const std::string &message)

Public Static Attributes

static const std::map<std::string, level> levelNames = {{"all", level::ALL}, {"All", level::ALL}, {"ALL", level::ALL}, {"trace", level::TRACE}, {"TRACE", level::TRACE}, {"debug", level::DEBUG_LVL}, {"DEBUG", level::DEBUG_LVL}, {"info", level::INFO}, {"INFO", level::INFO}, {"warning", level::WARNING}, {"WARNING", level::WARNING}, {"error", level::ERROR}, {"ERROR", level::ERROR}, {"critical", level::CRITICAL}, {"CRITICAL", level::CRITICAL}, {"fatal", level::CRITICAL}, {"FATAL", level::CRITICAL}, {"alert", level::ALERT}, {"ALERT", level::ALERT}, {"emergency", level::EMERGENCY}, {"EMERGENCY", level::EMERGENCY}, {"none", level::NONE}, {"None", level::NONE}, {"NONE", level::NONE},}

Protected Functions

Logged() = default

class MASIter

Public Types

using iterator_category = std::forward_iterator_tag

using value_type = FloatType

using difference_type = std::ptrdiff_t

using pointer = FloatType*

using reference = FloatType&

using Slice = ArraySlicer::Slice

using SliceIter = ArraySlicer::SliceIter

Public Functions

MASIter(ModelArraySlice &mas)

inline FloatType &operator*() const

inline MASIter &operator++()

inline bool operator!=(const MASIter &other) const

inline bool operator==(const MASIter &other) const

inline FloatType *operator->() const

inline MASIter operator++(int)

inline std::ostream &print(std::ostream &os) const

Public Members

friend ModelArraySlice

Private Members

ModelArray &data

SliceIter iter

class MEVPDynamics : public Nextsim::IDynamics, public Nextsim::Configured<MEVPDynamics>

Public Types

enum [anonymous]

Values:

enumerator PSTAR_KEY

enumerator DELTA_KEY

enumerator C_KEY

enumerator NSTEPS_KEY

enumerator RHOI_KEY

enumerator RHOA_KEY

enumerator RHOO_KEY

enumerator CATM_KEY

enumerator COCEAN_KEY

enumerator FC_KEY

enumerator ANGLE_KEY

Public Functions

MEVPDynamics()

inline virtual std::string getName() const override

virtual void prepareAdvection() override

virtual void update(const TimestepTime &tst) override

virtual void advectField(FloatType timestep, ModelArray &field, FloatType lowerLimit = -std::numeric_limits<FloatType>::infinity(), FloatType upperLimit = std::numeric_limits<FloatType>::infinity()) override

virtual void setData(const ModelState::DataMap&) override

virtual void configure() override

virtual ConfigMap getConfiguration() const override

Public Static Functions

static HelpMap &getHelpText(HelpMap &map, bool getAll)

static HelpMap &getHelpRecursive(HelpMap&, bool getAll)

Private Members

VPParameters params

MEVPDynamicsKernel<3> kernel

class MiniModelComponent

Subclassed by Nextsim::AtmIn, Nextsim::CouplIn, Nextsim::IceCalc, Nextsim::IceThermo

Public Static Attributes

static constexpr TextTag H_ICE0 = {"H_ICE0"}

static constexpr TextTag SW_IN = {"SW_IN"}

static constexpr TextTag H_ICE = {"H_ICE"}

class MissingData : public Nextsim::Configured<MissingData>

Public Static Functions

static inline FloatType value()

static inline void setValue(FloatType mdi)

Public Static Attributes

static constexpr FloatType defaultValue = 1.7e38

Private Static Functions

static inline FloatType &getValue()

class Model : public Nextsim::Configured<Model>

Public Types

enum [anonymous]

Values:

enumerator RESTARTFILE_KEY

enumerator STARTTIME_KEY

enumerator STOPTIME_KEY

enumerator RUNLENGTH_KEY

enumerator TIMESTEP_KEY

enumerator MISSINGVALUE_KEY

enumerator RESTARTPERIOD_KEY

enumerator RESTARTOUTFILE_KEY

Public Functions

Model()

~Model()

void configureRestarts()

void configureTime()

virtual void configure() override

inline ConfigMap getConfig() const

void run()

void writeRestartFile()

void setFinalFilename(const std::string &finalFile)

Public Static Functions

static HelpMap &getHelpText(HelpMap &map, bool getAll)

static HelpMap &getHelpRecursive(HelpMap &map, bool getAll)

Public Static Attributes

static const std::string restartOptionName = "model.init_file"

Private Members

Iterator iterator

DevStep modelStep

PrognosticData pData

bool configuredRestarts = false

bool configuredTime = false

class ModelArray

Public Types

using Slice = ArraySlicer::Slice

using TypeDimensions = std::map<Type, std::vector<Dimension>>

using DataType = Eigen::Array<FloatType, Eigen::Dynamic, Eigen::Dynamic, majority>

using Components = DataType::RowXpr

using ConstComponents = DataType::ConstRowXpr

using Component = DataType::ColXpr

using ConstComponent = DataType::ConstColXpr

using MultiDim = std::vector<size_t>

using TypeMap = std::map<ModelArray::Type, ModelArray::Type>

Public Functions

ModelArray()

ModelArray(const Type type, const std::pair<FloatType, FloatType> &bounds = {-std::numeric_limits<FloatType>::max(), std::numeric_limits<FloatType>::max()})

ModelArray(const ModelArray&)

inline virtual ~ModelArray()

ModelArray &operator=(const ModelArray&)

ModelArray &operator=(const FloatType &val)

ModelArray &operator=(const ModelArraySlice&)

inline ModelArray &operator=(const DataType &src)

inline operator DataType&()

inline operator const DataType&() const

ModelArraySlice operator[](const Slice&)

ConstModelArraySlice operator[](const Slice&) const

inline ModelArray &operator+=(const ModelArray &b)

inline ModelArray &operator-=(const ModelArray &b)

inline ModelArray &operator*=(const ModelArray &b)

inline ModelArray &operator/=(const ModelArray &b)

inline ModelArray &operator+=(FloatType b)

inline ModelArray &operator-=(FloatType b)

inline ModelArray &operator*=(FloatType b)

inline ModelArray &operator/=(FloatType b)

ModelArray operator+(const ModelArray&) const

ModelArray operator-(const ModelArray&) const

ModelArray operator*(const ModelArray&) const

ModelArray operator/(const ModelArray&) const

ModelArray operator-() const

ModelArray operator+(const FloatType&) const

ModelArray operator-(const FloatType&) const

ModelArray operator*(const FloatType&) const

ModelArray operator/(const FloatType&) const

ModelArray max(FloatType max) const

ModelArray min(FloatType min) const

ModelArray max(const ModelArray &maxArr) const

ModelArray min(const ModelArray &minArr) const

ModelArray &clampAbove(FloatType max)

ModelArray &clampBelow(FloatType min)

ModelArray &clampAbove(const ModelArray &maxArr)

ModelArray &clampBelow(const ModelArray &minArr)

inline size_t nDimensions() const

inline const MultiDim &dimensions() const

inline size_t size() const

inline size_t trueSize() const

inline const FloatType *getData() const

inline ModelArray::DataType &getDataRef()

inline const DataType &data() const

inline Type getType() const

inline void setDimensions(const MultiDim &dims)

inline void reinitialize()

void setData(FloatType value)

void setData(const FloatType *pData)

void setData(const DataType &data)

void setData(const ModelArray &source)

void assignData(const ModelArray &source)

void assignData(ModelArray &&source)

inline const FloatType &operator[](size_t i) const

const FloatType &operator[](const MultiDim &dims) const

template<typename ...Args> inline const FloatType &operator()(Args... args) const

inline FloatType &operator[](size_t i)

FloatType &operator[](const MultiDim&)

template<typename ...Args> inline FloatType &operator()(Args... args)

inline void setNComponents(size_t nComp)

inline Components components(size_t i)

inline const ConstComponents components(size_t i) const

Components components(const MultiDim &loc)

const ConstComponents components(const MultiDim &loc) const

inline Component component(size_t compo = 0)

inline const ConstComponent component(size_t compo = 0) const

inline operator Component()

inline ModelArray &operator=(const Component &src)

inline ModelArray &operator=(const ConstComponent &src)

inline size_t indexFromLocation(const MultiDim &loc) const

inline MultiDim locationFromIndex(size_t index) const

inline size_t nComponents() const

inline bool hasDoF() const

void setLimits(const FloatType lower, const FloatType upper)

void checkLimits(const ModelArray &mask) const

Public Static Functions

static inline size_t nDimensions(Type type)

static inline const MultiDim &dimensions(Type type)

static inline size_t size(Type type)

static inline size_t size(Dimension dim)

static void setDimensions(Type, const MultiDim&)

static void setDimension(Dimension dim, size_t globalLength)

static void setNComponents(std::map<Type, size_t> cMap)

static inline void setNComponents(Type type, size_t nComp)

static inline ModelArray::Type component0Type(ModelArray::Type withComponents)

static size_t indexFromLocation(Type type, const MultiDim &loc)

static MultiDim locationFromIndex(Type type, size_t index)

static inline size_t nComponents(const Type type)

static bool hasDoF(const Type type)

Public Static Attributes

static const int N_DEFINED_DIMENSIONS = static_cast<int>(Dimension::COUNT)

static TypeDimensions typeDimensions

static std::map<Dimension, DimensionSpec> definedDimensions = {{ModelArray::Dimension::X, {"x_dim", "xdim", 0, 0, 0}}, {ModelArray::Dimension::Y, {"y_dim", "ydim", 0, 0, 0}}, {ModelArray::Dimension::XVERTEX, {"x_vertex", "xvertex", 1, 1, 0}}, {ModelArray::Dimension::YVERTEX, {"y_vertex", "yvertex", 1, 1, 0}}, {ModelArray::Dimension::XCG, {"x_cg", "x_cg", 2, 2, 0}}, {ModelArray::Dimension::YCG, {"y_cg", "y_cg", 2, 2, 0}}, {ModelArray::Dimension::DG, {"dg_comp", "dg_comp", 6, 6, 0}}, {ModelArray::Dimension::DGSTRESS, {"dgstress_comp", "dgstress_comp", 8, 8, 0}}, {ModelArray::Dimension::NCOORDS, {"ncoords", "ncoords", 2, 2, 0}},}

static const std::map<Type, std::string> typeNames = {{ModelArray::Type::H, "HField"}, {ModelArray::Type::VERTEX, "VertexField"}, {ModelArray::Type::U, "UField"}, {ModelArray::Type::V, "VField"}, {ModelArray::Type::DG, "DGField"}, {ModelArray::Type::DGSTRESS, "DGSField"}, {ModelArray::Type::CG, "CGField"},}

static std::map<Type, Base> baseTypes = {{ModelArray::Type::H, ModelArray::Base::Cell}, {ModelArray::Type::VERTEX, ModelArray::Base::Vertex}, {ModelArray::Type::U, ModelArray::Base::Cell}, {ModelArray::Type::V, ModelArray::Base::Cell}, {ModelArray::Type::DG, ModelArray::Base::Cell}, {ModelArray::Type::DGSTRESS, ModelArray::Base::Cell}, {ModelArray::Type::CG, ModelArray::Base::Vertex},}

static const std::map<Type, Dimension> componentMap = {{Type::DG, Dimension::DG}, {Type::DGSTRESS, Dimension::DGSTRESS}, {Type::VERTEX, Dimension::NCOORDS},}

Protected Attributes

Type type

Private Members

FloatType lowerPhysicalLimit = -std::numeric_limits<FloatType>::max()

FloatType upperPhysicalLimit = std::numeric_limits<FloatType>::max()

FloatType fillValue = 0.

DataType m_data

friend ModelArraySlice

friend Halo

Private Static Functions

template<typename T = size_t, typename C, typename I> static inline T indexr(C dims, I first)

template<typename T = size_t, typename C, typename I> static inline T indexr(C dims, I first, I second)

template<typename T = size_t, typename C, typename I, typename ...Args> static inline T indexr(C dims, I first, Args... args)

template<typename T = size_t, typename C> static inline T indexr(C dims, const ModelArray::MultiDim &loc)

static const TypeMap definedComp0Map()

static void validateMaps()

Private Static Attributes

static bool areMapsInvalid = true

static SizeMap m_sz

static DimensionMap m_dims

template<const TextTag &fieldName, bool isReadWrite = RO> class ModelArrayAccessor

template<const TextTag &fieldName> class ModelArrayAccessor<fieldName, RO> : public Nextsim::ModelArrayAccessorBase<RO>

Public Functions

inline ModelArrayAccessor(ModelArrayStore &store)

template<const TextTag &fieldName> class ModelArrayAccessor<fieldName, RW> : public Nextsim::ModelArrayAccessorBase<RW>

Public Functions

inline ModelArrayAccessor(ModelArrayStore &store)

template<typename ...Args> inline ModelArrayAccessor(ModelArrayStore &store, bool isReadWriteExternal, Args&&... args)

Private Types

using Base = ModelArrayAccessorBase<RW>

template<bool isReadWrite = RO> class ModelArrayAccessorBase

template<> class ModelArrayAccessorBase<RO>

Subclassed by Nextsim::ModelArrayAccessor< fieldName, RO >, Nextsim::ModelArrayAccessorBase< RW >

Public Functions

inline ModelArrayAccessorBase(ModelArrayStore &store, const std::string &fieldName)

inline const ModelArray &getHostRO() const

inline const ConstModelArrayAuto &getAutoRO() const

template<typename ExecSpace> inline const ConstModelArrayAuto &getAutoRO(ExecSpace execSpace) const

Public Static Functions

static inline std::unordered_map<std::string, ModelArrayAccessorBase<RO>> getAll(const ModelArrayStore &store)

Protected Functions

inline ModelArrayAccessorBase(ModelArrayStore::ExtModelArray &_target)

Protected Attributes

ModelArrayStore::ExtModelArray &target

template<> class ModelArrayAccessorBase<RW> : public Nextsim::ModelArrayAccessorBase<RO>

Subclassed by Nextsim::ModelArrayAccessor< fieldName, RW >

Public Functions

inline ModelArrayAccessorBase(ModelArrayStore &store, const std::string &fieldName)

template<typename ...Args> inline ModelArrayAccessorBase(ModelArrayStore &store, const std::string &fieldName, bool isReadWriteExternal, Args&&... args)

inline ModelArray &getHostRW()

inline ModelArrayAuto &getAutoRW()

template<typename ExecSpace> inline ModelArrayAuto &getAutoRW(ExecSpace execSpace)

Private Types

using Base = ModelArrayAccessorBase<RO>

class ModelArraySlice

Public Types

using Slice = ArraySlicer::Slice

using SliceIter = ArraySlicer::SliceIter

using iterator = MASIter

Public Functions

ModelArraySlice() = delete

inline ModelArraySlice(ModelArray &ma, const Slice &sl)

ModelArraySlice &operator=(ModelArray &ma)

ModelArraySlice &operator=(ModelArraySlice &other)

ModelArraySlice &operator=(FloatType v)

template<typename T> inline ModelArraySlice &operator=(const T &buffer)

ModelArraySlice &operator=(const ModelArray::DataType &dataBuffer)

operator ModelArray::DataType() const

ModelArray &copyToModelArray(ModelArray &target) const

template<typename T> inline T &copyToBuffer(T &buffer)

template<typename T> inline const ModelArraySlice &copyToSlicedBuffer(T &target, SliceIter &targetIter) const

template<typename S> inline ModelArraySlice &copyFromSlicedBuffer(const S &source, SliceIter &sourceIter)

iterator begin()

iterator end()

Public Members

Slice slice

friend MASIter

friend ConstModelArraySlice

friend Halo

Private Members

ModelArray &data

Private Static Functions

template<typename S, typename T = S> static inline void copySliceWithIters(const S &source, SliceIter &sourceIter, T &target, SliceIter targetIter)

static void copyBetweenMAandMASlice(ModelArray &ma, const ModelArraySlice &mas, bool toSlice, const std::string &functionName)

class ModelArrayStore

Public Functions

bool checkAllRegistered() const

Private Functions

template<typename ...Args> inline ExtModelArray &registerArray(const std::string &field, bool isReadWrite, Args&&... args)

ExtModelArray &getRW(const std::string &field)

ExtModelArray &getRO(const std::string &field)

Private Members

std::unordered_map<std::string, ExtModelArrayFlagged> store

Friends

friend class ModelArrayAccessorBase

class ModelComponent

Subclassed by Nextsim::CheckingModelComponent, Nextsim::IDiagnosticOutput, Nextsim::IDynamics, Nextsim::IFreezingPoint, Nextsim::Module1, Nextsim::ModuleRequestAndSupply, Nextsim::ModuleSemiShared, Nextsim::ModuleShared, Nextsim::ModuleSupplyAndWait

Public Types

typedef Logged::level OutputLevel

Public Functions

ModelComponent()

virtual ~ModelComponent() = default

virtual std::string getName() const = 0

virtual void setData(const ModelState::DataMap &state) = 0

inline virtual ModelState getStateDiagnostic() const

inline virtual ModelState getStateDiagnostic(const OutputLevel&) const

inline virtual ModelState getStatePrognostic() const

Public Static Functions

static inline ModelArrayStore &getStore()

template<typename Fn> static inline void overElementsAuto(Fn &&fn)

template<typename Fn> static inline void overElements(Fn fn)

Protected Functions

inline virtual ConfigMap getConfiguration() const

Protected Static Functions

static void setOceanMask(const ModelArray &mask)

static void noLandMask()

static ModelArray mask(const ModelArray &data, FloatType missingValue = MissingData::value())

static const ModelArray &oceanMask()

static inline ModelArray &oceanMaskSingleton()

Private Static Functions

static inline std::unique_ptr<ModelArrayStore> &columnPhysicsStore()

static inline void destroyModelArrayStore()

Private Static Attributes

static size_t nOcean = 0

static std::vector<size_t> oceanIndex

static bool columnPhysicsStoreIsDestroyed

class ModelMetadata

Public Functions

void setDimensionsFromFile(const std::string &filename)

void setTimes(const TimePoint &start, const TimePoint &stop, const Duration &step)

void setTimes(const TimePoint &start, const Duration &runLength, const Duration &step)

void setTime(const TimePoint &time)

void incrementTime(const Duration &step)

inline const TimePoint &time() const

inline const TimePoint &startTime() const

inline const TimePoint &stopTime() const

inline const Duration &stepLength() const

inline const Duration &runLength() const

const std::string &structureName() const

inline void setConfig(const ConfigMap &config)

const ModelState &extractCoordinates(const ModelState &state)

ModelState &affixCoordinates(ModelState &state) const

Public Members

friend CommonRestartMetadata

std::string initialFileName

std::string finalFileName

Duration restartPeriod

Public Static Functions

static inline ModelMetadata &getInstance()

static void finalize()

Private Functions

ModelMetadata()

ModelMetadata(const ModelMetadata&) = delete

void readNeighbourData(netCDF::NcFile &ncFile)

Private Members

TimePoint m_time

ConfigMap m_config

TimePoint start

TimePoint stop

Duration step

Duration run

ModelArray m_vertexCoords

ModelArray m_coord1

ModelArray m_coord2

ModelArray m_gridAzimuth

bool isCartesian = false

bool hasParameters = false

bool isInitialized = false

Private Static Functions

static bool doOnce()

struct ModelState

Public Types

typedef std::map<std::string, ModelArray> DataMap

Public Functions

inline ModelState &merge(ModelState &source)

inline ModelState &merge(ModelState &&source)

inline ModelState &merge(ConfigMap &configSrc)

inline ModelState &merge(ConfigMap &&configSrc)

inline ModelState &merge(DataMap &dataSrc)

inline ModelState &merge(DataMap &&dataSrc)

Public Members

DataMap data

ConfigMap config

template<typename I> class Module

Public Types

using Fn = std::unique_ptr (*)()

using Map = std::map<std::string, Fn>

Public Functions

std::string moduleName()

HelpMap &getHelpRecursive(HelpMap &map, bool getAll)

std::string moduleName()

HelpMap &getHelpRecursive(HelpMap &map, bool getAll)

std::string moduleName()

Public Static Functions

static inline void setExternalImplementation(Fn generator)

static inline void setImplementation(const std::string &implName)

static inline std::unique_ptr getInstance()

static inline std::unique_ptr &getUniqueInstance(bool suppressInit = false)

static inline I &getImplementation()

static inline std::list<std::string> listImplementations()

static inline std::string implementation()

static std::string moduleName()

static HelpMap &getHelpRecursive(HelpMap &helpMap, bool getAll)

static inline void finalize()

Private Functions

const Module<Test::ITest>::Map &functionMap()

Module<Test::ITest>::Fn &getGenerationFunction()

const Module<Test::ITest2>::Map &functionMap()

Module<Test::ITest2>::Fn &getGenerationFunction()

const Module<Nextsim::IDynamics>::Map &functionMap()

std::string getDefaultImplementationName()

Module<Nextsim::IDynamics>::Fn &getGenerationFunction()

Private Static Functions

static std::string getDefaultImplementationName()

static inline Fn &getGenerationFunction()

static const Map &functionMap()

static inline bool &isConfigured()

static inline std::unique_ptr getInstanceInternal(bool setStaticInstance)

static inline void setImplementationInternal(const std::string &implName, bool setStaticInstance)

static inline void setExternalImplementationInternal(Fn generator, bool setStaticInstance)

class Module1 : public Nextsim::ModelComponent

Public Functions

inline Module1()

inline virtual std::string getName() const override

inline virtual void setData(const ModelState::DataMap &st) override

class ModuleRequestAndSupply : public Nextsim::ModelComponent

Public Functions

inline ModuleRequestAndSupply()

inline virtual void setData(const ModelState::DataMap &ms) override

inline virtual std::string getName() const override

inline virtual ModelState getStatePrognostic() const override

inline FloatType data()

inline FloatType refData()

Public Members

const FloatType ciceData = 0.6

Private Members

ModelArrayAccessor<Shared::C_ICE_DG, RW> ciceAccessor

ModelArrayAccessor<Shared::H_ICE_DG> hice_refAccessor

class ModuleSemiShared : public Nextsim::ModelComponent

Public Functions

inline ModuleSemiShared()

inline virtual void setData(const ModelState::DataMap &ms) override

inline virtual std::string getName() const override

inline virtual ModelState getStatePrognostic() const override

inline FloatType data()

inline FloatType refData()

Public Members

const FloatType qicData = 123

Private Members

ModelArrayAccessor<Shared::Q_IC, RW> qicAccessor

ModelArrayAccessor<Shared::Q_IO, RO> qio_refAccessor

class ModuleShared : public Nextsim::ModelComponent

Public Functions

inline ModuleShared()

inline virtual void setData(const ModelState::DataMap &ms) override

inline virtual std::string getName() const override

inline virtual ModelState getStatePrognostic() const override

inline FloatType data()

inline FloatType &refData()

inline void setRefData()

Public Members

const FloatType qioData = 234

const FloatType qicData = 246

Private Members

ModelArrayAccessor<Shared::Q_IO, RW> qioAccessor

ModelArrayAccessor<Shared::Q_IC, RW> qic_refAccessor

class ModuleSupplyAndWait : public Nextsim::ModelComponent

Public Functions

inline ModuleSupplyAndWait()

inline virtual void setData(const ModelState::DataMap &ms) override

inline virtual std::string getName() const override

inline virtual ModelState getStatePrognostic() const override

inline FloatType data()

inline FloatType refData()

Public Members

const FloatType hiceData = 1.2

Private Members

ModelArrayAccessor<Shared::H_ICE_DG, RW> hiceAccessor

ModelArrayAccessor<Shared::C_ICE_DG> cice_refAccessor

class monthlyCubicBSpline

Public Types

typedef boost::math::cubic_b_spline<FloatType> bSpline

Public Functions

inline explicit monthlyCubicBSpline(const std::vector<FloatType> &f)

inline FloatType operator()(FloatType dayOfYear, bool isLeap)

Private Members

std::shared_ptr<bSpline> m_spline

class NcFilePar : public netCDF::NcFile

Public Functions

NcFilePar() = default

NcFilePar(const std::string &filePath, const FileMode fMode, MPI_Comm comm, MPI_Info info = MPI_INFO_NULL)

void open_par(const std::string &path, const FileMode fMode, MPI_Comm comm, MPI_Info info)

class NetcdfMetadataConfiguration : public Nextsim::Configurator::AdditionalConfiguration

Public Functions

virtual std::stringstream read(const std::string &source) override

class NoOutput : public Nextsim::IDiagnosticOutput

Public Functions

NoOutput() = default

inline virtual void setFilenamePrefix(const std::string &filePrefix) override

inline virtual void outputState(const ModelState &state) override

inline virtual std::string getName() const override

class OutputSpec

Public Functions

inline OutputSpec()

inline OutputSpec(bool activate)

inline void setSuppressOutput()

inline bool suppressOutput() const

inline operator bool() const

inline void setAllComponents()

inline bool allComponents() const

Private Types

enum [anonymous]

Values:

enumerator SUPPRESS_OUTPUT

enumerator ALL_COMPONENTS

enumerator OUTPUTSPEC_COUNT

Private Members

std::bitset<OUTPUTSPEC_COUNT> bitVector

class ParaGridIO : public Nextsim::ParametricGrid::IParaGridIO

Public Types

using NetCDFFileType = netCDF::NcFile

Public Functions

ParaGridIO(ParametricGrid &grid)

virtual ~ParaGridIO()

virtual ModelState getModelState(const std::string &filePath) override

virtual void dumpModelState(const ModelState &state, const std::string &filePath) override

inline virtual ModelState readForcingTime(const std::set<std::string> &forcings, const TimePoint &time, const std::string &filePath) override

virtual void writeDiagnosticTime(const ModelState &state, const std::string &filePath) override

Public Static Functions

static void close(const std::string &filePath)

static ModelState readForcingTimeStatic(const std::set<std::string> &forcings, const TimePoint &time, const std::string &filePath)

Private Types

typedef std::map<std::string, std::pair<NetCDFFileType, size_t>> FileAndIndexMap

Private Functions

ParaGridIO() = delete

ParaGridIO(const ParaGridIO &other) = delete

ParaGridIO &operator=(const ParaGridIO &other) = delete

Private Members

const std::map<std::string, ModelArray::Type> dimensionKeys

const std::map<ModelArray::Dimension, bool> isDG

const std::map<ModelArray::Dimension, ModelArray::Type> dimCompMap

FileAndIndexMap &openFilesAndIndices

Private Static Functions

static void makeDimCompMap()

static void closeAllFiles()

static inline FileAndIndexMap &getOpenFilesAndIndices()

static bool doOnce()

class ParametricGrid : public Nextsim::IStructure

Public Types

typedef ModelArray::MultiDim GridDimensions

Public Functions

inline ParametricGrid()

inline virtual ~ParametricGrid()

inline virtual ModelState getModelState(const std::string &filePath) override

inline virtual void dumpModelState(const ModelState &state, const std::string &filePath, bool isRestart = false) const override

inline virtual const std::string &structureType() const override

inline void setIO(IParaGridIO *p)

Public Static Attributes

static const std::string structureName = "parametric_rectangular"

Private Members

IParaGridIO *pio

friend ParaGridIO

class PDTestDynamics : public Nextsim::DummyDynamics

Public Functions

inline virtual std::string getName() const override

inline virtual void setData(const ModelState::DataMap &ms) override

inline virtual ModelState getStateDiagnostic() const override

inline virtual ModelState getStatePrognostic() const override

Private Members

ModelState::DataMap dataMap

class PDWriter

Public Static Functions

static void write(const PrognosticData &pd, const std::string &filePath)

class PrognosticData : public Nextsim::CheckingModelComponent, public Nextsim::Configured<PrognosticData>

Public Types

enum [anonymous]

Values:

enumerator CHECKFIELDS_KEY

enumerator CHECKFIELDSFAST_KEY

Public Functions

PrognosticData()

virtual ~PrognosticData() = default

virtual void configure() override

inline virtual std::string getName() const override

virtual void setData(const ModelState::DataMap &ms) override

virtual ModelState getStateDiagnostic() const override

virtual ModelState getStatePrognostic() const override

void update(const TimestepTime &tsTime)

void writeRestartFile(const std::string &filePath) const

Public Static Functions

static HelpMap &getHelpText(HelpMap &map, bool getAll)

static HelpMap &getHelpRecursive(HelpMap &map, bool getAll)

Private Members

FloatType m_dt

ModelArrayAccessor<Shared::H_ICE_DG, RW> hiceAccessor

ModelArrayAccessor<Shared::C_ICE_DG, RW> ciceAccessor

ModelArrayAccessor<Shared::DAMAGE, RW> damageAccessor

ModelArrayAccessor<Shared::H_SNOW_DG, RW> hsnowAccessor

IAtmosphereBoundary *pAtmBdy

IOceanBoundary *pOcnBdy

IDynamics *pDynamics

IColumnPhysics *pColumnPhysics

class RectangularGrid : public Nextsim::IStructure

Public Functions

inline RectangularGrid()

inline RectangularGrid(const GridDimensions &dims)

inline virtual ~RectangularGrid()

inline virtual ModelState getModelState(const std::string &filePath) override

inline virtual void dumpModelState(const ModelState &state, const std::string &filePath, bool isRestart = false) const override

inline virtual const std::string &structureType() const override

inline void setDimensions(const GridDimensions &dims)

inline void setIO(IRectGridIO *p)

Public Static Attributes

static const std::string structureName = "simple_rectangular"

Private Members

int nx

int ny

IRectGridIO *pio

friend RectGridIO

Private Static Attributes

static const std::string xDimName = "x"

static const std::string yDimName = "y"

class RectGridIO : public Nextsim::RectangularGrid::IRectGridIO

Public Types

typedef RectangularGrid::GridDimensions GridDimensions

Public Functions

inline RectGridIO(RectangularGrid &grid)

virtual ~RectGridIO() = default

virtual ModelState getModelState(const std::string &filePath) override

virtual void dumpModelState(const ModelState &state, const std::string &filePath, bool isRestart) const override

Private Functions

RectGridIO() = default

class SimpleOutput : public Nextsim::IDiagnosticOutput

Public Functions

SimpleOutput() = default

inline virtual void setFilenamePrefix(const std::string &filePrefix) override

virtual void outputState(const ModelState &state) override

inline virtual std::string getName() const override

Private Members

std::string m_filePrefix

class SizeMap

Public Functions

SizeMap()

inline size_t &at(const Type &type)

inline const size_t &at(const Type &type) const

inline size_t &operator[](const Type &type)

inline size_t &operator[](Type &&type)

inline size_t size() const noexcept

void validate()

Protected Attributes

std::map<Type, size_t> m_sizes

class Slice

Public Types

using Int = std::ptrdiff_t

using VBounds = std::vector<Bounds>

Public Functions

inline Slice()

inline Slice(VBounds allBounds)

inline size_t n() const

Public Members

const VBounds bounds

class SliceIter

Public Types

using MultiDim = std::vector<size_t>

using Int = Slice::Int

Public Functions

inline SliceIter(const Slice &slice, const MultiDim &dimensions)

inline bool operator==(const SliceIter &other) const

inline SliceIter &operator++()

inline SliceIter operator++(int)

inline SliceIter &incrementDim(size_t dim)

SliceIter &operator--()

SliceIter operator--(int)

inline Int index() const

inline const MultiDim position() const

inline SliceIter &toBegin()

inline SliceIter &toEnd()

inline bool isBegin() const

inline bool isEnd() const

inline MultiDim shape() const

inline size_t size() const

inline Int start(size_t dim) const

inline Int start() const

inline Int nElements(size_t dim) const

inline Int nElements() const

inline Int step(size_t dim) const

inline Int step() const

inline std::ostream &print(std::ostream &os) const

Private Functions

inline Int dimEnd(size_t dim) const

inline bool stopTest(Int subject, size_t dim) const

inline bool stopTest(const MultiDim &loc, size_t dim) const

Private Members

const MultiDim m_dimensions

MultiDim current

const Slice m_slice

Private Static Functions

static inline Slice::VBounds realiseIndices(const Slice::VBounds &in, const MultiDim &dims)

class StartStepStop

Public Functions

inline StartStepStop(TimePoint start, Duration step, TimePoint stop)

inline bool isIn(const TimePoint &query)

inline bool doStep(const TimePoint &query)

Private Members

TimePoint m_start

Duration m_step

TimePoint m_stop

TimePoint m_last

class StructureFactory

Public Static Functions

static ModelState stateFromFile(const std::string &filePath)

static void fileFromState(const ModelState &state, const std::string &filePath, bool isRestart = false)

static void finaliseAllFiles()

Private Functions

StructureFactory() = default

struct TextTag

Public Functions

inline constexpr TextTag(const char *textIn)

template<std::size_t N> inline constexpr TextTag(const char (&a)[N])

inline operator std::string() const

Public Members

const char *text

class TheCount

Public Static Functions

static inline size_t increment()

static inline size_t preincrement()

static inline void incrementAndPrint()

static inline size_t value()

static inline size_t count()

static inline void reset()

Protected Static Functions

static inline size_t &get()

class TimeOptions

Public Static Functions

static inline bool &useDOY()

Private Types

enum TimeOption

Values:

enumerator USE_DOY

enumerator DAYS_360

enumerator COUNT

Private Static Attributes

static std::array<bool, COUNT> m_opt = {false, false}

class TimePoint

Public Types

typedef SystemClock Clock

typedef std::chrono::time_point<Clock, Duration::Basis> Basis

Public Functions

inline TimePoint()

inline TimePoint(const std::string &str)

TimePoint(const TimePoint&, const Duration&)

inline Duration operator-(const TimePoint &a) const

inline TimePoint operator-(const Duration &d) const

inline TimePoint &operator+=(const Duration &d)

inline TimePoint &operator-=(const Duration &d)

inline TimePoint operator+(const Duration &d) const

inline bool operator<=(const TimePoint &a) const

inline bool operator<(const TimePoint &a) const

inline bool operator>=(const TimePoint &a) const

inline bool operator>(const TimePoint &a) const

inline bool operator==(const TimePoint &a) const

inline bool operator!=(const TimePoint &a) const

inline std::istream &parse(std::istream &is)

inline TimePoint &parse(const std::string &str)

inline std::ostream &format(std::ostream &os, std::string formatStr = ymdhmsFormat) const

inline std::string format(std::string formatStr = ymdhmsFormat) const

std::tm *gmtime() const

Public Members

friend Duration

Public Static Attributes

static const std::string ymdFormat = "%Y-%m-%d"

static const std::string doyFormat = "%Y-%j"

static const std::string ymdhmsFormat = ymdFormat + hmsFormat

static const std::string doyhmsFormat = doyFormat + hmsFormat

static const std::string hmsFormat = "T%H:%M:%SZ"

Private Functions

inline TimePoint(const Basis &t)

Private Members

Basis m_t

struct TimestepTime

Public Members

TimePoint start

Duration step

template<typename T> struct ToNetCDFType

template<> struct ToNetCDFType<double>

Public Static Functions

static inline netCDF::NcDouble &get()

template<> struct ToNetCDFType<float>

Public Static Functions

static inline netCDF::NcFloat &get()

class UnescoFreezingImpl : public Nextsim::IFreezingPoint

Public Functions

inline virtual std::string getName() const override

inline KERNEL_IMPL_FUNCTION FloatType calculate (FloatType sss) const

module alt_names

Variables

nfirst = 9

nsecond = 10

nLayers = 1

ncg = 1

n_dg = 1

n_dgstress = 1

n_coords = 2

ncFile = netCDF4.Dataset("alt_names.nc", "w", format="NETCDF4")

structure_name

time_meta = ncFile.createVariable("time_meta", "i8")

data_time = 1263204000

units

formatted = ncFile.createVariable("formatted", str)

format

yDim = ncFile.createDimension("ydim", nfirst)

xDim = ncFile.createDimension("xdim", nsecond)

yVertexDim = ncFile.createDimension("yvertex", nfirst + 1)

xVertexDim = ncFile.createDimension("xvertex", nsecond + 1)

ycg_dim = ncFile.createDimension("y_cg", nfirst * ncg + 1)

xcg_dim = ncFile.createDimension("x_cg", nsecond * ncg + 1)

dg_comp = ncFile.createDimension("dg_comp", n_dg)

dgs_comp = ncFile.createDimension("dgstress_comp", n_dgstress)

n_coords_comp = ncFile.createDimension("ncoords", n_coords)

field_dims = ("ydim", "xdim")

coord_dims = ("yvertex", "xvertex", "ncoords")

space = 25000.0

xvertex1d = np.arange(0, space * (nsecond + 1), space)

yvertex1d = np.arange(0, space * (nfirst + 1), space)

xvertex = np.resize(xvertex1d, (nfirst + 1, nsecond + 1))

yvertex = np.resize(yvertex1d, (nsecond + 1, nfirst + 1)).transpose()

coords = ncFile.createVariable("coords", "f8", coord_dims)

x_cell1d = np.arange(space * 0.5, space * (nsecond + 0.5), space)

y_cell1d = np.arange(space * 0.5, space * (nfirst + 0.5), space)

x_cell = np.resize(x_cell1d, (nfirst, nsecond))

y_cell = np.resize(y_cell1d, (nsecond, nfirst)).transpose()

elem_x = ncFile.createVariable("xdim", "f8", field_dims)

elem_y = ncFile.createVariable("ydim", "f8", field_dims)

grid_azimuth = ncFile.createVariable("grid_azimuth", "f8", field_dims)

mask = ncFile.createVariable("mask", "f8", field_dims)

cice = ncFile.createVariable("cice", "f8", field_dims)

hice = ncFile.createVariable("hice", "f8", field_dims)

hsnow = ncFile.createVariable("hsnow", "f8", field_dims)

sss = ncFile.createVariable("sss", "f8", field_dims)

mu = -0.055

sst = ncFile.createVariable("sst", "f8", field_dims)

tice = ncFile.createVariable("tice", "f8", field_dims)

ice_melt = mu * 5

u = ncFile.createVariable("u", "f8", field_dims)

v = ncFile.createVariable("v", "f8", field_dims)

namespace ArraySlicer

Functions

inline std::ostream &operator<<(std::ostream &os, const Slice::Bounds &bounds)

inline std::ostream &operator<<(std::ostream &os, const Slice::VBounds &vBounds)

inline std::ostream &operator<<(std::ostream &os, const Slice &slice)

inline std::ostream &operator<<(std::ostream &os, const SliceIter &si)

namespace EnumWrap

Functions

template<typename E> std::istream &operator>>(std::istream &is, EnumWrapper<E> &e)

module generate_iodef

Variables

parser = argparse.ArgumentParser()

type

int

default

help

str

parsed_args = parser.parse_args()

template_dict = vars(parsed_args)

path

infile

env = Environment(loader=FileSystemLoader(path), autoescape=True)

template = env.get_template(infile)

outfile = template_dict.pop("outfile")

output = template.render(template_dict)

namespace Indexer

Functions

template<typename T = size_t, typename D = std::vector<T>, typename L = D> T indexer(const D &dims, const L &loc)

template<typename T = size_t, typename D = std::vector<T>, typename L = D> L deIndexer(const D &dims, const T &index)

namespace Module

Typedefs

using OptionMap = std::list<Nextsim::ConfigurationHelp>

using HelpMap = std::map<std::string, OptionMap>

using Config = Nextsim::ConfiguredModule

Functions

template<typename Int, typename Imp> std::unique_ptr<Int> newImpl()

template<typename I> std::unique_ptr getInstance()

template<typename I> I &getImplementation()

template<typename I> void setImplementation(const std::string &impl)

template<typename I> HelpMap &getHelpRecursive(HelpMap &map, bool getAll)

template<typename I> std::string implementation()

template<typename I> void finalize()

template<> Nextsim::IDynamics &getImplementation<Nextsim::IDynamics>()

template<> HelpMap &getHelpRecursive<Nextsim::IDynamics>(HelpMap &map, bool getAll)

Variables

const std::string DEFAULTIMPL = "DefaultImpl"

const std::string IMPL1 = "Impl1"

const std::string IMPL2 = "Impl2"

const std::string ANOTHERIMPL = "AnotherImpl"

const std::string PDTESTDYNAMICS = "Nextsim::PDTestDynamics"

module module_maker

Functions

denamespace(nname)

generator(module_class_name, fq_interface_name, fq_impl_names, help_names)

Variables

parser = argparse.ArgumentParser(description="Write out the text for a Nextsim module class source file.",epilog="Suffix the interface or any implementation name with an asterisk (*) to include a call to getHelpRecursive().",)

metavar

nargs

default

help

dest

required

args = parser.parse_args()

help_names = []

impl_names = []

interface_name = args.interface

iface = denamespace(interface_name)

modulepfx = iface[1:]

namespace netCDF

Functions

void setVariableCollective(NcVar var, NcFile &ncFile)

namespace Nextsim

Typedefs

typedef std::variant<double, float, unsigned, int, std::string> Fusi

typedef std::map<std::string, Fusi> ConfigMap

using FloatType = NEXTSIM_FLOAT_TYPE

using ElementIndex = size_t

using DefaultExecutionSpace = ExecutionSpaceDummy

using AdvectedField = ModelArray

using ModelArrayAuto = ModelArray

using ConstModelArrayAuto = const ModelArray

typedef std::chrono::system_clock SystemClock

typedef SystemClock::duration SystemDuration

using LinearFreezing = FreezingPointImpl<LinearFreezingImpl>

using UnescoFreezing = FreezingPointImpl<UnescoFreezingImpl>

typedef ModelMetadata::Edge Edge

typedef ModelMetadata::Corner Corner

typedef std::vector<int> vec

Enums

enum ConfigMapType

Values:

enumerator DOUBLE

enumerator FLOAT

enumerator UNSIGNED

enumerator INT

enumerator STRING

enumerator N_TYPES

Functions

static std::string section(const std::string &title)

static std::string option(const std::string &name)

static std::string defaultVal(const std::string &name)

static std::string type(const std::string &desc)

static std::string ansiMode(std::string mode)

inline std::ostream &operator<<(std::ostream &os, const ConfigurationHelp &help)

template<typename T> void tryConfigure(T &t)

template<typename T> void tryConfigure(T *p_t)

inline KERNEL_IMPL_FUNCTION FloatType kelvin (FloatType celsius)

inline KERNEL_IMPL_FUNCTION FloatType celsius (FloatType kelvin)

inline KERNEL_IMPL_FUNCTION FloatType degrees (FloatType radians)

inline KERNEL_IMPL_FUNCTION FloatType radians (FloatType degrees)

inline KERNEL_IMPL_FUNCTION FloatType mbar (FloatType pascals)

inline KERNEL_IMPL_FUNCTION FloatType pascals (FloatType mbar)

constexpr FloatType operator""_ft(long double v)

ModelArray operator+(const FloatType&, const ModelArray&)

ModelArray operator-(const FloatType&, const ModelArray&)

ModelArray operator*(const FloatType&, const ModelArray&)

ModelArray operator/(const FloatType&, const ModelArray&)

inline std::ostream &operator<<(std::ostream &os, const MASIter &it)

template<typename T> void readNetCDFVar(const netCDF::NcVar &var, const std::vector<size_t> &start, const std::vector<size_t> &size, T *dest)

std::time_t mkgmtime(std::tm *time, bool recalculateDoy = true)

int julianGregorianShiftDays(int year)

std::time_t timeFromISO(const std::string &iso)

std::time_t timeFromISO(std::istream &is)

inline double operator*(double a, const Duration &b)

inline double operator/(double a, const Duration &b)

inline double operator*(const Duration &a, double b)

inline double operator/(const Duration &a, double b)

inline std::istream &operator>>(std::istream &is, TimePoint &tp)

inline std::istream &operator>>(std::istream &is, Duration &dur)

inline std::ostream &operator<<(std::ostream &os, const TimePoint &tp)

inline std::ostream &operator<<(std::ostream &os, const Duration &dur)

DeviceBitset makeKokkosDeviceBitset(const std::vector<bool> &buf)

void checkStartStep(const std::string start_str, FloatType step)

static const std::regex ncSuffix (".nc$")

std::string concatenateFields(const std::set<std::string> &strSet)

void copyMeanComponent(const ModelArray &source, ModelArray &sink)

void dimensionSetter(const netCDF::NcFile &ncFile, const std::string &fieldName, ModelArray::Type type)

std::string structureNameFromFile(const std::string &filePath)

std::tm &tmDoy(std::tm &tm)

bool isYMDFormat(const std::string &iso)

bool isDOYFormat(const std::string &iso)

std::vector<std::string> splitString(const std::string &str, char delim)

std::string addTimeLeadingZeros(const std::string &in)

std::tm getTimTime(const std::string &in, bool isDOY)

Duration durationFromISO(const std::string &iso, int sign = +1)

Duration durationFromISO(std::istream &is, int sign = +1)

TEST_SUITE_BEGIN ("CommandLineParser")

TEST_CASE ("Parse config file names")

TEST_SUITE_END()

void runMe(const bool snapshot)

TEST_SUITE_BEGIN ("ConfigOutput")

TEST_CASE ("Test snapshot output")

TEST_SUITE_BEGIN ("Configurator")

TEST_CASE ("Parse one config stream using the raw configurator")

TEST_CASE ("Parse one config stream using the pointer configuration function")

TEST_CASE ("Parse two config streams for one class, reference helper function")

TEST_CASE ("Parse config streams for two overlapping class, try")

TEST_SUITE_BEGIN ("ConfiguredModule")

TEST_CASE ("Configure a module")

TEST_CASE ("Configure a module from a stream")

TEST_SUITE_BEGIN ("FileCallbackCloser")

TEST_CASE ("Test the FileHolder class")

TEST_CASE ("Close a file")

void throwHappy()

TEST_SUITE_BEGIN ("ModelFinalizer")

TEST_CASE ("Duplicate functions")

TEST_CASE ("Unique functions")

TEST_CASE ("Finalize")

TEST_CASE ("Exception")

template<typename T> void initializeTestData(T &data, size_t localNx, size_t localNy, size_t offsetX, size_t offsetY, bool isCG = false)

template<typename T> void verifyTestData(T &data, size_t localNx, size_t localNy, size_t offsetX, size_t offsetY, size_t nx, size_t ny, bool isCG = false)

TEST_SUITE_BEGIN ("Halo exchange tests")

MPI_TEST_CASE ("test halo exchange on 3 proc grid", 3)

MPI_TEST_CASE ("DGField", 3)

MPI_TEST_CASE ("DGVector", 3)

MPI_TEST_CASE ("DGVectorHolder", 3)

MPI_TEST_CASE ("CGVector", 3)

template<typename T> T zeroTime()

template<> std::chrono::time_point<Iterator::Clock> zeroTime<std::chrono::time_point<Iterator::Clock>>()

template<> size_t zeroTime<size_t>()

TEST_SUITE_BEGIN ("Iterator")

TEST_CASE ("Count iterator testing")

TEST_SUITE_BEGIN ("ModelArray")

TEST_CASE ("Two dimensional data access test")

TEST_CASE ("Higher dimensional indexing")

TEST_CASE ("Higher dimensional indexing 2")

TEST_CASE ("Copy constructor and copy assignment operator")

TEST_CASE ("Instance setDimensions sets instance dimensions")

TEST_CASE ("Arithmetic tests")

TEST_CASE ("Location from index")

TEST_CASE ("Components")

TEST_CASE ("Direct DataType access")

TEST_SUITE_BEGIN ("[ModelArrayAccessor]")

TEST_CASE ("Accessing the data")

hice0Src reinitialize()

REQUIRE_THROWS_AS ((ModelArrayAccessor< MiniModelComponent::H_ICE0, RW >(store)), std::logic_error)

REQUIRE_THROWS_AS ((ModelArrayAccessor< MiniModelComponent::H_ICE, RW >(store, RO)), std::logic_error)

TEST_CASE ("Accessing the data two ways")

TEST_CASE ("Full component access")

TEST_SUITE_BEGIN ("ModelArraySlice")

TEST_CASE ("Assign scalar to slice")

TEST_CASE ("Slice to Slice")

TEST_CASE ("ModelArray to Slice")

TEST_CASE ("Slice to ModelArray")

TEST_CASE ("Index a ModelArray with a Slice")

TEST_CASE ("Test buffers")

TEST_CASE ("General slice creation")

TEST_CASE ("Iterators")

TEST_CASE ("Eigen copying")

eaSrc resize(sliceNx *sliceNy, DG)

for (size_t j=0;j< sliceNy;++j)

REQUIRE (eaSrc(Indexer::indexer({ sliceNx, sliceNy }, { 2, 3 }), 4)==4+xMul *(2+yMul *3))

REQUIRE (maInter.components({ sliceX0+2, sliceY0+3 })[4]==-1.)

REQUIRE (maInter.components({ sliceX0 - 1, sliceY0 - 1 })[0]==-1.)

REQUIRE (maInter.components({ sliceX0 - 1, sliceY0 - 1 })[DG - 1]==-1.)

REQUIRE (maInter.components({ sliceX0+0, sliceY0+0 })[0]==0.)

REQUIRE (maInter.components({ sliceX0+0, sliceY0+0 })[DG - 1]==DG - 1)

REQUIRE (maInter.components({ sliceX0+1, sliceY0+0 })[0]==xMul)

REQUIRE (maInter.components({ sliceX0+1, sliceY0+0 })[DG - 1]==xMul+DG - 1)

REQUIRE (maInter.components({ sliceX0+0, sliceY0+1 })[0]==xMul *yMul)

REQUIRE (maInter.components({ sliceX0+0, sliceY0+1 })[DG - 1]==xMul *yMul+DG - 1)

REQUIRE (eaSink(Indexer::indexer({ sliceNx, sliceNy }, { 0, 0 }), 0)==0)

REQUIRE (eaSink(Indexer::indexer({ sliceNx, sliceNy }, { 0, 0 }), 5)==5)

REQUIRE (eaSink(Indexer::indexer({ sliceNx, sliceNy }, { 3, 5 }), 2)==2+xMul *(3+yMul *5))

REQUIRE (maSrc.components({ 2, 3 })[4]==4+xMul *(2+yMul *3))

perimeterBuffer resize (2 *nx+2 *ny, DG)

perimeterBuffer (Eigen::seqN(0, nx), Eigen::all)

perimeterBuffer(Eigen::seqN(nx, ny), Eigen::all)

perimeterBuffer (Eigen::seqN(nx+ny, nx), Eigen::all)

perimeterBuffer (Eigen::seqN(2 *nx+ny, ny), Eigen::all)

TEST_SUITE_BEGIN ("ModelComponent")

TEST_CASE ("Test array registration")

TEST_CASE ("Shared and semi-protected arrays")

static void testNonPeriodicBC(int test_rank)

TEST_SUITE_BEGIN ("ModelMetadata")

MPI_TEST_CASE ("Test getPartitionMetadata closed boundary", 3)

static void testNonPeriodicBC(int test_rank)

MPI_TEST_CASE ("Test getPartitionMetadata periodic boundary", 3)

TEST_SUITE_BEGIN ("MonthlyCubicBSpline")

TEST_CASE ("Test cyclicity")

TEST_CASE ("Albedo values")

void initializeTestData(HField &frac, DGField &fracDG, HField &mask, VertexField &coordinates, HField &x, HField &y)

TEST_SUITE_BEGIN ("ParaGrid")

grid setIO(pio)

HField fractional(ModelArray::Type::H)

DGField fractionalDG(ModelArray::Type::DG)

HField mask(ModelArray::Type::H)

VertexField coordinates(ModelArray::Type::VERTEX)

for (auto arr :arrays)

initializeTestData(fractional, fractionalDG, mask, coordinates, x, y)

REQUIRE (coordinates.components({ 3, 8 })[0] - coordinates.components({ 2, 8 })[0]==scale)

REQUIRE (coordinates.components({ 3, 8 })[1] - coordinates.components({ 3, 7 })[1]==scale)

metadata setTime (TimePoint("2000-01-01T00:00:00Z"))

metadata extractCoordinates(coordState)

metadata affixCoordinates(state)

grid dumpModelState (state, filename, true)

REQUIRE(std::filesystem::exists(std::filesystem::path(filename)))

REQUIRE(ModelArray::nComponents(ModelArray::Type::DG) = =DG)

REQUIRE(ModelArray::nComponents(ModelArray::Type::VERTEX) = =ModelArray::nCoords)

gridIn setIO(readIO)

REQUIRE (ms.data.size()==state.data.size())

REQUIRE (hiceRef.nDimensions()==2)

REQUIRE (hiceRef.dimensions()[0]==localNX)

REQUIRE (hiceRef.dimensions()[1]==localNY)

REQUIRE (coordRef.nDimensions()==2)

REQUIRE (coordRef.dimensions()[0]==localNX+1)

REQUIRE (coordRef.dimensions()[1]==localNY+1)

REQUIRE (coordRef.components({ 3, 8 })[0] - coordRef.components({ 2, 8 })[0]==scale)

REQUIRE (coordRef.components({ 3, 8 })[1] - coordRef.components({ 3, 7 })[1]==scale)

REQUIRE (ms.data.count(xName) > 0)

REQUIRE (xRef(3, 8)==coordRef.components({ 3, 7 })[0]+scale/2)

REQUIRE (ms.data.count(yName) > 0)

REQUIRE (yRef(3, 8)==coordRef.components({ 2, 8 })[1]+scale/2)

REQUIRE (ms.data.count(gridAzimuthName) > 0)

REQUIRE (ms.data.at(gridAzimuthName)(1, 1)==gridAzimuth0)

REQUIRE (Module::getImplementation< IStructure >().structureType()=="parametric_rectangular")

REQUIRE (fractional.nDimensions()==2)

pio close(diagFile)

REQUIRE(std::filesystem::exists(std::filesystem::path(diagFile)))

netCDF::NcFile ncFile(diagFile, netCDF::NcFile::read)

ncFile getAtt (grid.structureNodeName()).getValues(structureType)

REQUIRE(structureType = =grid.structureType())

REQUIRE (hiceVar.getDimCount()==4)

REQUIRE (ncFile.getVars().count(xName) > 0)

REQUIRE (ncFile.getVars().count(yName) > 0)

REQUIRE (ncFile.getVars().count(coordsName) > 0)

REQUIRE (ncFile.getVars().count(gridAzimuthName) > 0)

ncFile close()

HField index2d(ModelArray::Type::H)

REQUIRE (state.data.count(fieldName) > 0)

REQUIRE (index2d(3, 5)==(offsetX+3) *xFactor+5.)

std::string longRandomFilename ("a44f5cc1f7934a8ae8dd03a95308745d.nc")

REQUIRE_THROWS(state = gridIn.getModelState(longRandomFilename))

REQUIRE (ModelArray::dimensions(ModelArray::Type::H)[0]==nx)

REQUIRE (ModelArray::dimensions(ModelArray::Type::H)[1]==ny)

TEST_SUITE_BEGIN ("PrognosticData")

TEST_CASE ("PrognosticData call order test")

TEST_SUITE_BEGIN ("PrognosticDataIO")

TEST_SUITE_BEGIN ("RectGrid")

grid setIO (new RectGridIO(grid))

tice setData(ticeValue)

metadata setTime(TimePoint(date_string))

ModelArray x(ModelArray::Type::H)

ModelArray y(ModelArray::Type::H)

grid dumpModelState(state, filename)

REQUIRE (ms.data.at("hice")(targetX, targetY)==1.0201_ft)

REQUIRE(ticeIn(targetX, targetY) = =-1.0201_ft)

REQUIRE (ms.data.at(xName)(1, 0)==dx)

REQUIRE (ms.data.at(xName)(0, 1)==0)

REQUIRE (ms.data.at(yName)(0, 1)==dy)

TEST_SUITE_BEGIN ("Time")

TEST_CASE ("TimePoint parsing and formating")

TEST_CASE ("Julian-Gregorian shifts")

TEST_CASE ("mkgmtime")

TEST_CASE ("timeFromISO")

TEST_CASE ("TimePoints")

TEST_CASE ("Durations")

TEST_CASE ("gmtime and doy")

MPI_TEST_CASE ("TestXiosAxis", 3)

MPI_TEST_CASE ("TestXiosCalendar", 1)

MPI_TEST_CASE ("TestXiosReadDiagnostic", 3)

MPI_TEST_CASE ("TestXiosReadForcing", 2)

MPI_TEST_CASE ("TestXiosReadRestart", 2)

MPI_TEST_CASE ("TestXiosReadWriteRestart", 2)

MPI_TEST_CASE ("TestXiosWriteDiagnostic", 2)

MPI_TEST_CASE ("TestXiosWriteRestart", 2)

Variables

static std::string h1 = ""

static std::string h1End = ""

static std::string h2 = ""

static std::string h2End = ""

static std::string b = ""

static std::string u = ""

static std::string i = ""

static std::string bEnd = ""

static std::string uEnd = ""

static std::string iEnd = ""

static const std::string hiceName = "hice"

static const std::string ciceName = "cice"

static const std::string hsnowName = "hsnow"

static const std::string ticeName = "tice"

static const std::string tsurfName = "tsurf"

static const std::string maskName = "mask"

static const std::string uName = "u"

static const std::string vName = "v"

static const std::string sstName = "sst"

static const std::string sssName = "sss"

static const std::string damageName = "damage"

static const std::string shearName = "shear"

static const std::string divergenceName = "divergence"

static const std::string sigmaIName = "sigmaI"

static const std::string sigmaIIName = "sigmaII"

static const std::string uWindName = "uwind"

static const std::string vWindName = "vwind"

static const std::string uOceanName = "uocean"

static const std::string vOceanName = "vocean"

static const std::string sshName = "ssh"

static const std::string mldName = "mld"

static const std::string uIOStressName = "uiostress"

static const std::string vIOStressName = "viostress"

static const std::string coordsName = "coords"

static const std::string latitudeName = "latitude"

static const std::string longitudeName = "longitude"

static const std::string xName = "x_dim"

static const std::string yName = "y_dim"

static const std::string gridAzimuthName = "grid_azimuth"

static const std::string mdiName = "missing_value"

static const std::string timeName = "time"

static const Eigen::StorageOptions majority = Eigen::RowMajor

constexpr bool RW = true

constexpr bool RO = false

constexpr bool DETAILED_MEASUREMENTS = true

boost::log::sources::severity_logger<Logged::level> sl

static const std::map<int, std::string> keyMap = {{Model::RESTARTFILE_KEY, Model::restartOptionName}, {Model::STARTTIME_KEY, "model.start"}, {Model::STOPTIME_KEY, "model.stop"}, {Model::RUNLENGTH_KEY, "model.run_length"}, {Model::TIMESTEP_KEY, "model.time_step"}, {Model::MISSINGVALUE_KEY, "model.missing_value"}, {Model::RESTARTPERIOD_KEY, "model.restart_period"}, {Model::RESTARTOUTFILE_KEY, "model.restart_file"},}

static const std::string pfx = "ConfigOutput"

static const std::string periodKey = pfx + ".period"

static const std::string snapshotKey = pfx + ".snapshots"

static const std::string startKey = pfx + ".start"

static const std::string fieldNamesKey = pfx + ".field_names"

static const std::string fileNameKey = pfx + ".filename"

static const std::string filePeriodKey = pfx + ".file_period"

static const std::string modelStartKey = "model.start"

static const std::map<int, std::string> keyMap = {{ConfigOutput::PERIOD_KEY, periodKey}, {ConfigOutput::START_KEY, startKey}, {ConfigOutput::SNAPSHOT_KEY, snapshotKey}, {ConfigOutput::FIELDNAMES_KEY, fieldNamesKey}, {ConfigOutput::FILENAME_KEY, fileNameKey}, {ConfigOutput::FILEPERIOD_KEY, filePeriodKey},}

static const std::vector<std::string> namedFields = {uName, vName}

static const std::map<std::string, std::pair<ModelArray::Type, FloatType>> defaultFields = {}

static const std::string prefix = "BBMDynamics"

static const std::map<int, std::string> keyMap = {{BBMDynamics::C_KEY, prefix + ".C"}, {BBMDynamics::NU_KEY, prefix + ".nu"}, {BBMDynamics::YOUNG_KEY, prefix + ".young"}, {BBMDynamics::P0_KEY, prefix + ".P0"}, {BBMDynamics::LAMBDA0_KEY, prefix + ".lambda0"}, {BBMDynamics::ALPHA_KEY, prefix + ".alpha"}, {BBMDynamics::EXPPMAX_KEY, prefix + ".exppmax"}, {BBMDynamics::MU_KEY, prefix + ".mu"}, {BBMDynamics::NMAX_KEY, prefix + ".namx"}, {BBMDynamics::CLAB_KEY, prefix + ".clab"}, {BBMDynamics::NSTEPS_KEY, prefix + ".nsteps"}, {BBMDynamics::RHOI_KEY, prefix + ".rho_ice"}, {BBMDynamics::RHOA_KEY, prefix + ".rho_atm"}, {BBMDynamics::RHOO_KEY, prefix + ".rho_ocean"}, {BBMDynamics::CATM_KEY, prefix + ".drag_atm"}, {BBMDynamics::COCEAN_KEY, prefix + ".drag_ocean"}, {BBMDynamics::FC_KEY, prefix + ".Coriolis_parameter"}, {BBMDynamics::ANGLE_KEY, prefix + ".ocean_turning_angle"},}

static const std::vector<std::string> namedFields = {uName, vName}

static const std::string prefix = "MEVPDynamics"

static const std::map<int, std::string> keyMap = {{MEVPDynamics::PSTAR_KEY, prefix + ".Pstar"}, {MEVPDynamics::DELTA_KEY, prefix + ".DeltaMin"}, {MEVPDynamics::C_KEY, prefix + ".C"}, {MEVPDynamics::NSTEPS_KEY, prefix + ".nsteps"}, {MEVPDynamics::RHOI_KEY, prefix + ".rho_ice"}, {MEVPDynamics::RHOA_KEY, prefix + ".rho_atm"}, {MEVPDynamics::RHOO_KEY, prefix + ".rho_ocean"}, {MEVPDynamics::CATM_KEY, prefix + ".drag_atm"}, {MEVPDynamics::COCEAN_KEY, prefix + ".drag_ocean"}, {MEVPDynamics::FC_KEY, prefix + ".Coriolis_parameter"}, {MEVPDynamics::ANGLE_KEY, prefix + ".ocean_turning_angle"},}

static const std::vector<std::string> namedFields = {uName, vName}

static const std::string checkFieldsKey = "debug.check_fields"

static const std::string checkFieldsFastKey = "debug.check_fields_fast"

static const std::map<int, std::string> keyMap = {{PrognosticData::CHECKFIELDS_KEY, checkFieldsKey}, {PrognosticData::CHECKFIELDSFAST_KEY, checkFieldsFastKey}}

static constexpr bool checkFieldsDefault = false

static constexpr bool checkFieldsFastDefault = true

static const int minuteSeconds = 60

static const int hourSeconds = minuteSeconds * 60

static const int daySeconds = hourSeconds * 24

static const int yearSeconds = daySeconds * 365

static const int tmEpochYear = 1900

static const int unixEpochYear = 1970

const std::string testFileName = "testFileName.nc"

const std::string testFilesDir = TEST_FILES_DIR

const std::string file = testFilesDir + "/halo_cb_test_partition_metadata_3.nc"

static const int DG = 3

static const int CGDEGREE = 2

static const bool debug = false

ModelArrayAccessor< MiniModelComponent::H_ICE0, RW > hice0SrcAccessor (store, RO) = { ModelArrayStore store

HField &hice0Src = hice0SrcAccessor.getHostRW()

ModelArrayAccessor<MiniModelComponent::H_ICE, RW> hiceAccessor(store)

static const FloatType targetFlux = 320

constexpr TextTag sw_in = {"sw_in"}

size_t sliceNx = 7

size_t sliceNy = 11

size_t sliceX0 = 3

size_t sliceY0 = 5

FloatType xMul = 100

FloatType yMul = 100

ModelArray::DataType eaSrc

ModelArray maInter(ModelArray::Type::TWOCOMP) = -1.

Slice maSlice = {{{sliceX0, sliceX0 + sliceNx}, {sliceY0, sliceY0 + sliceNy}}}

ModelArray::DataType eaSink = -1

ModelArray maSrc(ModelArray::Type::TWOCOMP)

ModelArray::DataType perimeterBuffer

Slice left = {{{0}, {}}}

Slice right = {{{nx - 1}, {}}}

Slice bottom = {{{}, {0}}}

Slice top = {{{}, {ny - 1}}}

ModelArray maSnk(ModelArray::Type::TWOCOMP) = ModelArray::DataType(perimeterBuffer(Eigen::seqN(0, nx), Eigen::all))

constexpr auto BOTTOM = Edge::BOTTOM

constexpr auto RIGHT = Edge::RIGHT

constexpr auto TOP = Edge::TOP

constexpr auto LEFT = Edge::LEFT

constexpr auto TOP_LEFT = Corner::TOP_LEFT

constexpr auto TOP_RIGHT = Corner::TOP_RIGHT

constexpr auto BOTTOM_RIGHT = Corner::BOTTOM_RIGHT

constexpr auto BOTTOM_LEFT = Corner::BOTTOM_LEFT

ParametricGrid grid

ParaGridIO *pio = new ParaGridIO(grid)

auto &metadata = ModelMetadata::getInstance()

const auto localNX = nx

const auto localNY = ny

HField x

HField y

ModelArray *arrays[] = {&fractional, &fractionalDG, &mask, &coordinates, &x, &y}

DGField hice = fractionalDG + 10

DGField cice = fractionalDG + 20

DGField hsnow = fractionalDG + 30

DGField damage = fractionalDG * 0.

HField sss = fractional

HField gridAzimuth = gridAzimuth0

FloatType gridAzimuth0 = 45.

ModelState state = {{{maskName, mask}, {hiceName, hice}, {ciceName, cice}, {hsnowName, hsnow}, {damageName, damage},}, {}}

ModelState coordState = {{{xName, x}, {yName, y}, {coordsName, coordinates}, {gridAzimuthName, gridAzimuth},}, {}}

ParametricGrid gridIn

ParaGridIO *readIO = new ParaGridIO(gridIn)

ModelState ms = gridIn.getModelState(filename)

ModelArray &hiceRef = ms.data.at(hiceName)

ModelArray &coordRef = ms.data.at(coordsName)

ModelArray &xRef = ms.data.at(xName)

auto testa = xRef(3, 8)

auto testb = coordRef.components({3, 7})[0]

ModelArray &yRef = ms.data.at(yName)

std::string structureType

netCDF::NcVar hiceVar = ncFile.getVar(hiceName)

netCDF::NcVar ciceVar = ncFile.getVar(ciceName)

netCDF::NcVar maskVar = ncFile.getVar(maskName)

netCDF::NcVar timeVar = ncFile.getVar(timeName)

FloatType xFactor = 10

const size_t offsetX = 0

index2d = 0.

std::string fieldName = "index2d"

std::set<std::string> fields = {fieldName}

TimePoint time

size_t nx = 5

size_t ny = 7

FloatType yFactor = 0.01

auto dimX = ModelArray::Dimension::X

auto startX = ModelArray::definedDimensions.at(dimX).start

auto dimY = ModelArray::Dimension::Y

auto startY = ModelArray::definedDimensions.at(dimY).start

HField sst = fractional + 3

HField ticeValue = -(fractional + 1)

HField tice = ModelArray::HField()

FloatType dx = 25.

FloatType dy = 35.

size_t targetX = 1

size_t targetY = 2

HField ticeIn = ms.data.at("tsurf")

namespace Air

Variables

const FloatType cp = 1004.64

const FloatType Ra = 287.058

const FloatType rho = 1.2754

namespace CouplingFields

Variables

constexpr TextTag MLD = "MLD"

constexpr TextTag OCEAN_U = "U"

constexpr TextTag OCEAN_V = "V"

constexpr TextTag SSH = "SSH"

constexpr TextTag SSS = "SSS"

constexpr TextTag SST = "SST"

constexpr TextTag FWFLUX = "FWFLUX"

constexpr TextTag O_STRESS_X = "O_STRESS_X"

constexpr TextTag O_STRESS_Y = "O_STRESS_Y"

constexpr TextTag Q_SS_NO_SW = "Q_SS_NO_SW"

constexpr TextTag Q_SS_SW = "Q_SS_SW"

constexpr TextTag SFLUX = "SFLUX"

constexpr TextTag EVAP = "EVAP"

constexpr TextTag RAIN = "RAIN"

constexpr TextTag SNOW = "SNOW"

constexpr TextTag SUBL = "SUBL"

constexpr TextTag WIND_U = "WIND_U"

constexpr TextTag WIND_V = "WIND_V"

namespace Details

Functions

template<typename ReadT, typename DestT> void readConvertNetCDFVar(const netCDF::NcVar &var, const std::vector<size_t> &start, const std::vector<size_t> &size, DestT *dest)

namespace Ice

Variables

const FloatType cp = 2100.

const FloatType epsilon = 0.996

const FloatType kappa = 2.0334

const FloatType Lf = 333.55e3

const FloatType rho = 917

const FloatType rhoSnow = 330.

const FloatType s = 5

const FloatType Tm = 273.15

namespace PhysicalConstants

Variables

const FloatType g = 9.8321849378

const FloatType sigma = 5.670374419e-8

const FloatType vonKarman = 0.4

const FloatType omega = 7.2921158e-5

const FloatType Tt = 273.16

const FloatType tau = 6.28318530717958647652

const FloatType deg2rad = 0x1.1df46a2529d39p-6

const FloatType rad2deg = 0x1.ca5dc1a63c1f8p+5

namespace Protected

Variables

constexpr TextTag T_SURF = "T_SURF0"

constexpr TextTag DAMAGE = "DAMAGE0"

constexpr TextTag T_AIR = "T_AIR"

constexpr TextTag DEW_2M = "DEW_2M"

constexpr TextTag P_AIR = "P_AIR"

constexpr TextTag MIXRAT = "MIXRAT"

constexpr TextTag SW_IN = "SW_IN"

constexpr TextTag LW_IN = "LW_IN"

constexpr TextTag MLD = "MLD"

constexpr TextTag SNOW = "SNOWFALL"

constexpr TextTag SSS = "SSS"

constexpr TextTag SST = "SST"

constexpr TextTag EXT_SSS = "EXT_SSS"

constexpr TextTag EXT_SST = "EXT_SST"

constexpr TextTag SSH = "SSH"

constexpr TextTag ML_BULK_CP = "CPML"

constexpr TextTag TF = "TF"

constexpr TextTag WIND_SPEED = "WIND_SPEED"

constexpr TextTag OCEAN_U = "OCEAN_U"

constexpr TextTag OCEAN_V = "OCEAN_V"

constexpr TextTag WIND_U = "WIND_U"

constexpr TextTag WIND_V = "WIND_V"

constexpr TextTag ICE_U = "ICE_U"

constexpr TextTag ICE_V = "ICE_V"

constexpr TextTag IO_STRESS_X = "IO_STRESS_X"

constexpr TextTag IO_STRESS_Y = "IO_STRESS_Y"

constexpr TextTag SLAB_SST = "SLAB_SST"

constexpr TextTag SLAB_SSS = "SLAB_SSS"

constexpr TextTag SLAB_QDW = "SLAB_QDW"

constexpr TextTag SLAB_FDW = "SLAB_FDW"

constexpr TextTag SHEAR = "SHEAR"

constexpr TextTag DIV = "DIV"

constexpr TextTag SIGMAI = "SIGMAI"

constexpr TextTag SIGMAII = "SIGMAII"

constexpr TextTag ICE_ALBEDO = "ICE_ALBEDO"

constexpr TextTag ICE_PEN_SW = "ICE_PEN_SW"

namespace Shared

Variables

constexpr TextTag H_ICE_DG = "H_ICE_DG"

constexpr TextTag C_ICE_DG = "C_ICE_DG"

constexpr TextTag H_SNOW_DG = "H_SNOW_DG"

constexpr TextTag T_ICE = "T_ICE"

constexpr TextTag T_SURF = "T_SURF"

constexpr TextTag DAMAGE = "DAMAGE"

constexpr TextTag Q_IA = "Q_IA"

constexpr TextTag Q_IC = "Q_IC"

constexpr TextTag Q_IO = "Q_IO"

constexpr TextTag Q_OW = "Q_OW"

constexpr TextTag DQIA_DT = "DQIA_DT"

constexpr TextTag Q_PEN_SW = "Q_PEN_SW"

constexpr TextTag Q_SW_OW = "Q_SW_OW"

constexpr TextTag Q_SW_BASE = "Q_SW_BASE"

constexpr TextTag EVAP = "EVAP"

constexpr TextTag RAIN = "RAIN"

constexpr TextTag HSNOW_MELT = "HSNOW_MELT"

constexpr TextTag OW_STRESS_X = "OW_STRESS_X"

constexpr TextTag OW_STRESS_Y = "OW_STRESS_Y"

constexpr TextTag SUBLIM = "SUBLIM"

constexpr TextTag DELTA_HICE = "DELTA_HICE"

constexpr TextTag DELTA_CICE = "DELTA_CICE"

constexpr TextTag NEW_ICE = "NEW_ICE"

namespace Vapour

Variables

const FloatType cp = 1860.

const FloatType Lv0 = 2500.79e3

const FloatType Ra = 461.5

namespace Water

Variables

const FloatType cp = 4186.84

const FloatType Lf = Ice::Lf

const FloatType Lv0 = Vapour::Lv0

const FloatType mu = 0.055

const FloatType rho = 1000

const FloatType rhoOcean = 1025

const FloatType Tf = Ice::Tm

const FloatType TfOcean = -1.8

module ParaGridIO_input_test

Variables

sec_per_hr = 3600

hr_per_day = 24

nx = 10

ny = 9

ncg = 1

n_dg = 1

n_dgstress = 1

n_coords = 2

element_shape = (nx, ny)

x1d = np.arange(nx)

y1d = np.arange(ny)

element_x = np.tile(x1d, (ny, 1))

element_y = np.transpose(np.tile(y1d, (nx, 1)))

time_data = 10 * element_x + element_y

field_name = "index2d"

out_file = "ParaGridIO_input_test.nc"

ncFile = netCDF4.Dataset(out_file, "w", format="NETCDF4")

structure_name

formatted = ncFile.createVariable("formatted", str)

format

time_meta = ncFile.createVariable("time_meta", "i8")

the_time = 0

units

xDim = ncFile.createDimension("x_dim", nx)

yDim = ncFile.createDimension("y_dim", ny)

xVertexDim = ncFile.createDimension("x_vertex", nx + 1)

yVertexDim = ncFile.createDimension("y_vertex", ny + 1)

xcg_dim = ncFile.createDimension("x_cg", nx * ncg + 1)

ycg_dim = ncFile.createDimension("y_cg", ny * ncg + 1)

dg_comp = ncFile.createDimension("dg_comp", n_dg)

dgs_comp = ncFile.createDimension("dgstress_comp", n_dgstress)

n_coords_comp = ncFile.createDimension("ncoords", n_coords)

tDim = ncFile.createDimension("time", None)

nc_lons = ncFile.createVariable("longitude", "f8", ("y_dim", "x_dim"))

nc_lats = ncFile.createVariable("latitude", "f8", ("y_dim", "x_dim"))

nc_times = ncFile.createVariable("time", "f8", ("time"))

data = ncFile.createVariable(field_name, "f8", ("time", "y_dim", "x_dim"))

namespace std

namespace Test

file CommandLineParser.cpp

file CommonRestartMetadata.cpp

file ConfigurationHelpPrinter.cpp

file Configurator.cpp

file ConfiguredModule.cpp

file DevStep.cpp

file ModelArrayDetails.hpp

Enums

enum class Dimension

Values:

enumerator X

enumerator Y

enumerator XVERTEX

enumerator YVERTEX

enumerator XCG

enumerator YCG

enumerator DG

enumerator DGSTRESS

enumerator NCOORDS

enumerator COUNT

enumerator X

enumerator Y

enumerator XVERTEX

enumerator YVERTEX

enumerator COUNT

enumerator X

enumerator Y

enumerator Z

enumerator U

enumerator COMP

enumerator COUNT

enum class Type

Values:

enumerator H

enumerator VERTEX

enumerator U

enumerator V

enumerator DG

enumerator DGSTRESS

enumerator CG

enumerator H

enumerator U

enumerator V

enumerator VERTEX

enumerator ONED

enumerator TWOD

enumerator ZUFIELD

enumerator THREED

enumerator FOURD

enumerator TWOCOMP

enum class Base

Values:

enumerator Cell

enumerator Vertex

Functions

static ModelArray HField()

static ModelArray VertexField()

static ModelArray UField()

static ModelArray VField()

static ModelArray DGField()

static ModelArray DGSField()

static ModelArray CGField()

Variables

static const Type AdvectionType

static const size_t nCoords

file ModelArrayDetails.hpp

Enums

enum class Dimension

Values:

enumerator X

enumerator Y

enumerator XVERTEX

enumerator YVERTEX

enumerator XCG

enumerator YCG

enumerator DG

enumerator DGSTRESS

enumerator NCOORDS

enumerator COUNT

enumerator X

enumerator Y

enumerator XVERTEX

enumerator YVERTEX

enumerator COUNT

enumerator X

enumerator Y

enumerator Z

enumerator U

enumerator COMP

enumerator COUNT

enum class Type

Values:

enumerator H

enumerator VERTEX

enumerator U

enumerator V

enumerator DG

enumerator DGSTRESS

enumerator CG

enumerator H

enumerator U

enumerator V

enumerator VERTEX

enumerator ONED

enumerator TWOD

enumerator ZUFIELD

enumerator THREED

enumerator FOURD

enumerator TWOCOMP

Functions

static ModelArray HField()

static ModelArray UField()

static ModelArray VField()

static ModelArray VertexField()

Variables

static const Type AdvectionType

static const size_t nCoords

file ModelArrayDetails.hpp

Enums

enum class Dimension

Values:

enumerator X

enumerator Y

enumerator XVERTEX

enumerator YVERTEX

enumerator XCG

enumerator YCG

enumerator DG

enumerator DGSTRESS

enumerator NCOORDS

enumerator COUNT

enumerator X

enumerator Y

enumerator XVERTEX

enumerator YVERTEX

enumerator COUNT

enumerator X

enumerator Y

enumerator Z

enumerator U

enumerator COMP

enumerator COUNT

enum class Type

Values:

enumerator H

enumerator VERTEX

enumerator U

enumerator V

enumerator DG

enumerator DGSTRESS

enumerator CG

enumerator H

enumerator U

enumerator V

enumerator VERTEX

enumerator ONED

enumerator TWOD

enumerator ZUFIELD

enumerator THREED

enumerator FOURD

enumerator TWOCOMP

Functions

static ModelArray OneDField()

static ModelArray TwoDField()

static ModelArray ZUField()

static ModelArray ThreeDField()

static ModelArray FourDField()

Variables

static const Type AdvectionType

file ModelArrayTypedefs.hpp

Typedefs

typedef ModelArray HField

typedef ModelArray VertexField

typedef ModelArray UField

typedef ModelArray VField

typedef ModelArray DGField

typedef ModelArray DGSField

typedef ModelArray CGField

file ModelArrayTypedefs.hpp

Typedefs

typedef ModelArray HField

typedef ModelArray UField

typedef ModelArray VField

typedef ModelArray VertexField

file ModelArrayTypedefs.hpp

Typedefs

typedef ModelArray OneDField

typedef ModelArray TwoDField

typedef ModelArray ZUField

typedef ModelArray ThreeDField

typedef ModelArray FourDField

file ModelArrayDetails.cpp

Defines

DGCOMP

DGSTRESSCOMP

CGDEGREE

file ModelArrayDetails.cpp

file ModelArrayDetails.cpp

file FieldAdvection.cpp

file FileCallbackCloser.cpp

file Finalizer.cpp

file generate_iodef.py

file Halo.cpp

file CheckingModelComponent.hpp

file Chrono.hpp

file CommandLineParser.hpp

file CommonRestartMetadata.hpp

file ConfigMap.hpp

file ConfigurationHelp.hpp

file ConfigurationHelpPrinter.hpp

Variables

static std::string b

file Configurator.hpp

file Configured.hpp

file ConfiguredModule.hpp

file constants.hpp

file DevStep.hpp

file EnumWrapper.hpp

file FieldAdvection.hpp

file FileCallbackCloser.hpp

file Finalizer.hpp

file FloatType.hpp

file gridNames.hpp

file Halo.hpp

Defines

HALOWIDTH

file IModelStep.hpp

file indexer.hpp

file Iterator.hpp

file KernelAlternatives.hpp

Defines

KERNEL_IMPL_FUNCTION

OVER_ELEMENTS_LAMBDA

OVER_ELEMENTS_CLASS_LAMBDA

file Logged.hpp

file MissingData.hpp

file Model.hpp

file ModelArray.hpp

file ModelArrayAccessor.hpp

file ModelArraySlice.hpp

file ModelArrayStore.hpp

file ModelComponent.hpp

file ModelMetadata.hpp

file ModelMPI.hpp

file ModelState.hpp

file Module.hpp

file MonthlyCubicBSpline.hpp

Defines

NEW_SPLINES

file NetcdfMetadataConfiguration.hpp

file NetCDFUtils.hpp

file NextsimModule.hpp

file OutputSpec.hpp

file ParaGridIO.hpp

file ParallelNetcdfFile.hpp

file PrognosticData.hpp

file RectGridIO.hpp

file Slice.hpp

Defines

ceil(num, denom)

file StructureFactory.hpp

file TextTag.hpp

file Time.hpp

file Xios.hpp

file xios_c_interface.hpp

Functions

void cxios_init_client(const char *client_id, int len_client_id, MPI_Fint *f_local_comm, MPI_Fint *f_return_comm)

void cxios_finalize()

void cxios_context_initialize(const char *context_id, int len_context_id, MPI_Fint *f_comm)

void cxios_context_is_initialized(const char *context_id, int len_context_id, bool *initialized)

void cxios_context_valid_id(bool *_ret, const char *context_id, int len_context_id)

void cxios_context_get_current(xios::CContext **context_hdl)

void cxios_context_get_id(xios::CContext*, const char *context_id, int len_context_id)

void cxios_context_close_definition()

void cxios_context_finalize()

void cxios_date_convert_to_string(cxios_date date_c, char *str, int str_size)

cxios_date cxios_date_convert_from_string(const char *str, int str_size)

void cxios_duration_convert_to_string(cxios_duration dur_c, char *str, int str_size)

cxios_duration cxios_duration_convert_from_string(const char *str, int str_size)

void cxios_set_calendar_wrapper_date_start_date(xios::CCalendarWrapper *calendarWrapper_hdl, cxios_date start_date_c)

void cxios_get_current_calendar_wrapper(xios::CCalendarWrapper **_ret)

void cxios_get_calendar_wrapper_date_start_date(xios::CCalendarWrapper *calendarWrapper_hdl, cxios_date *start_date_c)

void cxios_get_current_date(cxios_date *date)

bool cxios_is_defined_calendar_wrapper_start_date(xios::CCalendarWrapper *calendar_wrapper_hdl)

void cxios_update_calendar(int step)

void cxios_set_calendar_wrapper_timestep(xios::CCalendarWrapper *calendar_wrapper_hdl, cxios_duration timestep_c)

bool cxios_is_defined_calendar_wrapper_timestep(xios::CCalendarWrapper *calendar_wrapper_hdl)

void cxios_update_calendar_timestep(xios::CCalendarWrapper *calendarWrapper_hdl)

void cxios_axis_handle_create(xios::CAxis **_ret, const char *_id, int _id_len)

void cxios_axis_valid_id(bool *_ret, const char *_id, int _id_len)

void cxios_get_axis_n_glo(xios::CAxis *axis_hdl, int *n_glo)

bool cxios_is_defined_axis_n_glo(xios::CAxis *axis_hdl)

void cxios_domaingroup_handle_create(xios::CDomainGroup **_ret, const char *_id, int _id_len)

void cxios_xml_tree_add_domain(xios::CDomainGroup *domain_grp, xios::CDomain **domain, const char *_id, int _id_len)

void cxios_domain_handle_create(xios::CDomain **_ret, const char *_id, int _id_len)

void cxios_domain_valid_id(bool *_ret, const char *_id, int _id_len)

void cxios_set_domain_type(xios::CDomain *domain_hdl, const char *type, int type_size)

void cxios_set_domain_dim_i_name(xios::CDomain *domain_hdl, const char *iname, int iname_size)

void cxios_set_domain_dim_j_name(xios::CDomain *domain_hdl, const char *jname, int jname_size)

void cxios_set_domain_lat_name(xios::CDomain *domain_hdl, const char *latname, int latname_size)

void cxios_set_domain_lon_name(xios::CDomain *domain_hdl, const char *lonname, int lonname_size)

void cxios_set_domain_ni_glo(xios::CDomain *domain_hdl, int ni_glo)

void cxios_set_domain_nj_glo(xios::CDomain *domain_hdl, int nj_glo)

void cxios_set_domain_ni(xios::CDomain *domain_hdl, int ni)

void cxios_set_domain_nj(xios::CDomain *domain_hdl, int nj)

void cxios_set_domain_ibegin(xios::CDomain *domain_hdl, int ibegin)

void cxios_set_domain_jbegin(xios::CDomain *domain_hdl, int jbegin)

bool cxios_is_defined_domain_type(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_dim_i_name(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_dim_j_name(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_lat_name(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_lon_name(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_ni_glo(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_nj_glo(xios::CDomain *domain_hdl)

void cxios_set_domain_lonvalue_1d(xios::CDomain *domain_hdl, double *data, const int *ni)

void cxios_set_domain_latvalue_1d(xios::CDomain *domain_hdl, double *data, const int *nj)

bool cxios_is_defined_domain_ni(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_nj(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_ibegin(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_jbegin(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_lonvalue_1d(xios::CDomain *domain_hdl)

bool cxios_is_defined_domain_latvalue_1d(xios::CDomain *domain_hdl)

void cxios_gridgroup_handle_create(xios::CGridGroup **_ret, const char *_id, int _id_len)

void cxios_xml_tree_add_grid(xios::CGridGroup *grid_grp, xios::CGrid **grid, const char *_id, int _id_len)

void cxios_grid_handle_create(xios::CGrid **_ret, const char *_id, int _id_len)

void cxios_grid_valid_id(bool *_ret, const char *_id, int _id_len)

void cxios_xml_tree_add_domaintogrid(xios::CGrid *grid, xios::CDomain **domain, const char *_id, int _id_len)

void cxios_fieldgroup_handle_create(xios::CFieldGroup **_ret, const char *_id, int _id_len)

void cxios_xml_tree_add_field(xios::CFieldGroup *field_grp, xios::CField **field, const char *_id, int _id_len)

void cxios_field_handle_create(xios::CField **_ret, const char *_id, int _id_len)

void cxios_field_valid_id(bool *_ret, const char *_id, int _id_len)

void cxios_set_field_name(xios::CField *field_hdl, const char *name, int name_size)

void cxios_set_field_operation(xios::CField *field_hdl, const char *operation, int operation_size)

void cxios_set_field_grid_ref(xios::CField *field_hdl, const char *grid_ref, int grid_ref_size)

void cxios_set_field_read_access(xios::CField *field_hdl, bool read_access)

void cxios_set_field_freq_offset(xios::CField *field_hdl, cxios_duration freq_offset)

void cxios_set_field_field_ref(xios::CField *field_hdl, const char *field_ref, int field_ref_size)

void cxios_get_field_grid_ref(xios::CField *field_hdl, char *grid_ref, int grid_ref_size)

void cxios_get_field_read_access(xios::CField *field_hdl, bool *read_access)

void cxios_get_field_freq_offset(xios::CField *field_hdl, cxios_duration *freq_offset)

bool cxios_is_defined_field_name(xios::CField *field_hdl)

bool cxios_is_defined_field_operation(xios::CField *field_hdl)

bool cxios_is_defined_field_grid_ref(xios::CField *field_hdl)

bool cxios_is_defined_field_read_access(xios::CField *field_hdl)

bool cxios_is_defined_field_freq_offset(xios::CField *field_hdl)

void cxios_filegroup_handle_create(xios::CFileGroup **_ret, const char *_id, int _id_len)

void cxios_xml_tree_add_file(xios::CFileGroup *file_grp, xios::CFile **file, const char *_id, int _id_len)

void cxios_file_handle_create(xios::CFile **_ret, const char *_id, int _id_len)

void cxios_file_valid_id(bool *_ret, const char *_id, int _id_len)

void cxios_set_file_name(xios::CFile *file_hdl, const char *name, int name_size)

void cxios_set_file_type(xios::CFile *file_hdl, const char *type, int type_size)

void cxios_set_file_output_freq(xios::CFile *file_hdl, cxios_duration output_freq_c)

void cxios_get_file_output_freq(xios::CFile *file_hdl, cxios_duration *output_freq_c)

void cxios_set_file_split_freq(xios::CFile *file_hdl, cxios_duration split_freq_c)

void cxios_set_file_mode(xios::CFile *file_hdl, const char *mode, int mode_size)

void cxios_set_file_par_access(xios::CFile *file_hdl, const char *par_access, int par_access_size)

void cxios_set_file_split_freq_format(xios::CFile *file_hdl, const char *split_freq_format, int split_freq_format_size)

bool cxios_is_defined_file_name(xios::CFile *file_hdl)

bool cxios_is_defined_file_type(xios::CFile *file_hdl)

bool cxios_is_defined_file_output_freq(xios::CFile *file_hdl)

bool cxios_is_defined_file_split_freq(xios::CFile *file_hdl)

bool cxios_is_defined_file_mode(xios::CFile *file_hdl)

bool cxios_is_defined_file_par_access(xios::CFile *file_hdl)

bool cxios_is_defined_file_split_freq_format(xios::CFile *file_hdl)

void cxios_xml_tree_add_fieldtofile(xios::CFile *file, xios::CField **field, const char *_id, int _id_len)

void cxios_write_data_k82(const char *fieldid, int fieldid_size, const double *data_k8, int data_size1, int data_size2, int tileid)

void cxios_write_data_k83(const char *fieldid, int fieldid_size, const double *data_k8, int data_size1, int data_size2, int data_size3, int tileid)

void cxios_read_data_k82(const char *fieldid, int fieldid_size, const double *data_k8, int data_size1, int data_size2)

void cxios_read_data_k83(const char *fieldid, int fieldid_size, const double *data_k8, int data_size1, int data_size2, int data_size3)

file Iterator.cpp

file KokkosModelArray.hpp

file KokkosTimer.hpp

file KokkosUtils.hpp

file KokkosModelArray.cpp

file KokkosUtils.cpp

file Logged.cpp

file main.cpp

Functions

int main(int argc, char *argv[])

file Model.cpp

file ModelArray.cpp

file ModelArraySlice.cpp

file ModelArrayStore.cpp

file ModelComponent.cpp

file ModelMetadata.cpp

file ModelMPI.cpp

file ConfigOutput.cpp

file ConfigOutput.hpp

file NoOutput.hpp

file SimpleOutput.hpp

file SimpleOutput.cpp

file BBMDynamics.cpp

file BBMDynamics.hpp

Defines

DGCOMP

file DummyDynamics.hpp

file FreeDriftDynamics.hpp

Defines

DGCOMP

file MEVPDynamics.hpp

Defines

DGCOMP

file MEVPDynamics.cpp

file LinearFreezing.hpp

file UnescoFreezing.hpp

file IDiagnosticOutput.hpp

file IDynamics.hpp

file IFreezingPoint.hpp

file IStructure.hpp

file ProtectedArrayNames.ipp

file SharedArrayNames.ipp

file module_maker.py

file README.md

file ParametricGrid.hpp

file RectangularGrid.hpp

file ParametricGrid.cpp

file RectangularGrid.cpp

file NetcdfMetadataConfiguration.cpp

file ParaGridIO.cpp

file ParaGridIO_Xios.cpp

file ParallelNetcdfFile.cpp

Variables

int g_ncid

file PDWriter.cpp

file PrognosticData.cpp

file RectGridIO.cpp

file StructureFactory.cpp

file Time.cpp

file Xios.cpp

file alt_names.py

file ArgV.cpp

file ArgV.hpp

file CommandLineParser_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

file ConfigOutput_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

Variables

const std::string test_files_dir = TEST_FILES_DIR

file Configurator_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

Variables

const std::map<int, std::string> keyMap2 = {{Config2::VALUE_KEY, "config.value"}, {Config2::NAME_KEY, "config.name"},}

const std::map<int, std::string> keyMap3 = {{Config3::VALUE_KEY, "config.value"}, {Config3::WEIGHT_KEY, "data.weight"},}

file ConfiguredModule_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

Typedefs

using HelpMap = int

using Config = Nextsim::ConfiguredModule

file DynamicsModuleForPDtest.cpp

file FileCallbackCloser_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

file Finalizer_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

file HaloExchangeCB_test.cpp

file Iterator_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

file Logged_test.cpp

file MainMPI.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT

Functions

int main(int argc, char **argv)

file MainTest.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT

Functions

int main(int argc, char **argv)

file ModelArray_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

file ModelArrayAccessor_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

file ModelArraySlice_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

Typedefs

using Slice = ArraySlicer::Slice

using SliceIter = ArraySlicer::SliceIter

Variables

const auto nx = 23

const auto ny = 17

const auto nz = 5

file ModelComponent_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

file ModelMetadataCB_test.cpp

Variables

const std::string testFilesDir = TEST_FILES_DIR

const std::string partitionFilenameCB = testFilesDir + "/halo_cb_test_partition_metadata_3.nc"

file ModelMetadataPB_test.cpp

Variables

const std::string testFilesDir = TEST_FILES_DIR

const std::string partitionFilenamePB = testFilesDir + "/halo_pb_test_partition_metadata_3.nc"

file MonthlyCubicBSpline_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

file ParaGrid_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

TEST_FILE_SOURCE

Variables

const std::string testFilesDir = TEST_FILES_DIR

const std::string filename = testFilesDir + "/paraGrid_test.nc"

const std::string diagFile = "paraGrid_diag.nc"

const std::string dateString = "2000-01-01T00:00:00Z"

static const int DG = 3

static const int DGSTRESS = 6

const size_t nx = 10

const size_t ny = 9

const Nextsim::FloatType yFactor = 0.01

const Nextsim::FloatType xFactor = 0.1

const Nextsim::FloatType scale = 1e5

file ParaGridIO_input_test.py

file PDTestDynamics.hpp

file PrognosticData_test.cpp

file PrognosticDataIO_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

TRUE

FALSE

ON

OFF

file moduleLoaderAssignments.ipp

Functions

if (module=="Nextsim::IFreezingPoint")

file moduleLoaderFunctions.ipp

Functions

std::unique_ptr<Nextsim::IFreezingPoint> newLinearFreezing()

std::unique_ptr<Nextsim::IFreezingPoint> newUnescoFreezing()

Variables

static Nextsim::IFreezingPoint *p_IFreezingPoint

std::unique_ptr<Nextsim::IFreezingPoint> (*pf_IFreezingPoint)()

static Nextsim::LinearFreezing i_LinearFreezing

static Nextsim::UnescoFreezing i_UnescoFreezing

file moduleLoaderHeaders.ipp

file moduleLoaderNames.ipp

Variables

m_availableImplementationNames = {{ "Nextsim::IFreezingPoint",{"Nextsim::LinearFreezing","Nextsim::UnescoFreezing",} },}

file RectGrid_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

Variables

const std::string test_files_dir = TEST_FILES_DIR

const std::string filename = test_files_dir + "/RectGrid_test.nc"

const std::string date_string = "2000-01-01T00:00:00Z"

file Slice_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

ceil(num, denom)

Typedefs

using Slice = ArraySlicer::Slice

using SliceIter = ArraySlicer::SliceIter

using MultiDim = SliceIter::MultiDim

Functions

std::string to_string(const MultiDim &v)

std::string to_string(const Slice &l)

TEST_SUITE_BEGIN ("Indexer")

TEST_CASE ("indexer <-> deIndexer")

TEST_SUITE_END()

TEST_SUITE_BEGIN ("Slice")

TEST_CASE ("One dimensional indexing")

TEST_CASE ("Multidimensional indexing")

TEST_CASE ("Negative steps")

bool matchIndices(SliceIter &si, std::vector<size_t> compare, bool debug = false)

TEST_CASE ("Test matchIndices")

bool match12(const Slice::VBounds &b, std::vector<size_t> compare, bool debug = false)

TEST_CASE ("Indexing behaviour")

bool makeZeroStep()

TEST_CASE ("Zero step")

TEST_CASE ("SliceIter equality")

TEST_CASE ("Two dimensions, slicing the end of the second dimension")

file Time_test.cpp

Defines

DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN

file XiosAxis_test.cpp

file XiosCalendar_test.cpp

file XiosReadDiagnostic_test.cpp

Variables

const std::string testFilesDir = TEST_FILES_DIR

const std::string diagnosticFilename = testFilesDir + "/diagnostic_2023-03-17T00:00:00Z-2023-03-17T02:59:59Z.nc"

static const int DGCOMP = 6

static const int DGSTRESSCOMP = 8

static const int CGDEGREE = 2

file XiosReadForcing_test.cpp

Variables

const std::string testFilesDir = TEST_FILES_DIR

const std::string inputFilename = testFilesDir + "/xios_test_input.nc"

const std::string era5ForcingFilename = testFilesDir + "/xios_test_era5_forcing.nc"

const std::string topazForcingFilename = testFilesDir + "/xios_test_topaz_forcing.nc"

static const int DGCOMP = 6

static const int DGSTRESSCOMP = 8

static const int CGDEGREE = 2

file XiosReadRestart_test.cpp

Variables

const std::string testFilesDir = TEST_FILES_DIR

const std::string restartFilename = testFilesDir + "/restart_2023-03-17T00:00:00Z-2023-03-17T02:59:59Z.nc"

static const int DGCOMP = 6

static const int DGSTRESSCOMP = 8

static const int CGDEGREE = 2

file XiosReadWriteRestart_test.cpp

Variables

const std::string testFilesDir = TEST_FILES_DIR

const std::string inputFilename = testFilesDir + "/xios_test_input.nc"

const std::string outputFilename = testFilesDir + "/readwrite%Y-%m-%dT%H:%M:%SZ.nc"

static const int DGCOMP = 6

static const int DGSTRESSCOMP = 8

static const int CGDEGREE = 2

file XiosWriteDiagnostic_test.cpp

Variables

const std::string testFilesDir = TEST_FILES_DIR

const std::string inputFilename = testFilesDir + "/xios_test_input.nc"

const std::string diagnosticFilename = testFilesDir + "/diagnostic%Y-%m-%dT%H:%M:%SZ.nc"

static const int DGCOMP = 6

static const int DGSTRESSCOMP = 8

static const int CGDEGREE = 2

file XiosWriteRestart_test.cpp

Variables

const std::string testFilesDir = TEST_FILES_DIR

const std::string inputFilename = testFilesDir + "/xios_test_input.nc"

const std::string outputFilename = testFilesDir + "/restart%Y-%m-%dT%H:%M:%SZ.nc"

static const int DGCOMP = 6

static const int DGSTRESSCOMP = 8

static const int CGDEGREE = 2

page md__home_docs_checkouts_readthedocs_org_user_builds_nextsim_dg_checkouts_latest_core_src_modules_README

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules/DiagnosticOutputModule

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/discontinuousgalerkin

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules/DynamicsModule

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/finitevolume

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules/FreezingPointModule

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules/FreezingPointModule/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules/DynamicsModule/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules/DiagnosticOutputModule/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/kokkos/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/test/testmodelarraydetails/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules/StructureModule/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/finitevolume/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/discontinuousgalerkin/include

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/kokkos

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/test/PrognosticDataTestModules

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/src/modules/StructureModule

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/test

dir /home/docs/checkouts/readthedocs.org/user_builds/nextsim-dg/checkouts/latest/core/test/testmodelarraydetails