{

try

{

return (*f)(std::forward<Args>(args)...);

}

catch(const std::runtime_error& re)

{

std::string errorMsg;

size_t start_pos = std::string(re.what()).find("$id");

if(start_pos == std::string::npos)

{

errorMsg = std::string("Error occurred when setting ") + identifier + ". " + re.what();

}

else

{

errorMsg = re.what();

errorMsg.replace(start_pos, 3, identifier);

}

throw std::runtime_error(errorMsg);

}

{

public:

py::function function;

Library(const py::function function){

this->function = function;

};

void setOutput(py::tuple& result, std::vector<double>& output, double *outputSize)

{

int nRows = 0, idx = 0;

for (py::handle rowHandle : result[0])

{

py::list rows = py::cast<py::list>(rowHandle);

for (py::handle value : rows)

{

output.push_back(py::cast<double>(value));

idx++;

}

nRows++;

}

outputSize[0] = nRows;

outputSize[1] = (nRows == 0) ? 0 : idx / nRows;

}

// Domain overload

void invoke(std::vector<double>& params, std::vector<double>& bulkIn, std::vector<double>& bulkOut,

int contrast, int domainNumber, std::vector<double>& output, double *outputSize, double *roughness)

{

auto f = py::cast<std::function<py::tuple(py::list, py::list, py::list, int, int)>>(this->function);

auto result = f(py::cast(params), py::cast(bulkIn), py::cast(bulkOut), contrast, domainNumber);

*roughness = py::cast<double>(result[1]);

setOutput(result, output, outputSize);

};

// Non-Domain overload

void invoke(std::vector<double>& params, std::vector<double>& bulkIn, std::vector<double>& bulkOut,

int contrast, std::vector<double>& output, double *outputSize, double *roughness)

{

auto f = py::cast<std::function<py::tuple(py::list, py::list, py::list, int)>>(this->function);

auto result = f(py::cast(params), py::cast(bulkIn), py::cast(bulkOut), contrast);

*roughness = py::cast<double>(result[1]);

setOutput(result, output, outputSize);

};

{

public:

std::unique_ptr<dylib> library;

std::string functionName;

DylibEngine(std::string libName, std::string functionName)

{

this->functionName = functionName;

this->library = std::unique_ptr<dylib>(new dylib(libName));

if (!library)

{

std::cerr << "dynamic library failed to load" << std::endl;

return;

}

};

~DylibEngine(){};

py::tuple invoke(std::vector<double>& params, std::vector<double>& bulkIn, std::vector<double>& bulkOut, int contrast, int domain=DEFAULT_DOMAIN)

{

try{

std::vector<double> tempOutput;

double *outputSize = new double[2];

double roughness = 0.0;

if (domain != -1) {

auto func = library->get_function<void(std::vector<double>&, std::vector<double>&, std::vector<double>&,

int, int, std::vector<double>&, double*, double*)>(functionName);

func(params, bulkIn, bulkOut, contrast, domain, tempOutput, outputSize, &roughness);

}

else {

auto func = library->get_function<void(std::vector<double>&, std::vector<double>&, std::vector<double>&,

int, std::vector<double>&, double*, double*)>(functionName);

func(params, bulkIn, bulkOut, contrast, tempOutput, outputSize, &roughness);

}

py::list output;

for (int32_T idx1{0}; idx1 < outputSize[0]; idx1++)

{

py::list rows;

for (int32_T idx2{0}; idx2 < outputSize[1]; idx2++)

{

rows.append(tempOutput[(int32_T)outputSize[1] * idx1 + idx2]);

}

output.append(rows);

}

return py::make_tuple(output, roughness);

}catch (const dylib::symbol_error &) {

throw std::runtime_error("failed to get dynamic library symbol for " + functionName);

}

};

{

std::string message;

double percent;

{

py::list reflectivity;

py::list shiftedData;

py::list sldProfiles;

py::list resampledLayers;

py::array_t<double> subRoughs;

py::array_t<double> resample;

py::array_t<double> dataPresent;

std::string modelType;

py::list contrastNames;

{

public:

std::unique_ptr<dylib> library;

py::function callback;

EventBridge(py::function callback)

{

std::string filename = "eventManager" + std::string(dylib::extension);

this->library = std::unique_ptr<dylib>(new dylib(std::getenv("RAT_PATH"), filename.c_str()));

if (!library)

{

std::cerr << "event manager dynamic library failed to load" << std::endl;

return;

}

this->callback = callback;

};

py::list unpackDataToCell(int rows, int cols, double* data, double* nData,

double* data2, double* nData2, bool isOutput2D=false)

{

py::list allResults;

int dims[2] = {0, 0};

int offset = 0;

for (int i = 0; i < rows; i++){

dims[0] = (int)nData[2*i];

dims[1] = (int)nData[2*i+1];

auto result = py::array_t<double, py::array::f_style>({dims[0], dims[1]});

std::memcpy(result.request().ptr, data + offset, result.nbytes());

offset += result.size();

if (isOutput2D){

py::list rowList;

rowList.append(result);

allResults.append(rowList);

}

else{

allResults.append(result);

}

}

if (data2 != NULL && nData2 != NULL)

{

// This is used to unpack the domains data into the second column

offset = 0;

for ( int i = 0; i < rows; i++){

dims[0] = (int)nData2[2*i];

dims[1] = (int)nData2[2*i+1];

auto result = py::array_t<double, py::array::f_style>({dims[0], dims[1]});

std::memcpy(result.request().ptr, data2 + offset, result.nbytes());

offset += result.size();

auto rowList = allResults[i].cast<py::list>();

rowList.append(result);

}

}

return allResults;

};

void eventCallback(const baseEvent& event)

{

if (event.type == EventTypes::Message) {

messageEvent* mEvent = (messageEvent*)&event;

this->callback(event.type, mEvent->msg);

} else if (event.type == EventTypes::Progress){

progressEvent* pEvent = (progressEvent*)&event;

ProgressEventData eventData;

eventData.message = pEvent->msg;

eventData.percent = pEvent->percent;

this->callback(event.type, eventData);

} else if (event.type == EventTypes::Plot){

plotEvent* pEvent = (plotEvent*)&event;

PlotEventData eventData;

eventData.modelType = std::string(pEvent->data->modelType);

eventData.subRoughs = py::array_t<double>(pEvent->data->nContrast);

std::memcpy(eventData.subRoughs.request().ptr, pEvent->data->subRoughs, eventData.subRoughs.nbytes());

eventData.resample = py::array_t<double>(pEvent->data->nContrast);

std::memcpy(eventData.resample.request().ptr, pEvent->data->resample, eventData.resample.nbytes());

eventData.dataPresent = py::array_t<double>(pEvent->data->nContrast);

std::memcpy(eventData.dataPresent.request().ptr, pEvent->data->dataPresent, eventData.dataPresent.nbytes());

eventData.reflectivity = unpackDataToCell(pEvent->data->nContrast, 1,

pEvent->data->reflect, pEvent->data->nReflect, NULL, NULL);

eventData.shiftedData = unpackDataToCell(pEvent->data->nContrast, 1,

pEvent->data->shiftedData, pEvent->data->nShiftedData, NULL, NULL);

eventData.sldProfiles = unpackDataToCell(pEvent->data->nContrast, (pEvent->data->nSldProfiles2 == NULL) ? 1 : 2,

pEvent->data->sldProfiles, pEvent->data->nSldProfiles,

pEvent->data->sldProfiles2, pEvent->data->nSldProfiles2, true);

eventData.resampledLayers = unpackDataToCell(pEvent->data->nContrast, (pEvent->data->nLayers2 == NULL) ? 1 : 2,

pEvent->data->layers, pEvent->data->nLayers,

pEvent->data->layers2, pEvent->data->nLayers2, true);

int offset = 0;

for (int i = 0; i < pEvent->data->nContrast; i++){

eventData.contrastNames.append(std::string(pEvent->data->contrastNames + offset,

pEvent->data->nContrastNames[i]));

offset += pEvent->data->nContrastNames[i];

}

this->callback(event.type, eventData);

}

};

void registerEvent(EventTypes eventType)

{

std::function<void(const baseEvent& event)> caller = std::bind(&EventBridge::eventCallback, this, std::placeholders::_1);

auto addListener = library->get_function<void(EventTypes, std::function<void(const baseEvent&)>)>("addListener");

addListener(eventType, caller);

};

void clear()

{

auto clearListeners = library->get_function<void(void)>("clearListeners");

clearListeners();

};

{

py::list reflectivity;

py::list sld;

py::list reflectivityXData;

py::list sldXData;

py::array_t<real_T> sampleChi;

{

py::array_t<real_T> percentile95;

py::array_t<real_T> percentile65;

py::array_t<real_T> mean;

{

real_T logZ;

py::array_t<real_T> nestSamples;

py::array_t<real_T> postSamples;

{

real_T nParams;

real_T nChains;

real_T nGenerations;

boolean_T parallel;

real_T CPU;

real_T jumpProbability;

real_T pUnitGamma;

real_T nCR;

real_T delta;

real_T steps;

real_T zeta;

std::string outlier;

boolean_T adaptPCR;

real_T thinning;

real_T epsilon;

boolean_T ABC;

boolean_T IO;

boolean_T storeOutput;

py::array_t<real_T> R;

{

py::array_t<real_T> allChains;

py::array_t<real_T> outlierChains;

real_T runtime;

real_T iteration;

real_T modelOutput;

py::array_t<real_T> AR;

py::array_t<real_T> R_stat;

py::array_t<real_T> CR;

{

PredictionIntervals predictionIntervals;

ConfidenceIntervals confidenceIntervals;

DreamParams dreamParams;

DreamOutput dreamOutput;

NestedSamplerOutput nestedSamplerOutput;

py::array_t<real_T> chain;

{

py::list param;

py::list backgroundParam;

py::list resolutionParam;

py::list bulkIn;

py::list bulkOut;

py::list qzshift;

py::list scalefactor;

py::list domainRatio;

py::list priorNames;

py::array_t<real_T> priorValues;

py::array_t<real_T> fitParam;

py::array_t<real_T> fitBackgroundParam;

py::array_t<real_T> fitQzshift;

py::array_t<real_T> fitScalefactor;

py::array_t<real_T> fitBulkIn;

py::array_t<real_T> fitBulkOut;

py::array_t<real_T> fitResolutionParam;

py::array_t<real_T> fitDomainRatio;

{

py::array_t<real_T> chiValues;

real_T sumChi;

{

py::array_t<real_T> backgroundParams;

py::array_t<real_T> scalefactors;

py::array_t<real_T> bulkIn;

py::array_t<real_T> bulkOut;

py::array_t<real_T> resolutionParams;

py::array_t<real_T> subRoughs;

py::array_t<real_T> resample;

py::list reflectivity;

py::list simulation;

py::list shiftedData;

py::list layerSlds;

py::list sldProfiles;

py::list resampledLayers;

Calculation calculationResults {};

ContrastParams contrastParams;

py::array_t<real_T> fitParams;

py::list fitNames;

py::array_t<real_T> param;

py::array_t<real_T> backgroundParam;

py::array_t<real_T> scalefactor;

py::array_t<real_T> qzshift;

py::array_t<real_T> bulkIn;

py::array_t<real_T> bulkOut;

py::array_t<real_T> resolutionParam;

py::array_t<real_T> domainRatio;

py::list f1;

py::list f2;

py::list f3;

py::list f4;

py::list f5;

py::list f6;

py::list f7;

py::list f8;

py::list f9;

py::list f10;

py::list f11;

py::list f12;

py::list f13;

py::list f14;

py::list f15;

py::list f16;

py::list f17;

py::list f18;

py::list f19;

py::list f20;

py::list f21;

py::array_t<real_T> contrastBackgroundParams;

py::array_t<real_T> contrastBackgroundActions;

std::string TF {};

py::array_t<real_T> resample;

py::array_t<real_T> dataPresent;

py::array_t<real_T> oilChiDataPresent;

real_T numberOfContrasts;

std::string geometry {};

bool useImaginary {};

py::array_t<real_T> contrastQzshifts;

py::array_t<real_T> contrastScalefactors;

py::array_t<real_T> contrastBulkIns;

py::array_t<real_T> contrastBulkOuts;

py::array_t<real_T> contrastResolutionParams;

py::array_t<real_T> backgroundParams;

py::array_t<real_T> qzshifts;

py::array_t<real_T> scalefactors;

py::array_t<real_T> bulkIn;

py::array_t<real_T> bulkOut;

py::array_t<real_T> resolutionParams;

py::array_t<real_T> params;

real_T numberOfLayers {};

std::string modelType {};

py::array_t<real_T> contrastCustomFiles;

py::array_t<real_T> contrastDomainRatios;

py::array_t<real_T> domainRatio;

real_T numberOfDomainContrasts {};

py::array_t<real_T> fitParams;

py::array_t<real_T> otherParams;

py::array_t<real_T> fitLimits;

py::array_t<real_T> otherLimits;

std::string parallel {};

std::string procedure {};

std::string display {};

real_T xTolerance {};

real_T funcTolerance {};

real_T maxFuncEvals {};

real_T maxIterations {};

real_T populationSize {};

real_T fWeight {};

real_T crossoverProbability {};

real_T targetValue {};

real_T numGenerations {};

real_T strategy {};

real_T nLive {};

real_T nMCMC {};

real_T propScale {};

real_T nsTolerance {};

boolean_T calcSldDuringFit {};

py::array_t<real_T> resampleParams;

real_T updateFreq {};

real_T updatePlotFreq {};

real_T nSamples {};

real_T nChains {};

real_T jumpProbability {};

real_T pUnitGamma {};

std::string boundHandling {};

boolean_T adaptPCR;

Checks checks {};

{

result_size[0] = 1;

result_size[1] = value.length();

for (int32_T idx1{0}; idx1 < value.length(); idx1++) {

result_data[idx1] = value[idx1];

}

{

result.set_size(1, value.length());

for (int32_T idx{0}; idx < value.length(); idx++) {

result[idx] = value[idx];

}

{

coder::array<real_T, 2U> result;

py::buffer_info buffer_info = value.request();

if (buffer_info.size == 0)

return result;

if (buffer_info.ndim != 1)

throw std::runtime_error("Expects a 1D numeric array");

result.set_size(1, buffer_info.shape[0]);

for (int32_T idx0{0}; idx0 < buffer_info.shape[0]; idx0++) {

result[idx0] = value.at(idx0);

}

return result;

{

coder::bounded_array<real_T, 10U, 2U> result {};

py::buffer_info buffer_info = value.request();

if (buffer_info.size == 0)

return result;

if (buffer_info.ndim != 1)

throw std::runtime_error("Expects a 1D numeric array");

result.size[0] = 1;

result.size[1] = buffer_info.shape[0];

for (int32_T idx0{0}; idx0 < buffer_info.shape[0]; idx0++) {

result.data[idx0] = value.at(idx0);

}

return result;

{

coder::array<real_T, 2U> result;

py::buffer_info buffer_info = value.request();

if (buffer_info.size == 0)

return result;

if (buffer_info.ndim != 2)

throw std::runtime_error("Expects a 2D numeric array");

result.set_size(buffer_info.shape[0], buffer_info.shape[1]);

int32_T idx {0};

for (int32_T idx0{0}; idx0 < buffer_info.shape[0]; idx0++) {

for (int32_T idx1{0}; idx1 < buffer_info.shape[1]; idx1++) {

idx = idx0 + result.size(0) * idx1;

result[idx] = value.at(idx0, idx1);

}

}

return result;

{

coder::array<RAT::cell_0, 1U> result;

result.set_size(values.size());

int32_T idx {0};

for (py::handle list: values)

{

py::list value = py::cast<py::list>(list);

if (py::len(list) != 4 || !py::isinstance<py::str>(value[0]) || !py::isinstance<py::str>(value[1]) ||

!py::isinstance<py::float_>(value[2]) || !py::isinstance<py::float_>(value[3]))

throw std::runtime_error("Expects a 2D list where each row must contain 4 elements. "

"Columns 1 and 2 must be strings and Columns 3 and 4 must be numeric arrays");

stringToRatCharArray(value[0].cast<std::string>(), result[idx].f1);

stringToRatCharArray(value[1].cast<std::string>(), result[idx].f2);

result[idx].f3 = value[2].cast<real_T>();

result[idx].f4 = value[3].cast<real_T>();

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_1, 1U> result;

result.set_size(values.size());

int32_T idx {0};

for (py::handle list: values)

{

if (py::isinstance<py::str>(list)) {

std::string value = py::cast<std::string>(list);

stringToRatCharArray(value, result[idx].f1);

idx++;

}

else

throw std::runtime_error("Expects a 1D list of strings");

}

return result;

{

RAT::struct0_T problem_struct;

problem_struct.useImaginary = problem.useImaginary;

problem_struct.numberOfLayers = problem.numberOfLayers;

problem_struct.numberOfDomainContrasts = problem.numberOfDomainContrasts;

problem_struct.numberOfContrasts = problem.numberOfContrasts;

stringToRatArray(problem.modelType, problem_struct.modelType.data, problem_struct.modelType.size);

stringToRatArray(problem.geometry, problem_struct.geometry.data, problem_struct.geometry.size);

stringToRatArray(problem.TF, problem_struct.TF.data, problem_struct.TF.size);

problem_struct.contrastBackgroundParams = customCaller("Problem.contrastBackgroundParams", pyArrayToRatArray1d, problem.contrastBackgroundParams);

problem_struct.contrastBackgroundActions = customCaller("Problem.contrastBackgroundActions", pyArrayToRatArray1d, problem.contrastBackgroundActions);

problem_struct.resample = customCaller("Problem.resample", pyArrayToRatArray1d, problem.resample);

problem_struct.dataPresent = customCaller("Problem.dataPresent", pyArrayToRatArray1d, problem.dataPresent);

problem_struct.oilChiDataPresent = customCaller("Problem.oilChiDataPresent", pyArrayToRatArray1d, problem.oilChiDataPresent);

problem_struct.contrastQzshifts = customCaller("Problem.contrastQzshifts", pyArrayToRatArray1d, problem.contrastQzshifts);

problem_struct.contrastScalefactors = customCaller("Problem.contrastScalefactors", pyArrayToRatArray1d, problem.contrastScalefactors);

problem_struct.contrastBulkIns = customCaller("Problem.contrastBulkIns", pyArrayToRatArray1d, problem.contrastBulkIns);

problem_struct.contrastBulkOuts = customCaller("Problem.contrastBulkOuts", pyArrayToRatArray1d, problem.contrastBulkOuts);

problem_struct.contrastResolutionParams = customCaller("Problem.contrastResolutionParams", pyArrayToRatArray1d, problem.contrastResolutionParams);

problem_struct.backgroundParams = customCaller("Problem.backgroundParams", pyArrayToRatArray1d, problem.backgroundParams);

problem_struct.qzshifts = customCaller("Problem.qzshifts", pyArrayToRatArray1d, problem.qzshifts);

problem_struct.scalefactors = customCaller("Problem.scalefactors", pyArrayToRatArray1d, problem.scalefactors);

problem_struct.bulkIn = customCaller("Problem.bulkIn", pyArrayToRatArray1d, problem.bulkIn);

problem_struct.bulkOut = customCaller("Problem.bulkOut", pyArrayToRatArray1d, problem.bulkOut);

problem_struct.resolutionParams = customCaller("Problem.resolutionParams", pyArrayToRatArray1d, problem.resolutionParams);

problem_struct.params = customCaller("Problem.params", pyArrayToRatArray1d, problem.params);

problem_struct.contrastCustomFiles = customCaller("Problem.contrastCustomFiles", pyArrayToRatArray1d, problem.contrastCustomFiles);

problem_struct.contrastDomainRatios = customCaller("Problem.contrastDomainRatios", pyArrayToRatArray1d, problem.contrastDomainRatios);

problem_struct.domainRatio = customCaller("Problem.domainRatio", pyArrayToRatArray1d, problem.domainRatio);

problem_struct.fitParams = customCaller("Problem.fitParams", pyArrayToRatArray1d, problem.fitParams);

problem_struct.otherParams = customCaller("Problem.otherParams", pyArrayToRatArray1d, problem.otherParams);

problem_struct.fitLimits = customCaller("Problem.fitLimits", pyArrayToRatArray2d, problem.fitLimits);

problem_struct.otherLimits = customCaller("Problem.otherLimits", pyArrayToRatArray2d, problem.otherLimits);

return problem_struct;

{

RAT::struct1_T limits_struct;

limits_struct.param = customCaller("Limits.param", pyArrayToRatArray2d, limits.param);

limits_struct.backgroundParam = customCaller("Limits.backgroundParam", pyArrayToRatArray2d, limits.backgroundParam);

limits_struct.qzshift = customCaller("Limits.qzshift", pyArrayToRatArray2d, limits.qzshift);

limits_struct.scalefactor = customCaller("Limits.scalefactor", pyArrayToRatArray2d, limits.scalefactor);

limits_struct.bulkIn = customCaller("Limits.bulkIn", pyArrayToRatArray2d, limits.bulkIn);

limits_struct.bulkOut = customCaller("Limits.bulkOut", pyArrayToRatArray2d, limits.bulkOut);

limits_struct.resolutionParam = customCaller("Limits.resolutionParam", pyArrayToRatArray2d, limits.resolutionParam);

limits_struct.domainRatio = customCaller("Limits.domainRatio", pyArrayToRatArray2d, limits.domainRatio);

return limits_struct;

{

RAT::struct3_T checks_struct;

checks_struct.fitParam = customCaller("Checks.fitParam", pyArrayToRatArray1d, checks.fitParam);

checks_struct.fitBackgroundParam = customCaller("Checks.fitBackgroundParam", pyArrayToRatArray1d, checks.fitBackgroundParam);

checks_struct.fitQzshift = customCaller("Checks.fitQzshift", pyArrayToRatArray1d, checks.fitQzshift);

checks_struct.fitScalefactor = customCaller("Checks.fitScalefactor", pyArrayToRatArray1d, checks.fitScalefactor);

checks_struct.fitBulkIn = customCaller("Checks.fitBulkIn", pyArrayToRatArray1d, checks.fitBulkIn);

checks_struct.fitBulkOut = customCaller("Checks.fitBulkOut", pyArrayToRatArray1d, checks.fitBulkOut);

checks_struct.fitResolutionParam = customCaller("Checks.fitResolutionParam", pyArrayToRatArray1d, checks.fitResolutionParam);

checks_struct.fitDomainRatio = customCaller("Checks.fitDomainRatio", pyArrayToRatArray1d, checks.fitDomainRatio);

return checks_struct;

{

RAT::struct4_T priors_struct;

priors_struct.param = customCaller("Priors.param", pyListToUnboundedCell0, priors.param);

priors_struct.backgroundParam = customCaller("Priors.backgroundParam", pyListToUnboundedCell0, priors.backgroundParam);

priors_struct.resolutionParam = customCaller("Priors.resolutionParam", pyListToUnboundedCell0, priors.resolutionParam);

priors_struct.qzshift = customCaller("Priors.qzshift", pyListToUnboundedCell0, priors.qzshift);

priors_struct.scalefactor = customCaller("Priors.scalefactor", pyListToUnboundedCell0, priors.scalefactor);

priors_struct.bulkIn = customCaller("Priors.bulkIn", pyListToUnboundedCell0, priors.bulkIn);

priors_struct.bulkOut = customCaller("Priors.bulkOut", pyListToUnboundedCell0, priors.bulkOut);

priors_struct.domainRatio = customCaller("Priors.domainRatio", pyListToUnboundedCell0, priors.domainRatio);

priors_struct.priorNames = customCaller("Priors.priorNames", pyListToUnboundedCell1, priors.priorNames);

priors_struct.priorValues = customCaller("Priors.priorValues", pyArrayToRatArray2d, priors.priorValues);

return priors_struct;

{

coder::array<RAT::cell_wrap_2, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

py::array_t<real_T> casted_array = py::cast<py::array>(array);

if (casted_array.size() != 2)

throw std::runtime_error("Expects a 2D list where each row contains exactly 2 numbers");

result[idx].f1[0] = casted_array.at(0);

result[idx].f1[1] = casted_array.at(1);

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_3, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

py::array_t<real_T> casted_array = py::cast<py::array>(array);

result[idx].f1 = customCaller("$id[" + std::to_string(idx) +"]", pyArrayToRatArray2d, casted_array);

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_4, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

py::array_t<real_T> casted_array = py::cast<py::array>(array);

result[idx].f1 = customCaller("$id[" + std::to_string(idx) +"]", pyArrayToRatArray1d, casted_array);

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_5, 1U> result;

result.set_size(values.size());

int32_T idx {0};

for (py::handle array: values)

{

py::array_t<real_T> casted_array = py::cast<py::array>(array);

result[idx].f1 = customCaller("$id[" + std::to_string(idx) +"]", pyArrayToRatBoundedArray, casted_array);

idx++;

}

return result;

{

coder::array<RAT::cell_wrap_6, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

if (py::isinstance<py::str>(array)) {

std::string name = py::cast<std::string>(array);

stringToRatArray(name, result[idx].f1.data, result[idx].f1.size);

idx++;

}

else

throw std::runtime_error("Expects a 1D list of strings");

}

return result;

{

coder::array<RAT::cell_wrap_6, 2U> result;

result.set_size(1, values.size());

int32_T idx {0};

for (py::handle array: values)

{

auto func = py::cast<py::function>(array);

std::string func_ptr = convertPtr2String<CallbackInterface>(new Library(func));

stringToRatArray(func_ptr, result[idx].f1.data, result[idx].f1.size);

idx++;

}

return result;

{

RAT::cell_7 cells_struct;

cells_struct.f1 = customCaller("Cells.f1", pyListToRatCellWrap2, cells.f1);

cells_struct.f2 = customCaller("Cells.f2", pyListToRatCellWrap3, cells.f2);

cells_struct.f3 = customCaller("Cells.f3", pyListToRatCellWrap2, cells.f3);

cells_struct.f4 = customCaller("Cells.f4", pyListToRatCellWrap2, cells.f4);

cells_struct.f5 = customCaller("Cells.f5", pyListToRatCellWrap4, cells.f5);

cells_struct.f6 = customCaller("Cells.f6", pyListToRatCellWrap5, cells.f6);

cells_struct.f7 = customCaller("Cells.f7", pyListToRatCellWrap6, cells.f7);

cells_struct.f8 = customCaller("Cells.f8", pyListToRatCellWrap6, cells.f8);

cells_struct.f9 = customCaller("Cells.f9", pyListToRatCellWrap6, cells.f9);

cells_struct.f10 = customCaller("Cells.f10", pyListToRatCellWrap6, cells.f10);

cells_struct.f11 = customCaller("Cells.f11", pyListToRatCellWrap6, cells.f11);

cells_struct.f12 = customCaller("Cells.f12", pyListToRatCellWrap6, cells.f12);

cells_struct.f13 = customCaller("Cells.f13", pyListToRatCellWrap6, cells.f13);

cells_struct.f14 = customCaller("Cells.f14", py_function_array_to_rat_cell_wrap_6, cells.f14);

cells_struct.f15 = customCaller("Cells.f15", pyListToRatCellWrap6, cells.f15);

cells_struct.f16 = customCaller("Cells.f16", pyListToRatCellWrap6, cells.f16);

cells_struct.f17 = customCaller("Cells.f17", pyListToRatCellWrap3, cells.f17);

cells_struct.f18 = customCaller("Cells.f18", pyListToRatCellWrap2, cells.f18);

cells_struct.f19 = customCaller("Cells.f19", pyListToRatCellWrap4, cells.f19);

cells_struct.f20 = customCaller("Cells.f20", pyListToRatCellWrap6, cells.f20);

cells_struct.f21 = customCaller("Cells.f21", pyListToRatCellWrap6, cells.f21);

return cells_struct;

{

RAT::struct2_T control_struct;

control_struct.funcTolerance = control.funcTolerance;

control_struct.maxFuncEvals = control.maxFuncEvals;

control_struct.maxIterations = control.maxIterations;

control_struct.populationSize = control.populationSize;

control_struct.fWeight = control.fWeight;

control_struct.crossoverProbability = control.crossoverProbability;

control_struct.targetValue = control.targetValue;

control_struct.numGenerations = control.numGenerations;

control_struct.strategy = control.strategy;

control_struct.nLive = control.nLive;

control_struct.nMCMC = control.nMCMC;

control_struct.propScale = control.propScale;

control_struct.nsTolerance = control.nsTolerance;

control_struct.calcSldDuringFit = control.calcSldDuringFit;

control_struct.updateFreq = control.updateFreq;

control_struct.updatePlotFreq = control.updatePlotFreq;

control_struct.nSamples = control.nSamples;

control_struct.nChains = control.nChains;

control_struct.jumpProbability = control.jumpProbability;

control_struct.pUnitGamma = control.pUnitGamma;

stringToRatArray(control.parallel, control_struct.parallel.data, control_struct.parallel.size);

stringToRatArray(control.procedure, control_struct.procedure.data, control_struct.procedure.size);

stringToRatArray(control.display, control_struct.display.data, control_struct.display.size);

control_struct.xTolerance = control.xTolerance;

control_struct.resampleParams[0] = control.resampleParams.at(0);

control_struct.resampleParams[1] = control.resampleParams.at(1);

stringToRatArray(control.boundHandling, control_struct.boundHandling.data, control_struct.boundHandling.size);

control_struct.adaptPCR = control.adaptPCR;

control_struct.checks = createStruct3(control.checks);

return control_struct;

{

auto size = (array.size(0) > 1) ? array.size(0) : array.size(1);

auto result_array = py::array_t<real_T>(size);

std::memcpy(result_array.request().ptr, array.data(), result_array.nbytes());

return result_array;

{

auto result_array = py::array_t<real_T, py::array::f_style>({array.size(0), array.size(1)});

std::memcpy(result_array.request().ptr, array.data(), result_array.nbytes());

return result_array;

{

// Copy problem to output

OutputResult output_result;

for (int32_T idx0{0}; idx0 < result.reflectivity.size(0); idx0++) {

auto tmp = result.reflectivity[idx0];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

output_result.reflectivity.append(array);

}

for (int32_T idx0{0}; idx0 < result.simulation.size(0); idx0++) {

auto tmp = result.simulation[idx0];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

output_result.simulation.append(array);

}

for (int32_T idx0{0}; idx0 < result.shiftedData.size(0); idx0++) {

auto tmp = result.shiftedData[idx0];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

output_result.shiftedData.append(array);

}

for (int32_T idx0{0}; idx0 < result.layerSlds.size(0); idx0++) {

py::list inner_list;

for (int32_T idx1{0}; idx1 < result.layerSlds.size(1); idx1++) {

auto tmp = result.layerSlds[idx0 + result.layerSlds.size(0) * idx1];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

inner_list.append(array);

}

output_result.layerSlds.append(inner_list);

}

for (int32_T idx0{0}; idx0 < result.sldProfiles.size(0); idx0++) {

py::list inner_list;

for (int32_T idx1{0}; idx1 < result.sldProfiles.size(1); idx1++) {

auto tmp = result.sldProfiles[idx0 + result.sldProfiles.size(0) * idx1];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

inner_list.append(array);

}

output_result.sldProfiles.append(inner_list);

}

for (int32_T idx0{0}; idx0 < result.resampledLayers.size(0); idx0++) {

py::list inner_list;

for (int32_T idx1{0}; idx1 < result.resampledLayers.size(1); idx1++) {

auto tmp = result.resampledLayers[idx0 + result.resampledLayers.size(0) * idx1];

auto array = py::array_t<real_T, py::array::f_style>({tmp.f1.size(0), tmp.f1.size(1)});

std::memcpy(array.request().ptr, tmp.f1.data(), array.nbytes());

inner_list.append(array);

}

output_result.resampledLayers.append(inner_list);

}

for (int32_T idx0{0}; idx0 < result.fitNames.size(0); idx0++) {

auto tmp = result.fitNames[idx0];

std::string str(tmp.f1.data(), tmp.f1.size(1));

output_result.fitNames.append(str);

}

output_result.fitParams = py::array_t<real_T>(result.fitParams.size(1));

auto buffer = output_result.fitParams.request();

std::memcpy(buffer.ptr, result.fitParams.data(), output_result.fitParams.size()*sizeof(real_T));

output_result.contrastParams.backgroundParams = py::array_t<real_T>(result.contrastParams.backgroundParams.size(0));

buffer = output_result.contrastParams.backgroundParams.request();

std::memcpy(buffer.ptr, result.contrastParams.backgroundParams.data(), output_result.contrastParams.backgroundParams.size()*sizeof(real_T));

output_result.contrastParams.scalefactors = py::array_t<real_T>(result.contrastParams.scalefactors.size(0));

buffer = output_result.contrastParams.scalefactors.request();

std::memcpy(buffer.ptr, result.contrastParams.scalefactors.data(), output_result.contrastParams.scalefactors.size()*sizeof(real_T));

output_result.contrastParams.bulkIn = py::array_t<real_T>(result.contrastParams.bulkIn.size(0));

buffer = output_result.contrastParams.bulkIn.request();

std::memcpy(buffer.ptr, result.contrastParams.bulkIn.data(), output_result.contrastParams.bulkIn.size()*sizeof(real_T));