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); }