ClumpInput.h File Reference

#include <algorithm>
#include <dirent.h>
#include <sys/types.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cmath>
#include <sstream>
#include "Math/Matrix.h"
#include <CMakeDefinitions.h>

Go to the source code of this file.

Classes
struct	ClumpData

Typedefs
typedef std::vector< double >	DoubleVector
typedef std::vector< DoubleVector >	Double2DVector
typedef std::vector< std::string >	StringVector

Functions
bool	CompareFunction (std::string a, std::string b)
double	RandomDouble (double Max)
void	LoadConf (ClumpData &a)
void	LoadPebbles (ClumpData &a)
void	LoadMass (ClumpData &a)
void	LoadTOI (ClumpData &a)
void	LoadPD (ClumpData &a)
void	LoadClumps (ClumpData &data, bool VERBOSE=false)
ClumpData	RotateClump (ClumpData data, int clump_index, DoubleVector new_pd)
DoubleVector	UniformRandomPDs ()

Typedef Documentation

Double2DVector

typedef std::vector<DoubleVector> Double2DVector

DoubleVector

typedef std::vector<double> DoubleVector

StringVector

typedef std::vector<std::string> StringVector

Function Documentation

CompareFunction()

bool CompareFunction	(	std::string	a,
		std::string	b
	)

{return a < b;}

Referenced by LoadConf().

LoadClumps()

void LoadClumps	(	ClumpData &	data,
		bool	VERBOSE = false
	)

// Main function that loads all the necessary files to initiate Clumps

{
 
    logger(INFO, "LOAD CLUMP DATA");
    LoadConf(data);
    LoadPebbles(data);
    LoadMass(data);
    LoadTOI(data);
    LoadPD(data);
    if (VERBOSE) {
        std::cout<<"LOADED CLUMPS"<<std::endl;
        for (int i = 0; i < data.pebblesX.size(); i++) {
            std::cout << data.clumpNames[i] << " mass:" << data.mass[i] << std::endl;
            std::cout << data.clumpNames[i] << " list of pebbles:" << std::endl;
            for (int j = 0; j < data.pebblesX[i].size(); j++) {
                std::cout << "Pebble " << j << ": (" << data.pebblesX[i][j] << "," << data.pebblesY[i][j] << ","
                          << data.pebblesZ[i][j] << ")," << data.pebblesR[i][j] << std::endl;
            }
 
            std::cout << data.clumpNames[i] << " TOI:" << std::endl;
            std::cout << data.toi[i][0] << "," << data.toi[i][1] << "," << data.toi[i][2] << std::endl;
            std::cout << data.toi[i][3] << "," << data.toi[i][4] << "," << data.toi[i][5] << std::endl;
            std::cout << data.toi[i][6] << "," << data.toi[i][7] << "," << data.toi[i][8] << std::endl;
 
            std::cout << data.clumpNames[i] << " Principal directions:" << std::endl;
            std::cout << data.pd[i][0] << "," << data.pd[i][1] << "," << data.pd[i][2] << std::endl;
            std::cout << data.pd[i][3] << "," << data.pd[i][4] << "," << data.pd[i][5] << std::endl;
            std::cout << data.pd[i][6] << "," << data.pd[i][7] << "," << data.pd[i][8] << std::endl;
        }
    }
 
}

References ClumpData::clumpNames, constants::i, INFO, LoadConf(), LoadMass(), LoadPD(), LoadPebbles(), LoadTOI(), logger, ClumpData::mass, ClumpData::pd, ClumpData::pebblesR, ClumpData::pebblesX, ClumpData::pebblesY, ClumpData::pebblesZ, ClumpData::toi, and VERBOSE.

Referenced by clumpTest::clumpTest(), and multiParticleT1::multiParticleT1().

LoadConf()

void LoadConf

(

ClumpData &

a

)

Loading available Clumps and their names

{
    // Path to MCLump tool
    a.path = getMercuryDPMSourceDir() + "/Tools/MClump/Clumps/";
 
    struct dirent *entry;
    DIR *dir = opendir(a.path.c_str());
    while ((entry = readdir(dir)) != NULL) {
        if (entry->d_type == DT_DIR){
            a.clumpNames.push_back(entry->d_name);
        }
    }
    closedir(dir);
 
    // remove "." and ".." from the list of dirs (position of those in the list is OS-sensitive, hence this code)
 
    std::sort(a.clumpNames.begin(), a.clumpNames.end(), CompareFunction);//sort the vector
    a.clumpNames.erase(a.clumpNames.begin());
    a.clumpNames.erase(a.clumpNames.begin());
 
    // Show the names of available Clumps
    for (int i = 0; i<a.clumpNames.size(); i++) std::cout << a.clumpNames[i] << std::endl;
 
}

References ClumpData::clumpNames, CompareFunction(), getMercuryDPMSourceDir(), constants::i, and ClumpData::path.

Referenced by LoadClumps().

LoadMass()

void LoadMass

(

ClumpData &

a

)

Load mass of a clump

{
    logger(INFO, "Loading clump masses...");
 
    a.mass.resize(a.clumpNames.size());
    
    for (int i = 0; i < a.clumpNames.size(); i++ ){
        std::ifstream infile((a.path + a.clumpNames[i] + "/Inertia/Mass.txt").c_str(), std::ios::in | std::ios::binary);
        std::string mass;
        infile >> mass;
        a.mass[i] = std::stof(mass);
        infile.close();
    }
    logger(INFO, "\t OK\n");
}

