Walls.h File Reference

#include <Walls/BaseWall.h>
#include <Walls/InfiniteWall.h>
#include <Walls/CylindricalWall.h>
#include <Walls/InfiniteWallWithHole.h>

Go to the source code of this file.

Classes
struct	SerializationWrappers::Wrapper< Base >

Namespaces
	SerializationWrappers

Functions
template<class Archive >
void	save (Archive &ar, const WallHandler &w)
template<class Archive >
void	load (Archive &ar, WallHandler &w)
template<class Archive >
void	save (Archive &ar, const SerializationWrappers::Wrapper< BaseWall > w)
template<class Archive >
void	load (Archive &ar, SerializationWrappers::Wrapper< BaseWall > &b)
template<class Archive >
void	load (Archive &ar, InfiniteWall &w)
template<class Archive >
void	save (Archive &ar, const InfiniteWall &w)
template<class Archive >
void	load (Archive &ar, CylindricalWall &w)
template<class Archive >
void	save (Archive &ar, const CylindricalWall &w)

Function Documentation

load() [1/4]

template<class Archive >

void load	(	Archive &	ar,
		CylindricalWall &	w
	)

                                             {
    //Vec3D position;
    Mdouble radius;
    ar( //CEREAL_NVP( position ),
        CEREAL_NVP( radius ));
}

References UniformPSDSelfTest::radius.

load() [2/4]

template<class Archive >

void load	(	Archive &	ar,
		InfiniteWall &	w
	)

                                         {
    Vec3D position, normal;
    ar( CEREAL_NVP( position ),
        CEREAL_NVP( normal ));
    w.setPosition( position );
    w.setNormal( normal );
}

References WallFunction::normal(), and w.

load() [3/4]

template<class Archive >

void load	(	Archive &	ar,
		SerializationWrappers::Wrapper< BaseWall > &	b
	)

{
    logger(DEBUG, "In load Generic Wall!");
    std::string type;
    ar(cereal::make_nvp("type", type));
    logger(INFO, "Type = %", type);
    if (type == "InfiniteWall")
    {
        b.data = new InfiniteWall();
        //ar( cereal::make_nvp("value", dynamic_cast<InfiniteWall*>(b)));
        load(ar, *(dynamic_cast<InfiniteWall*>(b.data)));
        /* } else if (type == "FiniteWall") {
             b = new InfiniteWall();
             ar( cereal::make_nvp("value", dynamic_cast<FiniteWall*>(b)));*/
    }
    else if (type == "InfiniteWallWithHole")
    {
        b.data = new InfiniteWallWithHole();
        //ar( cereal::make_nvp("value", dynamic_cast<InfiniteWallWithHole*>(b)));
    } else if (type == "CylindricalWall") {
        b.data = new CylindricalWall();
        //ar( cereal::make_nvp("value", dynamic_cast<CylindricalWall*>(b)));
        load( ar, *(dynamic_cast<CylindricalWall*>(b.data)));
    }
    
}

References b, DEBUG, INFO, load(), logger, oomph::Global_string_for_annotation::string(), and compute_granudrum_aor::type.

load() [4/4]

template<class Archive >

void load	(	Archive &	ar,
		WallHandler &	w
	)

                                       {
    cereal::size_type count;
    ar ( cereal::make_size_tag(count));
    
    //Due to inheritance etc etc, we need to create pointers here.
    logger(VERBOSE, "WallHandler");
    for (int i = 0; i < count; i++)
    {
        SerializationWrappers::Wrapper<BaseWall> wall;
        logger(INFO, " Pass % / %\n", i, count, Flusher::NO_FLUSH);
        ar(wall);
        logger(INFO, " Adding...\n", Flusher::NO_FLUSH);
        w.copyAndAddObject(wall.data);
        logger(INFO, " Done. ");
    }
}

References SerializationWrappers::Wrapper< Base >::data, i, INFO, logger, NO_FLUSH, VERBOSE, and w.

Referenced by load().

save() [1/4]

template<class Archive >

void save	(	Archive &	ar,
		const CylindricalWall &	w
	)

                                                   {
    ar ( //cereal::make_nvp("position", w.getPosition()),
         cereal::make_nvp("radius", w.getRadius()));
}

References w.

save() [2/4]

template<class Archive >

void save	(	Archive &	ar,
		const InfiniteWall &	w
	)

                                                {
    ar( cereal::make_nvp("position", w.getPosition()),
        cereal::make_nvp("normal", w.getNormal()));
}

References w.

save() [3/4]

template<class Archive >

void save	(	Archive &	ar,
		const SerializationWrappers::Wrapper< BaseWall >	w
	)

                                                                        {
    if (typeid(*(w.data)) == typeid(InfiniteWall)) {
        ar( cereal::make_nvp("type","InfiniteWall"));
        save( ar, *(dynamic_cast<InfiniteWall*>(w.data)));
        //ar( cereal::make_nvp("value", dynamic_cast<const InfiniteWall*>(b)));
    /*} else if (typeid(b) == typeid(FiniteWall)) {
        ar( cereal::make_nvp("type","FiniteWall"));
        ar( cereal::make_nvp("value", dynamic_cast<const FiniteWall*>(b))); */
    } else if (typeid(*(w.data)) == typeid (InfiniteWallWithHole)) {
        ar( cereal::make_nvp("type","InfiniteWallWithHole"));
        //save( ar, *(dynamic_cast<InfiniteWallWithHole*>(w.data)));
    } else if (typeid(*(w.data)) == typeid (CylindricalWall)) {
        ar( cereal::make_nvp("type","CylindricalWall"));
        save( ar, *(dynamic_cast<CylindricalWall*>(w.data)));
    }
    
}

References save(), and w.

save() [4/4]

template<class Archive >

void save	(	Archive &	ar,
		const WallHandler &	w
	)

                                             {
    ar ( cereal::make_size_tag(w.getNumberOfObjects()));
    for (const auto& wall UNUSED : w ) {
        ar ( w );
    }
}

References UNUSED, and w.

Referenced by save().