named_element_t &block_t::findOrCreateElem(const std::string &n) {
named_element_t *e = findElem(n);
if (e == NULL) {
elems.push_back(named_element_t(n));
e = &elems.back();
}
return *e;
}
bool searchMatrix(vector<vector<int>>& matrix, int target) {
for(int i = 0; i < matrix.size(); i ++){
if(matrix[i][0] <= target && matrix[i][matrix[i].size() - 1] >= target){
if(findElem(matrix[i], 0, matrix[i].size() - 1, target))
return true;
}
}
return false;
}
std::string JSONBlob::get(int pos, std::string const& key, std::string const& elem, AccessMode mode, int item) {
if (mode == AccessMode::Exact && item == NULL) return ""; //usage error
if (m_data.find(pos) != m_data.end()) {
if (m_data.at(pos).find(key) != m_data.at(pos).end()) {
return findElem(m_data.at(pos).at(key)[0], elem, mode, item);
}
}
return "";
}
int main ()
{
std::cout << "Starting " << std::endl;
// creating the head element
IntElem *head = new IntElem;
head->data = 5;
//insert element
int data = 5;
head= insertElem(head, data);
head= insertElem(head, 10);
head = insertElem(head, 12);
std::cout << "head element is now: " << head->data << std::endl;
std::cout << " Finding elem 5 " << findElem(head, 5) << std::endl;
std::cout << " Finding elem 7 " << findElem(head, 7) << std::endl;
deleteList(head);
return 0;
}
void BTree::removeElem(int value)
{
BTreeNode* pNode = findElem(value);
if(pNode == NULL)
return;
// 3 cases
// 1. Selected node has no child
if(pNode->leftNode == NULL && pNode->rightNode == NULL)
{
// get parent
// check whether selected node is parent's left / right child
// set left / right child == NULL
if(pNode->parentNode->leftNode->value == value)
{
pNode->parentNode->leftNode->value = 0;
free(pNode->parentNode->leftNode);
}
else
{
pNode->parentNode->rightNode->value = 0;
free(pNode->parentNode->rightNode);
}
}
// 2. Selcted node has child
// Replace node to be deleted with child
else
{
// 3. Selected node has 2 children
if(pNode->leftNode != NULL && pNode->rightNode != NULL)
{
// Find lowest elem from right tree
BTreeNode* pLowNode = findLowestElem(pNode->rightNode);
// pNode = lowest elem;
pNode->value = pLowNode->value;
//free lowest elem
free(pLowNode);
}
else // Selected node has one child
{
if(pNode->leftNode != NULL)
{
pNode->parentNode->leftNode = pNode->leftNode;
//free(pNode->leftNode);
}
else
{
pNode->parentNode->rightNode = pNode->rightNode;
pNode->parentNode->rightNode->parentNode = pNode->parentNode;
//free(pNode->rightNode);
}
}
}
// release memory for pNode
}
reader_base *findReader(const std::string &b, const std::string &e) const {
named_element_t *elem = findElem(b, e); if (elem) return elem->rd.ptr();
return NULL;
}
int Fenfloss::compute(const char *)
{
dprintf(1, "Fenfloss::compute\n");
int reattach = !strcmp(s_ConnectionMethod[p_ConnectionMethod->getValue()], "reattach");
if (reattach) {
p_ConnectionMethod->setValue(0);
stepNo = -1;
}
// Start: gettime
int numElem;
if (stepNo==0)
{
stepNo=1;
return STOP_PIPELINE;
}
// Find out, whether we have to re-start sim
use_boco2 = 0;
coDoSet *grid = (coDoSet*) p_grid->getCurrentObject();
coDoSet *boco = (coDoSet*) p_boco->getCurrentObject();
coDoSet *boco2 = (coDoSet*) p_boco2->getCurrentObject();
if (reattach)
d_distGridName = strdup(grid->getName());
// fl: debug
grid->getAllElements(&numProc);
dprintf(4, " Fenfloss::compute(const char *): grid: %s, %d\n", grid->getName(), numProc);
if (grid)
{
dprintf(1, "Fenfloss::compute reset\n");
// we have a new grid input object
const char *gridName = grid->getName();
if (strcmp(gridName,d_distGridName)!=0)
{
// sim currently running
if (stepNo>=0)
{
#ifndef WIN32
//system("killall -KILL p_flow_4.8.2");
sleep(5);
#endif
resetSimLib();
stepNo=-1;
}
delete [] d_distGridName;
d_distGridName = strcpy ( new char[strlen(gridName)+1] , gridName );
}
}
if ( (boco) && (!boco2) )
{
// first run! using boco bc object
sendInfo("no boco2 object, using boco object");
}
if ( (boco) && (boco2) )
{
// data on both boco-ports!
const char *bocoName = boco->getName();
// check if there is new data from domain decomposition
if ( strcmp(bocoName,d_distBocoName)!=0 )
{
// no new data from domain decomposition
sendInfo("simulation coupling! using boco2 bc object");
use_boco2 = 1;
}
else
{
// new data from domain decomposition
sendInfo("new data from domain decomposition ...");
}
}
coDoPolygons *poly_in, *poly_out = NULL;
int NumberOfPoints;
int NumberOfVertices, NumberOfPolygons;
float *inx_coord, *iny_coord, *inz_coord;
int *invertices, *inpolygons;
static int grid_size; // correct size of data arrays for visualization
const coDistributedObject *const *gridArr = grid->getAllElements(&numProc);
const coDistributedObject *const *bocoArr;
const coDistributedObject *const **procGrid;
const coDistributedObject *const **procBoco = 0;
const coDoIntArr *gridDim;
const coDoIntArr *bocoDim;
if (stepNo<0)
{
//const char *dir;
printf("Fenfloss::compute stepno < 0\n");
// get target directory
//dir = p_dir->getValue();
// CHECK TYPES .. later
if (!grid || !boco)
{
sendError("Data not received");
return FAIL;
}
if (!boco2)
bocoArr = boco->getAllElements(&numProc);
else
bocoArr = boco2->getAllElements(&numProc);
#ifndef DUMMY
///////////////////////////////////////////////////////////////////////
// start simulation
dprintf(0, "------------------starting simulation-------------------\n");
PrepareSimStart(numProc);
if (startSim(reattach))
return -1;
stepNo=0;
#endif
if (!reattach) {
dprintf(2,"sending parameters ...\n");
int32 command;
do {
recvBS_Data(&command, sizeof(command));
char name[128];
dprintf(4,"command: %d\n",command);
switch (command) {
case GET_SC_PARA_FLO:
case GET_V3_PARA_FLO:
case GET_SC_PARA_INT:
case GET_BOOL_PARA:
case GET_TEXT_PARA:
if (recvData((void*) name, 64) != 64)
dprintf(0, "error in initial parameters\n");
break;
case GET_INITIAL_PARA_DONE:
break;
default:
dprintf(0, "error: unsupported parameter in initialization\n");
break;
}
switch (command) {
case GET_SC_PARA_FLO: {
coFloatParam *param = dynamic_cast<coFloatParam *>(findElem(name));
struct { float val ; int32 error; } ret = {0.0,0};
if (param)
ret.val = param->getValue();
else if (!findAttribute(grid, name, "%f", (void *) &ret.val))
ret.error = -1;
dprintf(4, "sending %f %d\n", ret.val, ret.error);
sendBS_Data((void*) &ret, sizeof(ret));
break;
}
case GET_V3_PARA_FLO: {
coFloatVectorParam *param = dynamic_cast<coFloatVectorParam *>(findElem(name));
struct { float val[3] ; int32 error; } ret;
ret.error = 0;
if (param)
for(int i=0; i<3; i++) {
ret.val[i] = param->getValue(i);
dprintf(4,"param[%d]=%f\n",i,ret.val[i]);
}
else
ret.error = -1;
dprintf(4, "sending %f %d\n", ret.val[0], ret.error);
sendBS_Data((void*) &ret, sizeof(ret));
break;
}
case GET_SC_PARA_INT:
case GET_BOOL_PARA: {
int val = 0;
int error = 0;
if (command == GET_SC_PARA_INT) {
coIntScalarParam *param = dynamic_cast<coIntScalarParam *>(findElem(name));
if (param)
val = param->getValue();
else if (!findAttribute(grid, name, "%d", (void *) &val))
error = -1;
} else if (command == GET_BOOL_PARA) {
coBooleanParam *param = dynamic_cast<coBooleanParam *>(findElem(name));
if (param)
val = param->getValue();
else if (!findAttribute(grid, name, "%d", (void *) &val))
error = -1;
}
struct { int val; int32 error; } ret;
ret.val = val;
ret.error = error;
dprintf(4, "sending int para %d %d\n", ret.val, ret.error);
sendBS_Data((void*) &ret, sizeof(ret));
break;
}
case GET_TEXT_PARA: {
coStringParam *param = dynamic_cast<coStringParam *>(findElem(name));
char res[256];
memset(res, 0, 256);
if (param) {
const char *val = param->getValue();
if (val)
strncpy(res, val, 255);
} else
findAttribute(grid, name, "%s", (void *) res);
sendData(res, 256);
break;
}
default:
break;
}
} while (command != GET_INITIAL_PARA_DONE);
dprintf(2,"sending parameters ... done!\n");
}
///////////////////////////////////////////////////////////////////////
// send dimensions
int *idata,size=0;
int i,j;
procGrid = new const coDistributedObject *const*[numProc];
procBoco = new const coDistributedObject *const*[numProc];
for (i = 0; i < numProc; i++)
{
procGrid[i] = ((const coDoSet*)gridArr[i])->getAllElements(&numElem);
gridDim = (coDoIntArr *) procGrid[i][0];
idata = gridDim->getAddress();
size = gridDim->getDimension(0) * sizeof(int);
dprintf(1, "Fenfloss-Mod(%d): Compute(): Sending grid %d \n", __LINE__, size);
dprintf(1, " sending %d %d %d %d\n", idata[0], idata[1], idata[2], idata[3]);
if (!reattach) {
struct commandMsg data = { GEO_DIM, size };
sendBS_Data(&data, sizeof(data));
if (size)
sendBS_Data(idata,size);
}
}
for (i = 0; i < numProc; i++)
{
procBoco[i] = ((const coDoSet*)bocoArr[i])->getAllElements(&numElem);
bocoDim = (const coDoIntArr *) procBoco[i][0];
idata = bocoDim->getAddress();
size = bocoDim->getDimension(0) * sizeof(int);
dprintf(2, "Fenfloss-Mod(%d): Compute(): Sending bc %d \n", __LINE__, size);
if (!reattach) {
struct commandMsg data = { BOCO_DIM, size };
sendBS_Data(&data, sizeof(data));
if (size)
sendBS_Data(idata,size);
}
}
///////////////////////////////////////////////////////////////////////
// send grids
float *fdata;
for (i = 0; i < numProc; i++)
{
coDoFloat *floatArr = (coDoFloat *) procGrid[i][1];
floatArr->getAddress(&fdata);
size = floatArr->getNumPoints() * sizeof(float);
if (size)
{
dprintf(1, "FenFloss-Mod(%d) GRID: Sending (cpu=%d), size = %d Bytes\n", __LINE__, i, size);
if (!reattach) {
struct { int command; int size; } data = { SEND_GEO, size };
sendBS_Data(&data, sizeof(data));
sendBS_Data(fdata,size);
}
}
#ifdef DUMMY
else
testfile << " --- ignored one field" << endl;
#endif
// M. Becker: flow generates additional nodes
// if we want to be sure that data and grid-arrays have the same length,
// we have to shorten the data arrays (at the end of ::compute)!
if (i == 0)
{
coDoIntArr *intArr = (coDoIntArr *) procGrid[i][0];
idata = intArr->getAddress();
grid_size = idata[1];
dprintf(1, "*************************** grid_size: %d\n", grid_size);
}
for (j = 2; j < 11; j++)
{
coDoIntArr *intArr = (coDoIntArr *) procGrid[i][j];
idata = intArr->getAddress();
size = intArr->getDimension(0) * sizeof(int);
if (size)
{
dprintf(1, "FenFloss-Mod(%d) GRID: Sending (cpu=%d, j=%d), size = %d Bytes\n", __LINE__, i, j, size);
dprintf(4," idata[0] = %d, idata[1] = %d, idata[2] = %d\n",
idata[0], idata[1], idata[2]);
if (!reattach) {
sendBS_Data(idata,size);
}
}
#ifdef DUMMY
else
testfile << " --- ignored one field" << endl;
#endif
}
}
///////////////////////////////////////////////////////////////////////
// send boco
for (i = 0; i < numProc; i++)
{
if (!reattach) {
struct { int command; int size; } data = { SEND_BOCO, size };
sendBS_Data(&data, sizeof(data));
}
for (j = 1; j < 12; j++)
{
coDoIntArr *intArr = (coDoIntArr *) procBoco[i][j];
idata = intArr->getAddress();
size = intArr->getDimension(0) * sizeof(int);
if (size)
{
// debug, fl:
for(int k = 0; k < size/4; k++) {
dprintf(3,"send boco(%2d,%2d): %8d\n",i,j,idata[k]);
}
dprintf(2, "FenFloss-Mod(%d) BC: Sending (cpu=%d, j=%d), size = %d Bytes\n", __LINE__, i, j, size);
if (!reattach) {
sendBS_Data(idata,size);
}
}
#ifdef DUMMY
else
testfile << " --- ignored one field" << endl;
#endif
}
for (j = 12; j < 13; j++) // displ_wert
{
sendInfo("Sending RB-Data ...");
coDoFloat *floatArr = (coDoFloat *) procBoco[i][j];
floatArr->getAddress(&fdata);
size = floatArr->getNumPoints() * sizeof(float);
if (size)
{
dprintf(2, "FenFloss-Mod(%d) BC: Sending (cpu=%d, j=%d), size = %d Bytes\n", __LINE__, i, j, size);
if (!reattach) {
sendBS_Data(fdata,size);
}
/*<tmp>
if(j == 13)
{
sendInfo("Writing Diplacement-Data to file ...");
ofstream ofs("displwerte.debug");
for(int ji(0); ji<size; ji+=6)
{
ofs << fdata[ji] << " " << fdata[ji+1] << " " << fdata[ji+2] << " " << fdata[ji+3] << " " << fdata[ji+4] << " " << fdata[ji+5] << endl;
}
ofs.close();
}
</tmp>*/
}
#ifdef DUMMY
else
testfile << "--- ignored one field" << endl;
#endif
}
}
} /* endif(stepno < 0) */
#ifndef YAC
executeCommands();
#endif
numbc = 0;
for (int j = 0; j < numbc && bcrad; j++)
dprintf(4, "j=%d: bcrad=%f, bcvu=%f, bcvm=%f\n", j, bcrad[j], bcvu[j], bcvm[j]);
if (use_boco2)
{
// use boco2 object (from Flowmid module)!
bocoArr = boco2->getAllElements(&numProc);
if (!boco2_num_int) {
boco2_num_int = new int[numProc];
boco2_idata = new int*[numProc];
}
// size
for (int i = 0; i < numProc; i++)
{
if (boco2_idata[i]) delete [] boco2_idata[i];
procBoco[i] = ((coDoSet*)bocoArr[i])->getAllElements(&numElem);
bocoDim = (coDoIntArr *) procBoco[i][0];
boco2_num_int[i] = bocoDim->getDimension(0);
boco2_idata[i] = new int[boco2_num_int[i]];
memcpy(boco2_idata[i], bocoDim->getAddress(), boco2_num_int[i] * sizeof(int));
}
if (!boco2_num_float) {
boco2_num_float = new int[numProc];
boco2_fdata = new float*[numProc];
}
ofstream debugfile;
debugfile.open("boco2_bcin_data.txt");
// data
for (int i=0;i<numProc;i++)
{
float *address;
procBoco[i] = ((coDoSet*)bocoArr[i])->getAllElements(&numElem);
coDoFloat *floatArr = (coDoFloat *) procBoco[i][13]; // displ_wert
if (boco2_fdata[i]) delete [] boco2_fdata[i];
boco2_num_float[i] = floatArr->getNumPoints();
boco2_fdata[i] = new float[2 * boco2_num_float[i]]; // |displ_wert| == |pres_wert| ?
floatArr->getAddress(&address);
memcpy(boco2_fdata[i], address, boco2_num_float[i] * sizeof(float));
floatArr = (coDoFloat *) procBoco[i][14]; // pres_wert
floatArr->getAddress(&address);
memcpy(boco2_fdata[i] + boco2_num_float[i], address, boco2_num_float[i] * sizeof(float));
}
/*
for (int j=13;j<15;j++) // displ_wert, pres_wert
{
coDoFloat *floatArr = (coDoFloat *) procBoco[i][j];
floatArr->getAddress(&fdata);
size = floatArr->getNumPoints() * sizeof(float);
if (size)
{
printf("FenFloss-Mod(%d) BC: Sending (cpu=%d, j=%d), size = %d Bytes\n", __LINE__, i, j, size);
sendBS_Data(fdata,size);
}
if (j==13)
for (int k=0; k<size/4; k+=6)
{
debugfile << k/6 << " " << fdata[k]
<< " " << fdata[k+1]
<< " " << fdata[k+2]
<< " " << fdata[k+3]
<< " " << fdata[k+4]
<< " " << fdata[k+5]
<< endl;
}
debugfile.close();
#ifdef DUMMY
else
testfile << " --- ignored one field" << endl;
#endif
}
}
*/
}
//////////////////////////////
// we had to add to the spot point data, the description for
// CollectTimeSteps and the Plot module
// the output port for the VR Plugin
poly_in = (coDoPolygons *)p_in_bcin->getCurrentObject();
if (poly_in) {
NumberOfPoints = poly_in->getNumPoints();
NumberOfVertices = poly_in->getNumVertices();
NumberOfPolygons = poly_in->getNumPolygons();
poly_in->getAddresses(&inx_coord, &iny_coord, &inz_coord, &invertices, &inpolygons);
poly_out = new coDoPolygons(p_out_bcin->getObjName(),
NumberOfPoints,
inx_coord, iny_coord, inz_coord,
NumberOfVertices, invertices,
NumberOfPolygons, inpolygons);
poly_out->addAttribute("vertexOrder","1");
poly_out->addAttribute("COLOR","red");
p_out_bcin->setCurrentObject(poly_out);
}
#ifndef YAC
coFeedback feedback("FenflossPlugin");
feedback.addPara(p_updateInterval);
feedback.addPara(p_pauseSim);
feedback.addPara(p_GetSimData);
feedback.addPara(p_detachSim);
feedback.addPara(p_useInitial);
feedback.addPara(p_stopSim);
if (poly_in)
feedback.apply(poly_out);
#endif
// Flow knows now, that it has to send new simulation data
if (p_GetSimData->getValue())
p_GetSimData->setValue(0); // push off button
/*
if (p_stopSim->getValue())
p_stopSim->setValue(0); // push off button
*/
// M. Becker 17.6.2002
// resize data arrays to fit with original created grid for visualization
if (p_velocity->getCurrentObject()) // do this only if there is an object!
{
coDoVec3 *velo = (coDoVec3 *)p_velocity->getCurrentObject();
velo->setSize(grid_size);
coDoFloat *press = (coDoFloat *)p_press->getCurrentObject();
press->setSize(grid_size);
if (p_turb->getCurrentObject())
{
coDoFloat *turb = (coDoFloat *)p_turb->getCurrentObject();
turb->setSize(grid_size);
}
}
if (!p_velocity->getCurrentObject())
return STOP_PIPELINE;
else
return CONTINUE_PIPELINE;
}
bool findElem(vector<int>& arr, int start, int end, int target){
if(end - start <= 1)
return (target == arr[start] || target == arr[end]) ? true : false;
int mid = (start + end)/ 2;
return (target > arr[mid]) ? findElem(arr, mid, end, target) : findElem(arr, start, mid, target);
}
