void FillerBase::setTcal2(const String& tcaltime, const Vector<Float>& tcal) { uInt id = 0 ; Table tab = table_->tcal().table() ; Table result = //tab( nelements(tab.col("TCAL")) == uInt (tcal.size()) && // all(tab.col("TCAL")== tcal) && // tab.col("TIME") == tcaltime, 1 ) ; tab( nelements(tab.col("TCAL")) == uInt (tcal.size()) && all(tab.col("TCAL")== tcal), 1 ) ; if ( result.nrow() > 0 ) { ROTableColumn tmpCol( result, "ID" ) ; tmpCol.getScalar( 0, id ) ; } else { uInt rno = tab.nrow(); tab.addRow(); TableColumn idCol( tab, "ID" ) ; TableColumn tctimeCol( tab, "TIME" ) ; ArrayColumn<Float> tcalCol( tab, "TCAL" ) ; // get last assigned _id and increment if ( rno > 0 ) { idCol.getScalar(rno-1, id); id++; } tctimeCol.putScalar(rno, tcaltime); tcalCol.put(rno, tcal); idCol.putScalar(rno, id); } RecordFieldPtr<uInt> mcalidCol(row_.record(), "TCAL_ID"); *mcalidCol = id; }
/*** uInt STMolecules::addEntry( Double restfreq, const String& name, const String& formattedname ) { Table result = table_( near(table_.col("RESTFREQUENCY"), restfreq) ); uInt resultid = 0; if ( result.nrow() > 0) { ROScalarColumn<uInt> c(result, "ID"); c.get(0, resultid); } else { uInt rno = table_.nrow(); table_.addRow(); // get last assigned _id and increment if ( rno > 0 ) { idCol_.get(rno-1, resultid); resultid++; } restfreqCol_.put(rno, restfreq); nameCol_.put(rno, name); formattednameCol_.put(rno, formattedname); idCol_.put(rno, resultid); } return resultid; } ***/ uInt STMolecules::addEntry( Vector<Double> restfreq, const Vector<String>& name, const Vector<String>& formattedname ) { // How to handle this...? Table result = table_( nelements(table_.col("RESTFREQUENCY")) == uInt (restfreq.size()) && all(table_.col("RESTFREQUENCY")== restfreq), 1 ); uInt resultid = 0; if ( result.nrow() > 0) { ROScalarColumn<uInt> c(result, "ID"); c.get(0, resultid); } else { uInt rno = table_.nrow(); table_.addRow(); // get last assigned _id and increment if ( rno > 0 ) { idCol_.get(rno-1, resultid); resultid++; } restfreqCol_.put(rno, restfreq); nameCol_.put(rno, name); formattednameCol_.put(rno, formattedname); idCol_.put(rno, resultid); } return resultid; }
/** * Return the row count. the number of elements in the component. for * ObjComponent row count will be 0. */ int InstrumentTreeModel::rowCount(const QModelIndex &parent) const { // std::cout<<"rowCount +++++++++ row"<<parent.row()<<" column //"<<parent.column()<<" is valid "<<parent.isValid()<<'\n'; try { if (!parent.isValid()) // Root node row count is one. { return 1; // boost::dynamic_pointer_cast<ICompAssembly>(m_instrument)->nelements(); } else { auto instr = m_instrumentActor->getInstrument(); if (instr->getComponentID() == static_cast<Mantid::Geometry::ComponentID>( parent.internalPointer())) { return instr->nelements(); } boost::shared_ptr<const IComponent> comp = instr->getComponentByID(static_cast<Mantid::Geometry::ComponentID>( parent .internalPointer())); // static_cast<IComponent*>(parent.internalPointer()); boost::shared_ptr<const ICompAssembly> assembly = boost::dynamic_pointer_cast<const ICompAssembly>(comp); if (assembly) { return assembly->nelements(); } boost::shared_ptr<const IObjComponent> objcomp = boost::dynamic_pointer_cast<const IObjComponent>(comp); if (objcomp) return 0; } } catch (...) { // std::cout<<"Exception: in rowCount"<<'\n'; } return 0; }
void draw() { glDrawArrays(_mode, 0, nelements()); }
void Partitioning<Dim>::run() { int p = 2; int* pm = new int[p]; for(unsigned short i = 0; i < p; ++i) pm[i] = i * (Environment::numberOfProcessors() / p); bool excluded = std::binary_search(pm, pm + p, Environment::rank()); mpi::group new_group; if(excluded) new_group = Environment::worldComm().group().include(pm,pm+p); else new_group = Environment::worldComm().group().exclude(pm,pm+p); delete [] pm; boost::mpi::communicator bComm(Environment::worldComm(), new_group); std::vector<int> active( bComm.size(), true ); WorldComm wComm(bComm,bComm,bComm,bComm.rank(),active); //wComm.showMe(); boost::shared_ptr<Mesh<Simplex<Dim>>> mesh; if(!excluded) { std::cout << "proc " << Environment::rank() << " is not excluded and is locally rank " << wComm.rank() << " and loads mesh with " << wComm.globalSize() << " partitions\n"; // mesh = loadMesh(_mesh = new Mesh<Simplex<Dim>>(wComm), _worldcomm=wComm ); mesh = createGMSHMesh(_mesh = new Mesh<Simplex<Dim>>(wComm), _worldcomm = wComm, _desc = domain(_worldcomm = wComm, _name = "hypercube", _shape = "hypercube", _xmin = 0.0, _xmax = 1.0, _ymin = 0.0, _ymax = 1.0, _zmin = 0.0, _zmax = 1.0)); std::cout << " - nelement(mesh)=" << nelements(elements(mesh)) << "\n"; std::cout << " - loading space\n"; auto Vh = Pch<2>( mesh ); auto u = Vh->element("u"); auto f = expr( soption(_name="functions.f"), "f", wComm ); auto g = expr( soption(_name="functions.g"), "g", wComm ); auto v = Vh->element( g, "g" ); auto l = form1( _test=Vh ); l = integrate(_range=elements(mesh),_expr=f*id(v)); auto a = form2( _trial=Vh, _test=Vh); a = integrate(_range=elements(mesh), _expr=gradt(u)*trans(grad(v)) ); if(boption("gmsh.domain.usenames")) { if(nelements(markedfaces(mesh, "Dirichlet"), boption("use_global")) > 0) a+=on(_range=markedfaces(mesh, "Dirichlet"), _rhs=l, _element=u, _expr=g); } else a+=on(_range=boundaryfaces(mesh), _rhs=l, _element=u, _expr=g); a.solve(_rhs=l,_solution=u); auto e = exporter( _mesh=mesh ); //e->addRegions(); e->add( "u", u ); e->add( "g", v ); e->save(); } else { std::cout << "proc " << Environment::rank() << " is excluded and does not load mesh"; int np = 0; mpi::all_reduce(wComm, 1, np, std::plus<int>()); std::cout << "proc " << Environment::rank() << " - nb proc = " << np << "\n"; } } // Partitioning::run
void PartitionerMetis<MeshType>::partitionImpl ( mesh_ptrtype mesh, rank_type np ) { LOG(INFO) << "PartitionerMetis::partitionImpl starts..."; tic(); // Check for an easy return if (np == 1) { this->singlePartition (mesh); return; } const dof_id_type n_elems = mesh->numElements(); // build the graph // std::vector<Metis::idx_t> options(5); std::vector<Metis::idx_t> vwgt(n_elems); std::vector<Metis::idx_t> part(n_elems); // number of "nodes" (elements) in the graph Metis::idx_t n = static_cast<Metis::idx_t>(n_elems); // number of subdomains to create Metis::idx_t nparts = static_cast<Metis::idx_t>(np); // number of edges cut by the resulting partition Metis::idx_t edgecut = 0; std::map<dof_id_type, dof_id_type> global_index_map; { std::vector<dof_id_type> global_index(nelements(elements(mesh)),0); std::iota( global_index.begin(), global_index.end(), 0 ); size_type cnt = 0; for( auto const& elt : elements(mesh) ) { global_index_map.insert (std::make_pair(elt.id(), global_index[cnt++])); } } // Invoke METIS, but only on processor 0. // Then broadcast the resulting decomposition if ( Environment::isMasterRank() ) { CSRGraphMetis<Metis::idx_t> csr_graph; csr_graph.offsets.resize(mesh->numElements()+1, 0); // Local scope for these { #ifndef NDEBUG std::size_t graph_size=0; #endif // build the graph in CSR format. Note that // the edges in the graph will correspond to // face neighbors for( auto& elt: elements(mesh) ) { // (1) first pass - get the row sizes for each element by counting the number // of face neighbors. Also populate the vwght array if necessary const dof_id_type gid = global_index_map[elt.id()]; CHECK( gid < vwgt.size() ) << "Invalid gid " << gid << " greater or equal than " << vwgt.size(); // maybe there is a better weight? // The weight is used to define what a balanced graph is //if(!_weights) vwgt[gid] = elt.numPoints; //else //vwgt[gid] = static_cast<Metis::idx_t>((*_weights)[elem->id()]); unsigned int num_neighbors = 0; // Loop over the element's neighbors. An element // adjacency corresponds to a face neighbor for ( uint16_type ms=0; ms < elt.nNeighbors(); ms++ ) { element_type const* neighbor = NULL; size_type neighbor_id = elt.neighbor( ms ).first; if ( neighbor_id != invalid_size_type_value ) { num_neighbors++; } } std::cout << "element id " << elt.id() << " gid: " << gid << " w: " << vwgt[gid] << " neigh: " << num_neighbors << std::endl; csr_graph.prepareNumberNonZeros(gid, num_neighbors); #ifndef NDEBUG graph_size += num_neighbors; #endif } csr_graph.prepareForUse(); // (2) second pass - fill the compressed adjacency array for( auto& elt : elements(mesh) ) { dof_id_type gid = global_index_map[elt.id()]; unsigned int connection=0; // Loop over the element's neighbors. An element // adjacency corresponds to a face neighbor for ( uint16_type ms=0; ms < elt.nNeighbors(); ms++ ) { element_type const* neighbor = NULL; size_type neighbor_id = elt.neighbor( ms ).first; if ( neighbor_id != invalid_size_type_value ) { csr_graph(gid, connection++) = global_index_map[neighbor_id]; } } } #ifndef NDEBUG // We create a non-empty vals for a disconnected graph, to // work around a segfault from METIS. DCHECK( csr_graph.vals.size() == std::max(graph_size,std::size_t(1))) << "Invalid graph"; #endif } // done building the graph Metis::idx_t ncon = 1; // Select which type of partitioning to create // Use recursive if the number of partitions is less than or equal to 8 if (np <= 8) Metis::METIS_PartGraphRecursive(&n, &ncon, &csr_graph.offsets[0], &csr_graph.vals[0], &vwgt[0], NULL, NULL, &nparts, NULL, NULL, NULL, &edgecut, &part[0]); // Otherwise use kway else Metis::METIS_PartGraphKway(&n, &ncon, &csr_graph.offsets[0], &csr_graph.vals[0], &vwgt[0], NULL, NULL, &nparts, NULL, NULL, NULL, &edgecut, &part[0]); } // end processor 0 part // Assign the returned processor ids. The part array contains the processor // id for each element, but in terms of the contiguous indexing we defined // above LOG(INFO) << "PartitionerMetis::partitionImpl nelements : " << nelements(elements(mesh)); for( auto it = mesh->beginElement(), en = mesh->endElement(); it != en; ++it ) { dof_id_type gid = global_index_map[it->id()]; CHECK( gid < part.size() ) << "Invalid gid " << gid << " greater or equal than partition size " << part.size(); rank_type pid = static_cast<rank_type>(part[gid]); #if 0 mesh->elements().modify( it, [&pid]( element_type& e ) { e.setProcessId( pid ); std::cout << "element id " << e.id() << " process id " << e.processId() << "\n"; }); #else std::cout << "element id " << it->id() << " process id " << pid << "\n"; auto e = *it; e.setProcessId( pid ); mesh->elements().replace( it, e ); #endif } for( auto& e : allelements(mesh) ) { std::cout << "2. element id " << e.id() << " process id " << e.processId() << "\n"; } auto t = toc("PartitionerMetis::partitionImpl", FLAGS_v > 0 ); LOG(INFO) << "PartitionerMetis::partitionImpl done in " << t << "s"; }