DeclareField.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
namespace	dyno
	This is an implementation of AdditiveCCD based on peridyno.

Macros
#define	DEF_VAR(T, name, value, desc)
#define	DEF_VAR_IN(T, name, desc)
#define	DEF_VAR_OUT(T, name, desc)
#define	DEF_VAR_STATE(T, name, value, desc)
#define	DEF_INSTANCE_IN(T, name, desc)
#define	DEF_INSTANCE_OUT(T, name, desc)
#define	DEF_INSTANCE_IO(T, name, desc)
#define	DEF_INSTANCE_STATE(T, name, desc)
	Macro definitions for instance state.
#define	DEF_INSTANCES_STATE(T, name, desc)
	Macro definitions for an array of instance.
#define	DEF_INSTANCES_IN(T, name, desc)
#define	DEF_INSTANCES_OUT(T, name, desc)
#define	DEF_ARRAY_IN(T, name, device, desc)
#define	DEF_ARRAY_OUT(T, name, device, desc)
#define	DEF_ARRAY_IO(T, name, device, desc)
#define	DEF_ARRAY2D_IN(T, name, device, desc)
#define	DEF_ARRAY2D_OUT(T, name, device, desc)
#define	DEF_ARRAY2D_IO(T, name, device, desc)
#define	DEF_ARRAY3D_IN(T, name, device, desc)
#define	DEF_ARRAY3D_OUT(T, name, device, desc)
#define	DEF_ARRAY3D_IO(T, name, device, desc)
#define	DEF_ARRAYLIST_IN(T, name, device, desc)
#define	DEF_ARRAYLIST_OUT(T, name, device, desc)
#define	DEF_ARRAYLIST_IO(T, name, device, desc)

Macro Definition Documentation

DEF_ARRAY2D_IN

#define DEF_ARRAY2D_IN	(		T,
			name,
			device,
			desc )

Value:

private:                                                \
    FArray2D<T, device> in_##name = FArray2D<T, device>(std::string(#name), desc, FieldTypeEnum::In, this); \
public:                                                 \
    inline FArray2D<T, device>* in##name() {return &in_##name;}

Macro definition for input/output of type Array2D

Definition at line 124 of file DeclareField.h.

DEF_ARRAY2D_IO

#define DEF_ARRAY2D_IO	(		T,
			name,
			device,
			desc )

Value:

private:                                                \
    FArray2D<T, device> io_##name = FArray2D<T, device>(std::string(#name), desc, FieldTypeEnum::IO, this); \
public:                                                 \
    inline FArray2D<T, device>* in##name() {return &io_##name;} \
    inline FArray2D<T, device>* out##name() {return &io_##name;}

Definition at line 136 of file DeclareField.h.

DEF_ARRAY2D_OUT

#define DEF_ARRAY2D_OUT	(		T,
			name,
			device,
			desc )

Value:

private:                                                \
    FArray2D<T, device> out_##name = FArray2D<T, device>(std::string(#name), desc, FieldTypeEnum::Out, this);   \
public:                                                 \
    inline FArray2D<T, device>* out##name() {return &out_##name;}

Definition at line 130 of file DeclareField.h.

DEF_ARRAY3D_IN

#define DEF_ARRAY3D_IN	(		T,
			name,
			device,
			desc )

Value:

private:                                                \
    FArray3D<T, device> in_##name = FArray3D<T, device>(std::string(#name), desc, FieldTypeEnum::In, this); \
public:                                                 \
    inline FArray3D<T, device>* in##name() {return &in_##name;}

Macro definition for input/output of type Array3D

Definition at line 147 of file DeclareField.h.

DEF_ARRAY3D_IO

#define DEF_ARRAY3D_IO	(		T,
			name,
			device,
			desc )

Value:

private:                                                \
    FArray3D<T, device> io_##name = FArray3D<T, device>(std::string(#name), desc, FieldTypeEnum::IO, this); \
public:                                                 \
    inline FArray3D<T, device>* in##name() {return &io_##name;} \
    inline FArray3D<T, device>* out##name() {return &io_##name;}

