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