void testValues () { testcase ("values"); checkValues ("0.1.2", 0, 1, 2); checkValues ("1.2.3", 1, 2, 3); checkValues ("1.2.3-rc1", 1, 2, 3, ids ("rc1")); checkValues ("1.2.3-rc1.debug", 1, 2, 3, ids ("rc1", "debug")); checkValues ("1.2.3-rc1.debug.asm", 1, 2, 3, ids ("rc1", "debug", "asm")); checkValues ("1.2.3+full", 1, 2, 3, ids (), ids ("full")); checkValues ("1.2.3+full.prod", 1, 2, 3, ids (), ids ("full", "prod")); checkValues ("1.2.3+full.prod.x86", 1, 2, 3, ids (), ids ("full", "prod", "x86")); checkValues ("1.2.3-rc1.debug.asm+full.prod.x86", 1, 2, 3, ids ("rc1", "debug", "asm"), ids ("full", "prod", "x86")); }
void VisIntegrator::integrate() { const size_t samp_dim = 8; RNG rng; ImageSampler image_sampler(spp, image->width, image->height); // Sample array Array<float> samps; samps.resize(RAYS_AT_A_TIME * samp_dim); // Sample pixel coordinate array Array<uint16_t> coords; coords.resize(RAYS_AT_A_TIME * 2); // Light path array Array<VisPath> paths; paths.resize(RAYS_AT_A_TIME); // Ray and Intersection arrays Array<Ray> rays(RAYS_AT_A_TIME); Array<Intersection> intersections(RAYS_AT_A_TIME); // ids corresponding to the rays Array<uint32_t> ids(RAYS_AT_A_TIME); bool last = false; while (true) { // Generate a bunch of samples std::cout << "\t--------\n\tGenerating samples" << std::endl; std::cout.flush(); for (int i = 0; i < RAYS_AT_A_TIME; i++) { if (!image_sampler.get_next_sample(samp_dim, &(samps[i*samp_dim]), &(coords[i*2]))) { samps.resize(i*samp_dim); paths.resize(i); last = true; break; } else { paths[i].done = false; } } uint32_t ssize = samps.size() / samp_dim; // Size the ray buffer appropriately rays.resize(ssize); // Generate a bunch of camera rays std::cout << "\tGenerating camera rays" << std::endl; std::cout.flush(); for (uint32_t i = 0; i < ssize; i++) { float rx = (samps[i*samp_dim] - 0.5) * (image->max_x - image->min_x); float ry = (0.5 - samps[i*samp_dim+1]) * (image->max_y - image->min_y); float dx = (image->max_x - image->min_x) / image->width; float dy = (image->max_y - image->min_y) / image->height; rays[i] = scene->camera->generate_ray(rx, ry, dx, dy, samps[i*samp_dim+4], samps[i*samp_dim+2], samps[i*samp_dim+3]); rays[i].finalize(); ids[i] = i; } // Trace the camera rays std::cout << "\tTracing camera rays" << std::endl; std::cout.flush(); tracer->trace(rays, &intersections); // Update paths std::cout << "\tUpdating paths" << std::endl; std::cout.flush(); uint32_t rsize = rays.size(); for (uint32_t i = 0; i < rsize; i++) { if (intersections[i].hit) { // Ray hit something! Store intersection data paths[ids[i]].done = true; paths[ids[i]].col = intersections[i].col; } else { // Ray didn't hit anything, done and black background paths[ids[i]].done = true; paths[ids[i]].col = Color(0.0, 0.0, 0.0); } } // Accumulate the samples std::cout << "\tAccumulating samples" << std::endl; std::cout.flush(); for (size_t i = 0; i < ssize; i++) { image->add_sample(paths[i].col, coords[i*2], coords[i*2+1]); } // Print percentage complete static int32_t last_perc = -1; int32_t perc = image_sampler.percentage() * 100; if (perc > last_perc) { std::cout << perc << "%" << std::endl; last_perc = perc; } if (callback) callback(); if (last) break; } }
ErrorCode ReadGmsh::load_file(const char* filename, const EntityHandle*, const FileOptions&, const ReaderIface::SubsetList* subset_list, const Tag* file_id_tag) { int num_material_sets = 0; const int* material_set_list = 0; int zero = 0; if (subset_list) { if (subset_list->tag_list_length > 1 && !strcmp(subset_list->tag_list[0].tag_name, MATERIAL_SET_TAG_NAME)) { MB_SET_ERR(MB_UNSUPPORTED_OPERATION, "GMsh supports subset read only by material ID"); } material_set_list = subset_list->tag_list[0].tag_values; num_material_sets = subset_list->tag_list[0].num_tag_values; } geomSets.clear(); ErrorCode result = mdbImpl->tag_get_handle(GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, globalId, MB_TAG_DENSE | MB_TAG_CREAT, &zero); if (MB_SUCCESS != result) return result; // Create set for more convenient check for material set ids std::set<int> blocks; for (const int* mat_set_end = material_set_list + num_material_sets; material_set_list != mat_set_end; ++material_set_list) blocks.insert(*material_set_list); // Map of ID->handle for nodes std::map<long, EntityHandle> node_id_map; int data_size = 8; // Open file and hand off pointer to tokenizer FILE* file_ptr = fopen(filename, "r"); if (!file_ptr) { MB_SET_ERR(MB_FILE_DOES_NOT_EXIST, filename << ": " << strerror(errno)); } FileTokenizer tokens(file_ptr, readMeshIface); // Determine file format version const char* const start_tokens[] = {"$NOD", "$MeshFormat", 0}; int format_version = tokens.match_token(start_tokens); if (!format_version) return MB_FILE_DOES_NOT_EXIST; // If version 2.0, read additional header info if (2 == format_version) { double version; if (!tokens.get_doubles(1, &version)) return MB_FILE_WRITE_ERROR; if (version != 2.0 && version != 2.1 && version != 2.2) { MB_SET_ERR(MB_FILE_DOES_NOT_EXIST, filename << ": unknown format version: " << version); return MB_FILE_DOES_NOT_EXIST; } int file_format; if (!tokens.get_integers(1, &file_format) || !tokens.get_integers(1, &data_size) || !tokens.match_token("$EndMeshFormat")) return MB_FILE_WRITE_ERROR; // If physical entities in the gmsh file -> discard this const char* const phys_tokens[] = { "$Nodes", "$PhysicalNames", 0 }; int hasPhys = tokens.match_token(phys_tokens); if (hasPhys == 2) { long num_phys; if (!tokens.get_long_ints(1, &num_phys)) return MB_FILE_WRITE_ERROR; for (long loop_phys = 0; loop_phys < num_phys; loop_phys++) { long physDim; long physGroupNum; //char const * physName; if (!tokens.get_long_ints(1, &physDim)) return MB_FILE_WRITE_ERROR; if (!tokens.get_long_ints(1, &physGroupNum)) return MB_FILE_WRITE_ERROR; const char * ptc = tokens.get_string(); if (!ptc) return MB_FILE_WRITE_ERROR; // try to get to the end of the line, without reporting errors // really, we need to skip this while(!tokens.get_newline(false)) ptc = tokens.get_string(); } if (!tokens.match_token("$EndPhysicalNames") || !tokens.match_token( "$Nodes")) return MB_FILE_WRITE_ERROR; } } // Read number of nodes long num_nodes; if (!tokens.get_long_ints(1, &num_nodes)) return MB_FILE_WRITE_ERROR; // Allocate nodes std::vector<double*> coord_arrays; EntityHandle handle = 0; result = readMeshIface->get_node_coords(3, num_nodes, MB_START_ID, handle, coord_arrays); if (MB_SUCCESS != result) return result; // Read nodes double *x = coord_arrays[0], *y = coord_arrays[1], *z = coord_arrays[2]; for (long i = 0; i < num_nodes; ++i, ++handle) { long id; if (!tokens.get_long_ints(1, &id) || !tokens.get_doubles(1, x++) || !tokens.get_doubles(1, y++) || !tokens.get_doubles(1, z++)) return MB_FILE_WRITE_ERROR; if (!node_id_map.insert(std::pair<long, EntityHandle>(id, handle)).second) { MB_SET_ERR(MB_FILE_WRITE_ERROR, "Duplicate node ID at line " << tokens.line_number()); } } // Create reverse map from handle to id std::vector<int> ids(num_nodes); std::vector<int>::iterator id_iter = ids.begin(); std::vector<EntityHandle> handles(num_nodes); std::vector<EntityHandle>::iterator h_iter = handles.begin(); for (std::map<long, EntityHandle>::iterator i = node_id_map.begin(); i != node_id_map.end(); ++i, ++id_iter, ++h_iter) { *id_iter = i->first; * h_iter = i->second; } // Store IDs in tags result = mdbImpl->tag_set_data(globalId, &handles[0], num_nodes, &ids[0]); if (MB_SUCCESS != result) return result; if (file_id_tag) { result = mdbImpl->tag_set_data(*file_id_tag, &handles[0], num_nodes, &ids[0]); if (MB_SUCCESS != result) return result; } ids.clear(); handles.clear(); // Get tokens signifying end of node data and start of elements if (!tokens.match_token(format_version == 1 ? "$ENDNOD" : "$EndNodes") || !tokens.match_token(format_version == 1 ? "$ELM" : "$Elements")) return MB_FILE_WRITE_ERROR; // Get element count long num_elem; if (!tokens.get_long_ints(1, &num_elem)) return MB_FILE_WRITE_ERROR; // Lists of data accumulated for elements std::vector<EntityHandle> connectivity; std::vector<int> mat_set_list, geom_set_list, part_set_list, id_list; // Temporary, per-element data std::vector<int> int_data(5), tag_data(2); std::vector<long> tmp_conn; int curr_elem_type = -1; for (long i = 0; i < num_elem; ++i) { // Read element description // File format 1.0 if (1 == format_version) { if (!tokens.get_integers(5, &int_data[0])) return MB_FILE_WRITE_ERROR; tag_data[0] = int_data[2]; tag_data[1] = int_data[3]; if ((unsigned)tag_data[1] < GmshUtil::numGmshElemType && GmshUtil::gmshElemTypes[tag_data[1]].num_nodes != (unsigned)int_data[4]) { MB_SET_ERR(MB_FILE_WRITE_ERROR, "Invalid node count for element type at line " << tokens.line_number()); } } // File format 2.0 else { if (!tokens.get_integers(3, &int_data[0])) return MB_FILE_WRITE_ERROR; tag_data.resize(int_data[2]); if (!tokens.get_integers(tag_data.size(), &tag_data[0])) return MB_FILE_WRITE_ERROR; } // If a list of material sets was specified in the // argument list, skip any elements for which the // material set is not specified or is not in the // passed list. if (!blocks.empty() && (tag_data.empty() || blocks.find(tag_data[0]) != blocks.end())) continue; // If the next element is not the same type as the last one, // create a sequence for the block of elements we've read // to this point (all of the same type), and clear accumulated // data. if (int_data[1] != curr_elem_type) { if (!id_list.empty()) { // First iteration result = create_elements(GmshUtil::gmshElemTypes[curr_elem_type], id_list, mat_set_list, geom_set_list, part_set_list, connectivity, file_id_tag); if (MB_SUCCESS != result) return result; } id_list.clear(); mat_set_list.clear(); geom_set_list.clear(); part_set_list.clear(); connectivity.clear(); curr_elem_type = int_data[1]; if ((unsigned)curr_elem_type >= GmshUtil::numGmshElemType || GmshUtil::gmshElemTypes[curr_elem_type].mb_type == MBMAXTYPE) { MB_SET_ERR(MB_FILE_WRITE_ERROR, "Unsupported element type " << curr_elem_type << " at line " << tokens.line_number()); } tmp_conn.resize(GmshUtil::gmshElemTypes[curr_elem_type].num_nodes); } // Store data from element description id_list.push_back(int_data[0]); part_set_list.push_back(tag_data.size() > 2 ? tag_data[2] : 0); geom_set_list.push_back(tag_data.size() > 1 ? tag_data[1] : 0); mat_set_list.push_back(tag_data.size() > 0 ? tag_data[0] : 0); // Get element connectivity if (!tokens.get_long_ints(tmp_conn.size(), &tmp_conn[0])) return MB_FILE_WRITE_ERROR; // Convert connectivity from IDs to handles for (unsigned j = 0; j < tmp_conn.size(); ++j) { std::map<long, EntityHandle>::iterator k = node_id_map.find(tmp_conn[j]); if (k == node_id_map.end()) { MB_SET_ERR(MB_FILE_WRITE_ERROR, "Invalid node ID at line " << tokens.line_number()); } connectivity.push_back(k->second); } } // for (num_nodes) // Create entity sequence for last element(s). if (!id_list.empty()) { result = create_elements(GmshUtil::gmshElemTypes[curr_elem_type], id_list, mat_set_list, geom_set_list, part_set_list, connectivity, file_id_tag); if (MB_SUCCESS != result) return result; } // Construct parent-child relations for geometric sets. // Note: At the time this comment was written, the following // function was not implemented. result = create_geometric_topology(); geomSets.clear(); return result; }
void DirectLightingIntegrator::integrate() { const size_t samp_dim = 8; RNG rng; ImageSampler image_sampler(spp, image->width, image->height); // Sample array Array<float> samps(RAYS_AT_A_TIME * samp_dim); // Sample pixel coordinate array Array<uint16_t> coords(RAYS_AT_A_TIME * 2); // Light path array Array<DLPath> paths(RAYS_AT_A_TIME); // Ray and Intersection arrays Array<Ray> rays(RAYS_AT_A_TIME); Array<Intersection> intersections(RAYS_AT_A_TIME); // ids corresponding to the rays Array<uint32_t> ids(RAYS_AT_A_TIME); bool last = false; while (true) { // Generate a bunch of samples std::cout << "\t--------\n\tGenerating samples" << std::endl; std::cout.flush(); for (int i = 0; i < RAYS_AT_A_TIME; i++) { if (!image_sampler.get_next_sample(samp_dim, &(samps[i*samp_dim]), &(coords[i*2]))) { samps.resize(i*samp_dim); paths.resize(i); last = true; break; } else { paths[i].done = false; } } uint32_t ssize = samps.size() / samp_dim; // Size the ray buffer appropriately rays.resize(ssize); // Generate a bunch of camera rays std::cout << "\tGenerating camera rays" << std::endl; std::cout.flush(); for (uint32_t i = 0; i < ssize; i++) { float rx = (samps[i*samp_dim] - 0.5) * (image->max_x - image->min_x); float ry = (0.5 - samps[i*samp_dim+1]) * (image->max_y - image->min_y); float dx = (image->max_x - image->min_x) / image->width; float dy = (image->max_y - image->min_y) / image->height; rays[i] = scene->camera->generate_ray(rx, ry, dx, dy, samps[i*samp_dim+4], samps[i*samp_dim+2], samps[i*samp_dim+3]); rays[i].finalize(); ids[i] = i; } // Trace the camera rays std::cout << "\tTracing camera rays" << std::endl; std::cout.flush(); tracer->trace(rays, &intersections); // Update paths std::cout << "\tUpdating paths" << std::endl; std::cout.flush(); uint32_t rsize = rays.size(); for (uint32_t i = 0; i < rsize; i++) { if (intersections[i].hit) { // Ray hit something! Store intersection data paths[ids[i]].inter = intersections[i]; } else { // Ray didn't hit anything, done and black background paths[ids[i]].done = true; paths[ids[i]].col = Color(0.0, 0.0, 0.0); } } // Generate a bunch of shadow rays std::cout << "\tGenerating shadow rays" << std::endl; std::cout.flush(); uint32_t sri = 0; // Shadow ray index for (uint32_t i = 0; i < ssize; i++) { if (!paths[i].done) { // Select a light and store the normalization factor for it's output Light *lighty = scene->finite_lights[(uint32_t)(samps[i*samp_dim+5] * scene->finite_lights.size()) % scene->finite_lights.size()]; // Sample the light source Vec3 ld; paths[i].lcol = lighty->sample(intersections[i].p, samps[i*samp_dim+6], samps[i*samp_dim+7], rays[i].time, &ld) * (float)(scene->finite_lights.size()); // Create a shadow ray for this path float d = ld.length(); ld.normalize(); rays[sri].o = paths[i].inter.p + paths[i].inter.offset; rays[sri].d = ld; rays[sri].time = samps[i*samp_dim+4]; rays[sri].is_shadow_ray = true; rays[sri].ow = paths[i].inter.owp(); rays[sri].dw = 0.0f; //rays[sri].has_differentials = false; rays[sri].max_t = d; rays[sri].finalize(); ids[sri] = i; // Increment shadow ray index sri++; } } rays.resize(sri); // Trace the shadow rays std::cout << "\tTracing shadow rays" << std::endl; std::cout.flush(); tracer->trace(rays, &intersections); // Calculate sample colors std::cout << "\tCalculating sample colors" << std::endl; std::cout.flush(); rsize = rays.size(); for (uint32_t i = 0; i < rsize; i++) { uint32_t id = ids[i]; if (intersections[i].hit) { // Sample was shadowed paths[id].done = true; paths[id].col = Color(0.0, 0.0, 0.0); } else { // Sample was lit paths[id].inter.n.normalize(); float lambert = dot(rays[i].d, paths[id].inter.n); if (lambert < 0.0) lambert = 0.0; paths[id].col = paths[id].lcol * lambert; } } // Print percentage complete static int32_t last_perc = -1; int32_t perc = image_sampler.percentage() * 100; if (perc > last_perc) { std::cout << perc << "%" << std::endl; last_perc = perc; } if (!Config::no_output) { // Accumulate the samples std::cout << "\tAccumulating samples" << std::endl; std::cout.flush(); for (size_t i = 0; i < ssize; i++) { image->add_sample(paths[i].col, coords[i*2], coords[i*2+1]); } if (callback) callback(); } if (last) break; } }
//--------------------------------------------------------- DMat& NDG2D::ConformingHrefine2D(IMat& edgerefineflag, const DMat& Qin) //--------------------------------------------------------- { #if (0) OutputNodes(false); // volume nodes //OutputNodes(true); // face nodes #endif // function newQ = ConformingHrefine2D(edgerefineflag, Q) // Purpose: apply edge splits as requested by edgerefineflag IVec v1("v1"), v2("v2"), v3("v3"), tvi; DVec x1("x1"), x2("x2"), x3("x3"), y1("y1"), y2("y2"), y3("y3"); DVec a1("a1"), a2("a2"), a3("a3"); // count vertices assert (VX.size() == Nv); // find vertex triplets for elements to be refined v1 = EToV(All,1); v2 = EToV(All,2); v3 = EToV(All,3); x1 = VX(v1); x2 = VX(v2); x3 = VX(v3); y1 = VY(v1); y2 = VY(v2); y3 = VY(v3); // find angles at each element vertex (in radians) VertexAngles(x1,x2,x3,y1,y2,y3, a1,a2,a3); // absolute value of angle size a1.set_abs(); a2.set_abs(); a3.set_abs(); int k=0,k1=0,f1=0,k2=0,f2=0, e1=0,e2=0,e3=0, b1=0,b2=0,b3=0, ref=0; IVec m1,m2,m3; DVec mx1, my1, mx2, my2, mx3, my3; // create new vertices at edge centers of marked elements // (use unique numbering derived from unique edge number)) m1 = max(IVec(Nv*(v1-1)+v2+1), IVec(Nv*(v2-1)+v1+1)); mx1=0.5*(x1+x2); my1=0.5*(y1+y2); m2 = max(IVec(Nv*(v2-1)+v3+1), IVec(Nv*(v3-1)+v2+1)); mx2=0.5*(x2+x3); my2=0.5*(y2+y3); m3 = max(IVec(Nv*(v1-1)+v3+1), IVec(Nv*(v3-1)+v1+1)); mx3=0.5*(x3+x1); my3=0.5*(y3+y1); // ensure that both elements sharing an edge are split for (k1=1; k1<=K; ++k1) { for (f1=1; f1<=Nfaces; ++f1) { if (edgerefineflag(k1,f1)) { k2 = EToE(k1,f1); f2 = EToF(k1,f1); edgerefineflag(k2,f2) = 1; } } } // store old data IMat oldEToV = EToV; DVec oldVX = VX, oldVY = VY; // count the number of elements in the refined mesh int newK = countrefinefaces(edgerefineflag); EToV.resize(newK, Nfaces, true, 0); IMat newBCType(newK,3, "newBCType"); // kold = []; IVec kold(newK, "kold"); Index1D KI,KIo; int sk=1, skstart=0, skend=0; for (k=1; k<=K; ++k) { skstart = sk; e1 = edgerefineflag(k,1); b1 = BCType(k,1); e2 = edgerefineflag(k,2); b2 = BCType(k,2); e3 = edgerefineflag(k,3); b3 = BCType(k,3); ref = e1 + 2*e2 + 4*e3; switch (ref) { case 0: EToV(sk, All) = IVec(v1(k),v2(k),v3(k)); newBCType(sk,All) = IVec(b1, b2, b3); ++sk; break; case 1: EToV(sk, All) = IVec(v1(k),m1(k),v3(k)); newBCType(sk,All) = IVec(b1, 0, b3); ++sk; EToV(sk, All) = IVec(m1(k),v2(k),v3(k)); newBCType(sk,All) = IVec(b1, b2, 0); ++sk; break; case 2: EToV(sk, All) = IVec(v2(k),m2(k),v1(k)); newBCType(sk,All) = IVec(b2, 0, b1); ++sk; EToV(sk, All) = IVec(m2(k),v3(k),v1(k)); newBCType(sk,All) = IVec(b2, b3, 0); ++sk; break; case 4: EToV(sk, All) = IVec(v3(k),m3(k),v2(k)); newBCType(sk,All) = IVec(b3, 0, b2); ++sk; EToV(sk, All) = IVec(m3(k),v1(k),v2(k)); newBCType(sk,All) = IVec(b3, b1, 0); ++sk; break; case 3: EToV(sk, All) = IVec(m1(k),v2(k),m2(k)); newBCType(sk,All) = IVec(b1, b2, 0); ++sk; if (a1(k) > a3(k)) { // split largest angle EToV(sk, All) = IVec(v1(k),m1(k),m2(k)); newBCType(sk,All) = IVec(b1, 0, 0); ++sk; EToV(sk, All) = IVec(v1(k),m2(k),v3(k)); newBCType(sk,All) = IVec( 0, b2, b3); ++sk; } else { EToV(sk, All) = IVec(v3(k),m1(k),m2(k)); newBCType(sk,All) = IVec( 0, 0, b2); ++sk; EToV(sk, All) = IVec(v3(k),v1(k),m1(k)); newBCType(sk,All) = IVec(b3, b1, 0); ++sk; } break; case 5: EToV(sk, All) = IVec(v1(k),m1(k),m3(k)); newBCType(sk,All) = IVec(b1, 0, b3); ++sk; if (a2(k) > a3(k)) { // split largest angle EToV(sk, All) = IVec(v2(k),m3(k),m1(k)); newBCType(sk,All) = IVec( 0, 0, b1); ++sk; EToV(sk, All) = IVec(v2(k),v3(k),m3(k)); newBCType(sk,All) = IVec(b2, b3, 0); ++sk; } else { EToV(sk, All) = IVec(v3(k),m3(k),m1(k)); newBCType(sk,All) = IVec(b3, 0, 0); ++sk; EToV(sk, All) = IVec(v3(k),m1(k),v2(k)); newBCType(sk,All) = IVec( 0, b1, b2); ++sk; } break; case 6: EToV(sk, All) = IVec(v3(k),m3(k),m2(k)); newBCType(sk,All) = IVec(b3, 0, b2); ++sk; if (a1(k) > a2(k)) { // split largest angle EToV(sk, All) = IVec(v1(k),m2(k),m3(k)); newBCType(sk,All) = IVec( 0, 0, b3); ++sk; EToV(sk, All) = IVec(v1(k),v2(k),m2(k)); newBCType(sk,All) = IVec(b1, b2, 0); ++sk; } else { EToV(sk, All) = IVec(v2(k),m2(k),m3(k)); newBCType(sk,All) = IVec(b2, 0, 0); ++sk; EToV(sk, All) = IVec(v2(k),m3(k),v1(k)); newBCType(sk,All) = IVec( 0 , b3, b1); ++sk; } break; default: // split all EToV(sk, All) = IVec(m1(k),m2(k),m3(k)); newBCType(sk, All) = IVec( 0, 0, 0); ++sk; EToV(sk, All) = IVec(v1(k),m1(k),m3(k)); newBCType(sk, All) = IVec(b1, 0, b3); ++sk; EToV(sk, All) = IVec(v2(k),m2(k),m1(k)); newBCType(sk, All) = IVec(b2, 0, b1); ++sk; EToV(sk, All) = IVec(v3(k),m3(k),m2(k)); newBCType(sk, All) = IVec(b3, 0, b2); ++sk; break; } skend = sk; // kold = [kold; k*ones(skend-skstart, 1)]; // element k is to be refined into (1:4) child elements. // store parent element numbers in array "kold" to help // with accessing parent vertex data during refinement. KI.reset(skstart, skend-1); // ids of child elements kold(KI) = k; // mark as children of element k } // Finished with edgerefineflag. Delete if OBJ_temp if (edgerefineflag.get_mode() == OBJ_temp) { delete (&edgerefineflag); } // renumber new nodes contiguously // ids = unique([v1;v2;v3;m1;m2;m3]); bool unique=true; IVec IDS, ids; IDS = concat( concat(v1,v2,v3), concat(m1,m2,m3) ); ids = sort(IDS, unique); Nv = ids.size(); int max_id = EToV.max_val(); umMSG(1, "max id in EToV is %d\n", max_id); // M N nnz vals triplet CSi newids(max_id,1, Nv, 1, 1 ); // newids = sparse(max(max(EToV)),1); int i=0, j=1; for (i=1; i<=Nv; ++i) { // newids(ids)= (1:Nv); newids.set1(ids(i),j, i); // load 1-based triplets } // row col x newids.compress(); // convert to csc form // Matlab ----------------------------------------------- // v1 = newids(v1); v2 = newids(v2); v3 = newids(v3); // m1 = newids(m1); m2 = newids(m2); m3 = newids(m3); //------------------------------------------------------- int KVi=v1.size(), KMi=m1.size(); // read from copies, overwrite originals // 1. reload ids for new vertices tvi = v1; for (i=1;i<=KVi;++i) {v1(i) = newids(tvi(i), 1);} tvi = v2; for (i=1;i<=KVi;++i) {v2(i) = newids(tvi(i), 1);} tvi = v3; for (i=1;i<=KVi;++i) {v3(i) = newids(tvi(i), 1);} // 2. load ids for new (midpoint) vertices tvi = m1; for (i=1;i<=KMi;++i) {m1(i) = newids(tvi(i), 1);} tvi = m2; for (i=1;i<=KMi;++i) {m2(i) = newids(tvi(i), 1);} tvi = m3; for (i=1;i<=KMi;++i) {m3(i) = newids(tvi(i), 1);} VX.resize(Nv); VY.resize(Nv); VX(v1) = x1; VX(v2) = x2; VX(v3) = x3; VY(v1) = y1; VY(v2) = y2; VY(v3) = y3; VX(m1) = mx1; VX(m2) = mx2; VX(m3) = mx3; VY(m1) = my1; VY(m2) = my2; VY(m3) = my3; if (newK != (sk-1)) { umERROR("NDG2D::ConformingHrefine2D", "Inconsistent element count: expect %d, but sk = %d", newK, (sk-1)); } else { K = newK; // sk-1; } // dumpIMat(EToV, "EToV (before)"); // EToV = newids(EToV); for (j=1; j<=3; ++j) { for (k=1; k<=K; ++k) { EToV(k,j) = newids(EToV(k,j), 1); } } #if (0) dumpIMat(EToV, "EToV (after)"); // umERROR("Checking ids", "Nigel, check EToV"); #endif BCType = newBCType; Nv = VX.size(); // xold = x; yold = y; StartUp2D(); #if (1) OutputNodes(false); // volume nodes //OutputNodes(true); // face nodes //umERROR("Exiting early", "Check adapted {volume,face} nodes"); #endif // allocate return object int Nfields = Qin.num_cols(); DMat* tmpQ = new DMat(Np*K, Nfields, "newQ", OBJ_temp); DMat& newQ = *tmpQ; // use a reference for syntax // quick return, if no interpolation is required if (Qin.size()<1) { return newQ; } DVec rOUT(Np),sOUT(Np),xout,yout,xy1(2),xy2(2),xy3(2),tmp(2),rhs; int ko=0,kv1=0,kv2=0,kv3=0,n=0; DMat A(2,2), interp; DMat oldQ = const_cast<DMat&>(Qin); for (k=1; k<=K; ++k) { ko = kold(k); xout = x(All,k); yout = y(All,k); kv1=oldEToV(ko,1); kv2=oldEToV(ko,2); kv3=oldEToV(ko,3); xy1.set(oldVX(kv1), oldVY(kv1)); xy2.set(oldVX(kv2), oldVY(kv2)); xy3.set(oldVX(kv3), oldVY(kv3)); A.set_col(1, xy2-xy1); A.set_col(2, xy3-xy1); for (i=1; i<=Np; ++i) { tmp.set(xout(i), yout(i)); rhs = 2.0*tmp - xy2 - xy3; tmp = A|rhs; rOUT(i) = tmp(1); sOUT(i) = tmp(2); } KI.reset (Np*(k -1)+1, Np*k ); // nodes in new element k KIo.reset(Np*(ko-1)+1, Np*ko); // nodes in old element ko interp = Vandermonde2D(N, rOUT, sOUT)*invV; for (n=1; n<=Nfields; ++n) { //newQ(:,k,n)= interp* Q(:,ko,n); //DVec tm1 = interp*oldQ(KIo,n); //dumpDVec(tm1, "tm1"); newQ(KI,n) = interp*oldQ(KIo,n); } } return newQ; }
void ICUServiceTest::testAPI_Two() { UErrorCode status = U_ZERO_ERROR; TestStringService service; service.registerFactory(new AnonymousStringFactory(), status); // anonymous factory will still handle the id { UErrorCode status = U_ZERO_ERROR; const UnicodeString en_US = "en_US"; UnicodeString* result = (UnicodeString*)service.get(en_US, status); confirmEqual("21) locale", result, &en_US); delete result; } // still normalizes id { UErrorCode status = U_ZERO_ERROR; const UnicodeString en_US_BAR = "en_US_BAR"; UnicodeString resultID; UnicodeString* result = (UnicodeString*)service.get("EN_us_bar", &resultID, status); confirmEqual("22) locale", &resultID, &en_US_BAR); delete result; } // we can override for particular ids UnicodeString* singleton0 = new UnicodeString("Zero"); service.registerInstance(singleton0, "en_US_BAR", status); { UErrorCode status = U_ZERO_ERROR; UnicodeString* result = (UnicodeString*)service.get("en_US_BAR", status); confirmEqual("23) override super", result, singleton0); delete result; } // empty service should not recognize anything service.reset(); { UErrorCode status = U_ZERO_ERROR; UnicodeString* result = (UnicodeString*)service.get("en_US", status); confirmIdentical("24) empty", result, NULL); } // create a custom multiple key factory { UnicodeString xids[] = { "en_US_VALLEY_GIRL", "en_US_VALLEY_BOY", "en_US_SURFER_GAL", "en_US_SURFER_DUDE" }; int32_t count = sizeof(xids)/sizeof(UnicodeString); ICUServiceFactory* f = new TestMultipleKeyStringFactory(xids, count, "Later"); service.registerFactory(f, status); } // iterate over the visual ids returned by the multiple factory { UErrorCode status = U_ZERO_ERROR; UVector ids(uhash_deleteUnicodeString, uhash_compareUnicodeString, 0, status); service.getVisibleIDs(ids, status); for (int i = 0; i < ids.size(); ++i) { const UnicodeString* id = (const UnicodeString*)ids[i]; UnicodeString* result = (UnicodeString*)service.get(*id, status); if (result) { logln(" " + *id + " --> " + *result); delete result; } else { errln("could not find " + *id); } } // four visible ids confirmIdentical("25) visible ids", ids.size(), 4); } // iterate over the display names { UErrorCode status = U_ZERO_ERROR; UVector names(status); service.getDisplayNames(names, status); for (int i = 0; i < names.size(); ++i) { const StringPair* pair = (const StringPair*)names[i]; logln(" " + pair->displayName + " --> " + pair->id); } confirmIdentical("26) display names", names.size(), 4); } // no valid display name { UnicodeString name; service.getDisplayName("en_US_VALLEY_GEEK", name); confirmBoolean("27) get display name", name.isBogus()); } { UnicodeString name; service.getDisplayName("en_US_SURFER_DUDE", name, Locale::getEnglish()); confirmStringsEqual("28) get display name", name, "English (United States, SURFER_DUDE)"); } // register another multiple factory { UnicodeString xids[] = { "en_US_SURFER", "en_US_SURFER_GAL", "en_US_SILICON", "en_US_SILICON_GEEK", }; int32_t count = sizeof(xids)/sizeof(UnicodeString); ICUServiceFactory* f = new TestMultipleKeyStringFactory(xids, count, "Rad dude"); service.registerFactory(f, status); } // this time, we have seven display names // Rad dude's surfer gal 'replaces' Later's surfer gal { UErrorCode status = U_ZERO_ERROR; UVector names(status); service.getDisplayNames(names, Locale("es"), status); for (int i = 0; i < names.size(); ++i) { const StringPair* pair = (const StringPair*)names[i]; logln(" " + pair->displayName + " --> " + pair->id); } confirmIdentical("29) display names", names.size(), 7); } // we should get the display name corresponding to the actual id // returned by the id we used. { UErrorCode status = U_ZERO_ERROR; UnicodeString actualID; UnicodeString id = "en_us_surfer_gal"; UnicodeString* gal = (UnicodeString*)service.get(id, &actualID, status); if (gal != NULL) { UnicodeString displayName; logln("actual id: " + actualID); service.getDisplayName(actualID, displayName, Locale::getEnglish()); logln("found actual: " + *gal + " with display name: " + displayName); confirmBoolean("30) found display name for actual", !displayName.isBogus()); service.getDisplayName(id, displayName, Locale::getEnglish()); logln("found actual: " + *gal + " with display name: " + displayName); confirmBoolean("31) found display name for query", displayName.isBogus()); delete gal; } else { errln("30) service could not find entry for " + id); } } // this should be handled by the 'dude' factory, since it overrides en_US_SURFER. { UErrorCode status = U_ZERO_ERROR; UnicodeString actualID; UnicodeString id = "en_US_SURFER_BOZO"; UnicodeString* bozo = (UnicodeString*)service.get(id, &actualID, status); if (bozo != NULL) { UnicodeString displayName; service.getDisplayName(actualID, displayName, Locale::getEnglish()); logln("found actual: " + *bozo + " with display name: " + displayName); confirmBoolean("32) found display name for actual", !displayName.isBogus()); service.getDisplayName(id, displayName, Locale::getEnglish()); logln("found actual: " + *bozo + " with display name: " + displayName); confirmBoolean("33) found display name for query", displayName.isBogus()); delete bozo; } else { errln("32) service could not find entry for " + id); } } // certainly not default... { confirmBoolean("34) is default ", !service.isDefault()); } { UErrorCode status = U_ZERO_ERROR; UVector ids(uhash_deleteUnicodeString, uhash_compareUnicodeString, 0, status); service.getVisibleIDs(ids, status); for (int i = 0; i < ids.size(); ++i) { const UnicodeString* id = (const UnicodeString*)ids[i]; msgstr(*id + "? ", service.get(*id, status)); } logstr("valleygirl? ", service.get("en_US_VALLEY_GIRL", status)); logstr("valleyboy? ", service.get("en_US_VALLEY_BOY", status)); logstr("valleydude? ", service.get("en_US_VALLEY_DUDE", status)); logstr("surfergirl? ", service.get("en_US_SURFER_GIRL", status)); } }
JSObject * GlobalObject::initFunctionAndObjectClasses(JSContext *cx) { JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment); JS_ASSERT(isNative()); /* * Calling a function from a cleared global triggers this (yeah, I know). * Uncomment this once bug 470510 is fixed (if that bug doesn't remove * isCleared entirely). */ // JS_ASSERT(!isCleared()); /* If cx has no global object, make this the global object. */ if (!cx->globalObject) JS_SetGlobalObject(cx, this); /* * Create |Object.prototype| first, mirroring CreateBlankProto but for the * prototype of the created object. */ JSObject *objectProto = NewObjectWithGivenProto(cx, &ObjectClass, NULL, this); if (!objectProto || !objectProto->setSingletonType(cx)) return NULL; /* * The default 'new' type of Object.prototype is required by type inference * to have unknown properties, to simplify handling of e.g. heterogenous * objects in JSON and script literals. */ if (!objectProto->setNewTypeUnknown(cx)) return NULL; /* Create |Function.prototype| next so we can create other functions. */ JSFunction *functionProto; { JSObject *proto = NewObjectWithGivenProto(cx, &FunctionClass, objectProto, this); if (!proto) return NULL; /* * Bizarrely, |Function.prototype| must be an interpreted function, so * give it the guts to be one. */ functionProto = js_NewFunction(cx, proto, NULL, 0, JSFUN_INTERPRETED, this, NULL); if (!functionProto) return NULL; JS_ASSERT(proto == functionProto); functionProto->flags |= JSFUN_PROTOTYPE; JSScript *script = JSScript::NewScript(cx, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, JSVERSION_DEFAULT); if (!script) return NULL; script->noScriptRval = true; script->code[0] = JSOP_STOP; script->code[1] = SRC_NULL; functionProto->initScript(script); functionProto->getType(cx)->interpretedFunction = functionProto; script->setFunction(functionProto); if (!proto->setSingletonType(cx)) return NULL; /* * The default 'new' type of Function.prototype is required by type * inference to have unknown properties, to simplify handling of e.g. * CloneFunctionObject. */ if (!proto->setNewTypeUnknown(cx)) return NULL; } /* Create the Object function now that we have a [[Prototype]] for it. */ jsid objectId = ATOM_TO_JSID(CLASS_ATOM(cx, Object)); JSFunction *objectCtor; { JSObject *ctor = NewObjectWithGivenProto(cx, &FunctionClass, functionProto, this); if (!ctor) return NULL; objectCtor = js_NewFunction(cx, ctor, js_Object, 1, JSFUN_CONSTRUCTOR, this, JSID_TO_ATOM(objectId)); if (!objectCtor) return NULL; JS_ASSERT(ctor == objectCtor); objectCtor->setConstructorClass(&ObjectClass); } /* * Install |Object| and |Object.prototype| for the benefit of subsequent * code that looks for them. */ setObjectClassDetails(objectCtor, objectProto); /* Create |Function| so it and |Function.prototype| can be installed. */ jsid functionId = ATOM_TO_JSID(CLASS_ATOM(cx, Function)); JSFunction *functionCtor; { JSObject *ctor = NewObjectWithGivenProto(cx, &FunctionClass, functionProto, this); if (!ctor) return NULL; functionCtor = js_NewFunction(cx, ctor, Function, 1, JSFUN_CONSTRUCTOR, this, JSID_TO_ATOM(functionId)); if (!functionCtor) return NULL; JS_ASSERT(ctor == functionCtor); functionCtor->setConstructorClass(&FunctionClass); } /* * Install |Function| and |Function.prototype| so that we can freely create * functions and objects without special effort. */ setFunctionClassDetails(functionCtor, functionProto); /* * The hard part's done: now go back and add all the properties these * primordial values have. */ if (!LinkConstructorAndPrototype(cx, objectCtor, objectProto) || !DefinePropertiesAndBrand(cx, objectProto, object_props, object_methods) || !DefinePropertiesAndBrand(cx, objectCtor, NULL, object_static_methods) || !LinkConstructorAndPrototype(cx, functionCtor, functionProto) || !DefinePropertiesAndBrand(cx, functionProto, NULL, function_methods) || !DefinePropertiesAndBrand(cx, functionCtor, NULL, NULL)) { return NULL; } /* Add the global Function and Object properties now. */ if (!addDataProperty(cx, objectId, JSProto_Object + JSProto_LIMIT * 2, 0)) return NULL; if (!addDataProperty(cx, functionId, JSProto_Function + JSProto_LIMIT * 2, 0)) return NULL; /* Heavy lifting done, but lingering tasks remain. */ /* ES5 15.1.2.1. */ jsid id = ATOM_TO_JSID(cx->runtime->atomState.evalAtom); JSObject *evalobj = js_DefineFunction(cx, this, id, eval, 1, JSFUN_STUB_GSOPS); if (!evalobj) return NULL; setOriginalEval(evalobj); /* ES5 13.2.3: Construct the unique [[ThrowTypeError]] function object. */ JSFunction *throwTypeError = js_NewFunction(cx, NULL, ThrowTypeError, 0, 0, this, NULL); if (!throwTypeError) return NULL; AutoIdVector ids(cx); if (!throwTypeError->preventExtensions(cx, &ids)) return NULL; setThrowTypeError(throwTypeError); /* * The global object should have |Object.prototype| as its [[Prototype]]. * Eventually we'd like to have standard classes be there from the start, * and thus we would know we were always setting what had previously been a * null [[Prototype]], but right now some code assumes it can set the * [[Prototype]] before standard classes have been initialized. For now, * only set the [[Prototype]] if it hasn't already been set. */ if (shouldSplicePrototype(cx) && !splicePrototype(cx, objectProto)) return NULL; /* * Notify any debuggers about the creation of the script for * |Function.prototype| -- after all initialization, for simplicity. */ js_CallNewScriptHook(cx, functionProto->script(), functionProto); return functionProto; }
TEST_F(InstanceTest, Set_construction) { SetInstance ids("String", "create:", std::vector<std::string>({"ids"})); EXPECT_EQ(ids.type(), "Set"); EXPECT_EQ(ids.name(), "ids"); EXPECT_EQ(ids.representation(), "{}"); }
void passwd_cache::loadConfig() { // initialize cache with any configured mappings char *usermap_str = param("USERID_MAP"); if( !usermap_str ) { return; } // format is "username=uid,gid,gid2,gid3,... user2=uid2,gid2,..." // first split on spaces, which separate the records // If gid2 is "?", then we assume that supplemental groups // are unknown. StringList usermap(usermap_str," "); free( usermap_str ); char *username; usermap.rewind(); while( (username=usermap.next()) ) { char *userids = strchr(username,'='); ASSERT( userids ); *userids = '\0'; userids++; // the user ids are separated by commas StringList ids(userids,","); ids.rewind(); struct passwd pwent; char const *idstr = ids.next(); uid_t uid; gid_t gid; if( !idstr || !parseUid(idstr,&uid) ) { EXCEPT("Invalid USERID_MAP entry %s=%s",username,userids); } idstr = ids.next(); if( !idstr || !parseGid(idstr,&gid) ) { EXCEPT("Invalid USERID_MAP entry %s=%s",username,userids); } pwent.pw_name = username; pwent.pw_uid = uid; pwent.pw_gid = gid; cache_uid(&pwent); idstr = ids.next(); if( idstr && !strcmp(idstr,"?") ) { continue; // no information about supplemental groups } ids.rewind(); ids.next(); // go to first group id group_entry *group_cache_entry; if ( group_table->lookup(username, group_cache_entry) < 0 ) { init_group_entry(group_cache_entry); } /* now get the group list */ if ( group_cache_entry->gidlist != NULL ) { delete[] group_cache_entry->gidlist; group_cache_entry->gidlist = NULL; } group_cache_entry->gidlist_sz = ids.number()-1; group_cache_entry->gidlist = new gid_t[group_cache_entry->gidlist_sz]; unsigned g; for(g=0; g<group_cache_entry->gidlist_sz; g++) { idstr = ids.next(); ASSERT( idstr ); if( !parseGid(idstr,&group_cache_entry->gidlist[g]) ) { EXCEPT("Invalid USERID_MAP entry %s=%s",username,userids); } } /* finally, insert info into our cache */ group_cache_entry->lastupdated = time(NULL); group_table->insert(username, group_cache_entry); } }
void loadcontainers() { cScpIterator* iter = NULL; std::string script1, script2; SI32 gump = INVALID; BasicPosition uprleft = {INVALID,INVALID}; BasicPosition dwnrght = {INVALID,INVALID}; UI32VECTOR *vet = new UI32VECTOR; int cont=0; int loopexit=0; do { safedelete(iter); iter = Scripts::Containers->getNewIterator("SECTION CONTAINER %i", cont++); if( iter==NULL ) continue; gump = INVALID; uprleft.x = INVALID; uprleft.y = INVALID; dwnrght.x = INVALID; dwnrght.y = INVALID; vet->clear(); do { iter->parseLine(script1, script2); if ( script1[0]!='}' && script1[0]!='{' ) { if ( "ID" == script1 ) vet->push_back( str2num( script2 ) ); else if ( "GUMP" == script1 ) gump = str2num( script2 ); else if ( "X1" == script1 ) uprleft.x= str2num( script2 ); else if ( "Y1" == script1 ) uprleft.y= str2num( script2 ); else if ( "X2" == script1 ) dwnrght.x= str2num( script2 ); else if ( "Y2" == script1 ) dwnrght.y= str2num( script2 ); else WarnOut("[ERROR] wrong line ( %s ) parsed on containers.xss", script1.c_str() ); } } while ( script1[0] !='}' && ++loopexit < MAXLOOPS ); if( (gump!=INVALID) && (uprleft.x!=INVALID) && (dwnrght.x!=INVALID) && (uprleft.y!=INVALID) && (dwnrght.y!=INVALID) ) { cont_gump_st dummy; dummy.downright = dwnrght; dummy.upperleft = uprleft; dummy.gump = gump; contInfoGump[gump] = dummy; CONTINFOGUMPMAP::iterator iter( contInfoGump.find(gump) ); if( iter != contInfoGump.end() ) { UI32VECTOR::iterator ids( vet->begin() ), end( vet->end() ); for(; ids != end; ++ids ) contInfo[(*ids)] = iter; } else ConOut("[ERROR] on parse of containers.xss" ); } else ConOut("[ERROR] on parse of containers.xss" ); } while ( script1 != "EOF" && ++loopexit < MAXLOOPS ); safedelete(iter); // ConOut("\n"); // for(CONTINFOMAP::iterator debug=contInfo.begin(); debug!=contInfo.end(); debug++ ) // ConOut( "id %i ha gump %i \n ", debug->first, (debug->second)->second.gump); }
//--------------------------------------------------------- void NDG3D::Hrefine3D(IVec& refineflag) //--------------------------------------------------------- { DVec lVX("lVX"), lVY("lVY"), lVZ("lVZ"); int a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10; // a b c d e f g h i j lVX.load(10, " 0 1 0 0 0.5 0.5 0.0 0.0 0.5 0.0 "); lVY.load(10, " 0 0 1 0 0.0 0.5 0.5 0.0 0.0 0.5 "); lVZ.load(10, " 0 0 0 1 0.0 0.0 0.0 0.5 0.5 0.5 "); assert(4 == Nfaces); IMat lEToV(8,4, "lEToV"), im84(8,4, "im84"), oFnodes(4,6, "oFnodes"); set84(lEToV, 8,4, a, e, g, h, e, b, f, i, g, f, c, j, h, i, j, d, e, g, h, i, h, i, g, j, e, f, g, i, g, i, f, j); set46(oFnodes, 4,6, a, e, b, f, c, g, a, e, b, i, d, h, b, f, c, j, d, i, a, g, c, j, d, h); IMat vnum(gRowData, 4,3, "1 2 3 1 2 4 2 3 4 3 1 4"); int lK = lEToV.num_rows(); IMat lBCType(lK, Nfaces), tm1, tm2; IVec tv(3),tv1,tv2, oFn,vnp,ksids; int kk=0,ff=0,oo=0; for (kk=1; kk<=lK; ++kk) { for (ff=1; ff<=Nfaces; ++ff) { for (oo=1; oo<=Nfaces; ++oo) { oFn = oFnodes.get_row(oo); vnp = vnum.get_row(ff); tm1 = lEToV(kk, vnp); const IVec& knodes = dynamic_cast<const IVec&>(tm1); //tv = intersect(lEToV(k, vnum(p,All)), oFnodes(o,All)); tv = intersect(knodes, oFn); if ( tv.length()==3 ) { lBCType(kk, ff) = oo; } } } } int NV = VX.length()+1; int sp_len = NV + NV*NV; // sparse buffers nnz vals,triplet CSd newVX(sp_len,1, NV, 1, 1); CSd newVY(sp_len,1, NV, 1, 1); CSd newVZ(sp_len,1, NV, 1, 1); Index1D II(1, NV-1); newVX(II,1) = VX; newVY(II,1) = VY; newVZ(II,1) = VZ; IVec ids("ids"); int oldK = K, f1=0; for (int k1=1; k1<=oldK; ++k1) { if (refineflag(k1)) { a = EToV(k1,1); b = EToV(k1,2); c = EToV(k1,3); d = EToV(k1,4); e = NV + std::max(a*NV+b, b*NV + a); f = NV + std::max(b*NV+c, c*NV + b); g = NV + std::max(a*NV+c, c*NV + a); h = NV + std::max(a*NV+d, d*NV + a); i = NV + std::max(b*NV+d, d*NV + b); j = NV + std::max(c*NV+d, d*NV + c); //ks = [k1, K+1:K+7]; IVec ks(1, k1); ks.append(Range(K+1,K+7)); //-------------------------- // EToV(ks,:) = [a e g h; // e b f i; // g f c j; // h i j d; // e g h i; // h i g j; // e f g i; // g i f j]; //-------------------------- set84(im84, 8,4, a, e, g, h, e, b, f, i, g, f, c, j, h, i, j, d, e, g, h, i, h, i, g, j, e, f, g, i, g, i, f, j); //EToV(ks,All) = im84; EToV.merge_rows(ks, im84); for (f1=1; f1<=Nfaces; ++f1) { tv = lBCType(All,f1); ids = find(tv, '!', 0); ksids = ks(ids); tm1 = lBCType(ids,f1); tm2 = BCType(k1, (const IVec&)tm1); // expand BCType to accommodate new range int maxI=ksids.max_val(), maxR=BCType.num_rows(); if (maxI>maxR) {BCType.realloc(maxI, BCType.num_cols());} BCType(ksids,f1) = trans(tm2); } K += 7; newVX.set1(e,1, 0.5*(VX(a)+VX(b))); newVX.set1(f,1, 0.5*(VX(b)+VX(c))); newVX.set1(g,1, 0.5*(VX(c)+VX(a))); newVX.set1(h,1, 0.5*(VX(a)+VX(d))); newVX.set1(i,1, 0.5*(VX(b)+VX(d))); newVX.set1(j,1, 0.5*(VX(c)+VX(d))); newVY.set1(e,1, 0.5*(VY(a)+VY(b))); newVY.set1(f,1, 0.5*(VY(b)+VY(c))); newVY.set1(g,1, 0.5*(VY(c)+VY(a))); newVY.set1(h,1, 0.5*(VY(a)+VY(d))); newVY.set1(i,1, 0.5*(VY(b)+VY(d))); newVY.set1(j,1, 0.5*(VY(c)+VY(d))); newVZ.set1(e,1, 0.5*(VZ(a)+VZ(b))); newVZ.set1(f,1, 0.5*(VZ(b)+VZ(c))); newVZ.set1(g,1, 0.5*(VZ(c)+VZ(a))); newVZ.set1(h,1, 0.5*(VZ(a)+VZ(d))); newVZ.set1(i,1, 0.5*(VZ(b)+VZ(d))); newVZ.set1(j,1, 0.5*(VZ(c)+VZ(d))); } } //------------------------------------- // drop duplicates and sort //------------------------------------- newVX.compress(true); newVY.compress(true); newVZ.compress(true); //ids = sort(unique(EToV(:)), 'ascend'); ids = unique(EToV); int len=ids.max_val(); IVec gnum(len); gnum(ids) = Range(1,ids.length()); VX = full( newVX, ids ); VY = full( newVY, ids ); VZ = full( newVZ, ids ); // EToV = gnum(EToV); EToV.set_map(EToV, gnum); int NV_old = NV-1; // local counters this->Nv = VX.length(); // update member variable umLOG(1, "Hrefine3D [%d] : old Nv = %4d, new Nv = %4d\n", ++refine_count, NV_old, Nv); umLOG(1, " old K = %4d, new K = %4d\n\n", oldK, K); #if (0) tetramesh(EToV, [VX', VY', VZ']) #endif }
ExportTranslationNotes::ExportTranslationNotes(const ustring & filename, const vector < unsigned int >&ids_to_display, bool export_all) // Exports the notes from the database. /* The exported xml file will look so: <?xml version="1.0" encoding="UTF-8"?> <bibledit-notes version="3"> <note> <reference> </reference> <project> </project> <category> </category> <text> </text> <date-created> </date-created> <date-modified> </date-modified> <user> </user> </note> </bibledit-notes> This is subject to change as bibledit's notes system develops. */ :progresswindow("Exporting notes", true) { // Save variables. my_export_all = export_all; // Start process. try { // Write to outputfile. WriteText wt(filename); my_wt = &wt; // Opening lines. wt.text("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); wt.text("<bibledit-notes version=\"4\">\n"); // Connect to index database. // Note: The index is not the source of the notes. // This implies that, if the index is not up-to-date, // then the export will not be correct. error = NULL; rc = sqlite3_open(notes_index_filename().c_str(), &db); if (rc) throw runtime_error(sqlite3_errmsg(db)); sqlite3_busy_timeout(db, 1000); // Currently this is the notes table schema: // id integer, reference text, project text, category text, casefolded text, created integer, modified integer // Get the number of notes. SqliteReader sqlitereader(0); rc = sqlite3_exec(db, "select count(*) from notes;", sqlitereader.callback, &sqlitereader, &error); if (rc != SQLITE_OK) { throw runtime_error(error); } if (!sqlitereader.ustring0.empty()) { notes_count = convert_to_int (sqlitereader.ustring0[0]); } progresswindow.set_iterate(0, 1, notes_count); // Exporting everything or a selection? set < gint > ids(ids_to_display.begin(), ids_to_display.end()); my_ids = &ids; // Go through all the notes. note_counter = 0; rc = sqlite3_exec(db, "select reference, project, category, casefolded, created, modified from notes;", data_callback, this, &error); if (rc != SQLITE_OK) { throw runtime_error(error); } // Closing lines. wt.text("</bibledit-notes>\n"); } catch(exception & ex) { if (!progresswindow.cancel) { gtkw_dialog_error(NULL, ex.what()); gw_critical(ex.what()); } } }
void PlanarAdjacencyAnnotator::annotate(Crag& crag) { if (optionCragType.as<std::string>() == "empty") return; UTIL_TIME_METHOD; util::box<float, 3> cragBB = crag.getBoundingBox(); util::point<float, 3> resolution; for (Crag::NodeIt n(crag); n != lemon::INVALID; ++n) { if (!crag.isLeafNode(n)) continue; resolution = crag.getVolume(n).getResolution(); break; } // no nodes? if (resolution.isZero()) return; // create a vigra multi-array large enough to hold all volumes vigra::MultiArray<3, int> ids( vigra::Shape3( cragBB.width() /resolution.x(), cragBB.height()/resolution.y(), cragBB.depth() /resolution.z()), std::numeric_limits<int>::max()); for (Crag::NodeIt n(crag); n != lemon::INVALID; ++n) { if (!crag.isLeafNode(n)) continue; const util::point<float, 3>& volumeOffset = crag.getVolume(n).getOffset(); const util::box<unsigned int, 3>& volumeDiscreteBB = crag.getVolume(n).getDiscreteBoundingBox(); util::point<unsigned int, 3> begin = (volumeOffset - cragBB.min())/resolution; util::point<unsigned int, 3> end = begin + util::point<unsigned int, 3>( volumeDiscreteBB.width(), volumeDiscreteBB.height(), volumeDiscreteBB.depth()); vigra::combineTwoMultiArrays( crag.getVolume(n).data(), ids.subarray( vigra::Shape3( begin.x(), begin.y(), begin.z()), vigra::Shape3( end.x(), end.y(), end.z())), ids.subarray( vigra::Shape3( begin.x(), begin.y(), begin.z()), vigra::Shape3( end.x(), end.y(), end.z())), vigra::functor::ifThenElse( vigra::functor::Arg1() == vigra::functor::Param(1), vigra::functor::Param(crag.id(n)), vigra::functor::Arg2() )); } //vigra::exportImage( //ids.bind<2>(0), //vigra::ImageExportInfo("debug/ids.tif")); typedef vigra::GridGraph<3> GridGraphType; typedef vigra::AdjacencyListGraph RagType; GridGraphType grid( ids.shape(), _neighborhood == Direct ? vigra::DirectNeighborhood : vigra::IndirectNeighborhood); RagType rag; RagType::EdgeMap<std::vector<GridGraphType::Edge>> affiliatedEdges; vigra::makeRegionAdjacencyGraph( grid, ids, rag, affiliatedEdges, std::numeric_limits<int>::max()); unsigned int numAdded = 0; crag.setGridGraph(grid); for (RagType::EdgeIt e(rag); e != lemon::INVALID; ++e) { int u = rag.id(rag.u(*e)); int v = rag.id(rag.v(*e)); Crag::Edge newEdge = crag.addAdjacencyEdge( crag.nodeFromId(u), crag.nodeFromId(v)); crag.setAffiliatedEdges( newEdge, affiliatedEdges[*e]); numAdded++; LOG_ALL(planaradjacencyannotatorlog) << "adding leaf node adjacency between " << u << " and " << v << std::endl; } LOG_USER(planaradjacencyannotatorlog) << "added " << numAdded << " leaf node adjacency edges" << std::endl; if (optionCragType.as<std::string>() == "full") propagateLeafAdjacencies(crag); }
void NETWORK::get_coordinates( double _z, double _dx, double _dy, std::vector<double>& _lrc, std::vector<double>& _x, std::vector<double>& _y ) const { /// create reachable set sizes std::vector<double> rss( Order, 0.0 ); for(int i=0; i<Order; i++) rss[i] = (double)Order * _lrc[i]; /// make levels // sort local reaching centralities std::vector<int> ids( Order, 0 ); for(int i=0; i<Order; i++) ids[i] = i; int len = Order; double rss_elem; int id; bool swapped = false; do { swapped = false; for(int i=1; i<len; i++) { if( rss[i-1] > rss[i] ) { rss_elem = rss[i-1]; rss[i-1] = rss[i]; rss[i] = rss_elem; id = ids[i-1]; ids[i-1] = ids[i]; ids[i] = id; swapped = true; } } len--; } while( swapped ); // network reaching centrality mean and variance double global_av = 0.0; double global_sd = 0.0; double threshold = 0.0; for(int i=0; i<Order; i++) { global_av += rss[i]; global_sd += rss[i]*rss[i]; } global_av /= (double)Order; global_sd = sqrt( fabs(global_sd/(double)Order - global_av*global_av) ); threshold = _z * global_sd + 0.00001; // in case of GRC = 0 // sort nodes in levels int number_of_levels = 0; int level_first_node = 0; int current_node = 1; std::vector<int> levels( Order, -1 ); levels[0] = 0; // start putting nodes in level until we reach last node while( current_node < Order ) { // pick the next node and calculate level average and standard deviation double level_av = 0.0; double level_sd = 0.0; for(int i=level_first_node; i<=current_node; i++) { level_av += rss[i]; level_sd += rss[i]*rss[i]; } level_av /= 1 + current_node - level_first_node; level_sd = sqrt( fabs(level_sd/double(1+current_node-level_first_node) - level_av*level_av) ); // if level deviation is lower than the threshold, keep node, otherwise start new level and put node there if( level_sd < threshold ) { levels[current_node] = number_of_levels; current_node++; } else { levels[current_node] = number_of_levels + 1; number_of_levels++; level_first_node = current_node; current_node++; } } number_of_levels++; /// set y coordinates std::vector<int> nodes_per_level( number_of_levels, 0 ); // calculate level averages std::vector<double> averages( number_of_levels, 0.0 ); for(int i=0; i<Order; i++) { averages[levels[i]] += rss[i]; nodes_per_level[levels[i]]++; } for(int i=0; i<number_of_levels; i++) averages[i] /= nodes_per_level[i]; std::vector<double> y_differences( number_of_levels, 0.0 ); std::vector<double> y_coordinates( number_of_levels, 0.0 ); y_differences[0] = 0.0; y_coordinates[0] = 0.0; double minimum_difference = _dy * (double)Order; for(int i=1; i<number_of_levels; i++) { y_differences[i] = log( averages[i]-averages[i-1] + 1.0 ); if( y_differences[i] < minimum_difference ) minimum_difference = y_differences[i]; } for(int i=1; i<number_of_levels; i++) y_coordinates[i] = y_coordinates[i-1] + _dy*y_differences[i]/minimum_difference; _y.assign( Order, 0.0 ); for(int i=0; i<Order; i++) _y[ids[i]] = y_coordinates[levels[i]]; /// set x coordinates std::vector<double> x_coordinate_starts( number_of_levels, 0.0 ); for(int i=0; i<number_of_levels; i++) { x_coordinate_starts[i] = -0.5 * _dx * (nodes_per_level[i] - 1); nodes_per_level[i] = 0; } _x.assign( Order, 0.0 ); for(int i=0; i<Order; i++) { _x[ids[i]] = x_coordinate_starts[levels[i]] + _dx * nodes_per_level[levels[i]]; nodes_per_level[levels[i]]++; } }
//--------------------------------------------------------- void NDG2D::MakeCylinder2D ( const IMat& faces, double ra, double xo, double yo ) //--------------------------------------------------------- { // Function: MakeCylinder2D(faces, ra, xo, yo) // Purpose: Use Gordon-Hall blending with an isoparametric // map to modify a list of faces so they conform // to a cylinder of radius r centered at (xo,yo) int NCurveFaces = faces.num_rows(); IVec vflag(VX.size()); IMat VFlag(EToV.num_rows(),EToV.num_cols()); int n=0,k=0,f=0,v1=0,v2=0; double theta1=0.0,theta2=0.0,x1=0.0,x2=0.0,y1=0.0,y2=0.0; double newx1=0.0,newx2=0.0,newy1=0.0,newy2=0.0; DVec vr, fr, theta, fdx,fdy, vdx, vdy, blend,numer,denom; IVec va,vb,vc, ks, Fm_f, ids; DMat Vface, Vvol; for (n=1; n<=NCurveFaces; ++n) { // move vertices of faces to be curved onto circle k = faces(n,1); f = faces(n,2); v1 = EToV(k, f); v2 = EToV(k, umMOD(f,Nfaces)+1); theta1 = atan2(VY(v1),VX(v1)); theta2 = atan2(VY(v2),VX(v2)); newx1 = xo + ra*cos(theta1); newy1 = yo + ra*sin(theta1); newx2 = xo + ra*cos(theta2); newy2 = yo + ra*sin(theta2); // update mesh vertex locations VX(v1) = newx1; VX(v2) = newx2; VY(v1) = newy1; VY(v2) = newy2; // store modified vertex numbers vflag(v1) = 1; vflag(v2) = 1; } // map modified vertex flag to each element //vflag = vflag(EToV); VFlag.set_map(EToV, vflag); // (map, values) // locate elements with at least one modified vertex //ks = find(sum(vflag,2)>0); ks = find(VFlag.row_sums(), '>', 0); // build coordinates of all the corrected nodes IMat VA=EToV(ks,1), VB=EToV(ks,2), VC=EToV(ks,3); // FIXME: loading 2D mapped data into 1D vectors int Nr=VA.num_rows(); va.copy(Nr,VA.data()); vb.copy(Nr,VB.data()); vc.copy(Nr,VC.data()); // Note: outer products of (Vector,MappedRegion1D) x(All,ks) = 0.5*(-(r+s)*VX(va)+(1.0+r)*VX(vb)+(1.0+s)*VX(vc)); y(All,ks) = 0.5*(-(r+s)*VY(va)+(1.0+r)*VY(vb)+(1.0+s)*VY(vc)); // deform specified faces for (n=1; n<=NCurveFaces; ++n) { k = faces(n,1); f = faces(n,2); // find vertex locations for this face and tangential coordinate if (f==1) { v1=EToV(k,1); v2=EToV(k,2); vr=r; } else if (f==2) { v1=EToV(k,2); v2=EToV(k,3); vr=s; } else if (f==3) { v1=EToV(k,1); v2=EToV(k,3); vr=s; } fr = vr(Fmask(All,f)); x1 = VX(v1); y1 = VY(v1); x2 = VX(v2); y2 = VY(v2); // move vertices at end points of this face to the cylinder theta1 = atan2(y1-yo, x1-xo); theta2 = atan2(y2-yo, x2-xo); // check to make sure they are in the same quadrant if ((theta2 > 0.0) && (theta1 < 0.0)) { theta1 += 2*pi; } if ((theta1 > 0.0) && (theta2 < 0.0)) { theta2 += 2*pi; } // distribute N+1 nodes by arc-length along edge theta = 0.5*theta1*(1.0-fr) + 0.5*theta2*(1.0+fr); // evaluate deformation of coordinates fdx = xo + ra*apply(cos,theta) - x(Fmask(All,f),k); fdy = yo + ra*apply(sin,theta) - y(Fmask(All,f),k); // build 1D Vandermonde matrix for face nodes and volume nodes Vface = Vandermonde1D(N, fr); Vvol = Vandermonde1D(N, vr); // compute unblended volume deformations vdx = Vvol * (Vface|fdx); vdy = Vvol * (Vface|fdy); // blend deformation and increment node coordinates ids = find(abs(1.0-vr), '>', 1e-7); // warp and blend denom = 1.0-vr(ids); if (1==f) { numer = -(r(ids)+s(ids)); } else if (2==f) { numer = (r(ids)+1.0 ); } else if (3==f) { numer = -(r(ids)+s(ids)); } blend = numer.dd(denom); //----------------------------------- // x(ids,k) += blend.dm(vdx(ids)); // VC++ compiler specific? // y(ids,k) += blend.dm(vdy(ids)); //----------------------------------- // unroll the above operator int Nr = ids.size(), id=0; for (int m=1; m<=Nr; ++m) { id=ids(m); x(id,k) += blend(m)*vdx(id); y(id,k) += blend(m)*vdy(id); } } // repair other coordinate dependent information Fx = x(Fmask, All); Fy = y(Fmask, All); ::GeometricFactors2D(x,y,Dr,Ds, rx,sx,ry,sy,J); Normals2D(); Fscale = sJ.dd(J(Fmask,All)); }
af::Msg* threadProcessMsgCase( ThreadArgs * i_args, af::Msg * i_msg) { //i_msg->stdOut(); //printf("IM=%d LM=%d MM=%d\n", i_msg->getMagicNumber(), af::Msg::Magic, af::Environment::getMagicMode()); af::Msg * o_msg_response = NULL; switch( i_msg->type()) { case af::Msg::TVersionMismatch: { AFCommon::QueueLogError( i_msg->v_generateInfoString( false)); o_msg_response = new af::Msg( af::Msg::TVersionMismatch, 1); break; } case af::Msg::TMagicMismatch: { std::string err = "Magick number mismatch: recieved "; err += af::itos( i_msg->getMagicNumber()) + " != " + af::itos( af::Msg::Magic) += " local."; AFCommon::QueueLogError( err); o_msg_response = new af::Msg( af::Msg::TMagicMismatch, 1); break; } case af::Msg::TMagicNumber: { std::string msg = "Magick Number " + af::itos( af::Msg::Magic) + " changed to " + af::itos( i_msg->int32()); AFCommon::QueueLog( msg); o_msg_response = new af::Msg(); o_msg_response->setString( msg); af::Msg::Magic = i_msg->int32(); break; } case af::Msg::TInvalid: { AFCommon::QueueLogError( std::string("Invalid message recieved: ") + i_msg->v_generateInfoString( false)); break; } case af::Msg::TNULL: case af::Msg::TDATA: case af::Msg::TTESTDATA: case af::Msg::TStringList: { i_msg->stdOutData(); break; } case af::Msg::THTTP: case af::Msg::TJSON: { return threadProcessJSON( i_args, i_msg); } case af::Msg::TString: { std::string str = i_msg->getString(); if( str.empty()) break; AFCommon::QueueLog( str); AfContainerLock mLock( i_args->monitors, AfContainerLock::WRITELOCK); i_args->monitors->sendMessage( str); break; } case af::Msg::TStatRequest: { o_msg_response = new af::Msg; af::statwrite( o_msg_response); break; } case af::Msg::TConfirm: { printf("Thread process message: Msg::TConfirm: %d\n", i_msg->int32()); i_args->msgQueue->pushMsg( new af::Msg( af::Msg::TConfirm, 1)); o_msg_response = new af::Msg( af::Msg::TConfirm, 1 - i_msg->int32()); break; } case af::Msg::TConfigLoad: { AfContainerLock jlock( i_args->jobs, AfContainerLock::WRITELOCK); AfContainerLock rlock( i_args->renders, AfContainerLock::WRITELOCK); AfContainerLock tlock( i_args->talks, AfContainerLock::WRITELOCK); AfContainerLock ulock( i_args->users, AfContainerLock::WRITELOCK); printf("\n ========= RELOADING CONFIG =========\n\n"); std::string message; if( af::Environment::reload()) { message = "Reloaded successfully."; printf("\n ========= CONFIG RELOADED SUCCESSFULLY =========\n\n"); } else { message = "Failed, see server logs fo details."; printf("\n ========= CONFIG RELOADING FAILED =========\n\n"); } o_msg_response = new af::Msg(); o_msg_response->setString( message); break; } case af::Msg::TFarmLoad: { AfContainerLock mLock( i_args->monitors, AfContainerLock::WRITELOCK); AfContainerLock rlock( i_args->renders, AfContainerLock::WRITELOCK); printf("\n ========= RELOADING FARM =========\n\n"); std::string message; if( af::loadFarm( true)) { RenderContainerIt rendersIt( i_args->renders); for( RenderAf *render = rendersIt.render(); render != NULL; rendersIt.next(), render = rendersIt.render()) { render->getFarmHost(); i_args->monitors->addEvent( af::Msg::TMonitorRendersChanged, render->getId()); } message = "Reloaded successfully."; printf("\n ========= FARM RELOADED SUCCESSFULLY =========\n\n"); } else { message = "Failed, see server logs fo details. Check farm with \"afcmd fcheck\" at first."; printf("\n ========= FARM RELOADING FAILED =========\n\n"); } o_msg_response = new af::Msg(); o_msg_response->setString( message); break; } // ---------------------------------- Monitor ---------------------------------// case af::Msg::TMonitorRegister: { AfContainerLock lock( i_args->monitors, AfContainerLock::WRITELOCK); MonitorAf * newMonitor = new MonitorAf( i_msg); newMonitor->setAddressIP( i_msg->getAddress()); o_msg_response = i_args->monitors->addMonitor( newMonitor); break; } case af::Msg::TMonitorUpdateId: { AfContainerLock lock( i_args->monitors, AfContainerLock::READLOCK); if( i_args->monitors->updateId( i_msg->int32())) { o_msg_response = new af::Msg( af::Msg::TMonitorId, i_msg->int32()); } else { o_msg_response = new af::Msg( af::Msg::TMonitorId, 0); } break; } case af::Msg::TMonitorsListRequest: { AfContainerLock lock( i_args->monitors, AfContainerLock::READLOCK); o_msg_response = i_args->monitors->generateList( af::Msg::TMonitorsList); break; } case af::Msg::TMonitorsListRequestIds: { AfContainerLock lock( i_args->monitors, AfContainerLock::READLOCK); af::MCGeneral ids( i_msg); o_msg_response = i_args->monitors->generateList( af::Msg::TMonitorsList, ids); break; } case af::Msg::TMonitorLogRequestId: { AfContainerLock lock( i_args->monitors, AfContainerLock::READLOCK); MonitorContainerIt it( i_args->monitors); MonitorAf* node = it.getMonitor( i_msg->int32()); if( node == NULL ) { // FIXME: Better to return some message in any case. break; } o_msg_response = new af::Msg(); o_msg_response->setStringList( node->getLog()); break; } // ---------------------------------- Talk ---------------------------------// case af::Msg::TTalkRegister: { AfContainerLock mlock( i_args->monitors, AfContainerLock::WRITELOCK); AfContainerLock tlock( i_args->talks, AfContainerLock::WRITELOCK); TalkAf * newTalk = new TalkAf( i_msg); newTalk->setAddressIP( i_msg->getAddress()); o_msg_response = i_args->talks->addTalk( newTalk, i_args->monitors); break; } case af::Msg::TTalksListRequest: { AfContainerLock lock( i_args->talks, AfContainerLock::READLOCK); o_msg_response = i_args->talks->generateList( af::Msg::TTalksList); break; } case af::Msg::TTalksListRequestIds: { AfContainerLock lock( i_args->talks, AfContainerLock::READLOCK); af::MCGeneral ids( i_msg); o_msg_response = i_args->talks->generateList( af::Msg::TTalksList, ids); break; } case af::Msg::TTalkUpdateId: { AfContainerLock lock( i_args->talks, AfContainerLock::READLOCK); if( i_args->talks->updateId( i_msg->int32())) { o_msg_response = i_args->talks->generateList( af::Msg::TTalksList); } else { o_msg_response = new af::Msg( af::Msg::TTalkId, 0); } break; } case af::Msg::TTalkDistributeData: { AfContainerLock lock( i_args->talks, AfContainerLock::READLOCK); i_args->talks->distributeData( i_msg); break; } // ---------------------------------- Render -------------------------------// case af::Msg::TRenderRegister: { //printf("case af::Msg::TRenderRegister:\n"); AfContainerLock mLock( i_args->monitors, AfContainerLock::WRITELOCK); AfContainerLock rLock( i_args->renders, AfContainerLock::WRITELOCK); RenderAf * newRender = new RenderAf( i_msg); newRender->setAddressIP( i_msg->getAddress()); o_msg_response = i_args->renders->addRender( newRender, i_args->monitors); break; } case af::Msg::TRenderUpdate: { //printf("case af::Msg::TRenderUpdate:\n"); AfContainerLock lock( i_args->renders, AfContainerLock::READLOCK); af::Render render_up( i_msg); //printf("Msg::TRenderUpdate: %s - %s\n", render_up.getName().toUtf8().data(), time2Qstr( time(NULL)).toUtf8().data()); RenderContainerIt rendersIt( i_args->renders); RenderAf* render = rendersIt.getRender( render_up.getId()); int id = 0; // If there is not such render, a zero id will be send. // It is a signal for client to register again (may be server was restarted). if((render != NULL) && ( render->update( &render_up))) { id = render->getId(); } o_msg_response = new af::Msg( af::Msg::TRenderId, id); break; } case af::Msg::TRendersListRequest: { AfContainerLock lock( i_args->renders, AfContainerLock::READLOCK); o_msg_response = i_args->renders->generateList( af::Msg::TRendersList); break; } case af::Msg::TRendersListRequestIds: { AfContainerLock lock( i_args->renders, AfContainerLock::READLOCK); af::MCGeneral ids( i_msg); o_msg_response = i_args->renders->generateList( af::Msg::TRendersList, ids); break; } case af::Msg::TRendersResourcesRequestIds: { AfContainerLock lock( i_args->renders, AfContainerLock::READLOCK); af::MCGeneral ids( i_msg); o_msg_response = i_args->renders->generateList( af::Msg::TRendersResources, ids); break; } case af::Msg::TRenderLogRequestId: { AfContainerLock lock( i_args->renders, AfContainerLock::READLOCK); RenderContainerIt rendersIt( i_args->renders); RenderAf* render = rendersIt.getRender( i_msg->int32()); if( render == NULL ) { // FIXME: Better to return some message in any case. break; } o_msg_response = new af::Msg; o_msg_response->setStringList( render->getLog()); break; } case af::Msg::TRenderTasksLogRequestId: { AfContainerLock lock( i_args->renders, AfContainerLock::READLOCK); RenderContainerIt rendersIt( i_args->renders); RenderAf* render = rendersIt.getRender( i_msg->int32()); if( render == NULL ) { // FIXME: Better to return some message in any case. break; } o_msg_response = new af::Msg; if( render->getTasksLog().empty()) { o_msg_response->setString("No tasks execution log."); } else { o_msg_response->setStringList( render->getTasksLog()); } break; } case af::Msg::TRenderInfoRequestId: { AfContainerLock lock( i_args->renders, AfContainerLock::READLOCK); RenderContainerIt rendersIt( i_args->renders); RenderAf* render = rendersIt.getRender( i_msg->int32()); if( render == NULL ) { // FIXME: Better to return some message in any case. break; } o_msg_response = render->writeFullInfo(); break; } // ---------------------------------- Users -------------------------------// case af::Msg::TUserIdRequest: { AfContainerLock lock( i_args->users, AfContainerLock::READLOCK); af::MsgClassUserHost usr( i_msg); std::string name = usr.getUserName(); int id = 0; UserContainerIt usersIt( i_args->users); for( af::User *user = usersIt.user(); user != NULL; usersIt.next(), user = usersIt.user()) { if( user->getName() == name) { id = user->getId(); } } o_msg_response = new af::Msg( af::Msg::TUserId, id); break; } case af::Msg::TUsersListRequest: { AfContainerLock lock( i_args->users, AfContainerLock::READLOCK); o_msg_response = i_args->users->generateList( af::Msg::TUsersList); break; } case af::Msg::TUsersListRequestIds: { AfContainerLock lock( i_args->users, AfContainerLock::READLOCK); af::MCGeneral ids( i_msg); o_msg_response = i_args->users->generateList( af::Msg::TUsersList, ids); break; } case af::Msg::TUserLogRequestId: { AfContainerLock lock( i_args->users, AfContainerLock::READLOCK); UserContainerIt usersIt( i_args->users); UserAf* user = usersIt.getUser( i_msg->int32()); if( user == NULL ) { // FIXME: Better to return some message in any case. break; } o_msg_response = new af::Msg(); o_msg_response->setStringList( user->getLog()); break; } case af::Msg::TUserJobsOrderRequestId: { AfContainerLock lock( i_args->users, AfContainerLock::READLOCK); UserContainerIt usersIt( i_args->users); UserAf* user = usersIt.getUser( i_msg->int32()); if( user == NULL ) { // FIXME: Better to return some message in any case. break; } af::MCGeneral ids; ids.setId( user->getId()); ids.setList( user->generateJobsIds()); o_msg_response = new af::Msg( af::Msg::TUserJobsOrder, &ids); break; } // ------------------------------------- Job -------------------------------// case af::Msg::TJobRequestId: { AfContainerLock lock( i_args->jobs, AfContainerLock::READLOCK); JobContainerIt jobsIt( i_args->jobs); JobAf* job = jobsIt.getJob( i_msg->int32()); if( job == NULL ) { o_msg_response = new af::Msg( af::Msg::TJobRequestId, 0); break; } o_msg_response = new af::Msg( af::Msg::TJob, job); break; } case af::Msg::TJobLogRequestId: { AfContainerLock lock( i_args->jobs, AfContainerLock::READLOCK); JobContainerIt jobsIt( i_args->jobs); JobAf* job = jobsIt.getJob( i_msg->int32()); if( job == NULL ) { // FIXME: Better to return some message in any case. break; } o_msg_response = new af::Msg(); o_msg_response->setStringList( job->getLog()); break; } case af::Msg::TJobErrorHostsRequestId: { AfContainerLock lock( i_args->jobs, AfContainerLock::READLOCK); JobContainerIt jobsIt( i_args->jobs); JobAf* job = jobsIt.getJob( i_msg->int32()); if( job == NULL ) { // FIXME: Better to return some message in any case. break; } o_msg_response = new af::Msg(); o_msg_response->setString( job->v_getErrorHostsListString()); break; } case af::Msg::TJobProgressRequestId: { AfContainerLock lock( i_args->jobs, AfContainerLock::READLOCK); JobContainerIt jobsIt( i_args->jobs); JobAf* job = jobsIt.getJob( i_msg->int32()); if( job == NULL ) { // FIXME: Send back the same message on error - is it good? o_msg_response = new af::Msg( af::Msg::TJobProgressRequestId, 0); break; } o_msg_response = new af::Msg; job->writeProgress( *o_msg_response); break; } case af::Msg::TJobsListRequest: { AfContainerLock lock( i_args->jobs, AfContainerLock::READLOCK); o_msg_response = i_args->jobs->generateList( af::Msg::TJobsList); break; } case af::Msg::TJobsListRequestIds: { AfContainerLock lock( i_args->jobs, AfContainerLock::READLOCK); af::MCGeneral ids( i_msg); o_msg_response = i_args->jobs->generateList( af::Msg::TJobsList, ids); break; } case af::Msg::TJobsListRequestUserId: { AfContainerLock jLock( i_args->jobs, AfContainerLock::READLOCK); AfContainerLock uLock( i_args->users, AfContainerLock::READLOCK); o_msg_response = i_args->users->generateJobsList( i_msg->int32()); if( o_msg_response == NULL ) { o_msg_response = new af::Msg( af::Msg::TUserId, 0); } break; } case af::Msg::TJobsListRequestUsersIds: { AfContainerLock jLock( i_args->jobs, AfContainerLock::READLOCK); AfContainerLock uLock( i_args->users, AfContainerLock::READLOCK); af::MCGeneral mcids( i_msg); std::string type_name; o_msg_response = i_args->users->generateJobsList( mcids.getList(), type_name); break; } case af::Msg::TTaskRequest: { AfContainerLock lock( i_args->jobs, AfContainerLock::READLOCK); af::MCTaskPos mctaskpos( i_msg); JobContainerIt jobsIt( i_args->jobs); JobAf* job = jobsIt.getJob( mctaskpos.getJobId()); if( job == NULL ) { o_msg_response = new af::Msg(); std::ostringstream stream; stream << "Msg::TTaskRequest: No job with id=" << mctaskpos.getJobId(); o_msg_response->setString( stream.str()); break; } af::TaskExec * task = job->generateTask( mctaskpos.getNumBlock(), mctaskpos.getNumTask()); if( task ) { o_msg_response = new af::Msg( af::Msg::TTask, task); delete task; } else { o_msg_response = new af::Msg(); std::ostringstream stream; stream << "Msg::TTaskRequest: No such task[" << mctaskpos.getJobId() << "][" << mctaskpos.getNumBlock() << "][" << mctaskpos.getNumTask() << "]"; o_msg_response->setString( stream.str()); } break; } case af::Msg::TTaskLogRequest: { AfContainerLock lock( i_args->jobs, AfContainerLock::READLOCK); af::MCTaskPos mctaskpos( i_msg); JobContainerIt jobsIt( i_args->jobs); JobAf* job = jobsIt.getJob( mctaskpos.getJobId()); if( job == NULL ) { o_msg_response = new af::Msg(); std::ostringstream stream; stream << "Msg::TTaskLogRequest: No job with id=" << mctaskpos.getJobId(); o_msg_response->setString( stream.str()); break; } const std::list<std::string> * list = &(job->getTaskLog( mctaskpos.getNumBlock(), mctaskpos.getNumTask())); if( list == NULL ) { // FIXME: Better to return some message in any case. break; } o_msg_response = new af::Msg(); if( list->size() == 0) { std::list<std::string> list; list.push_back("Task log is empty."); o_msg_response->setStringList( list); } else { o_msg_response->setStringList( *list); } break; } case af::Msg::TTaskErrorHostsRequest: { AfContainerLock lock( i_args->jobs, AfContainerLock::READLOCK); af::MCTaskPos mctaskpos( i_msg); JobContainerIt jobsIt( i_args->jobs); JobAf* job = jobsIt.getJob( mctaskpos.getJobId()); if( job == NULL ) { // FIXME: Better to return some message in any case. break; } o_msg_response = new af::Msg(); o_msg_response->setString( job->v_getErrorHostsListString( mctaskpos.getNumBlock(), mctaskpos.getNumTask())); break; } case af::Msg::TTaskOutputRequest: { af::Msg * msg_request_render = NULL; std::string filename, error; af::MCTaskPos tp( i_msg); //printf("ThreadReadMsg::msgCase: case af::Msg::TJobTaskOutputRequest: job=%d, block=%d, task=%d, number=%d\n", tp.getJobId(), tp.getNumBlock(), tp.getNumTask(), tp.getNumber()); { AfContainerLock jLock( i_args->jobs, AfContainerLock::READLOCK); AfContainerLock rLock( i_args->renders, AfContainerLock::READLOCK); JobContainerIt jobsIt( i_args->jobs); JobAf* job = jobsIt.getJob( tp.getJobId()); if( job == NULL ) { o_msg_response = af::msgString("Error: Job is NULL."); AFCommon::QueueLogError("Jobs is NULL"); break; } // Trying to set message to request output from running remote host. msg_request_render = job->v_getTaskStdOut( tp.getNumBlock(), tp.getNumTask(), tp.getNumber(), i_args->renders, filename, error); if( error.size()) { if( msg_request_render ) delete msg_request_render; o_msg_response = af::msgString( error); AFCommon::QueueLogError( error); break; } } if( filename.size()) { // // Retrieving output from file // int readsize = -1; char * data = af::fileRead( filename, readsize, af::Msg::SizeDataMax, &error); if( data ) { o_msg_response = new af::Msg(); o_msg_response->setData( readsize, data); delete [] data; } else if( error.size()) { error = std::string("Getting task output: ") + error; AFCommon::QueueLogError( error); o_msg_response = af::msgString( error); } } else if( msg_request_render) { // // Retrieving output from render // msg_request_render->setReceiving(); bool ok; o_msg_response = af::msgsend( msg_request_render, ok, af::VerboseOn); if( o_msg_response == NULL ) { error = "Retrieving output from render failed. See server logs for details."; o_msg_response = af::msgString( error); AFCommon::QueueLogError( error); } delete msg_request_render; } else { if( error.size()) { o_msg_response = af::msgString( error); AFCommon::QueueLogError("TTaskOutputRequest: Neiter message nor filename\n" + error); } else AFCommon::QueueLogError("TTaskOutputRequest: Neiter message nor filename."); } break; } case af::Msg::TJobsWeightRequest: { AfContainerLock jLock( i_args->jobs, AfContainerLock::READLOCK); af::MCJobsWeight jobsWeight; i_args->jobs->getWeight( jobsWeight); o_msg_response = new af::Msg( af::Msg::TJobsWeight, &jobsWeight); break; } // Cases for run cycle thread: case af::Msg::TTaskUpdateState: { af::MCTaskUp taskup( i_msg); af::MCTaskPos taskpos( taskup.getNumJob(), taskup.getNumBlock(), taskup.getNumTask(), taskup.getNumber()); o_msg_response = new af::Msg( af::Msg::TRenderCloseTask, &taskpos); } case af::Msg::TTaskUpdatePercent: case af::Msg::TTaskListenOutput: case af::Msg::TRenderDeregister: case af::Msg::TTalkDeregister: /* { // Check magic number mismatch mode: // All message types above are not allowed in "GetOnly" mode. if( i_msg->isMagicInvalid() && ( af::Environment::getMagicMode() <= af::MMM_GetOnly )) { std::string err = "Magic Mismatch Mode: \""; err += af::Environment::getMagicModeName(); err += "\""; err += "\nMessage type not allowed: \""; err += af::Msg::TNAMES[i_msg->type()]; err += "\""; AFCommon::QueueLogError( err); delete i_msg; return o_msg_response; } // Only Monitor message types are allowed in "GetOnly" mode. }*/ case af::Msg::TMonitorSubscribe: case af::Msg::TMonitorUnsubscribe: case af::Msg::TMonitorDeregister: case af::Msg::TMonitorUsersJobs: case af::Msg::TMonitorJobsIdsAdd: case af::Msg::TMonitorJobsIdsSet: case af::Msg::TMonitorJobsIdsDel: case af::Msg::TMonitorMessage: { // Push message for run cycle thread. i_args->msgQueue->pushMsg( i_msg); // Need to return here to not to delete input message (i_msg) later. return o_msg_response; // ( o_msg_response is NULL in all cases except Msg::TTaskUpdateState, // in that case render should recieve an answer to close task // and finish sending any updates for the task ) } // -------------------------------------------------------------------------// default: { AFCommon::QueueLogError( std::string("Unknown message recieved: ") + i_msg->v_generateInfoString( false)); break; } } // Deleting input message as it not needed any more. delete i_msg; // Returning an answer return o_msg_response; }
void ICUServiceTest::testAPI_One() { // create a service using locale keys, TestIntegerService service; // register an object with one locale, // search for an object with a more specific locale // should return the original object UErrorCode status = U_ZERO_ERROR; Integer* singleton0 = new Integer(0); service.registerInstance(singleton0, "en_US", status); { UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("en_US_FOO", status); confirmEqual("1) en_US_FOO -> en_US", result, singleton0); delete result; } // register a new object with the more specific locale // search for an object with that locale // should return the new object Integer* singleton1 = new Integer(1); service.registerInstance(singleton1, "en_US_FOO", status); { UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("en_US_FOO", status); confirmEqual("2) en_US_FOO -> en_US_FOO", result, singleton1); delete result; } // search for an object that falls back to the first registered locale { UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("en_US_BAR", status); confirmEqual("3) en_US_BAR -> en_US", result, singleton0); delete result; } // get a list of the factories, should be two { confirmIdentical("4) factory size", service.countFactories(), 2); } // register a new object with yet another locale Integer* singleton2 = new Integer(2); service.registerInstance(singleton2, "en", status); { confirmIdentical("5) factory size", service.countFactories(), 3); } // search for an object with the new locale // stack of factories is now en, en_US_FOO, en_US // search for en_US should still find en_US object { UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("en_US_BAR", status); confirmEqual("6) en_US_BAR -> en_US", result, singleton0); delete result; } // register a new object with an old id, should hide earlier factory using this id, but leave it there Integer* singleton3 = new Integer(3); URegistryKey s3key = service.registerInstance(singleton3, "en_US", status); { confirmIdentical("9) factory size", service.countFactories(), 4); } // should get data from that new factory { UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("en_US_BAR", status); confirmEqual("10) en_US_BAR -> (3)", result, singleton3); delete result; } // remove new factory // should have fewer factories again // singleton3 dead! { UErrorCode status = U_ZERO_ERROR; service.unregister(s3key, status); confirmIdentical("11) factory size", service.countFactories(), 3); } // should get original data again after remove factory { UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("en_US_BAR", status); confirmEqual("12) en_US_BAR -> (3)", result, singleton0); delete result; } // shouldn't find unregistered ids { UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("foo", status); confirmIdentical("13) foo -> null", result, NULL); delete result; } // should find non-canonical strings { UnicodeString resultID; UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("EN_us_fOo", &resultID, status); confirmEqual("14a) find-non-canonical", result, singleton1); confirmStringsEqual("14b) find non-canonical", resultID, "en_US_FOO"); delete result; } // should be able to register non-canonical strings and get them canonicalized Integer* singleton4 = new Integer(4); service.registerInstance(singleton4, "eN_ca_dUde", status); { UnicodeString resultID; UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("En_Ca_DuDe", &resultID, status); confirmEqual("15a) find-non-canonical", result, singleton4); confirmStringsEqual("15b) register non-canonical", resultID, "en_CA_DUDE"); delete result; } // should be able to register invisible factories, these will not // be visible by default, but if you know the secret password you // can still access these services... Integer* singleton5 = new Integer(5); service.registerInstance(singleton5, "en_US_BAR", FALSE, status); { UErrorCode status = U_ZERO_ERROR; Integer* result = (Integer*)service.get("en_US_BAR", status); confirmEqual("17) get invisible", result, singleton5); delete result; } // should not be able to locate invisible services { UErrorCode status = U_ZERO_ERROR; UVector ids(uhash_deleteUnicodeString, uhash_compareUnicodeString, status); service.getVisibleIDs(ids, status); UnicodeString target = "en_US_BAR"; confirmBoolean("18) find invisible", !ids.contains(&target)); } // clear factory and caches service.reset(); confirmBoolean("19) is default", service.isDefault()); }
//***************************************************************************** void CDbMessageText::ExportText(CStretchyBuffer& buf, const char* pTagName) //Outputs message (language) texts for this message ID as XML tags. { ASSERT(pTagName); const Language::LANGUAGE eLanguage = Language::GetLanguage(); CCoordSet ids(GetMessageTextIDs(this->eMessageID)); bool bActiveLanguageFound = false; for (CCoordSet::const_iterator id = ids.begin(); id != ids.end(); ++id) { //Append XML fields for each message text for this messageID. const UINT wLanguageIndex = id->wY; if (!wLanguageIndex || wLanguageIndex >= Language::LanguageCount) continue; //not a valid language ID -- skip it buf += "<"; buf += pTagName; if (eLanguage == wLanguageIndex) bActiveLanguageFound = true; buf += " lang='"; buf += Language::GetCode(wLanguageIndex); BYTE* pbOutStr = NULL; c4_Bytes MessageTextBytes = p_MessageText(GetRowRef(V_MessageTexts, id->wX)); const WCHAR *pText = GetMessageText(MessageTextBytes); const UINT wSize = to_utf8(pText, pbOutStr); buf += "' text=\""; if (wSize) { //Replace characters that are illegal in XML strings with entities. string outstr; for (UINT wIndex = 0; wIndex < wSize; ++wIndex) switch (pbOutStr[wIndex]) { case 10: outstr += " "; break; case 13: outstr += " "; break; case '"': outstr += """; break; case '<': outstr += "<"; break; case '>': outstr += ">"; break; case '&': outstr += "&"; break; case '\'': //allow apostrophes in text default: outstr += pbOutStr[wIndex]; break; } buf.Append((const BYTE*)outstr.c_str(), outstr.size()); } delete[] pbOutStr; buf += "\"/>" NEWLINE; } //Add an empty language tag for the active language when texts for other //languages, but not this one, are found. if (!bActiveLanguageFound && !ids.empty()) { buf += "<"; buf += pTagName; buf += " lang='"; buf += Language::GetCode(eLanguage); buf += "' text=\"\"/>" NEWLINE; } }
void ICUServiceTest::testRBF() { // resource bundle factory. UErrorCode status = U_ZERO_ERROR; TestStringService service; service.registerFactory(new ICUResourceBundleFactory(), status); // list all of the resources { UErrorCode status = U_ZERO_ERROR; UVector ids(uhash_deleteUnicodeString, uhash_compareUnicodeString, 0, status); service.getVisibleIDs(ids, status); logln("all visible ids:"); for (int i = 0; i < ids.size(); ++i) { const UnicodeString* id = (const UnicodeString*)ids[i]; logln(*id); } } // get all the display names of these resources // this should be fast since the display names were cached. { UErrorCode status = U_ZERO_ERROR; UVector names(status); service.getDisplayNames(names, Locale::getGermany(), status); logln("service display names for de_DE"); for (int i = 0; i < names.size(); ++i) { const StringPair* pair = (const StringPair*)names[i]; logln(" " + pair->displayName + " --> " + pair->id); } } service.registerFactory(new CalifornioLanguageFactory(), status); // get all the display names of these resources { logln("californio language factory:"); const char* idNames[] = { CalifornioLanguageFactory::californio, CalifornioLanguageFactory::valley, CalifornioLanguageFactory::surfer, CalifornioLanguageFactory::geek, }; int32_t count = sizeof(idNames)/sizeof(idNames[0]); for (int i = 0; i < count; ++i) { logln(UnicodeString("\n --- ") + idNames[i] + " ---"); { UErrorCode status = U_ZERO_ERROR; UVector names(status); service.getDisplayNames(names, idNames[i], status); for (int i = 0; i < names.size(); ++i) { const StringPair* pair = (const StringPair*)names[i]; logln(" " + pair->displayName + " --> " + pair->id); } } } } CalifornioLanguageFactory::cleanup(); }
/*----------------------------------------------------------------------* | finalize construction of this interface | *----------------------------------------------------------------------*/ bool MOERTEL::Interface::Complete() { if (IsComplete()) { if (OutLevel()>0) std::cout << "MOERTEL: ***WRN*** MOERTEL::Interface::InterfaceComplete:\n" << "MOERTEL: ***WRN*** InterfaceComplete() was called before, do nothing\n" << "MOERTEL: ***WRN*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; return true; } //------------------------------------------------------------------- // check for NULL entries in maps bool ok = true; for (int i=0; i<2; ++i) { std::map<int,Teuchos::RCP<MOERTEL::Node> >::const_iterator curr; for (curr=node_[i].begin(); curr!=node_[i].end(); ++curr) { if (curr->second == Teuchos::null) { std::cout << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** Interface # " << Id_ << ":\n" << "***ERR*** found NULL entry in map of nodes\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; ok = false; } } } for (int i=0; i<2; ++i) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator curr; for (curr=seg_[i].begin(); curr!=seg_[i].end(); ++curr) { if (curr->second == Teuchos::null) { std::cout << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** Interface # " << Id_ << ":\n" << "***ERR*** found NULL entry in map of segments\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; ok = false; } } } int lok = ok; int gok = 1; gcomm_.MinAll(&lok,&gok,1); if (!gok) return false; //------------------------------------------------------------------- // check whether all nodes for segments are present // (take in account that node might be on different processor) // this test is expensive and does not scale. It is therefore only performed // when user requests a high output level #if 1 if (OutLevel()>9) { for (int proc=0; proc<gcomm_.NumProc(); ++proc) { for (int side=0; side<2; ++side) { // create length of list of all nodes adjacent to segments on proc int sendsize = 0; if (proc==gcomm_.MyPID()) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator curr; for (curr=seg_[side].begin(); curr!=seg_[side].end(); ++curr) sendsize += curr->second->Nnode(); } gcomm_.Broadcast(&sendsize,1,proc); // create list of all nodes adjacent to segments on proc std::vector<int> ids(sendsize); if (proc==gcomm_.MyPID()) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator curr; int counter=0; for (curr=seg_[side].begin(); curr!=seg_[side].end(); ++curr) { const int* segids = curr->second->NodeIds(); for (int i=0; i<curr->second->Nnode(); ++i) ids[counter++] = segids[i]; } } gcomm_.Broadcast(&ids[0],sendsize,proc); // check on all processors for nodes in ids std::vector<int> foundit(sendsize); std::vector<int> gfoundit(sendsize); for (int i=0; i<sendsize; ++i) { foundit[i] = 0; if (node_[side].find(ids[i]) != node_[side].end()) foundit[i] = 1; } gcomm_.MaxAll(&foundit[0],&gfoundit[0],sendsize); for (int i=0; i<sendsize; ++i) { if (gfoundit[i]!=1) { if (gcomm_.MyPID()==proc) std::cout << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** cannot find segment's node # " << ids[i] << "\n" << "***ERR*** in map of all nodes on all procs\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; ids.clear(); foundit.clear(); gfoundit.clear(); gcomm_.Barrier(); return false; } } // tidy up ids.clear(); foundit.clear(); gfoundit.clear(); } // for (int size=0; side<2; ++side) } // for (int proc=0; proc<gcomm_.NumProc(); ++proc) } #endif //------------------------------------------------------------------- // find all procs that have business on this interface (own nodes/segments) // build a Epetra_comm that contains only those procs // this intra-communicator will be used to handle most stuff on this // interface so the interface will not block all other procs { #ifdef EPETRA_MPI std::vector<int> lin(gcomm_.NumProc()); std::vector<int> gin(gcomm_.NumProc()); for (int i=0; i<gcomm_.NumProc(); ++i) lin[i] = 0; // check ownership of any segments for (int i=0; i<2; ++i) if (seg_[i].size() != 0) { lin[gcomm_.MyPID()] = 1; break; } // check ownership of any nodes for (int i=0; i<2; ++i) if (node_[i].size() != 0) { lin[gcomm_.MyPID()] = 1; break; } gcomm_.MaxAll(&lin[0],&gin[0],gcomm_.NumProc()); lin.clear(); // typecast the Epetra_Comm to Epetra_MpiComm Epetra_MpiComm* epetrampicomm = dynamic_cast<Epetra_MpiComm*>(&gcomm_); if (!epetrampicomm) { std::stringstream oss; oss << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** Interface " << Id() << ": Epetra_Comm is not an Epetra_MpiComm\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw ReportError(oss); } // split the communicator into participating and none-participating procs int color; int key = gcomm_.MyPID(); // I am taking part in the new comm if I have any ownership if (gin[gcomm_.MyPID()]) color = 0; // I am not taking part in the new comm else color = MPI_UNDEFINED; // tidy up gin.clear(); // create the local communicator MPI_Comm mpi_global_comm = epetrampicomm->GetMpiComm(); MPI_Comm* mpi_local_comm = new MPI_Comm(); MPI_Comm_split(mpi_global_comm,color,key,mpi_local_comm); // create the new Epetra_MpiComm if (*mpi_local_comm == MPI_COMM_NULL) lcomm_ = Teuchos::null; else lcomm_ = Teuchos::rcp(new Epetra_MpiComm(*mpi_local_comm)); // FIXME: who destroys the MPI_Comm inside? #if 0 // test this stuff on the mpi level int grank,lrank; MPI_Comm_rank(mpi_global_comm,&grank); if (*mpi_local_comm != MPI_COMM_NULL) MPI_Comm_rank(*mpi_local_comm,&lrank); else lrank = -1; for (int proc=0; proc<gcomm_.NumProc(); ++proc) { if (proc==gcomm_.MyPID()) std::cout << "using mpi comms: I am global rank " << grank << " and local rank " << lrank << std::endl; gcomm_.Barrier(); } // test this stuff on the epetra level if (lComm()) for (int proc=0; proc<lcomm_->NumProc(); ++proc) { if (proc==lcomm_->MyPID()) std::cout << "using epetra comms: I am global rank " << gcomm_.MyPID() << " and local rank " << lcomm_->MyPID() << std::endl; lcomm_->Barrier(); } gcomm_.Barrier(); #endif #else // the easy serial case Epetra_SerialComm* serialcomm = dynamic_cast<Epetra_SerialComm*>(&gcomm_); if (!serialcomm) { std::stringstream oss; oss << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** Interface " << Id() << ": Epetra_Comm is not an Epetra_SerialComm\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw ReportError(oss); } lcomm_ = Teuchos::rcp(new Epetra_SerialComm(*serialcomm)); #endif // end of #ifdef PARALLEL } //------------------------------------------------------------------- // create a map of all nodes to there PID (process id) if (lComm()) for (int proc=0; proc<lcomm_->NumProc(); ++proc) { int lnnodes = 0; if (proc==lcomm_->MyPID()) lnnodes = node_[0].size() + node_[1].size(); lcomm_->Broadcast(&lnnodes,1,proc); std::vector<int> ids(lnnodes); if (proc==lcomm_->MyPID()) { std::map<int,Teuchos::RCP<MOERTEL::Node> >::const_iterator curr; int counter=0; for (int side=0; side<2; ++side) for (curr=node_[side].begin(); curr!=node_[side].end(); ++curr) ids[counter++] = curr->first; } lcomm_->Broadcast(&ids[0],lnnodes,proc); for (int i=0; i<lnnodes; ++i) nodePID_.insert(std::pair<int,int>(ids[i],proc)); ids.clear(); } //------------------------------------------------------------------- // create a map of all segments to there PID (process id) if (lComm()) for (int proc=0; proc<lcomm_->NumProc(); ++proc) { int lnsegs = 0; if (proc==lcomm_->MyPID()) lnsegs = seg_[0].size() + seg_[1].size(); lcomm_->Broadcast(&lnsegs,1,proc); std::vector<int> ids(lnsegs); if (proc==lcomm_->MyPID()) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator curr; int counter=0; for (int side=0; side<2; ++side) for (curr=seg_[side].begin(); curr!=seg_[side].end(); ++curr) ids[counter++] = curr->first; } lcomm_->Broadcast(&ids[0],lnsegs,proc); for (int i=0; i<lnsegs; ++i) segPID_.insert(std::pair<int,int>(ids[i],proc)); ids.clear(); } //------------------------------------------------------------------- // set isComplete_ flag // we set it here already as we will be using some methods that require it // from now on isComplete_ = true; //------------------------------------------------------------------- // make the nodes know there adjacent segments // find max number of nodes to a segment if (lComm()) { int lmaxnnode = 0; int gmaxnnode = 0; for (int side=0; side<2; ++side) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator scurr; for (scurr=seg_[side].begin(); scurr!=seg_[side].end(); ++scurr) if (lmaxnnode < scurr->second->Nnode()) lmaxnnode = scurr->second->Nnode(); } lcomm_->MaxAll(&lmaxnnode,&gmaxnnode,1); // loop all procs and broadcast their adjacency for (int proc=0; proc<lcomm_->NumProc(); ++proc) { // local number of segments int lnseg = 0; if (proc==lcomm_->MyPID()) lnseg = seg_[0].size() + seg_[1].size(); lcomm_->Broadcast(&lnseg,1,proc); // allocate vector to hold adjacency int offset = gmaxnnode+2; int size = lnseg*offset; std::vector<int> adj(size); // proc fills adjacency vector adj and broadcasts if (proc==lcomm_->MyPID()) { int count = 0; for (int side=0; side<2; ++side) { std::map<int,Teuchos::RCP<MOERTEL::Segment> >::const_iterator scurr; for (scurr=seg_[side].begin(); scurr!=seg_[side].end(); ++scurr) { Teuchos::RCP<MOERTEL::Segment> seg = scurr->second; adj[count] = seg->Id(); adj[count+1] = seg->Nnode(); const int* ids = seg->NodeIds(); for (int i=0; i<seg->Nnode(); ++i) adj[count+2+i] = ids[i]; count += offset; } } } lcomm_->Broadcast(&adj[0],size,proc); // all procs read adj and add segment to the nodes they own int count = 0; for (int i=0; i<lnseg; ++i) { int segid = adj[count]; int nnode = adj[count+1]; for (int j=0; j<nnode; ++j) { int nid = adj[count+2+j]; if (lcomm_->MyPID() == NodePID(nid)) { // I own this node, so set the segment segid in it Teuchos::RCP<MOERTEL::Node> node = GetNodeViewLocal(nid); if (node == Teuchos::null) { std::stringstream oss; oss << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** cannot find node " << nid << "\n" << "***ERR*** in map of all nodes on this proc\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw ReportError(oss); } node->AddSegment(segid); } else continue; } count += offset; } adj.clear(); } // for (int proc=0; proc<lcomm_->NumProc(); ++proc) } // if (lComm()) //------------------------------------------------------------------- // build redundant segments and nodes if (lComm()) { int ok = 0; ok += RedundantSegments(0); ok += RedundantSegments(1); ok += RedundantNodes(0); ok += RedundantNodes(1); if (ok != 4) { std::stringstream oss; oss << "***ERR*** MOERTEL::Interface::Complete:\n" << "***ERR*** building of redundant information failed\n" << "***ERR*** file/line: " << __FILE__ << "/" << __LINE__ << "\n"; throw ReportError(oss); } } //------------------------------------------------------------------- // make topology segments <-> nodes for each side if (lComm()) BuildNodeSegmentTopology(); //------------------------------------------------------------------- // delete distributed nodes and segments for (int i=0; i<2; ++i) { seg_[i].clear(); node_[i].clear(); } //------------------------------------------------------------------- // we are done // note that there might not be any functions on the interface yet // they still have to be set return ok; }
BlkResTestDiffusion::BlkResTestDiffusion(const InputParameters & parameters) : Kernel(modifyParams(parameters)) { // Get an test enum from the kernel parameters MooseEnum test = parameters.get<MooseEnum>("test"); // test that hasBlocks is working if (test == "hasBlocks") { // Define a SubdomainName vector for testing against std::vector<SubdomainName> id_names(2); id_names[0] = "1"; id_names[1] = "2"; // Define a SubdomainID vector for testing against std::vector<SubdomainID> ids(2); ids[0] = 1; ids[1] = 2; // Define a SubdomainID set for testing against std::set<SubdomainID> id_set(ids.begin(), ids.end()); // Test true single SudomainName input if (!hasBlocks("1")) mooseError("Test 1: hasBlocks(SubdomainName) = true failed"); // Test false of single Subdomain input if (hasBlocks("3")) mooseError("Test 2: hasBlocks(SubdomainName) = false failed"); // Test true vector SubdomainName input if (!hasBlocks(id_names)) mooseError("Test 3: hasBlocks(std::vector<SubdomainName>) = true failed"); // Test false vector SudomainName input id_names.push_back("3"); if (hasBlocks(id_names)) mooseError("Test 4: hasBlocks(std::vector<SubdomainName>) = false failed"); // Test true single SubdomainID input if (!hasBlocks(1)) mooseError("Test 5: hasBlocks(SubdomainID) = true failed"); // Test false single SubdomainID input if (hasBlocks(5)) mooseError("Test 6: hasBlocks(SubdomainID) = false failed"); // Test true for std::vector<SubdomainID> if (!hasBlocks(ids)) mooseError("Test 7: hasBlocks(std::vector<SubdomainID>) = true failed"); // Test false for std::vector<SubdomainID> ids.push_back(4); if (hasBlocks(ids)) mooseError("Test 8: hasBlocks(std::vector<SubdomainID>) = false failed"); // Test true for std::set<SubdomainID> if (!hasBlocks(id_set)) mooseError("Test 9: hasBlocks(std::set<SubdomainID) = true failed"); // Test false for std::set<SubdomainID> id_set.insert(12); if (hasBlocks(id_set)) mooseError("Test 10: hasBlocks(std::set<SubdomainID>) = false failed"); // This is the expected error, all the above tests passed mooseError("hasBlocks testing passed"); } // Test of stored ANY_BLOCK_ID on object else if (test == "hasBlocks_ANY_BLOCK_ID") { // Test that ANY_BLOCK_ID is working if (hasBlocks(1)) mooseError("hasBlocks_ANY_BLOCK_ID test passed"); else mooseError("hasBlocks_ANY_BLOCK_ID test failed"); } // Test that the blocks() method is working else if (test == "blocks") { const std::vector<SubdomainName> & blks = blocks(); if (blks[0] == "1" && blks[1] == "2" && blks.size() == 2) mooseError("Blocks testing passed"); // expected error else mooseError("Blocks testing failed"); } // Test that the getSubdomains() is working else if (test == "blockIDs") { const std::set<SubdomainID> & ids = blockIDs(); if (ids.count(1) == 1 && ids.count(2) == 1) mooseError("blockIDs testing passed"); // expected error else mooseError("blockIDs testing failed"); } // Test that the isSubset() is working else if (test == "isBlockSubset") { std::set<SubdomainID> sub_id; sub_id.insert(10); sub_id.insert(1); sub_id.insert(4); sub_id.insert(2); if (isBlockSubset(sub_id)) mooseError("isBlockSubset testing passed"); // expected error else mooseError("isBlockSubset testing failed"); } // Test that hasMaterialPropertyBlock is working properly else if (test == "hasBlockMaterialProperty_true") { if (hasBlockMaterialProperty<Real>("a")) mooseError("hasBlockMaterialProperty is true, test passed"); // expected error else mooseError("hasBlockMaterialProperty is false, test failed"); } else if (test == "hasBlockMaterialProperty_false") { if (hasBlockMaterialProperty<Real>("b")) mooseError("hasBlockMaterialProperty is true, test failed"); else mooseError("hasBlockMaterialProperty is false, test passed"); // expected error } }
void LevelParser::parseTileLayer(TiXmlElement* pTileElement, std::vector<Layer*> *pLayers, const std::vector<Tileset>* pTilesets, std::vector<TileLayer*> *pCollisionLayers) { TileLayer* pTileLayer = new TileLayer(m_tileSize, m_width, m_height, *pTilesets); bool collidable = false; // tile data std::vector<std::vector<int>> data; std::string decodedIDs; TiXmlElement* pDataNode; for(TiXmlElement* e = pTileElement->FirstChildElement(); e != NULL; e = e->NextSiblingElement()) { if(e->Value() == std::string("properties")) { for(TiXmlElement* property = e->FirstChildElement(); property != NULL; property = property->NextSiblingElement()) { if(property->Value() == std::string("property")) { if(property->Attribute("name") == std::string("collidable")) { collidable = true; } } } } if(e->Value() == std::string("data")) { pDataNode = e; } } for(TiXmlNode* e = pDataNode->FirstChild(); e != NULL; e = e->NextSibling()) { TiXmlText* text = e->ToText(); std::string t = text->Value(); decodedIDs = base64_decode(t); } // uncompress zlib compression uLongf sizeofids = m_width * m_height * sizeof(int); std::vector<int> ids(m_width * m_height); uncompress((Bytef*)&ids[0], &sizeofids,(const Bytef*)decodedIDs.c_str(), decodedIDs.size()); std::vector<int> layerRow(m_width); for(int j = 0; j < m_height; j++) { data.push_back(layerRow); } for(int rows = 0; rows < m_height; rows++) { for(int cols = 0; cols < m_width; cols++) { data[rows][cols] = ids[rows * m_width + cols]; } } pTileLayer->setTileIDs(data); if(collidable) { pCollisionLayers->push_back(pTileLayer); } pLayers->push_back(pTileLayer); }
static CSeenIds* NewL(RDbDatabase& aDb) { auto_ptr<CSeenIds> ids(new (ELeave) CSeenIds(aDb)); ids->ConstructL(); return ids.release(); }
int main() { // LOAD DATA arma::mat X; // A) Toy Data // char inputFile[] = "../data_files/toyclusters/toyclusters.dat"; // B) X4.dat //char inputFile[] = "./X4.dat"; // C) fisher data //char inputFile[] = "./fisher.dat"; // D) MNIST data //char inputFile[] = "../data_files/MNIST/MNIST.dat"; // E) Reduced MNIST (5000x400) //char inputFile[] = "../data_files/MNIST/MNISTreduced.dat"; // F) Reduced MNIST (0 and 1) (1000x400) //char inputFile[] = "../data_files/MNIST/MNISTlittle.dat"; // G) Girl.png (512x768, RGB, already unrolled) //char inputFile[] = "girl.dat"; // H) Pool.png (383x512, RGB, already unrolled) //char inputFile[] = "pool.dat"; // I) Cat.png (733x490, RGB, unrolled) //char inputFile[] = "cat.dat"; // J) Airplane.png (512x512, RGB, unrolled) //char inputFile[] = "airplane.dat"; // K) Monarch.png (512x768, RGB, unrolled) //char inputFile[] = "monarch.dat"; // L) tulips.png (512x768 ,RGB, unrolled) //char inputFile[] = "tulips.dat"; // M) demo.dat (2d data) char inputFile[] = "demo.dat"; // INITIALIZE PARAMETERS X.load(inputFile); const arma::uword N = X.n_rows; const arma::uword D = X.n_cols; arma::umat ids(N,1); // needed to shuffle indices later arma::umat shuffled_ids(N,1); for (arma::uword i = 0; i < N; ++i) { ids(i,0) = i; } arma::arma_rng::set_seed_random(); // set arma rng // int seed = time(NULL); // set RNG seed to current time // srand(seed); arma::uword initial_K = 32; // initial number of clusters arma::uword K = initial_K; arma::umat clusters(N,1); // contains cluster assignments for each data point for (arma::uword i = 0; i < N; ++i) { clusters(i, 0) = i%K; // initialize as [0,1,...,K-1,0,1,...,K-1,0,...] } arma::umat cluster_sizes(N,1,arma::fill::zeros); // contains num data points in cluster k for (arma::uword i = 0; i < N; ++i) { cluster_sizes(clusters(i,0), 0) += 1; } arma::mat mu(N, D, arma::fill::zeros); // contains cluster mean parameters arma::mat filler(D,D,arma::fill::eye); std::vector<arma::mat> sigma(N,filler); // contains cluster covariance parameters if (K < N) { // set parameters not belonging to any cluster to -999 mu.rows(K,N-1).fill(-999); for (arma::uword k = K; k < N; ++k) { sigma[k].fill(-999); } } arma::umat uword_dummy(1,1); // dummy 1x1 matrix; // for (arma::uword i = 0; i <N; ++i) { // std::cout << sigma[i] << std::endl; // } // std::cout << X << std::endl // << N << std::endl // << D << std::endl // << K << std::endl // << clusters << std::endl // << cluster_sizes << std::endl // << ids << std::endl; // INITIALIZE HYPER PARAMETERS // Dirichlet Process concentration parameter is alpha: double alpha = 1; // Dirichlet Process base distribution (i.e. prior) is // H(mu,sigma) = NIW(mu,Sigma|m_0,k_0,S_0,nu_0) = N(mu|m_0,Sigma/k_0)IW(Sigma|S_0,nu_0) arma::mat perturbation(D,D,arma::fill::eye); perturbation *= 0.000001; //const arma::mat S_0 = arma::cov(X,X,1) + perturbation; // S_xbar / N const arma::mat S_0(D,D,arma::fill::eye); const double nu_0 = D + 2; const arma::mat m_0 = mean(X).t(); const double k_0 = 0.01; // std::cout << "S_0" << S_0 << std::endl; // std::cout << S_0 << std::endl // << nu_0 << std::endl // << m_0 << std::endl // << k_0 << std::endl; // INITIALIZE SAMPLING PARAMETERS arma::uword NUM_SWEEPS = 250; // number of Gibbs iterations bool SAVE_CHAIN = false; // save output of each Gibbs iteration? // arma::uword BURN_IN = NUM_SWEEPS - 10; // arma::uword CHAINSIZE = NUM_SWEEPS - BURN_IN; // std::vector<arma::uword> chain_K(CHAINSIZE, K); // Initialize chain variable to initial parameters for convinience // std::vector<arma::umat> chain_clusters(CHAINSIZE, clusters); // std::vector<arma::umat> chain_clusterSizes(CHAINSIZE, cluster_sizes); // std::vector<arma::mat> chain_mu(CHAINSIZE, mu); // std::vector<std::vector<arma::mat> > chain_sigma(CHAINSIZE, sigma); // for (arma::uword sweep = 0; sweep < CHAINSIZE; ++sweep) { // std::cout << sweep << " K\n" << chain_K[sweep] << std::endl // << sweep << " clusters\n" << chain_clusters[sweep] << std::endl // << sweep << " sizes\n" << chain_clusterSizes[sweep] << std::endl // << sweep << " mu\n" << chain_mu[sweep] << std::endl; // for (arma::uword i = 0; i < N; ++i) { // std::cout << sweep << " " << i << " sigma\n" << chain_sigma[sweep][i] << std::endl; // } // } // START CHAIN std::cout << "Starting Algorithm with K = " << K << std::endl; for (arma::uword sweep = 0; sweep < NUM_SWEEPS; ++sweep) { // shuffle indices shuffled_ids = shuffle(ids); // std::cout << shuffled_ids << std::endl; // SAMPLE CLUSTERS for (arma::uword j = 0; j < N; ++j){ // std::cout << "j = " << j << std::endl; arma::uword i = shuffled_ids(j); arma::mat x = X.row(i).t(); // current data point // Remove i's statistics and any empty clusters arma::uword c = clusters(i,0); // current cluster cluster_sizes(c,0) -= 1; //std::cout << "old c = " << c << std::endl; if (cluster_sizes(c,0) == 0) { // remove empty cluster cluster_sizes(c,0) = cluster_sizes(K-1,0); // move entries for K onto position c mu.row(c) = mu.row(K-1); sigma[c] = sigma[K-1]; uword_dummy(0,0) = c; arma::uvec idx = find(clusters == K - 1); clusters.each_row(idx) = uword_dummy; cluster_sizes(K-1,0) = 0; mu.row(K-1).fill(-999); sigma[K-1].fill(-999); --K; } // quick test of logMvnPdf: // arma::mat m_(2,1); // arma::mat s_(2,2); // arma::mat t_(2,1); // m_ << 1 << arma::endr << 2; // s_ << 3 << -0.2 << arma::endr << -0.2 << 1; // t_ << -3 << arma::endr << -3; // double lpdf = logMvnPdf(t_, m_, s_); // std::cout << lpdf << std::endl; // śhould be -19.1034 (works) // Find categorical distribution over clusters (tested) arma::mat logP(K+1, 1, arma::fill::zeros); // quick test of logInvWishPdf // arma::mat si_(2,2), s_(2,2); // double nu_ = 4; // si_ << 1 << 0.5 << arma::endr << 0.5 << 4; // s_ << 3 << -0.2 << arma::endr << -0.2 << 1; // double lpdf = logInvWishPdf(si_, s_, nu_); // std::cout << lpdf << std::endl; // should be -7.4399 (it is) // quick test for logNormInvWishPdf // arma::mat si_(2,2), s_(2,2); // arma :: mat mu_(2,1), m_(2,1); // double k_ = 0.5, nu_ = 4; // si_ << 1 << 0.5 << arma::endr << 0.5 << 4; // s_ << 3 << -0.2 << arma::endr << -0.2 << 1; // mu_ << -3 << arma::endr << -3; // m_ << 1 << arma::endr << 2; // double lp = logNormInvWishPdf(mu_,si_,m_,k_,s_,nu_); // std::cout << lp << std::endl; // should equal -15.2318 (it is) // p(existing clusters) (tested) for (arma::uword k = 0; k < K; ++k) { arma::mat m_ = mu.row(k).t(); arma::mat s_ = sigma[k]; logP(k,0) = log(cluster_sizes(k,0)) - log(N-1+alpha) + logMvnPdf(x,m_,s_); } // p(new cluster): find partition function (tested) // arma::mat dummy_mu(D, 1, arma::fill::zeros); // arma::mat dummy_sigma(D, D, arma::fill::eye); // double logPrior, logLklihd, logPstr, logPartition; // posterior hyperparameters (tested) arma::mat m_1(D,1), S_1(D,D); double k_1, nu_1; k_1 = k_0 + 1; nu_1 = nu_0 + 1; m_1 = (k_0*m_0 + x) / k_1; S_1 = S_0 + x * x.t() + k_0 * (m_0 * m_0.t()) - k_1 * (m_1 * m_1.t()); // std::cout << k_1 << std::endl // << nu_1 << std::endl // << m_1 << std::endl // << S_1 << std::endl; // // partition = likelihood*prior/posterior (tested) // // (perhaps a direct computation of the partition function would be better) // logPrior = logNormInvWishPdf(dummy_mu, dummy_sigma, m_0, k_0, S_0, nu_0); // logLklihd = logMvnPdf(x, dummy_mu, dummy_sigma); // logPstr = logNormInvWishPdf(dummy_mu, dummy_sigma, m_1, k_1, S_1, nu_1); // logPartition = logPrior + logLklihd - logPstr; // std::cout << "log Prior = " << logPrior << std::endl // << "log Likelihood = " << logLklihd << std::endl // << "log Posterior = " << logPstr << std::endl // << "log Partition = " << logPartition << std::endl; // Computing partition directly double logS0,signS0,logS1,signS1; arma::log_det(logS0,signS0,S_0); arma::log_det(logS1,signS1,S_1); /*std::cout << "log(det(S_0)) = " << logS0 << std::endl << "log(det(S_1)) = " << logS1 << std::endl;*/ double term1 = 0.5*D*(log(k_0)-log(k_1)); double term2 = -0.5*D*log(arma::datum::pi); double term3 = 0.5*(nu_0*logS0 - nu_1*logS1); double term4 = lgamma(0.5*nu_1); double term5 = -lgamma(0.5*(nu_1-D)); double logPartition = term1+term2+term3+term4+term5; /*double logPartition = 0.5*D*(log(k_0)-log(k_1)-log(arma::datum::pi)) \ /+0.5*(nu_0*logS0 - nu_1*logS1) + lgamma(0.5*nu_1) - lgamma(0.5*(nu_1-D));*/ /* std::cout << "term1 = " << term1 << std::endl << "term2 = " << term2 << std::endl << "term3 = " << term3 << std::endl << "term4 = " << term4 << std::endl << "term5 = " << term5 << std::endl;*/ //std::cout << "logP = " << logPartition << std::endl; // p(new cluster): (tested) logP(K,0) = log(alpha) - log(N - 1 + alpha) + logPartition; // std::cout << "logP(new cluster) = " << logP(K,0) << std::endl; //if(i == 49) //assert(false); // sample cluster for i arma::uword c_ = logCatRnd(logP); clusters(i,0) = c_; //if (j % 10 == 0){ //std::cout << "New c = " << c_ << std::endl; //std::cout << "logP = \n" << logP << std::endl; //} // quick test for mvnRnd // arma::mat mu, si; // mu << 1 << arma::endr << 2; // si << 1 << 0.9 << arma::endr << 0.9 << 1; // arma::mat m = mvnRnd(mu, si); // std::cout << m << std::endl; // quick test for invWishRnd // double df = 4; // arma::mat si(2,2); // si << 1 << 1 << arma::endr << 1 << 1; // arma::mat S = invWishRnd(si,df); // std::cout << S << std::endl; if (c_ == K) { // Sample parameters for any new-born clusters from posterior cluster_sizes(K, 0) = 1; arma::mat si_ = invWishRnd(S_1, nu_1); //arma::mat si_ = S_1; arma::mat mu_ = mvnRnd(m_1, si_/k_1); //arma::mat mu_ = m_1; mu.row(K) = mu_.t(); sigma[K] = si_; K += 1; } else { cluster_sizes(c_,0) += 1; } // if (sweep == 0) // std::cout << " K = " << K << std::endl; // // if (j == N-1) { // // std::cout << logP << std::endl; // // std::cout << K << std::endl; // // assert(false); // // } // std::cout << "K = " << K << "\n" << std::endl; } // sample CLUSTER PARAMETERS FROM POSTERIOR for (arma::uword k = 0; k < K; ++k) { // std::cout << "k = " << k << std::endl; // cluster data arma::mat Xk = X.rows(find(clusters == k)); arma::uword Nk = cluster_sizes(k,0); // posterior hyperparameters arma::mat m_Nk(D,1), S_Nk(D,D); double k_Nk, nu_Nk; arma::mat sum_k = sum(Xk,0).t(); arma::mat cov_k(D, D, arma::fill::zeros); for (arma::uword l = 0; l < Nk; ++l) { cov_k += Xk.row(l).t() * Xk.row(l); } k_Nk = k_0 + Nk; nu_Nk = nu_0 + Nk; m_Nk = (k_0 * m_0 + sum_k) / k_Nk; S_Nk = S_0 + cov_k + k_0 * (m_0 * m_0.t()) - k_Nk * (m_Nk * m_Nk.t()); // sample fresh parameters arma::mat si_ = invWishRnd(S_Nk, nu_Nk); //arma::mat si_ = S_Nk; arma::mat mu_ = mvnRnd(m_Nk, si_/k_Nk); //arma::mat mu_ = m_Nk; mu.row(k) = mu_.t(); sigma[k] = si_; } std::cout << "Iteration " << sweep + 1 << "/" << NUM_SWEEPS<< " done. K = " << K << std::endl; // // STORE CHAIN // if (SAVE_CHAIN) { // if (sweep >= BURN_IN) { // chain_K[sweep - BURN_IN] = K; // chain_clusters[sweep - BURN_IN] = clusters; // chain_clusterSizes[sweep - BURN_IN] = cluster_sizes; // chain_mu[sweep - BURN_IN] = mu; // chain_sigma[sweep - BURN_IN] = sigma; // } // } } std::cout << "Final cluster sizes: " << std::endl << cluster_sizes.rows(0, K-1) << std::endl; // WRITE OUPUT DATA TO FILE arma::mat MU = mu.rows(0,K-1); arma::mat SIGMA(D*K,D); for (arma::uword k = 0; k < K; ++k) { SIGMA.rows(k*D,(k+1)*D-1) = sigma[k]; } arma::umat IDX = clusters; // A) toycluster data // char MuFile[] = "../data_files/toyclusters/dpmMU.out"; // char SigmaFile[] = "../data_files/toyclusters/dpmSIGMA.out"; // char IdxFile[] = "../data_files/toyclusters/dpmIDX.out"; // B) X4.dat char MuFile[] = "dpmMU.out"; char SigmaFile[] = "dpmSIGMA.out"; char IdxFile[] = "dpmIDX.out"; std::ofstream KFile("K.out"); MU.save(MuFile, arma::raw_ascii); SIGMA.save(SigmaFile, arma::raw_ascii); IDX.save(IdxFile, arma::raw_ascii); KFile << "K = " << K << std::endl; if (SAVE_CHAIN) {} // std::ofstream chainKFile("chainK.out"); // std::ofstream chainClustersFile("chainClusters.out"); // std::ofstream chainClusterSizesFile("chainClusterSizes.out"); // std::ofstream chainMuFile("chainMu.out"); // std::ofstream chainSigmaFile("chainSigma.out"); // chainKFile << "Dirichlet Process Mixture Model.\nInput: " << inputFile << std::endl // << "Number of iterations of Gibbs Sampler: " << NUM_SWEEPS << std::endl // << "Burn-In: " << BURN_IN << std::endl // << "Initial number of clusters: " << initial_K << std::endl // << "Output: Number of cluster (K)\n" << std::endl; // chainClustersFile << "Dirichlet Process Mixture Model.\nInput: " << inputFile << std::endl // << "Number of iterations of Gibbs Sampler: " << NUM_SWEEPS << std::endl // << "Burn-In: " << BURN_IN << std::endl // << "Initial number of clusters: " << initial_K << std::endl // << "Output: Cluster identities (clusters)\n" << std::endl; // chainClusterSizesFile << "Dirichlet Process Mixture Model.\nInput: " << inputFile << std::endl // << "Number of iterations of Gibbs Sampler: " << NUM_SWEEPS << std::endl // << "Burn-In: " << BURN_IN << std::endl // << "Initial number of clusters: " << initial_K << std::endl // << "Output: Size of clusters (cluster_sizes)\n" << std::endl; // chainMuFile << "Dirichlet Process Mixture Model.\nInput: " << inputFile << std::endl // << "Number of iterations of Gibbs Sampler: " << NUM_SWEEPS << std::endl // << "Burn-In: " << BURN_IN << std::endl // << "Initial number of clusters: " << initial_K << std::endl // << "Output: Samples for cluster mean parameters (mu. Note: means stored in rows)\n" << std::endl; // chainSigmaFile << "Dirichlet Process Mixture Model.\nInput: " << inputFile << std::endl // << "Number of iterations of Gibbs Sampler: " << NUM_SWEEPS << std::endl // << "Burn-In " << BURN_IN << std::endl // << "Initial number of clusters: " << initial_K << std::endl // << "Output: Samples for cluster covariances (sigma)\n" << std::endl; // for (arma::uword sweep = 0; sweep < CHAINSIZE; ++sweep) { // arma::uword K = chain_K[sweep]; // chainKFile << "Sweep #" << BURN_IN + sweep + 1 << "\n" << chain_K[sweep] << std::endl; // chainClustersFile << "Sweep #" << BURN_IN + sweep + 1 << "\n" << chain_clusters[sweep] << std::endl; // chainClusterSizesFile << "Sweep #" << BURN_IN + sweep + 1 << "\n" << chain_clusterSizes[sweep].rows(0, K - 1) << std::endl; // chainMuFile << "Sweep #" << BURN_IN + sweep + 1 << "\n" << chain_mu[sweep].rows(0, K - 1) << std::endl; // chainSigmaFile << "Sweep #" << BURN_IN + sweep + 1<< "\n"; // for (arma::uword i = 0; i < K; ++i) { // chainSigmaFile << chain_sigma[sweep][i] << std::endl; // } // chainSigmaFile << std::endl; // } // } return 0; }
int main (int argc, char* argv[]) { ApplicationsLib::LogogSetup logog_setup; TCLAP::CmdLine cmd( "Creates boundary conditions for mesh nodes along polylines." "The documentation is available at https://docs.opengeosys.org/docs/tools/model-preparation/create-boundary-conditions-along-a-polyline", ' ', "0.1"); TCLAP::ValueArg<bool> gml_arg("", "gml", "if switched on write found nodes to file in gml format", false, 0, "bool"); cmd.add(gml_arg); TCLAP::ValueArg<std::string> output_base_fname("o", "output-base-file-name", "the base name of the file the output (geometry (gli) and boundary"\ "condition (bc)) will be written to", true, "", "file name"); cmd.add(output_base_fname); TCLAP::ValueArg<std::string> bc_type("t", "type", "the process type the boundary condition will be written for "\ "currently LIQUID_FLOW (primary variable PRESSURE1) and "\ "GROUNDWATER_FLOW (primary variable HEAD, default) are supported", true, "", "process type as string (LIQUID_FLOW or GROUNDWATER_FLOW (default))"); cmd.add(bc_type); TCLAP::ValueArg<double> search_length_arg("s", "search-length", "The size of the search length. The default value is " "std::numeric_limits<double>::epsilon()", false, std::numeric_limits<double>::epsilon(), "floating point number"); cmd.add(search_length_arg); TCLAP::ValueArg<std::string> geometry_fname("i", "input-geometry", "the name of the file containing the input geometry", true, "", "file name"); cmd.add(geometry_fname); TCLAP::ValueArg<std::string> mesh_arg("m", "mesh-file", "the name of the file containing the mesh", true, "", "file name"); cmd.add(mesh_arg); cmd.parse(argc, argv); // *** read mesh INFO("Reading mesh \"%s\" ... ", mesh_arg.getValue().c_str()); MeshLib::Mesh * subsurface_mesh(FileIO::readMeshFromFile(mesh_arg.getValue())); INFO("done."); INFO("Extracting top surface of mesh \"%s\" ... ", mesh_arg.getValue().c_str()); const MathLib::Vector3 dir(0,0,-1); double const angle(90); std::unique_ptr<MeshLib::Mesh> surface_mesh( MeshLib::MeshSurfaceExtraction::getMeshSurface(*subsurface_mesh, dir, angle)); INFO("done."); delete subsurface_mesh; subsurface_mesh = nullptr; // *** read geometry GeoLib::GEOObjects geometries; FileIO::readGeometryFromFile(geometry_fname.getValue(), geometries); std::string geo_name; { std::vector<std::string> geo_names; geometries.getGeometryNames(geo_names); geo_name = geo_names[0]; } // *** check if the data is usable // *** get vector of polylines std::vector<GeoLib::Polyline*> const* plys(geometries.getPolylineVec(geo_name)); if (!plys) { ERR("Could not get vector of polylines out of geometry \"%s\".", geo_name.c_str()); return -1; } MeshGeoToolsLib::SearchLength search_length_strategy; if (search_length_arg.isSet()) { search_length_strategy = MeshGeoToolsLib::SearchLength(search_length_arg.getValue()); } GeoLib::GEOObjects geometry_sets; MeshGeoToolsLib::MeshNodeSearcher mesh_searcher(*surface_mesh, search_length_strategy); for(std::size_t k(0); k<plys->size(); k++) { std::vector<std::size_t> ids (mesh_searcher.getMeshNodeIDsAlongPolyline(*((*plys)[k]))); if (ids.empty()) continue; std::string geo_name("Polyline-"+std::to_string(k)); convertMeshNodesToGeometry(surface_mesh->getNodes(), ids, geo_name, geometry_sets); } // merge all together std::vector<std::string> geo_names; geometry_sets.getGeometryNames(geo_names); if (geo_names.empty()) { ERR("Did not find mesh nodes along polylines."); return -1; } std::string merge_name("AllMeshNodesAlongPolylines"); if (geometry_sets.mergeGeometries(geo_names, merge_name) == 2) merge_name = geo_names[0]; GeoLib::PointVec const* pnt_vec(geometry_sets.getPointVecObj(merge_name)); std::vector<GeoLib::Point*> const* merged_pnts(pnt_vec->getVector()); std::vector<GeoLib::Point> pnts_with_id; const std::size_t n_merged_pnts(merged_pnts->size()); for(std::size_t k(0); k<n_merged_pnts; ++k) { pnts_with_id.emplace_back(*((*merged_pnts)[k]), k); } std::sort(pnts_with_id.begin(), pnts_with_id.end(), [](GeoLib::Point const& p0, GeoLib::Point const& p1) { return p0 < p1; } ); double const eps (std::numeric_limits<double>::epsilon()); auto surface_pnts = std::unique_ptr<std::vector<GeoLib::Point*>>( new std::vector<GeoLib::Point*>); std::map<std::string, std::size_t> *name_id_map( new std::map<std::string, std::size_t> ); // insert first point surface_pnts->push_back( new GeoLib::Point(pnts_with_id[0], surface_pnts->size())); std::string element_name; pnt_vec->getNameOfElementByID(0, element_name); name_id_map->insert( std::pair<std::string, std::size_t>(element_name,0) ); for (std::size_t k(1); k < n_merged_pnts; ++k) { const GeoLib::Point& p0 (pnts_with_id[k-1]); const GeoLib::Point& p1 (pnts_with_id[k]); if (std::abs (p0[0] - p1[0]) > eps || std::abs (p0[1] - p1[1]) > eps) { surface_pnts->push_back(new GeoLib::Point(pnts_with_id[k], surface_pnts->size())); std::string element_name; pnt_vec->getNameOfElementByID(k, element_name); name_id_map->insert( std::pair<std::string, std::size_t>(element_name, surface_pnts->size()-1) ); } } std::string surface_name(BaseLib::dropFileExtension(mesh_arg.getValue())+"-MeshNodesAlongPolylines"); geometry_sets.addPointVec(std::move(surface_pnts), surface_name, name_id_map, 1e-6); // write the BCs and the merged geometry set to file std::string const base_fname( BaseLib::dropFileExtension(output_base_fname.getValue())); writeBCsAndGeometry(geometry_sets, surface_name, base_fname, bc_type.getValue(), gml_arg.getValue()); return 0; }
TEUCHOS_UNIT_TEST(DirBC, DirBCManager_finalizeBCEqns) { MPI_Comm comm = MPI_COMM_WORLD; int numProcs = 1; #ifndef FEI_SER MPI_Comm_size(comm, &numProcs); #endif if (numProcs > 1) { FEI_COUT << "skipping test of fei::DirichletBCManager::finalizeBCEqn, which only" << " runs on 1 proc." << FEI_ENDL; return; } int idtype = 0; int fieldID = 0; int fieldSize = 2; int offsetIntoField = 1; std::vector<int> ids(5); std::vector<double> vals(5); ids[0] = 2; vals[0] = 2.0; ids[1] = 1; vals[1] = 1.0; ids[2] = 3; vals[2] = 3.0; ids[3] = 4; vals[3] = 4.0; ids[4] = 0; vals[4] = 0.0; fei::SharedPtr<fei::VectorSpace> vspace(new fei::VectorSpace(comm)); vspace->defineFields(1, &fieldID, &fieldSize); vspace->defineIDTypes(1, &idtype); fei::SharedPtr<fei::MatrixGraph> mgraph(new fei::MatrixGraph_Impl2(vspace, vspace)); int numIDs = 1; int patternID = mgraph->definePattern(numIDs, idtype); int blockID = 0; mgraph->initConnectivityBlock(blockID, ids.size(), patternID); for(size_t i = 0; i<ids.size(); ++i) { mgraph->initConnectivity(blockID, i, &ids[i]); } mgraph->initComplete(); fei::DirichletBCManager bcmgr(mgraph->getRowSpace()); bcmgr.addBCRecords(5, idtype, fieldID, offsetIntoField, &ids[0], &vals[0]); fei::SharedPtr<fei::FillableMat> inner(new fei::FillableMat); fei::SharedPtr<fei::Matrix_Impl<fei::FillableMat> > feimat(new fei::Matrix_Impl<fei::FillableMat>(inner, mgraph, ids.size())); TEUCHOS_TEST_EQUALITY(bcmgr.finalizeBCEqns(*feimat, false), 0, out, success); TEUCHOS_TEST_EQUALITY(feimat->getGlobalNumRows(), feimat->getLocalNumRows(),out,success); TEUCHOS_TEST_EQUALITY(feimat->getGlobalNumRows(), (int)ids.size(), out, success); }
Containers::Array<ALuint> sourceIds(const std::vector<std::reference_wrapper<Source>>& sources) { Containers::Array<ALuint> ids(sources.size()); for(auto it = sources.begin(); it != sources.end(); ++it) ids[it-sources.begin()] = it->get().id(); return ids; }
TEUCHOS_UNIT_TEST(DirBC, DirBCManager_addBCRecords) { MPI_Comm comm = MPI_COMM_WORLD; int idtype = 0; int fieldID = 0; int fieldSize = 2; int offsetIntoField = 1; std::vector<int> ids(5); std::vector<double> vals(5); ids[0] = 2; vals[0] = 2.0; ids[1] = 1; vals[1] = 1.0; ids[2] = 3; vals[2] = 3.0; ids[3] = 4; vals[3] = 4.0; ids[4] = 0; vals[4] = 0.0; fei::SharedPtr<fei::VectorSpace> vspace(new fei::VectorSpace(comm)); vspace->defineFields(1, &fieldID, &fieldSize); vspace->defineIDTypes(1, &idtype); fei::SharedPtr<fei::MatrixGraph> mgraph(new fei::MatrixGraph_Impl2(vspace, vspace)); int numIDs = 1; int patternID = mgraph->definePattern(numIDs, idtype, fieldID); int blockID = 0; mgraph->initConnectivityBlock(blockID, ids.size(), patternID); for(size_t i = 0; i<ids.size(); ++i) { mgraph->initConnectivity(blockID, i, &ids[i]); } mgraph->initComplete(); fei::DirichletBCManager bcmgr(mgraph->getRowSpace()); bcmgr.addBCRecords(5, idtype, fieldID, offsetIntoField, &ids[0], &vals[0]); if (bcmgr.getNumBCRecords() != 5) { throw std::runtime_error("test_DirBCManager test 1 failed."); } std::vector<int> offsetsIntoField(5, 1); bcmgr.addBCRecords(5, idtype, fieldID, &ids[0], &offsetsIntoField[0], &vals[0]); if (bcmgr.getNumBCRecords() != 5) { throw std::runtime_error("test_DirBCManager test 2 failed."); } offsetsIntoField[1] = 0; offsetsIntoField[3] = 0; offsetsIntoField[4] = 0; bcmgr.addBCRecords(5, idtype, fieldID, &ids[0], &offsetsIntoField[0], &vals[0]); if (bcmgr.getNumBCRecords() != 8) { throw std::runtime_error("test_DirBCManager test 3 failed."); } }
static CAcceptedMsgs* NewL(RDbDatabase& aDb) { auto_ptr<CAcceptedMsgs> ids(new (ELeave) CAcceptedMsgs(aDb)); ids->ConstructL(); return ids.release(); }
BOOL ReadWindowPos( LPTSTR pszKeyName, PINT px, PINT py, PINT pcx, PINT pcy, BOOL *pfMaximized) { static CHAR szSep[] = " ,"; TCHAR szBuf[CCHTEXTMAX]; CHAR szBufAnsi[CCHTEXTMAX]; PSTR psz; BOOL fDefCharUsed; if (!GetPrivateProfileString(ids(IDS_APPNAME), pszKeyName, szEmpty, szBuf, CCHTEXTMAX, ids(IDS_DLGEDITINI))) return FALSE; WideCharToMultiByte(CP_ACP, 0, szBuf, -1, szBufAnsi, CCHTEXTMAX, NULL, &fDefCharUsed); if (!(psz = strtok(szBufAnsi, szSep))) return FALSE; *px = atoi(psz); if (!(psz = strtok(NULL, szSep))) return FALSE; *py = atoi(psz); if (!(psz = strtok(NULL, szSep))) return FALSE; *pcx = atoi(psz); if (!(psz = strtok(NULL, szSep))) return FALSE; *pcy = atoi(psz); /* * If there is a "1" following the coordinates, the window was * maximized when it was saved. */ *pfMaximized = FALSE; if ((psz = strtok(NULL, szSep)) && atoi(psz) == 1) *pfMaximized = TRUE; /* * Don't allow a zero sized window. */ if (*pcx == 0 || *pcy == 0) return FALSE; /* * Return success. */ return TRUE; #if 0 static TCHAR szSep[] = L" ,"; TCHAR szBuf[CCHTEXTMAX]; LPTSTR psz; if (!GetPrivateProfileString(ids(IDS_APPNAME), pszKeyName, szEmpty, szBuf, CCHTEXTMAX, ids(IDS_DLGEDITINI))) return FALSE; if (!(psz = wcstok(szBuf, szSep))) return FALSE; *px = awtoi(psz); if (!(psz = wcstok(NULL, szSep))) return FALSE; *py = awtoi(psz); if (!(psz = wcstok(NULL, szSep))) return FALSE; *pcx = awtoi(psz); if (!(psz = wcstok(NULL, szSep))) return FALSE; *pcy = awtoi(psz); /* * If there is a "1" following the coordinates, the window was * maximized when it was saved. */ *pfMaximized = FALSE; if ((psz = wcstok(NULL, szSep)) && awtoi(psz) == 1) *pfMaximized = TRUE; /* * Don't allow a zero sized window. */ if (*pcx == 0 || *pcy == 0) return FALSE; /* * Return success. */ return TRUE; #endif //BUGBUG UNICODE }