Definition at line 159 of file DeclareField.h.

DEF_ARRAY3D_OUT

#define DEF_ARRAY3D_OUT	(		T,
			name,
			device,
			desc )

Value:

private:                                                \
    FArray3D<T, device> out_##name = FArray3D<T, device>(std::string(#name), desc, FieldTypeEnum::Out, this);   \
public:                                                 \
    inline FArray3D<T, device>* out##name() {return &out_##name;}

Definition at line 153 of file DeclareField.h.

DEF_ARRAY_IN

#define DEF_ARRAY_IN	(		T,
			name,
			device,
			desc )

Value:

private:                                    \
    FArray<T, device> in_##name = FArray<T, device>(std::string(#name), desc, FieldTypeEnum::In, this); \
public:                                 \
    inline FArray<T, device>* in##name() {return &in_##name;}

Macro definition for input/output of type Array

Definition at line 101 of file DeclareField.h.

DEF_ARRAY_IO

#define DEF_ARRAY_IO	(		T,
			name,
			device,
			desc )

Value:

private:                                    \
    FArray<T, device> io_##name = FArray<T, device>(std::string(#name), desc, FieldTypeEnum::IO, this); \
public:                                 \
    inline FArray<T, device>* in##name() {return &io_##name;}       \
    inline FArray<T, device>* out##name() {return &io_##name;}

Definition at line 113 of file DeclareField.h.

DEF_ARRAY_OUT

#define DEF_ARRAY_OUT	(		T,
			name,
			device,
			desc )

Value:

private:                                    \
    FArray<T, device> out_##name = FArray<T, device>(std::string(#name), desc, FieldTypeEnum::Out, this);   \
public:                                 \
    inline FArray<T, device>* out##name() {return &out_##name;}

Definition at line 107 of file DeclareField.h.

DEF_ARRAYLIST_IN

#define DEF_ARRAYLIST_IN	(		T,
			name,
			device,
			desc )

Value:

private:                                                \
    FArrayList<T, device> in_##name = FArrayList<T, device>(std::string(#name), desc, FieldTypeEnum::In, this); \
public:                                                 \
    inline FArrayList<T, device>* in##name() {return &in_##name;}

Macro definition for input/output of type ArrayList

Definition at line 170 of file DeclareField.h.

DEF_ARRAYLIST_IO

#define DEF_ARRAYLIST_IO	(		T,
			name,
			device,
			desc )

Value:

private:                                                \
    FArrayList<T, device> io_##name = FArrayList<T, device>(std::string(#name), desc, FieldTypeEnum::IO, this); \
public:                                                 \
    inline FArrayList<T, device>* in##name() {return &io_##name;}   \
    inline FArrayList<T, device>* out##name() {return &io_##name;}

Definition at line 182 of file DeclareField.h.

DEF_ARRAYLIST_OUT

#define DEF_ARRAYLIST_OUT	(		T,
			name,
			device,
			desc )

Value:

private:                                                \
    FArrayList<T, device> out_##name = FArrayList<T, device>(std::string(#name), desc, FieldTypeEnum::Out, this);   \
public:                                                 \
    inline FArrayList<T, device>* out##name() {return &out_##name;}

Definition at line 176 of file DeclareField.h.

DEF_INSTANCE_IN

#define DEF_INSTANCE_IN	(		T,
			name,
			desc )

Value:

private:                                    \
    FInstance<T> in_##name = FInstance<T>(std::string(#name), desc, FieldTypeEnum::In, this);           \
public:                                     \
    inline FInstance<T>* in##name() {return &in_##name;}

Macro definition for input/output of type instance

Definition at line 48 of file DeclareField.h.

DEF_INSTANCE_IO

#define DEF_INSTANCE_IO	(		T,
			name,
			desc )

Value:

private:                                    \
    FInstance<T> io_##name = FInstance<T>(std::string(#name), desc, FieldTypeEnum::IO, this);           \
public:                                 \
    inline FInstance<T>* io##name() {return &io_##name;}

Definition at line 60 of file DeclareField.h.

