cuIBM/parseBodiesFile_8cu_source.html

 #include <fstream>
 #include <vector>

 #include "io.h"
 #include "utilities/body.h"
 #include "yaml-cpp/yaml.h"


 namespace io
 {

 void parseBodiesNode(const YAML::Node &node, body &Body, parameterDB &DB)
 {
     for (int i=0; i<2; i++)
         Body.X0[i] = node["centerRotation"][i].as<real>(0.0);
     // initial configuration
     for (int i=0; i<2; i++)
     {
         Body.Xc0[i] = node["initialOffset"][i].as<real>(0.0);
         Body.Xc[i] = Body.Xc0[i];
     }
     // initial angle of attack
     Body.Theta0 = node["angleOfAttack"].as<real>(0.0) * M_PI / 180.0;
     Body.Theta = Body.Theta0;
     // moving flags
     for (int i=0; i<2; i++)
         Body.moving[i] = node["moving"][i].as<bool>(false);
     // velocity
     for (int i=0; i<2; i++)
         Body.velocity[i] = node["velocity"][i].as<real>(0.0);
     // omega
     Body.omega = node["omega"].as<real>(0.0);
     // oscillation in X
     for (int i=0; i<3; i++)
         Body.xOscillation[i] = node["xOscillation"][i].as<real>(0.0);
     Body.xOscillation[1] *= 2 * M_PI;
     // oscillation in Y
     for (int i=0; i<3; i++)
         Body.yOscillation[i] = node["yOscillation"][i].as<real>(0.0);
     Body.yOscillation[1] *= 2 * M_PI;
     // pitch oscillation
     for (int i=0; i<3; i++)
         Body.pitchOscillation[i] = node["pitchOscillation"][i].as<real>(0.0);
     Body.pitchOscillation[0] *= M_PI / 180.0;
     Body.pitchOscillation[1] *= 2 * M_PI;

     // get the type of body and read in appropriate details
     std::string type = node["type"].as<std::string>();
     if (type == "points")
     {
         std::string fileName = node["pointsFile"].as<std::string>();
         std::string folderPath = DB["inputs"]["caseFolder"].get<std::string>();
         std::ifstream inFile((folderPath + "/" + fileName).c_str());
         inFile >> Body.numPoints;
         Body.X.resize(Body.numPoints);
         Body.Y.resize(Body.numPoints);
         for (int i=0; i<Body.numPoints; i++)
             inFile >> Body.X[i] >> Body.Y[i];
         inFile.close();
     }
     else if (type == "lineSegment")
     {
         real startX = node["segmentOptions"][0].as<real>();
         real endX = node["segmentOptions"][1].as<real>();
         real startY = node["segmentOptions"][2].as<real>();
         real endY = node["segmentOptions"][3].as<real>();
         int numPoints = node["segmentOptions"][4].as<int>();
         Body.numPoints = numPoints;
         // initialize line segment
     }
     else if (type == "circle")
     {
         real cx = node["circleOptions"][0].as<real>();
         real cy = node["circleOptions"][1].as<real>();
         real R = node["circleOptions"][2].as<real>();
         int numPoints = node["circleOptions"][3].as<int>();
         Body.numPoints = numPoints;
         // initialize circle
         Body.X.resize(numPoints);
         Body.Y.resize(numPoints);
         for (int i=0; i<Body.numPoints; i++)
         {
             Body.X[i] = cx + R*cos(i*2*M_PI/Body.numPoints);
             Body.Y[i] = cy + R*sin(i*2*M_PI/Body.numPoints);
         }
     }
     else
     {
         printf("Error: Unknown body type '%s'!\n", type.c_str());
         exit(-1);
     }
 } // parseBodiesNode


 void parseBodiesFile(std::string &bodiesFile, parameterDB &DB)
 {
     if (!std::ifstream(bodiesFile.c_str()))
     {
         if (DB["simulation"]["ibmScheme"].get<ibmScheme>() != NAVIER_STOKES)
         {
             printf("Error: Missing YAML file bodies.yaml!\n");
             exit(-1);
         }
         return;
     }
     printf("Parsing YAML file with bodies info ...\n");
     YAML::Node nodes = YAML::LoadFile(bodiesFile);
     body Body;
     std::vector<body> *B = DB["flow"]["bodies"].get<std::vector<body> *>();
     for (int i=0; i<nodes.size(); i++)
     {
         Body.reset();
         parseBodiesNode(nodes[i], Body, DB);
         B->push_back(Body);
     }
 } // parseBodiesFile

 } // End of namespace io
body::xOscillation
real xOscillation[3]
amplitude, angular frequency and phase difference of oscillation in the x-direction ...
Definition: body.h:46

body.h
Definition of the class body.

real
double real
Is a float or a double depending on the machine precision.
Definition: types.h:116

body::pitchOscillation
real pitchOscillation[3]
amplitude, angular frequency and phase difference of pitch oscillation
Definition: body.h:46

body::Y
vecH Y
reference y-coordinate of boundary points
Definition: body.h:28

body
Contains information about an immersed boundary in the flow.
Definition: body.h:23

io.h
Declaration of the functions of the namespace io.

parameterDB
std::map< std::string, componentParameter > parameterDB
Map from a string to a componentParameter.
Definition: parameterDB.h:64

io
Contains functions related to I/O tasks.

body::X
vecH X
reference x-coordinate of boundary points
Definition: body.h:28

NAVIER_STOKES
no immersed bodies - Perot (1993)
Definition: types.h:76

body::X0
real X0[2]
reference center of rotation
Definition: body.h:31

body::Theta0
real Theta0
initial angle of attack
Definition: body.h:33

body::Xc
real Xc[2]
actual center of rotation (x- and y-coordinates)
Definition: body.h:36

body::Theta
real Theta
actual angle of attack (counterclockwise is positive)
Definition: body.h:36

body::omega
real omega
uniform rotational velocity
Definition: body.h:43

body::velocity
real velocity[2]
uniform translational velocity (x- and y-components)
Definition: body.h:43

io::parseBodiesFile
void parseBodiesFile(std::string &bodiesFile, parameterDB &DB)
Parses the bodies.yaml file and stores information about the immersed bodies.
Definition: parseBodiesFile.cu:117

body::moving
bool moving[2]
flag to indicate if the body is moving (translating or rotating)
Definition: body.h:41

body::numPoints
int numPoints
number of boundary points
Definition: body.h:26

body::Xc0
real Xc0[2]
initial position of center of rotation
Definition: body.h:33

io::parseBodiesNode
void parseBodiesNode(const YAML::Node &node, body &Body, parameterDB &DB)
Overloads the operator >>. Stores information about an immersed body.
Definition: parseBodiesFile.cu:29

body::reset
void reset()
Resets the position and motion of the body.
Definition: body.h:84

body::yOscillation
real yOscillation[3]
amplitude, angular frequency and phase difference of oscillation in the y-direction ...
Definition: body.h:46