travis/qtrocket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP

Browse Source
This commit is contained in:
Travis Hunter 2023-04-22 17:37:41 -06:00
parent 32c9cda4b8
commit 620cd80fe4
12 changed files with 107 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
QtRocket.cpp
View File

@ -95,7 +95,7 @@ int QtRocket::run(int argc, char* argv[])
return 0;
}
void QtRocket::addMotorModels(std::vector<MotorModel>& m)
void QtRocket::addMotorModels(std::vector<model::MotorModel>& m)
{
for(const auto& i : m)
{

4
QtRocket.h
View File

@ -41,7 +41,7 @@ public:
std::shared_ptr<sim::AtmosphericModel> getAtmosphereModel() { return atmosphere; }
void addMotorModels(std::vector<MotorModel>& m);
void addMotorModels(std::vector<model::MotorModel>& m);
void addRocket(std::shared_ptr<Rocket> r) { rocket = r; }
@ -58,7 +58,7 @@ private:
static QtRocket* instance;
// Motor "database(s)"
std::vector<MotorModel> motorModels;
std::vector<model::MotorModel> motorModels;
utils::Logger* logger;

2
gui/MainWindow.cpp
View File

@ -143,7 +143,7 @@ void MainWindow::on_loadRSE_button_clicked()
QComboBox* engineSelector =
ui->rocketPartButtons->findChild<QComboBox*>(QString("engineSelectorComboBox"));
const std::vector<MotorModel>& motors = loader.getMotors();
const std::vector<model::MotorModel>& motors = loader.getMotors();
for(const auto& motor : motors)
{
std::cout << "Adding: " << motor.commonName << std::endl;

2
gui/ThrustCurveMotorSelector.cpp
View File

@ -56,7 +56,7 @@ void ThrustCurveMotorSelector::on_searchButton_clicked()
c.addCriteria("manufacturer", manufacturer);
c.addCriteria("impulseClass", impulseClass);
std::vector<MotorModel> motors = tcApi->searchMotors(c);
std::vector<model::MotorModel> motors = tcApi->searchMotors(c);
for(const auto& i : motors)
{

3
model/MotorCase.h
View File

@ -1,6 +1,8 @@
#ifndef MODEL_MOTORCASE_H
#define MODEL_MOTORCASE_H
namespace model
{
class MotorCase
{
public:
@ -11,4 +13,5 @@ private:
};
} // namespace model
#endif // MODEL_MOTORCASE_H

7
model/MotorModel.cpp
View File

@ -1,4 +1,7 @@
#include "MotorModel.h"
#include "model/MotorModel.h"
namespace model
{
MotorModel::MotorModel()
{
@ -9,3 +12,5 @@ MotorModel::~MotorModel()
{
}
} // namespace model

58
model/MotorModel.h
View File

@ -16,6 +16,9 @@
// qtrocket theaders
#include "ThrustCurve.h"
namespace model
{
/**
* @brief The MotorModel class
*
@ -134,6 +137,14 @@ public:
else
return std::string("OOP");
}
static AVAILABILITY toEnum(const std::string& name)
{
if(name == "regular")
return AVAILABILITY::REGULAR;
else
return AVAILABILITY::OOP;
}
};
/**
@ -171,6 +182,22 @@ public:
else // UNK - Unknown
return std::string("Unkown");
}
static CERTORG toEnum(const std::string& name)
{
if(name == "AMRS")
return CERTORG::AMRS;
else if(name == "CAR")
return CERTORG::CAR;
else if(name == "NAR")
return CERTORG::NAR;
else if(name == "TRA")
return CERTORG::TRA;
else if(name == "UNC")
return CERTORG::UNC;
else // Unknown
return CERTORG::UNK;
}
};
/**
@ -202,6 +229,17 @@ public:
else
return std::string("Hybrid");
}
static MOTORTYPE toEnum(const std::string& name)
{
if(name == "SU" ||
name == "Single Use")
return MOTORTYPE::SU;
else if(name == "Hybrid")
return MOTORTYPE::HYBRID;
else if(name == "reload" ||
name == "Reload")
return MOTORTYPE::RELOAD;
}
};
/**
@ -245,6 +283,24 @@ public:
return std::string("Unknown");
}
}
static MOTORMANUFACTURER toEnum(const std::string& name)
{
if(name == "AeroTech" ||
name == "Aerotech")
return MOTORMANUFACTURER::AEROTECH;
else if(name == "AMW")
return MOTORMANUFACTURER::AMW;
else if(name == "Cesaroni")
return MOTORMANUFACTURER::CESARONI;
else if(name == "Estes")
return MOTORMANUFACTURER::ESTES;
else if(name == "Loki")
return MOTORMANUFACTURER::LOKI;
else if(name == "Apogee")
return MOTORMANUFACTURER::APOGEE;
else
return MOTORMANUFACTURER::UNKNOWN;
}
};
/// TODO: make these MotorModel members private. Public just for testing
@ -279,4 +335,6 @@ public:
};
} // namespace model
#endif // MODEL_MOTORMODEL_H

6
model/MotorModelDatabase.h
View File

@ -34,7 +34,7 @@ public:
* @param manufacturer The manufacturer to search for
* @return vector of MotorModels from a given manufacturer
*/
std::vector<MotorModel> findMotorsByManufacturer(const std::string& manufacturer);
std::vector<model::MotorModel> findMotorsByManufacturer(const std::string& manufacturer);
/**
* @brief findMotersByImpulseClass returns a vector of MotorModels with a given
@ -42,11 +42,11 @@ public:
* @param imClass Impulse class to search for
* @return vector of MotorModels with a given Impulse class
*/
std::vector<MotorModel> findMotersByImpulseClass(const std::string& imClass);
std::vector<model::MotorModel> findMotersByImpulseClass(const std::string& imClass);
private:
std::vector<MotorModel> motors;
std::vector<model::MotorModel> motors;
};

60
utils/RSEDatabaseLoader.cpp
View File

@ -35,23 +35,18 @@ RSEDatabaseLoader::~RSEDatabaseLoader()
void RSEDatabaseLoader::buildAndAppendMotorModel(boost::property_tree::ptree& v)
{
MotorModel mm;
mm.availability = MotorModel::MotorAvailability(MotorModel::AVAILABILITY::REGULAR);
model::MotorModel mm;
mm.availability = model::MotorModel::MotorAvailability(model::MotorModel::AVAILABILITY::REGULAR);
mm.avgThrust = v.get<double>("<xmlattr>.avgThrust", 0.0);
mm.burnTime = v.get<double>("<xmlattr>.burn-time", 0.0);
mm.certOrg = MotorModel::CertOrg(MotorModel::CERTORG::UNK);
mm.certOrg = model::MotorModel::CertOrg(model::MotorModel::CERTORG::UNK);
mm.commonName = v.get<std::string>("<xmlattr>.code", "");
// mm.delays = extract vector from csv list
// mm.designation = What is this?
// This is in the form of dia="18.", or dia="38."
{
std::string dia = v.get<std::string>("<xmlattr>.dia", "");
dia = dia.substr(0, dia.length() - 1);
mm.diameter = std::stoi(dia);
}
mm.diameter = v.get<double>("<xmlattr>.dia", 0.0);
// impulse class is the motor letter designation. extract from the first character
// of the commonName since it isn't given explicity in the RSE file
mm.impulseClass = mm.commonName[0];
@ -59,38 +54,12 @@ void RSEDatabaseLoader::buildAndAppendMotorModel(boost::property_tree::ptree& v)
// infoUrl not present in RSE file
mm.infoUrl = "";
mm.length = v.get<double>("<xmlattr>.len", 0.0);
{
std::string manufacturer = v.get<std::string>("<xmlattr>.mfg", "");
MotorModel::MotorManufacturer manu(MotorModel::MOTORMANUFACTURER::UNKNOWN);
if(manufacturer == "Aerotech")
manu = MotorModel::MOTORMANUFACTURER::AEROTECH;
else if(manufacturer == "Animal Motor Works")
manu = MotorModel::MOTORMANUFACTURER::AMW;
else if(manufacturer == "Apogee")
manu = MotorModel::MOTORMANUFACTURER::APOGEE;
mm.manufacturer = manu;
}
mm.manufacturer = model::MotorModel::MotorManufacturer::toEnum(v.get<std::string>("<xmlattr>.mfg", ""));
mm.maxThrust = v.get<double>("<xmlattr>.peakThrust", 0.0);
mm.propWeight = v.get<double>("<xmlattr>.propWt", 0.0);
mm.totalImpulse = v.get<double>("<xmlattr>.Itot", 0.0);
{
std::string type = v.get<std::string>("<xmlattr>.Type");
MotorModel::MotorType mt(MotorModel::MOTORTYPE::SU);
if(type.compare("reloadable") == 0)
{
mt = MotorModel::MOTORTYPE::RELOAD;
}
else if(type.compare("hybrid") == 0)
{
mt = MotorModel::MOTORTYPE::HYBRID;
}
else
{
// single use, which is default
}
mm.type = mt;
}
mm.type = model::MotorModel::MotorType::toEnum(v.get<std::string>("<xmlattr>.Type"));
// Now get the thrust data
std::vector<std::pair<double, double>> thrustData;
@ -100,23 +69,6 @@ void RSEDatabaseLoader::buildAndAppendMotorModel(boost::property_tree::ptree& v)
double fdata = w.second.get<double>("<xmlattr>.f");
thrustData.push_back(std::make_pair(tdata, fdata));
}
/*
std::cout << "\n--------------------------------------------\n";
std::cout << "name: " << mm.commonName << std::endl;
std::cout << "impulseClass: " << mm.impulseClass << std::endl;
std::cout << "length: " << mm.length << std::endl;
std::cout << "manufacturer: " << mm.manufacturer << std::endl;
std::cout << "maxThrust: " << mm.maxThrust << std::endl;
std::cout << "propWeight: " << mm.propWeight << std::endl;
std::cout << "totalImpulse: " << mm.totalImpulse << std::endl;
std::cout << "--------------------------------------------\n";
std::cout << "thrust data:\n";
for(const auto& i : thrustData)
{
std::cout << "(" << i.first << ", " << i.second << ")\n";
}
*/
motors.emplace_back(std::move(mm));
}

4
utils/RSEDatabaseLoader.h
View File

@ -23,10 +23,10 @@ public:
RSEDatabaseLoader(const std::string& filename);
~RSEDatabaseLoader();
const std::vector<MotorModel>& getMotors() const { return motors; }
const std::vector<model::MotorModel>& getMotors() const { return motors; }
private:
std::vector<MotorModel> motors;
std::vector<model::MotorModel> motors;
void buildAndAppendMotorModel(boost::property_tree::ptree& v);

40
utils/ThrustCurveAPI.cpp
View File

@ -26,7 +26,7 @@ ThrustCurveAPI::~ThrustCurveAPI()
}
MotorModel ThrustCurveAPI::getMotorData(const std::string& motorId)
model::MotorModel ThrustCurveAPI::getMotorData(const std::string& motorId)
{
std::stringstream endpoint;
endpoint << hostname << "download.json?motorId=" << motorId << "&data=samples";
@ -35,7 +35,7 @@ MotorModel ThrustCurveAPI::getMotorData(const std::string& motorId)
std::string res = curlConnection.get(endpoint.str(), extraHeaders);
/// TODO: fix this
MotorModel mm;
model::MotorModel mm;
return mm;
}
@ -62,17 +62,17 @@ ThrustcurveMetadata ThrustCurveAPI::getMetadata()
std::string org = (*iter)["abbrev"].asString();
if(org == "AMRS")
ret.certOrgs.emplace_back(MotorModel::CERTORG::AMRS);
ret.certOrgs.emplace_back(model::MotorModel::CERTORG::AMRS);
else if(org == "CAR")
ret.certOrgs.emplace_back(MotorModel::CERTORG::CAR);
ret.certOrgs.emplace_back(model::MotorModel::CERTORG::CAR);
else if(org == "NAR")
ret.certOrgs.emplace_back(MotorModel::CERTORG::NAR);
ret.certOrgs.emplace_back(model::MotorModel::CERTORG::NAR);
else if(org == "TRA")
ret.certOrgs.emplace_back(MotorModel::CERTORG::TRA);
ret.certOrgs.emplace_back(model::MotorModel::CERTORG::TRA);
else if(org == "UNC")
ret.certOrgs.emplace_back(MotorModel::CERTORG::UNC);
ret.certOrgs.emplace_back(model::MotorModel::CERTORG::UNC);
else
ret.certOrgs.emplace_back(MotorModel::CERTORG::UNK);
ret.certOrgs.emplace_back(model::MotorModel::CERTORG::UNK);
}
for(Json::ValueConstIterator iter = jsonResult["diameters"].begin();
iter != jsonResult["diameters"].end();
@ -98,11 +98,11 @@ ThrustcurveMetadata ThrustCurveAPI::getMetadata()
{
std::string type = (*iter)["types"].asString();
if(type == "SU")
ret.types.emplace_back(MotorModel::MOTORTYPE::SU);
ret.types.emplace_back(model::MotorModel::MOTORTYPE::SU);
else if(type == "reload")
ret.types.emplace_back(MotorModel::MOTORTYPE::RELOAD);
ret.types.emplace_back(model::MotorModel::MOTORTYPE::RELOAD);
else
ret.types.emplace_back(MotorModel::MOTORTYPE::HYBRID);
ret.types.emplace_back(model::MotorModel::MOTORTYPE::HYBRID);
}
}
catch(const std::exception& e)
@ -119,9 +119,9 @@ ThrustcurveMetadata ThrustCurveAPI::getMetadata()
}
std::vector<MotorModel> ThrustCurveAPI::searchMotors(const SearchCriteria& c)
std::vector<model::MotorModel> ThrustCurveAPI::searchMotors(const SearchCriteria& c)
{
std::vector<MotorModel> retVal;
std::vector<model::MotorModel> retVal;
std::string endpoint = hostname;
endpoint += "search.json?";
for(const auto& i : c.criteria)
@ -148,14 +148,14 @@ std::vector<MotorModel> ThrustCurveAPI::searchMotors(const SearchCriteria& c)
iter != jsonResult["results"].end();
++iter)
{
MotorModel mm;
model::MotorModel mm;
mm.commonName = (*iter)["commonName"].asString();
std::string availability = (*iter)["availability"].asString();
if(availability == "regular")
mm.availability = MotorModel::MotorAvailability(MotorModel::AVAILABILITY::REGULAR);
mm.availability = model::MotorModel::MotorAvailability(model::MotorModel::AVAILABILITY::REGULAR);
else
mm.availability = MotorModel::MotorAvailability(MotorModel::AVAILABILITY::OOP);
mm.availability = model::MotorModel::MotorAvailability(model::MotorModel::AVAILABILITY::OOP);
mm.avgThrust = (*iter)["avgThrustN"].asDouble();
mm.burnTime = (*iter)["burnTimeS"].asDouble();
@ -167,7 +167,7 @@ std::vector<MotorModel> ThrustCurveAPI::searchMotors(const SearchCriteria& c)
mm.length = (*iter)["length"].asDouble();
std::string manu = (*iter)["manufacturer"].asString();
if(manu == "AeroTech")
mm.manufacturer = MotorModel::MOTORMANUFACTURER::AEROTECH;
mm.manufacturer = model::MotorModel::MOTORMANUFACTURER::AEROTECH;
//mm.manufacturer = (*iter)["manufacturer"].asString();
mm.maxThrust = (*iter)["maxThrustN"].asDouble();
mm.motorIdTC = (*iter)["motorId"].asString();
@ -179,11 +179,11 @@ std::vector<MotorModel> ThrustCurveAPI::searchMotors(const SearchCriteria& c)
std::string type = (*iter)["type"].asString();
if(type == "SU")
mm.type = MotorModel::MotorType(MotorModel::MOTORTYPE::SU);
mm.type = model::MotorModel::MotorType(model::MotorModel::MOTORTYPE::SU);
else if(type == "reload")
mm.type = MotorModel::MotorType(MotorModel::MOTORTYPE::RELOAD);
mm.type = model::MotorModel::MotorType(model::MotorModel::MOTORTYPE::RELOAD);
else
mm.type = MotorModel::MotorType(MotorModel::MOTORTYPE::HYBRID);
mm.type = model::MotorModel::MotorType(model::MotorModel::MOTORTYPE::HYBRID);
retVal.push_back(mm);
}

8
utils/ThrustCurveAPI.h
View File

@ -31,11 +31,11 @@ public:
ThrustcurveMetadata& operator=(ThrustcurveMetadata&&) = default;
//private:
std::vector<MotorModel::CertOrg> certOrgs;
std::vector<model::MotorModel::CertOrg> certOrgs;
std::vector<double> diameters;
std::vector<std::string> impulseClasses;
std::map<std::string, std::string> manufacturers;
std::vector<MotorModel::MotorType> types;
std::vector<model::MotorModel::MotorType> types;
};
@ -73,7 +73,7 @@ public:
* @brief getThrustCurve will download the thrust data for the given Motor using the motorId
* @param m MotorModel to populate
*/
MotorModel getMotorData(const std::string& motorId);
model::MotorModel getMotorData(const std::string& motorId);
/**
@ -82,7 +82,7 @@ public:
ThrustcurveMetadata getMetadata();
std::vector<MotorModel> searchMotors(const SearchCriteria& c);
std::vector<model::MotorModel> searchMotors(const SearchCriteria& c);