DEF_INSTANCE_OUT

#define DEF_INSTANCE_OUT	(		T,
			name,
			desc )

Value:

private:                                    \
    FInstance<T> out_##name = FInstance<T>(std::string(#name), desc, FieldTypeEnum::Out, this);         \
public:                                 \
    inline FInstance<T>* out##name() {return &out_##name;}

Definition at line 54 of file DeclareField.h.

DEF_INSTANCE_STATE

#define DEF_INSTANCE_STATE	(		T,
			name,
			desc )

Value:

private:                                    \
    FInstance<T> state_##name = FInstance<T>(std::string(#name), desc, FieldTypeEnum::State, this); \
public:                                 \
    inline FInstance<T>* state##name() {return &state_##name;}

Macro definitions for instance state.

Definition at line 70 of file DeclareField.h.

DEF_INSTANCES_IN

#define DEF_INSTANCES_IN	(		T,
			name,
			desc )

Value:

private:                                    \
    FArray<std::shared_ptr<T>, DeviceType::CPU> in_##name = FArray<std::shared_ptr<T>, DeviceType::CPU>(std::string(#name)+std::string("(s)"), desc, FieldTypeEnum::In, this);  \
public:                                 \
    inline FArray<std::shared_ptr<T>, DeviceType::CPU>* in##name##s() {return &in_##name;}

Definition at line 85 of file DeclareField.h.

DEF_INSTANCES_OUT

#define DEF_INSTANCES_OUT	(		T,
			name,
			desc )

Value:

private:                                    \
    FArray<std::shared_ptr<T>, DeviceType::CPU> out_##name = FArray<std::shared_ptr<T>, DeviceType::CPU>(std::string(#name)+std::string("(s)"), desc, FieldTypeEnum::Out, this);    \
public:                                 \
    inline FArray<std::shared_ptr<T>, DeviceType::CPU>* out##namee##s() {return &out_##name;}

Definition at line 91 of file DeclareField.h.

DEF_INSTANCES_STATE

#define DEF_INSTANCES_STATE	(		T,
			name,
			desc )

Value:

private:                                    \
    FArray<std::shared_ptr<T>, DeviceType::CPU> state_##name = FArray<std::shared_ptr<T>, DeviceType::CPU>(std::string(#name)+std::string("(s)"), desc, FieldTypeEnum::State, this);    \
public:                                 \
    inline FArray<std::shared_ptr<T>, DeviceType::CPU>* state##name##s() {return &state_##name;}

Macro definitions for an array of instance.

Definition at line 79 of file DeclareField.h.

DEF_VAR

#define DEF_VAR	(		T,
			name,
			value,
			desc )

Value:

private:                                    \
    FVar<T> var_##name = FVar<T>(T(value), std::string(#name), desc, FieldTypeEnum::Param, this);          \
public:                                     \
    inline FVar<T>* var##name() {return &var_##name;}

Definition at line 21 of file DeclareField.h.

DEF_VAR_IN

#define DEF_VAR_IN	(		T,
			name,
			desc )

Value:

private:                                    \
    FVar<T> in_##name = FVar<T>(std::string(#name), desc, FieldTypeEnum::In, this);         \
public:                                     \
    inline FVar<T>* in##name() {return &in_##name;}

Definition at line 27 of file DeclareField.h.

DEF_VAR_OUT

#define DEF_VAR_OUT	(		T,
			name,
			desc )

Value:

private:                                    \
    FVar<T> out_##name = FVar<T>(std::string(#name), desc, FieldTypeEnum::Out, this);           \
public:                                 \
    inline FVar<T>* out##name() {return &out_##name;}

Definition at line 33 of file DeclareField.h.

DEF_VAR_STATE

#define DEF_VAR_STATE	(		T,
			name,
			value,
			desc )

Value:

private:                                    \
    FVar<T> state_##name = FVar<T>(T(value), std::string(#name), desc, FieldTypeEnum::State, this);            \
public:                                     \
    inline FVar<T>* state##name() {return &state_##name;}

Definition at line 39 of file DeclareField.h.