Ioss::ElementTopology* Ioss::ElementTopology::boundary_type(int face_number) const
{
if (parametric_dimension() == 3 && spatial_dimension() == 3)
return face_type(face_number);
if (parametric_dimension() == 2 && spatial_dimension() == 2)
return edge_type(face_number);
if (is_element()) {
if (parametric_dimension() == 2) {
// A shell has faces and edges in its boundary...
if (face_number == 0) return nullptr;
assert(spatial_dimension() == 3);
if (face_number > number_faces()) {
return edge_type(face_number - number_faces());
} else {
return face_type(face_number);
}
} else if (parametric_dimension() == 1) {
return edge_type(face_number);
}
} else {
if (parametric_dimension() == 2) {
assert(spatial_dimension() == 3);
return edge_type(face_number);
}
}
return nullptr;
}
void get_pair_type(long num_hbonds, char **hb_atom1, char **hb_atom2,
long i, long j, char *bseq, char *type)
/* Indentify the type of pair interaction according to Leontis and
Westhof' nomenclature */
{
char type_wd1[5], type_wd2[5], **atom;
long nh1,nh2;
atom=cmatrix(0,num_hbonds+40, 0,4);
if(num_hbonds >= 1){
get_unequility(num_hbonds, hb_atom1, &nh1, atom);
edge_type(nh1, atom, i, bseq, type_wd1);
get_unequility(num_hbonds, hb_atom2, &nh2, atom);
edge_type(nh2, atom, j, bseq, type_wd2);
sprintf(type,"%s/%s",type_wd1, type_wd2);
}else
sprintf(type,"?/?");
}
void add_edge(vertex_id_type source, vertex_id_type target, edge_data_type data) {
// now assum both source and target are inserted
vertex_neighbours& s_out_nbr = vertex_id_2_out_edges[source];
vertex_neighbours& t_in_nbr = vertex_id_2_in_edges[target];
s_out_nbr.push_back( edge_type(*this, source, target) );
t_in_nbr.push_back( edge_type(*this, source, target) );
++nedge;
}
edge_type rMatRec(intT nn, intT randStart, intT randStride) {
if (nn==1) return edge_type(0,0);
else {
edge_type x = rMatRec(nn/2, randStart + randStride, randStride);
double r = dataGen::hash<double>(randStart);
if (r < a) return x;
else if (r < ab) return edge_type(x.src,x.dst+nn/2);
else if (r < abc) return edge_type(x.src+nn/2, x.dst);
else return edge_type(x.src+nn/2, x.dst+nn/2);
}
}
edge_type toEdge() const
{
return edge_type(
ia,ib,
addOrientation(clipb,orientation)
);
}
inline dimacs_basic_reader incr( incr_mode mode ) {
if( mode == edge ) {
BOOST_ASSERT( !read_edges.empty() );
read_edges.pop();
}
else if( mode == edge_weight ) {
BOOST_ASSERT( !read_edge_weights.empty() );
read_edge_weights.pop();
}
if( (mode == edge && read_edges.empty()) ||
(mode == edge_weight && read_edge_weights.empty() )) {
if( seen_edges > num_edges ) {
boost::throw_exception(dimacs_exception());
}
while( getline( inpt, buf ) && !buf.empty() && buf[0] == 'c' );
if( !inpt.eof() ) {
int source, dest, weight;
read_edge_line((char*) buf.c_str(), source, dest, weight);
seen_edges++;
source--;
dest--;
read_edges.push( edge_type( source, dest ) );
if (want_weights) {
read_edge_weights.push( weight );
}
}
BOOST_ASSERT( read_edges.size() < 100 );
BOOST_ASSERT( read_edge_weights.size() < 100 );
}
// the 1000000 just happens to be about how many edges can be read in
// 10s
// if( !(seen_edges % 1000000) && !process_id( pg ) && mode == edge ) {
// std::cout << "read " << seen_edges << " edges" << std::endl;
// }
return *this;
}
operator edge_type() const {
return edge_type(graph_ref, e);
}
edge_type dereference() const {
To* to=_container.get(_i);
return edge_type(APElement(_i), to);
}
