Merge pull request #64 from ManuelLerchner/51-sheet-3-task-4-simulation-of-a-falling-drop-wall

51 sheet 3 task 4 simulation of a falling drop wall

Author: ManuelLerchner

input/body_collision.xml

@@ -8,6 +8,7 @@
         <video_length>30</video_length>
         <delta_t>0.00005</delta_t>
         <end_time>20.0</end_time>
+        <third_dimension>true</third_dimension>
         <particle_container>
             <linkedcells_container>
                 <domain_size>
@@ -18,7 +19,7 @@
                 <cutoff_radius>10</cutoff_radius>
                 <boundary_conditions>
                     <left>
-                        <outflow />
+                        <reflective />
                     </left>
                     <right>
                         <reflective />
@@ -30,7 +31,7 @@
                         <reflective />
                     </top>
                     <back>
-                        <outflow />
+                        <reflective />
                     </back>
                     <front>
                         <reflective />	
@@ -57,8 +58,8 @@
             <mass>1</mass>
             <velocity>
                 <x>10.0</x>
-                <y>10.0</y>
-                <z>10.0</z>
+                <y>0.0</y>
+                <z>0.0</z>
             </velocity>
             <type>0</type>
         </cuboid_spawner>

input/body_collision_assignment3.xml

@@ -8,6 +8,7 @@
         <video_length>30</video_length>
         <delta_t>0.0005</delta_t>
         <end_time>20.0</end_time>
+        <third_dimension>false</third_dimension>
         <particle_container>
             <linkedcells_container>
                 <domain_size>

input/falling_drop_assignment3.xml

@@ -0,0 +1,64 @@
+<?xml version="1.0"?>
+<configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="simulation_schema.xsd">
+
+    <settings>
+        <fps>24</fps>
+        <video_length>30</video_length>
+        <delta_t>0.00005</delta_t>
+        <end_time>10.0</end_time>
+        <third_dimension>false</third_dimension>
+        <particle_container>
+            <linkedcells_container>
+                <domain_size>
+                    <x>120</x>
+                    <y>50</y>
+                    <z>1</z>
+                </domain_size>
+                <cutoff_radius>3.0</cutoff_radius>
+                <boundary_conditions>
+                    <left>
+                        <reflective />
+                    </left>
+                    <right>
+                        <reflective />
+                    </right>
+                    <bottom>
+                        <reflective />
+                    </bottom>
+                    <top>
+                        <reflective />
+                    </top>
+                    <back>
+                        <reflective />
+                    </back>
+                    <front>
+                        <reflective />
+                    </front>
+                </boundary_conditions>
+            </linkedcells_container>
+        </particle_container>
+    </settings>
+
+    <particles>
+        <sphere_spawner>
+          <center>
+            <x>60.0</x>
+            <y>25.0</y>
+            <z>0.5</z>
+          </center>
+          <radius>15</radius>
+          <grid_spacing>1.1225</grid_spacing>
+          <temperature>0.1</temperature>
+          <mass>1.0</mass>
+          <velocity>
+            <x>0.0</x>
+            <y>-10.0</y>
+            <z>0.0</z>
+          </velocity>
+          <type>0</type>
+        </sphere_spawner>
+
+    </particles>
+
+</configuration>

src/io/input/xml/XMLFileReader.cpp