References ClumpData::clumpNames, constants::i, INFO, logger, ClumpData::mass, and ClumpData::path.

Referenced by LoadClumps().

LoadPD()

void LoadPD

(

ClumpData &

a

)

Load pre-computed principal directions (PDs) of a clump. Normally MClump tool aligns PDs with the global Cartesian axes.

{
    logger(INFO, "Loading clump PD..");
    a.pd.resize(a.clumpNames.size());
 
    for (int i = 0; i < a.clumpNames.size(); i++ ){
        std::ifstream infile((a.path + a.clumpNames[i] + "/Inertia/PD.txt").c_str(), std::ios::in | std::ios::binary);
        std::string line{};
        while (std::getline(infile, line)) {
            std::istringstream iss(line);
            std::string substring{};
            StringVector val;
            while (std::getline(iss, substring, ',')) val.push_back(substring);
            for (int k = 0; k < 3; k++) a.pd[i].push_back(std::stof(val[k]));
        }
        infile.close();
    }
    logger(INFO, "\t OK\n");
}

References ClumpData::clumpNames, constants::i, INFO, logger, ClumpData::path, and ClumpData::pd.

Referenced by LoadClumps().

LoadPebbles()

void LoadPebbles

(

ClumpData &

a

)

Loading pebbles of a clump

{
    logger(INFO, "Loading clump pebbles...");
 
    a.pebblesX.resize(a.clumpNames.size());
    a.pebblesY.resize(a.clumpNames.size());
    a.pebblesZ.resize(a.clumpNames.size());
    a.pebblesR.resize(a.clumpNames.size());
 
    for (int i = 0; i < a.clumpNames.size(); i++ ){
        std::ifstream infile((a.path + a.clumpNames[i] + "/Clump/Clump.txt").c_str(), std::ios::in | std::ios::binary);
        std::string line{};
        while (std::getline(infile, line)) {
            std::istringstream iss(line);
            std::string substring{};
            StringVector val;
            while (std::getline(iss, substring, ',')) val.push_back(substring);
            a.pebblesX[i].push_back(std::stof(val[0]));
            a.pebblesY[i].push_back(std::stof(val[1]));
            a.pebblesZ[i].push_back(std::stof(val[2]));
            a.pebblesR[i].push_back(std::stof(val[3]));
        }
        infile.close();
    }
    logger(INFO, "\t OK\n");
}

References ClumpData::clumpNames, constants::i, INFO, logger, ClumpData::path, ClumpData::pebblesR, ClumpData::pebblesX, ClumpData::pebblesY, and ClumpData::pebblesZ.

Referenced by LoadClumps().

LoadTOI()

void LoadTOI

(

ClumpData &

a

)

Load tensor of inertia (TOI) of a clump

{
    logger(INFO, "Loading clump TOI..");
    a.toi.resize(a.clumpNames.size());
 
    for (int i = 0; i < a.clumpNames.size(); i++ ){
        std::ifstream infile((a.path + a.clumpNames[i] + "/Inertia/TOI.txt").c_str(), std::ios::in | std::ios::binary);
        std::string line{};
        while (std::getline(infile, line)) {
            std::istringstream iss(line);
            std::string substring{};
            StringVector val;
            while (std::getline(iss, substring, ',')) val.push_back(substring);
            for (int k = 0; k < 3; k++) a.toi[i].push_back(std::stof(val[k]));
        }
        infile.close();
    }
    logger(INFO, "\t OK\n");
}

References ClumpData::clumpNames, constants::i, INFO, logger, ClumpData::path, and ClumpData::toi.

Referenced by LoadClumps().

RandomDouble()

double RandomDouble

(

double

Max

)

{return Max*((double) rand() / (RAND_MAX));}

Referenced by multiParticleT1::setupInitialConditions(), and UniformRandomPDs().

RotateClump()

ClumpData RotateClump	(	ClumpData	data,
		int	clump_index,
		DoubleVector	new_pd
	)

Changes PDs of the clump - sufficient for clump to be properly rotated

{
    ClumpData new_data = data;
    new_data.pd[clump_index] = new_pd;
    return new_data;
}

References ClumpData::pd.

Referenced by multiParticleT1::setupInitialConditions().

UniformRandomPDs()

DoubleVector UniformRandomPDs

(

)

Generate random (and isotropically distributed) principal directions frame

                               {
 
    Vec3D n1, n2, n3, ref;
 
    // basis vector n1
    double r1 = RandomDouble(2) - 1.0;
    double r2 = RandomDouble(1);
 
    double theta = acos(r1); // Note that for isotropy of n1 theta is NOT uniform!
    double phi = 2 * M_PI * r2;
 
    n1 = Vec3D(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta));
 
    // basis vector n2
    r1 = RandomDouble(1);
    r2 = RandomDouble(1);
 
    theta = acos(2 * r1 - 1); // Note that for isotropy of n1 theta is NOT uniform!
    phi = 2 * M_PI * r2;
 
    ref = Vec3D(sin(theta) * cos(phi), sin(theta) * sin(phi), cos(theta));
    n2 = Vec3D::cross(ref, n1); n2.normalise();
    n3 = Vec3D::cross(n1, n2); n3.normalise();
    return DoubleVector{n1.X, n1.Y, n1.Z, n2.X, n2.Y, n2.Z, n3.X, n3.Y, n3.Z};
 
}

References mathsFunc::cos(), Vec3D::cross(), Vec3D::normalise(), RandomDouble(), mathsFunc::sin(), Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by multiParticleT1::setupInitialConditions().