Skip to content

Commit

Permalink
refactor c part
Browse files Browse the repository at this point in the history 
Signed-off-by: Etienne LESOT <[email protected]>
  • Loading branch information
@EtienneLt
EtienneLt committed Jun 14, 2024
1 parent bd809a2 commit dcb32b2
Show file tree
Hide file tree
Showing 8 changed files with 268 additions and 85 deletions.
1 change: 1 addition & 0 deletions cpp/powsybl-cpp/powsybl-api.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -313,6 +313,7 @@ typedef struct {
typedef struct zone_struct {
char* id;
char** injections_ids;
int injections_ids_count;
double* injections_shift_keys;
int length;
} zone;
Expand Down
144 changes: 84 additions & 60 deletions cpp/powsybl-cpp/powsybl-cpp.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -172,37 +172,34 @@ std::map<std::string, std::string> convertMapStructToStdMap(string_map* map) {
}

char* copyStringToCharPtr(const std::string& str) {
char* c = new char[str.size() + 1];
char* c = initializeCharPointer(str.size() + 1);
str.copy(c, str.size());
c[str.size()] = '\0';
return c;
}

char** copyVectorStringToCharPtrPtr(const std::vector<std::string>& strings) {
char** charPtrPtr = new char*[strings.size()];
char** charPtrPtr = initializeCharPointerPointer(strings.size());
for (int i = 0; i < strings.size(); i++) {
charPtrPtr[i] = copyStringToCharPtr(strings[i]);
}
return charPtrPtr;
}

int* copyVectorInt(const std::vector<int>& ints) {
int* intPtr = new int[ints.size()];
int* intPtr = initializeIntPointer(ints.size());
std::copy(ints.begin(), ints.end(), intPtr);
return intPtr;
}

double* copyVectorDouble(const std::vector<double>& doubles) {
double* doublePtr = new double[doubles.size()];
double* doublePtr = initializeDoublePointer(doubles.size());
std::copy(doubles.begin(), doubles.end(), doublePtr);
return doublePtr;
}

void deleteCharPtrPtr(char** charPtrPtr, int length) {
for (int i = 0; i < length; i++) {
delete[] charPtrPtr[i];
}
delete[] charPtrPtr;
freeCharPointerPointer(charPtrPtr);
}

void freeCString(char* str) {
Expand All @@ -221,12 +218,6 @@ void copyCharPtrPtrToVector(char** src, int count, std::vector<std::string>& des
std::copy(src, src + count, std::back_inserter(dest));
}

void deleteLoadFlowParameters(loadflow_parameters* ptr) {
pypowsybl::deleteCharPtrPtr(ptr->countries_to_balance, ptr->countries_to_balance_count);
pypowsybl::deleteCharPtrPtr(ptr->provider_parameters_keys, ptr->provider_parameters_keys_count);
pypowsybl::deleteCharPtrPtr(ptr->provider_parameters_values, ptr->provider_parameters_values_count);
}

LoadFlowParameters::LoadFlowParameters(loadflow_parameters* src) {
voltage_init_mode = static_cast<VoltageInitMode>(src->voltage_init_mode);
transformer_voltage_control_on = (bool) src->transformer_voltage_control_on;
Expand Down Expand Up @@ -267,19 +258,14 @@ void LoadFlowParameters::load_to_c_struct(loadflow_parameters& res) const {
}

std::shared_ptr<loadflow_parameters> LoadFlowParameters::to_c_struct() const {
loadflow_parameters* res = new loadflow_parameters();
loadflow_parameters* res = PowsyblCaller::get()->callJava<loadflow_parameters*>(::createLoadFlowParameters);
load_to_c_struct(*res);
//Memory has been allocated here on C side, we need to clean it up on C side (not java side)
return std::shared_ptr<loadflow_parameters>(res, [](loadflow_parameters* ptr){
deleteLoadFlowParameters(ptr);
delete ptr;
PowsyblCaller::get()->callJava(::freeLoadFlowParameters, ptr);
});
}

void deleteLoadFlowValidationParameters(loadflow_validation_parameters* ptr) {
deleteLoadFlowParameters(&ptr->loadflow_parameters);
}

LoadFlowValidationParameters::LoadFlowValidationParameters(loadflow_validation_parameters* src):
loadflow_parameters(&src->loadflow_parameters)
{
Expand Down Expand Up @@ -309,21 +295,14 @@ void LoadFlowValidationParameters::load_to_c_struct(loadflow_validation_paramete
}

std::shared_ptr<loadflow_validation_parameters> LoadFlowValidationParameters::to_c_struct() const {
loadflow_validation_parameters* res = new loadflow_validation_parameters();
loadflow_validation_parameters* res = PowsyblCaller::get()->callJava<loadflow_validation_parameters*>(::createValidationConfig);
load_to_c_struct(*res);
//Memory has been allocated here on C side, we need to clean it up on C side (not java side)
return std::shared_ptr<loadflow_validation_parameters>(res, [](loadflow_validation_parameters* ptr){
deleteLoadFlowValidationParameters(ptr);
delete ptr;
PowsyblCaller::get()->callJava(::freeValidationConfig, ptr);
});
}

void deleteSecurityAnalysisParameters(security_analysis_parameters* ptr) {
deleteLoadFlowParameters(&ptr->loadflow_parameters);
pypowsybl::deleteCharPtrPtr(ptr->provider_parameters_keys, ptr->provider_parameters_keys_count);
pypowsybl::deleteCharPtrPtr(ptr->provider_parameters_values, ptr->provider_parameters_values_count);
}

SecurityAnalysisParameters::SecurityAnalysisParameters(security_analysis_parameters* src):
loadflow_parameters(&src->loadflow_parameters)
{
Expand All @@ -337,7 +316,7 @@ SecurityAnalysisParameters::SecurityAnalysisParameters(security_analysis_paramet
}

std::shared_ptr<security_analysis_parameters> SecurityAnalysisParameters::to_c_struct() const {
security_analysis_parameters* res = new security_analysis_parameters();
security_analysis_parameters* res = PowsyblCaller::get()->callJava<security_analysis_parameters*>(::createSecurityAnalysisParameters);
loadflow_parameters.load_to_c_struct(res->loadflow_parameters);
res->flow_proportional_threshold = (double) flow_proportional_threshold;
res->low_voltage_proportional_threshold = (double) low_voltage_proportional_threshold;
Expand All @@ -350,17 +329,10 @@ std::shared_ptr<security_analysis_parameters> SecurityAnalysisParameters::to_c_s
res->provider_parameters_values_count = provider_parameters_values.size();
//Memory has been allocated here on C side, we need to clean it up on C side (not java side)
return std::shared_ptr<security_analysis_parameters>(res, [](security_analysis_parameters* ptr){
deleteSecurityAnalysisParameters(ptr);
delete ptr;
PowsyblCaller::get()->callJava(::freeSecurityAnalysisParameters, ptr);
});
}

void deleteSensitivityAnalysisParameters(sensitivity_analysis_parameters* ptr) {
deleteLoadFlowParameters(&ptr->loadflow_parameters);
pypowsybl::deleteCharPtrPtr(ptr->provider_parameters_keys, ptr->provider_parameters_keys_count);
pypowsybl::deleteCharPtrPtr(ptr->provider_parameters_values, ptr->provider_parameters_values_count);
}

SensitivityAnalysisParameters::SensitivityAnalysisParameters(sensitivity_analysis_parameters* src):
loadflow_parameters(&src->loadflow_parameters)
{
Expand All @@ -369,16 +341,15 @@ SensitivityAnalysisParameters::SensitivityAnalysisParameters(sensitivity_analysi
}

std::shared_ptr<sensitivity_analysis_parameters> SensitivityAnalysisParameters::to_c_struct() const {
sensitivity_analysis_parameters* res = new sensitivity_analysis_parameters();
sensitivity_analysis_parameters* res = PowsyblCaller::get()->callJava<sensitivity_analysis_parameters*>(::createSensitivityAnalysisParameters);
loadflow_parameters.load_to_c_struct(res->loadflow_parameters);
res->provider_parameters_keys = pypowsybl::copyVectorStringToCharPtrPtr(provider_parameters_keys);
res->provider_parameters_keys_count = provider_parameters_keys.size();
res->provider_parameters_values = pypowsybl::copyVectorStringToCharPtrPtr(provider_parameters_values);
res->provider_parameters_values_count = provider_parameters_values.size();
//Memory has been allocated here on C side, we need to clean it up on C side (not java side)
return std::shared_ptr<sensitivity_analysis_parameters>(res, [](sensitivity_analysis_parameters* ptr){
deleteSensitivityAnalysisParameters(ptr);
delete ptr;
PowsyblCaller::get()->callJava(::freeSensitivityAnalysisParameters, ptr);
});
}

Expand All @@ -392,7 +363,7 @@ FlowDecompositionParameters::FlowDecompositionParameters(flow_decomposition_para
}

std::shared_ptr<flow_decomposition_parameters> FlowDecompositionParameters::to_c_struct() const {
flow_decomposition_parameters* res = new flow_decomposition_parameters();
flow_decomposition_parameters* res = PowsyblCaller::get()->callJava<flow_decomposition_parameters*>(::createFlowDecompositionParameters);
res->enable_losses_compensation = (unsigned char) enable_losses_compensation;
res->losses_compensation_epsilon = losses_compensation_epsilon;
res->sensitivity_epsilon = sensitivity_epsilon;
Expand All @@ -401,7 +372,7 @@ std::shared_ptr<flow_decomposition_parameters> FlowDecompositionParameters::to_c
res->sensitivity_variable_batch_size = (int) sensitivity_variable_batch_size;
//Memory has been allocated here on C side, we need to clean it up on C side (not java side)
return std::shared_ptr<flow_decomposition_parameters>(res, [](flow_decomposition_parameters* ptr){
delete ptr;
PowsyblCaller::get()->callJava(::freeFlowDecompositionParameters, ptr);
});
}

Expand Down Expand Up @@ -771,27 +742,25 @@ void addOperatorStrategy(const JavaHandle& analysisContext, std::string operator
}

::zone* createZone(const std::string& id, const std::vector<std::string>& injectionsIds, const std::vector<double>& injectionsShiftKeys) {
auto z = new ::zone;
auto z = PowsyblCaller::get()->callJava<zone*>(::createZonePointer);
z->id = copyStringToCharPtr(id);
z->length = injectionsIds.size();
z->injections_ids = new char*[injectionsIds.size()];
z->injections_ids = initializeCharPointerPointer(injectionsIds.size());
z->injections_ids_count = injectionsIds.size();
for (int i = 0; i < injectionsIds.size(); i++) {
z->injections_ids[i] = copyStringToCharPtr(injectionsIds[i]);
}
z->injections_shift_keys = new double[injectionsShiftKeys.size()];
z->injections_shift_keys = initializeDoublePointer(injectionsShiftKeys.size());
for (int i = 0; i < injectionsIds.size(); i++) {
z->injections_shift_keys[i] = injectionsShiftKeys[i];
}
return z;
}

void deleteZone(::zone* z) {
delete[] z->id;
for (int i = 0; i < z->length; i++) {
delete[] z->injections_ids[i];
}
delete[] z->injections_ids;
delete[] z->injections_shift_keys;
freeCharPointer(z->id);
freeCharPointerPointer(z->injections_ids);
freeDoublePointer(z->injections_shift_keys);
}

class ZonesPtr {
Expand Down Expand Up @@ -1223,20 +1192,20 @@ void NadParameters::nad_to_c_struct(nad_parameters& res) const {
}

std::shared_ptr<sld_parameters> SldParameters::to_c_struct() const {
sld_parameters* res = new sld_parameters();
sld_parameters* res = PowsyblCaller::get()->callJava<sld_parameters*>(::createSldParameters);
sld_to_c_struct(*res);
//Memory has been allocated here on C side, we need to clean it up on C side (not java side)
return std::shared_ptr<sld_parameters>(res, [](sld_parameters* ptr){
delete ptr;
PowsyblCaller::get()->callJava(::freeSldParameters, ptr);
});
}

std::shared_ptr<nad_parameters> NadParameters::to_c_struct() const {
nad_parameters* res = new nad_parameters();
nad_parameters* res = PowsyblCaller::get()->callJava<nad_parameters*>(::createNadParameters);
nad_to_c_struct(*res);
//Memory has been allocated here on C side, we need to clean it up on C side (not java side)
return std::shared_ptr<nad_parameters>(res, [](nad_parameters* ptr){
delete ptr;
PowsyblCaller::get()->callJava(::freeNadParameters, ptr);
});
}

Expand Down Expand Up @@ -1358,7 +1327,7 @@ ShortCircuitAnalysisParameters::ShortCircuitAnalysisParameters(shortcircuit_anal
}

std::shared_ptr<shortcircuit_analysis_parameters> ShortCircuitAnalysisParameters::to_c_struct() const {
shortcircuit_analysis_parameters* res = new shortcircuit_analysis_parameters();
shortcircuit_analysis_parameters* res = PowsyblCaller::get()->callJava<shortcircuit_analysis_parameters*>(::createShortCircuitAnalysisParameters);
res->with_voltage_result = (bool) with_voltage_result;
res->with_feeder_result = (bool) with_feeder_result;
res->with_limit_violations = (bool) with_limit_violations;
Expand All @@ -1371,10 +1340,9 @@ std::shared_ptr<shortcircuit_analysis_parameters> ShortCircuitAnalysisParameters
res->provider_parameters_values = pypowsybl::copyVectorStringToCharPtrPtr(provider_parameters_values);
res->provider_parameters_values_count = provider_parameters_values.size();

//Memory has been allocated here on C side, we need to clean it up on C side (not java side)
return std::shared_ptr<shortcircuit_analysis_parameters>(res, [](shortcircuit_analysis_parameters* ptr){
deleteShortCircuitAnalysisParameters(ptr);
delete ptr;
PowsyblCaller::get()->callJava(::freeShortCircuitAnalysisParameters, ptr);
});
}

Expand Down Expand Up @@ -1508,4 +1476,60 @@ JavaHandle runVoltageInitializer(bool debug, const JavaHandle& networkHandle, co
return pypowsybl::PowsyblCaller::get()->callJava<JavaHandle>(::runVoltageInitializer, debug, networkHandle, paramsHandle);
}

SeriesArray* initializeSeriesArrayObject(int columnsNumber) {
return new SeriesArray(pypowsybl::PowsyblCaller::get()->callJava<array*>(::initializeSeriesArray, columnsNumber));
}

DataframesArray* initializeDataframesArray(int columnsNumber) {
return new DataframesArray(pypowsybl::PowsyblCaller::get()->callJava<array*>(::initializeDataframeArray, columnsNumber));
}

char** initializeCharPointerPointer(int size) {
return pypowsybl::PowsyblCaller::get()->callJava<char**>(::initializeCharCharPointer, size);
}

void freeCharPointerPointer(char** charPointerPointer) {
pypowsybl::PowsyblCaller::get()->callJava(::freeCharCharPointer, charPointerPointer);
}

char* initializeCharPointer(int size) {
return pypowsybl::PowsyblCaller::get()->callJava<char*>(::initializeCharPointer, size);
}

void freeCharPointer(char* charPointer) {
pypowsybl::PowsyblCaller::get()->callJava(::freeCharPointer, charPointer);
}

int* initializeIntPointer(int size) {
return pypowsybl::PowsyblCaller::get()->callJava<int*>(::initializeIntPointer, size);
}

void freeIntPointer(int* intPointer) {
pypowsybl::PowsyblCaller::get()->callJava(::freeIntPointer, intPointer);
}

double* initializeDoublePointer(double size) {
return pypowsybl::PowsyblCaller::get()->callJava<double*>(::initializeDoublePointer, size);
}

void freeDoublePointer(double* doublePointer) {
pypowsybl::PowsyblCaller::get()->callJava(::freeDoublePointer, doublePointer);
}

dataframe* initializeDataframePointer() {
return pypowsybl::PowsyblCaller::get()->callJava<dataframe*>(::initializeDataframePointer);
}

void freeDataframePointer(dataframe* dataframe) {
pypowsybl::PowsyblCaller::get()->callJava(::freeDataframePointer, dataframe);
}

dataframe_array* initializeDataframeArrayPointer() {
return pypowsybl::PowsyblCaller::get()->callJava<dataframe_array*>(::initializeDataframeArrayObject);
}

void freeDataframeArrayPointer(dataframe_array* dataframe_array) {
pypowsybl::PowsyblCaller::get()->callJava(::freeDataframeArrayObject, dataframe_array);
}

}
16 changes: 15 additions & 1 deletion cpp/powsybl-cpp/powsybl-cpp.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -190,6 +190,7 @@ typedef Array<post_contingency_result> PostContingencyResultArray;
typedef Array<operator_strategy_result> OperatorStrategyResultArray;
typedef Array<limit_violation> LimitViolationArray;
typedef Array<series> SeriesArray;
typedef Array<dataframe> DataframesArray;


template<typename T>
Expand Down Expand Up @@ -788,6 +789,19 @@ SeriesArray* getFaultResults(const JavaHandle& shortCircuitAnalysisResult, bool
SeriesArray* getFeederResults(const JavaHandle& shortCircuitAnalysisResult, bool withFortescueResult);
SeriesArray* getShortCircuitLimitViolations(const JavaHandle& shortCircuitAnalysisResult);
SeriesArray* getShortCircuitBusResults(const JavaHandle& shortCircuitAnalysisResult, bool withFortescueResult);

SeriesArray* initializeSeriesArrayObject(int columnsNumber);
DataframesArray* initializeDataframesArray(int columnsNumber);
char** initializeCharPointerPointer(int size);
void freeCharPointerPointer(char** charPointerPointer);
char* initializeCharPointer(int size);
void freeCharPointer(char* charPointer);
int* initializeIntPointer(int size);
void freeIntPointer(int* intPointer);
double* initializeDoublePointer(double size);
void freeDoublePointer(double* doublePointer);
dataframe* initializeDataframePointer();
void freeDataframePointer(dataframe* dataframe);
dataframe_array* initializeDataframeArrayPointer();
void freeDataframeArrayPointer(dataframe_array* dataframe_array);
}
#endif //PYPOWSYBL_H
Loading

0 comments on commit dcb32b2

Please sign in to comment.