@@ -29,19 +29,19 @@ SimulationParams XMLFileReader::readFile(const std::string& filepath, std::uniqu
 
         // Spawn particles specified in the XML file
         for (auto xsd_cuboid : particles.cuboid_spawner()) {
-            auto spawner = XSDTypeAdapter::convertToCuboidSpawner(xsd_cuboid);
+            auto spawner = XSDTypeAdapter::convertToCuboidSpawner(xsd_cuboid, settings.third_dimension());
             particle_container->reserve(particle_container->size() + spawner.getEstimatedNumberOfParticles());
             spawner.spawnParticles(particle_container);
         }
 
         for (auto xsd_sphere : particles.sphere_spawner()) {
-            auto spawner = XSDTypeAdapter::convertToSphereSpawner(xsd_sphere);
+            auto spawner = XSDTypeAdapter::convertToSphereSpawner(xsd_sphere, settings.third_dimension());
             particle_container->reserve(particle_container->size() + spawner.getEstimatedNumberOfParticles());
             spawner.spawnParticles(particle_container);
         }
 
         for (auto xsd_particle : particles.single_particle()) {
-            auto particle = XSDTypeAdapter::convertToParticle(xsd_particle);
+            auto particle = XSDTypeAdapter::convertToParticle(xsd_particle, settings.third_dimension());
             particle_container->addParticle(particle);
         }
 

src/io/input/xml/parser/XSDTypeAdapter.cpp

@@ -6,7 +6,7 @@
 #include "utils/ArrayUtils.h"
 #include "utils/MaxwellBoltzmannDistribution.h"
 
-CuboidSpawner XSDTypeAdapter::convertToCuboidSpawner(const particles::cuboid_spawner_type& cuboid) {
+CuboidSpawner XSDTypeAdapter::convertToCuboidSpawner(const particles::cuboid_spawner_type& cuboid, bool third_dimension) {
     auto lower_left_front_corner = convertToVector(cuboid.lower_left_front_corner());
     auto grid_dimensions = convertToVector(cuboid.grid_dim());
     auto initial_velocity = convertToVector(cuboid.velocity());
@@ -21,6 +21,11 @@ CuboidSpawner XSDTypeAdapter::convertToCuboidSpawner(const particles::cuboid_spa
         exit(-1);
     }
 
+    if (!third_dimension && grid_dimensions[2] > 1) {
+        Logger::logger->error("Cuboid grid dimensions must be 1 in z direction if third dimension is disabled");
+        exit(-1);
+    }
+
     if (grid_spacing <= 0) {
         Logger::logger->error("Cuboid grid spacing must be positive");
         exit(-1);
@@ -36,11 +41,11 @@ CuboidSpawner XSDTypeAdapter::convertToCuboidSpawner(const particles::cuboid_spa
         exit(-1);
     }
 
-    return CuboidSpawner{lower_left_front_corner, grid_dimensions,        grid_spacing, mass,
-                         initial_velocity,        static_cast<int>(type), temperature};
+    return CuboidSpawner{lower_left_front_corner, grid_dimensions,        grid_spacing,    mass,
+                         initial_velocity,        static_cast<int>(type), third_dimension, temperature};
 }
 
-SphereSpawner XSDTypeAdapter::convertToSphereSpawner(const particles::sphere_spawner_type& sphere) {
+SphereSpawner XSDTypeAdapter::convertToSphereSpawner(const particles::sphere_spawner_type& sphere, bool third_dimension) {
     auto center = convertToVector(sphere.center());
     auto initial_velocity = convertToVector(sphere.velocity());
 
@@ -70,12 +75,14 @@ SphereSpawner XSDTypeAdapter::convertToSphereSpawner(const particles::sphere_spa
         exit(-1);
     }
 
-    return SphereSpawner{center, static_cast<int>(radius), grid_spacing, mass, initial_velocity, static_cast<int>(type), temperature};
+    return SphereSpawner{center,           static_cast<int>(radius), grid_spacing,    mass,
+                         initial_velocity, static_cast<int>(type),   third_dimension, temperature};
 }
 
-Particle XSDTypeAdapter::convertToParticle(const particles::single_particle_type& particle) {
+Particle XSDTypeAdapter::convertToParticle(const particles::single_particle_type& particle, bool third_dimension) {
     auto position = convertToVector(particle.position());
-    auto initial_velocity = convertToVector(particle.velocity()) + maxwellBoltzmannDistributedVelocity(particle.temperature(), 2);
+    auto initial_velocity =
+        convertToVector(particle.velocity()) + maxwellBoltzmannDistributedVelocity(particle.temperature(), third_dimension ? 3 : 2);
 
     auto mass = particle.mass();
     auto type = particle.type();

src/io/input/xml/parser/XSDTypeAdapter.h

@@ -17,25 +17,28 @@ class XSDTypeAdapter {
      * @brief Converts a cuboid from the XSD format to the internal format
      *
      * @param cuboid Cuboid in the XSD format
+     * @param third_dimension Whether the third dimension is enabled
      * @return CuboidSpawner parsed from the given cuboid in the XSD format
      */
-    static CuboidSpawner convertToCuboidSpawner(const particles::cuboid_spawner_type& cuboid);
+    static CuboidSpawner convertToCuboidSpawner(const particles::cuboid_spawner_type& cuboid, bool third_dimension);
 
     /**
      * @brief Converts a sphere from the XSD format to the internal format
      *
      * @param sphere Sphere in the XSD format
+     * @param third_dimension Whether the third dimension is enabled
      * @return SphereSpawner parsed from the given sphere in the XSD format
      */
-    static SphereSpawner convertToSphereSpawner(const particles::sphere_spawner_type& sphere);
+    static SphereSpawner convertToSphereSpawner(const particles::sphere_spawner_type& sphere, bool third_dimension);
 
     /**
      * @brief Converts a particle from the XSD format to the internal format
      *
      * @param particle Particle in the XSD format
+     * @param third_dimension Whether the third dimension is enabled
      * @return Particle parsed from the given particle in the XSD format
      */
-    static Particle convertToParticle(const particles::single_particle_type& particle);
+    static Particle convertToParticle(const particles::single_particle_type& particle, bool third_dimension);
 
     /**
      * @brief Converts a container type from the XSD format to the internal format

src/io/input/xml/parser/simulation_schema.cpp

@@ -418,6 +418,12 @@ settings::end_time_type& settings::end_time() { return this->end_time_.get(); }
 
 void settings::end_time(const end_time_type& x) { this->end_time_.set(x); }
 
+const settings::third_dimension_type& settings::third_dimension() const { return this->third_dimension_.get(); }
+
+settings::third_dimension_type& settings::third_dimension() { return this->third_dimension_.get(); }
+
+void settings::third_dimension(const third_dimension_type& x) { this->third_dimension_.set(x); }
+
 const settings::particle_container_type& settings::particle_container() const { return this->particle_container_.get(); }
 
 settings::particle_container_type& settings::particle_container() { return this->particle_container_.get(); }
@@ -1647,21 +1653,23 @@ configuration::~configuration() {}
 //
 
 settings::settings(const fps_type& fps, const video_length_type& video_length, const delta_t_type& delta_t, const end_time_type& end_time,
-                   const particle_container_type& particle_container)
+                   const third_dimension_type& third_dimension, const particle_container_type& particle_container)
     : ::xml_schema::type(),
       fps_(fps, this),
       video_length_(video_length, this),
       delta_t_(delta_t, this),
       end_time_(end_time, this),
+      third_dimension_(third_dimension, this),
       particle_container_(particle_container, this) {}
 
 settings::settings(const fps_type& fps, const video_length_type& video_length, const delta_t_type& delta_t, const end_time_type& end_time,
-                   ::std::unique_ptr<particle_container_type> particle_container)
+                   const third_dimension_type& third_dimension, ::std::unique_ptr<particle_container_type> particle_container)
     : ::xml_schema::type(),
       fps_(fps, this),
       video_length_(video_length, this),
       delta_t_(delta_t, this),
       end_time_(end_time, this),
+      third_dimension_(third_dimension, this),
       particle_container_(std::move(particle_container), this) {}
 
 settings::settings(const settings& x, ::xml_schema::flags f, ::xml_schema::container* c)
@@ -1670,6 +1678,7 @@ settings::settings(const settings& x, ::xml_schema::flags f, ::xml_schema::conta
       video_length_(x.video_length_, f, this),
       delta_t_(x.delta_t_, f, this),
       end_time_(x.end_time_, f, this),
+      third_dimension_(x.third_dimension_, f, this),
       particle_container_(x.particle_container_, f, this) {}
 
 settings::settings(const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c)
@@ -1678,6 +1687,7 @@ settings::settings(const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_
       video_length_(this),
       delta_t_(this),
       end_time_(this),
+      third_dimension_(this),
       particle_container_(this) {
     if ((f & ::xml_schema::flags::base) == 0) {
         ::xsd::cxx::xml::dom::parser<char> p(e, true, false, false);
@@ -1726,6 +1736,15 @@ void settings::parse(::xsd::cxx::xml::dom::parser<char>& p, ::xml_schema::flags
             }
         }
 
+        // third_dimension
+        //
+        if (n.name() == "third_dimension" && n.namespace_().empty()) {
+            if (!third_dimension_.present()) {
+                this->third_dimension_.set(third_dimension_traits::create(i, f, this));
+                continue;
+            }
+        }
+
         // particle_container
         //
         if (n.name() == "particle_container" && n.namespace_().empty()) {
@@ -1756,6 +1775,10 @@ void settings::parse(::xsd::cxx::xml::dom::parser<char>& p, ::xml_schema::flags
         throw ::xsd::cxx::tree::expected_element<char>("end_time", "");
     }
 
+    if (!third_dimension_.present()) {
+        throw ::xsd::cxx::tree::expected_element<char>("third_dimension", "");
+    }
+
     if (!particle_container_.present()) {
         throw ::xsd::cxx::tree::expected_element<char>("particle_container", "");
     }
@@ -1770,6 +1793,7 @@ settings& settings::operator=(const settings& x) {
         this->video_length_ = x.video_length_;
         this->delta_t_ = x.delta_t_;
         this->end_time_ = x.end_time_;
+        this->third_dimension_ = x.third_dimension_;
         this->particle_container_ = x.particle_container_;
     }
 
@@ -2492,6 +2516,14 @@ void operator<<(::xercesc::DOMElement& e, const settings& i) {
         s << ::xml_schema::as_double(i.end_time());
     }
 
+    // third_dimension
+    //
+    {
+        ::xercesc::DOMElement& s(::xsd::cxx::xml::dom::create_element("third_dimension", e));
+
+        s << i.third_dimension();
+    }
+
     // particle_container
     //
     {