/** Fill the node to element adjacency table for both
this element and its corresponding ghosts
*/
void FEM_Node::setElemAdjacency(int type, const FEM_Elem &elem){
int nodesPerElem = elem.getNodesPer();
FEM_VarIndexAttribute *adjacencyAttr = elemAdjacency;
CkVec<CkVec<ElemID> > &adjacencyTable = elemAdjacency->get();
FEM_VarIndexAttribute *ghostAdjacencyAttr = ((FEM_Node *)getGhost())->elemAdjacency;
CkVec<CkVec<ElemID> > &ghostAdjacencyTable = ghostAdjacencyAttr->get();
// Scan through elements
for(int i=0;i<elem.size();i++){
const int *conn = elem.connFor(i);
for(int j=0;j<nodesPerElem;j++){
int node = conn[j];
if (node!=-1){
if(FEM_Is_ghost_index(node)){
int idx = ghostAdjacencyAttr->findInRow(FEM_To_ghost_index(node),var_id(type,i));
if(idx == -1) {// If not currently in the adjacency list, push onto list
ghostAdjacencyTable[FEM_To_ghost_index(node)].push_back(var_id(type,i));
}
}
else{
int idx = adjacencyAttr->findInRow(node,var_id(type,i));
if(idx == -1) {// If not currently in the adjacency list, push onto list
adjacencyTable[node].push_back(var_id(type,i));
}
}
}
}
}
// Scan through ghost elements
if(elem.getGhost()){
for(int i=0;i<((FEM_Elem*)elem.getGhost())->size();i++){
const int *conn = ((FEM_Elem*)elem.getGhost())->connFor(i);
for(int j=0;j<nodesPerElem;j++){
int node = conn[j];
if (node!=-1){
if(FEM_Is_ghost_index(node)){
int idx = ghostAdjacencyAttr->findInRow(FEM_To_ghost_index(node),var_id(type,FEM_From_ghost_index(i)));
if(idx == -1){ // If not currently in the adjacency list, push onto list
ghostAdjacencyTable[FEM_To_ghost_index(node)].push_back(var_id(type,FEM_From_ghost_index(i)));
}
}
else{
int idx = adjacencyAttr->findInRow(node,var_id(type,FEM_From_ghost_index(i)));
if(idx == -1){// If not currently in the adjacency list, push onto list
adjacencyTable[node].push_back(var_id(type,FEM_From_ghost_index(i)));
}
}
}
}
}
}
}
//***************************************************************
void CToolCreateEntity::commit(const NLMISC::CVector &createPosition, float createAngle)
{
//H_AUTO(R2_CToolCreateEntity_commit)
if (_CreateState == ChooseArrayOrigin)
{
if (!getEditor().verifyRoomLeft(0, 1))
{
getUI().executeLuaScript("r2:checkStaticQuota(1)");
return;
}
setContextHelp(CI18N::get("uiR2EDDrawArrayContextHelp"));
_CreateState = DrawArray;
_ArrayDefaultAngle = createAngle;
_ArrayOrigin = createPosition;
_ArrayEnd = createPosition;
updateArray(getGhost());
removeGhostSlot();
return;
}
CEntityCL *ghost = getGhost();
if (!ghost) return;
cloneEntityIntoScenario(ghost,
createPosition,
createAngle,
true, /* new action */
false /* create ghost */);
if (isMultiPos() && isShiftDown())
{
// prevent newly created ghost to be removed twice ...
removeGhostSlot();
// re set this tool to generate a new entity look
getUI().runActionHandler("r2ed_create_entity", NULL, "PaletteId=" + _PaletteId);
}
}
// ************************************************************************
CObject* CObjectTableClient::clone() const
{
//H_AUTO(R2_CObjectTableClient_clone)
CObjectTableClient *ret = new CObjectTableClient();
// NB : don't copy the reference because there can be only one CObjectTableClient per instance (other copy are for undo/redo or network)
TContainer::const_iterator first(_Value.begin()), last(_Value.end());
for ( ;first != last; ++first )
{
nlassert(first->second);
ret->add(first->first, first->second->clone());
}
ret->setGhost(getGhost());
return ret;
}
/** Populate the entire node to node adjacency table
Two nodes are considered adjacent if they both are
in the connectivity table for a common element.
This choice for definition of adjacent nodes
does not take into account what are edges
of the element, but it does simplify the computation.
It will work fine for triangles and tetrahedra, but
may not make as much sense for more complicated
element types where all nodes are not directly connected by edges.
*/
void FEM_Node::setNodeAdjacency(const FEM_Elem &elem){
//CkPrintf("In FEM_Node::setNodeAdjacency()\n");
int nodesPerElem = elem.getNodesPer();
CkVec<CkVec<var_id> > &adjacencyTable = nodeAdjacency->get();
FEM_VarIndexAttribute *ghostAdjacencyAttr = ((FEM_Node *)getGhost())->nodeAdjacency;
CkVec<CkVec<var_id> > &ghostAdjacencyTable = ghostAdjacencyAttr->get();
// Add the adjacencies defined by the non-ghost elements
for(int i=0;i<elem.size();i++) { // for each element of the given type
const int *conn = elem.connFor(i);
for(int j=0;j<nodesPerElem;j++){ // for each node adjacent to the element
const int nodej = conn[j];
if (nodej!=-1){
if(FEM_Is_ghost_index(nodej)) { // A ghost node
for(int k=0;k<nodesPerElem;k++){
const int nodek=conn[k];
if(nodek != nodej){
var_id nodeID = var_id::createNodeID(1,nodek);
int idx = ghostAdjacencyAttr->findInRow(FEM_To_ghost_index(nodej),nodeID);
if(idx == -1){
//if(nodej==-5|| nodek==-5) CkPrintf("G %d->%d not found adding\n", nodej, nodek);
ghostAdjacencyTable[FEM_To_ghost_index(nodej)].push_back(nodeID);
}
{
//if(nodej==-5|| nodek==-5) CkPrintf("G %d->%d found already\n", nodej, nodek);
}
}
}
}
else { // A non-ghost node, almost same as for ghost nodes
for(int k=0;k<nodesPerElem;k++){
const int nodek=conn[k];
if(nodek != nodej){
var_id nodeID = var_id::createNodeID(1,nodek);
int idx = nodeAdjacency->findInRow(nodej,nodeID);
if(idx == -1){
//if(nodej==-5|| nodek==-5) CkPrintf("NG %d->%d not found--adding\n", nodej, nodek);
adjacencyTable[nodej].push_back(nodeID);
}
{
//if(nodej==-5 || nodek==-5) CkPrintf("NG %d->%d found already\n", nodej, nodek);
}
}
}
}
}
}
}
for(int i=0;i<((FEM_Elem*)elem.getGhost())->size();i++) { // for each element of the given type
const int *conn = ((FEM_Elem*)elem.getGhost())->connFor(i);
for(int j=0;j<nodesPerElem;j++){ // for each node adjacent to the element
const int nodej = conn[j];
if (nodej!=-1){
if(FEM_Is_ghost_index(nodej)) { // A ghost node
for(int k=0;k<nodesPerElem;k++){
const int nodek=conn[k];
if(nodek != nodej){
var_id nodeID = var_id::createNodeID(1,nodek);
int idx = ghostAdjacencyAttr->findInRow(FEM_To_ghost_index(nodej),nodeID);
if(idx == -1){
//if(nodej==-5|| nodek==-5) CkPrintf("G-G %d->%d not found adding\n", nodej, nodek);
ghostAdjacencyTable[FEM_To_ghost_index(nodej)].push_back(nodeID);
}
{
//if(nodej==-5|| nodek==-5) CkPrintf("G-G %d->%d found already\n", nodej, nodek);
}
}
}
}
else { // A non-ghost node, almost same as for ghost nodes
for(int k=0;k<nodesPerElem;k++){
const int nodek=conn[k];
if(nodek != nodej){
var_id nodeID = var_id::createNodeID(1,nodek);
int idx = nodeAdjacency->findInRow(nodej,nodeID);
if(idx == -1){
//if(nodej==-5|| nodek==-5) CkPrintf("G-NG %d->%d not found--adding\n", nodej, nodek);
adjacencyTable[nodej].push_back(nodeID);
}
{
//if (nodej==-5 || nodek==-5) CkPrintf("G-NG %d->%d found already\n", nodej, nodek);
}
}
}
}
}
}
}
}
