int main(){
int status;
//read line of words
char** line = readLineOfWords();
TokenNode **tokens;
while (line != NULL)
{
int pid = fork();
bool isBackground = isBackgroundProcess(line);
if (pid == 0){
tokens = getStartNode(line);
}
if (isBackground){
if (pid == 0){
processLineOfTokens(tokens);
}
}else{
if (pid == 0){
processLineOfTokens(tokens);
}else{
int status;
waitpid(pid,&status,0);
}
}
line = readLineOfWords();
}
return 0;
}
//! \copydoc NodalConstrainASM2DHelper::constrainEdge
void constrainEdge(int item, int comp, int basis, int idx)
{
size_t ofs = getStartNode(basis);
int n1, n2, node = 1;
pch->getSize(n1,n2,basis);
switch (item) {
case 2: // Right edge (positive I-direction)
node += n1-1;
case 1: // Left edge (negative I-direction)
for (int i2 = 1; i2 <= n2; i2++, node += n1) {
int gn = pch->getNodeID(ofs+node);
if (gn != idx)
pch->add2PC(pch->getNodeID(ofs+node), comp, idx);
}
break;
case 4: // Back edge (positive J-direction)
node += n1*(n2-1);
case 3: // Front edge (negative J-direction)
for (int i1 = 1; i1 <= n1; i1++, node++) {
int gn = pch->getNodeID(ofs+node);
if (gn != idx)
pch->add2PC(gn, comp, idx);
}
default:
break;
}
}
//! \copydoc NodalConstrainASM2DHelper::getCorner
int getCorner(int vertex, int basis)
{
int n1, n2;
pch->getSize(n1, n2, basis);
size_t ofs = getStartNode(basis);
const std::vector<int> idxs = {1, n1, n1*(n2-1)+1, n1*n2};
return pch->getNodeID(idxs[vertex-1]+ofs);
}
//! \brief Constrain the patch to a given node.
//! \param[in] comp Component to constrain
//! \param[in] basis Basis to constrain vertex for.
//! \param[in] idx Global node to constrain patch to.
void constrainPatch(int comp, int basis, int idx)
{
size_t ofs = getStartNode(basis);
for (size_t i = 1; i <= bpch->getNoNodes(basis); ++i) {
int gn = bpch->getNodeID(ofs+i);
if (gn != idx)
bpch->add2PC(bpch->getNodeID(ofs+i), comp, idx);
}
}
//! \copydoc NodalConstraintASMHelper::getCorner
int getCorner(int vertex, int basis)
{
size_t ofs = getStartNode(basis);
int n1, n2, n3;
pch->getSize(n1, n2, n3, basis);
int ofs_j = n1*(n2-1);
int ofs_k = n1*n2*(n3-1);
const std::vector<int> idxs = { 1, n1,
ofs_j+1, ofs_j+n1,
ofs_k+1, ofs_k+n1,
ofs_k+ofs_j+1, ofs_k+ofs_j+n1};
return pch->getNodeID(idxs[vertex-1]+ofs);
}
//! \copydoc NodalConstrainASMHelper::constrainEdge
void constrainEdge(int item, int comp, int basis, int idx)
{
size_t node = getStartNode(basis)+1;
int n1, n2, n3;
pch->getSize(n1,n2,n3,basis);
size_t inc = 1;
int n;
if (item > 8) {
inc = n1*n2;
n = n3;
} else if (item > 4) {
inc = n1;
n = n2;
} else
n = n1;
switch (item)
{
case 6:
case 10:
node += n1 - 1;
break;
case 2:
case 11:
node += n1*(n2-1);
break;
case 12:
node += n1*n2 - 1;
break;
case 3:
case 7:
node += n1*n2*(n3-1);
break;
case 8:
node += n1*(n2*(n3-1) + 1) - 1;
break;
case 4:
node += n1*(n2*n3-1);
break;
}
for (int i = 1; i <= n; i++, node += inc) {
int gn = pch->getNodeID(node);
if (gn != idx)
pch->add2PC(gn, comp, idx);
}
}
//! \brief Constrain a given face to a given node.
//! \param item Face index on patch
//! \param comp Component to constrain
//! \param basis Basis to constrain edge for
//! \param idx Global node to constrain edge to.
void constrainFace(int item, int comp, int basis, int idx)
{
int node = getStartNode(basis)+1;
int n1, n2, n3;
pch->getSize(n1,n2,n3,basis);
const std::vector<int> faceDir = {-1, 1, -2, 2, -3, 3};
switch (faceDir[item-1])
{
case 1: // Right face (positive I-direction)
node += n1-1;
case -1: // Left face (negative I-direction)
for (int i3 = 1; i3 <= n3; i3++)
for (int i2 = 1; i2 <= n2; i2++, node += n1) {
int gn = pch->getNodeID(node);
if (gn != idx)
pch->add2PC(gn, comp, idx);
}
break;
case 2: // Back face (positive J-direction)
node += n1*(n2-1);
case -2: // Front face (negative J-direction)
for (int i3 = 1; i3 <= n3; i3++, node += n1*(n2-1))
for (int i1 = 1; i1 <= n1; i1++, node++) {
int gn = pch->getNodeID(node);
if (gn != idx)
pch->add2PC(gn, comp, idx);
}
break;
case 3: // Top face (positive K-direction)
node += n1*n2*(n3-1);
case -3: // Bottom face (negative K-direction)
for (int i2 = 1; i2 <= n2; i2++)
for (int i1 = 1; i1 <= n1; i1++, node++) {
int gn = pch->getNodeID(node);
if (gn != idx)
pch->add2PC(gn, comp, idx);
}
break;
}
}
//! \brief Obtain the global node number of a given corner node on patch.
//! \param vertex Vertex to obtain
//! \param basis Basis for vertex
int getCorner(int vertex, int basis)
{
size_t ofs = getStartNode(basis);
return pch->getNodeID(ofs+(vertex==1?1:pch->getSize(basis)));
}
int main() {
int rv;
double rvd;
NeighLL neighLL2;
ClusterLL ClLL;
ClusterLL ClLL2;
ClusterLL ClLL3;
ClusterLL ClLL6;
ClusterLL ClLL5;
MidPoint mp2;
//////////////////////////////////////////////////////////////////////
printf("Testing:newClusterLL\n");
ClLL = newClusterLL(-1);
assert(ClLL==NULL);
ClLL = newClusterLL(1);
assert(ClLL!=NULL);
printf("Testing:deleteClusterLL\n");
rv = deleteClusterLL(NULL);
assert(rv==-1);
rv = deleteClusterLL(ClLL);
assert(rv==0);
printf("Testing:deleteClusterLLNodes\n");
ClLL = newClusterLL(3);
assert(ClLL!=NULL);
rv = deleteClusterLLNodes(ClLL);
assert(rv==0);
printf("Testing:deleteAllClusterLL\n");
ClLL = newClusterLL(4);
rv = deleteAllClusterLL(NULL);
assert(rv==-1);
rv = deleteAllClusterLL(&ClLL);
assert(rv==0);
printf("Testing:printNodesClusterLL\n");
rv = printNodesClusterLL(NULL);
assert(rv==-1);
ClLL = newClusterLL(5);
printf("Should print no Nodes but the cluster id should be 5\n");
rv = printNodesClusterLL(ClLL);
assert(rv==0);
printf("Testing:getNextClusterLL\n");
ClLL2 = getNextClusterLL(NULL);
assert(ClLL2==NULL);
ClLL2 = newClusterLL(84);
deleteClusterLL(ClLL2);
ClLL2 = getNextClusterLL(ClLL);
assert(ClLL2==NULL);
deleteClusterLL(ClLL2);
printf("Testing:printClusterLL\n");
rv = printClusterLL(NULL);
assert(rv==-1);
rv = printClusterLL(ClLL);
assert(rv==0); //start here
printf("Testing:getCluster_NeighLL");
neighLL2=getCluster_NeiLL(NULL);
assert(neighLL2==NULL);
neighLL2=getCluster_NeiLL(ClLL);
assert(neighLL2==0); //have to create and set neighbor of ClLL
printf("Testing:setCluster_NeiLL");
printf("Testing:getCluster_id\n");
rv = getCluster_id(NULL);
assert(rv==-1);
rv = getCluster_id(ClLL);
assert(rv==5);
printf("Testing:getCluster_numNodes\n");
rv = getCluster_numNodes(NULL);
assert(rv==-1);
rv = getCluster_numNodes(ClLL);
assert(rv==0);
printf("Testing:setCluster_elecXFid");
printf("Testing:setCluster_elecXBid");
printf("Testing:setCluster_elecYLid");
printf("Testing:setCluster_elecYRid");
printf("Testing:setCluster_elecZBid");
printf("Testing:setCluster_elecZAid");
printf("Testing:getCluster_NeighLL");
printf("Testing:setCluster_NeiLL");
printf("Testing:setCluster_elecXid\n");
rv = setCluster_elecXid(&ClLL, -1);
assert(rv==-1);
rv = setCluster_elecXid(&ClLL, 2);
assert(rv==-1);
rv = setCluster_elecXid(NULL, 1);
assert(rv==-1);
rv = setCluster_elecXid(&ClLL, 1);
assert(rv==0);
rv = setCluster_elecXid(&ClLL, 0);
assert(rv==0);
rv = setCluster_elecXid(&ClLL, 1);
assert(rv==-1);
printf("Testing:setCluster_elecYid\n");
rv = setCluster_elecYid(&ClLL, -1);
assert(rv==-1);
rv = setCluster_elecYid(&ClLL, 2);
assert(rv==-1);
rv = setCluster_elecYid(NULL, 1);
assert(rv==-1);
rv = setCluster_elecYid(&ClLL, 1);
assert(rv==0);
rv = setCluster_elecYid(&ClLL, 0);
assert(rv==0);
rv = setCluster_elecYid(&ClLL, 1);
assert(rv==-1);
printf("Testing:setCluster_elecZid\n");
rv = setCluster_elecZid(&ClLL, -1);
assert(rv==-1);
rv = setCluster_elecZid(&ClLL, 2);
assert(rv==-1);
rv = setCluster_elecZid(NULL, 1);
assert(rv==-1);
rv = setCluster_elecZid(&ClLL, 1);
assert(rv==0);
rv = setCluster_elecZid(&ClLL, 0);
assert(rv==0);
rv = setCluster_elecZid(&ClLL, 1);
assert(rv==-1);
ClLL2 = newClusterLL(66);
int ElecXF = 1;
printf("Testing:setCluster_elecXsum\n");
rv = setCluster_elecXsum(ClLL, 1.1, ElecXF);
assert(rv==-1);
rv = setCluster_elecXsum(ClLL, -1.1,ElecXF);
assert(rv==-1);
rv = setCluster_elecXsum(NULL, 1,ElecXF);
assert(rv==-1);
rv = setCluster_elecXsum(ClLL2,1,ElecXF);
assert(rv==-1);
Electrode elxf = newElectrode();
rv = setCluster_elecXF(&ClLL2,elxf);
assert(rv==0);
rv = setCluster_elecXsum(ClLL2, 1.1, ElecXF);
assert(rv==0);
int ElecYR = 1;
printf("Testing:setCluster_elecYsum\n");
rv = setCluster_elecYsum(ClLL, 2.1, ElecYR);
assert(rv==-1);
rv = setCluster_elecYsum(ClLL, -2, ElecYR);
assert(rv==-1);
rv = setCluster_elecYsum(NULL, 1, ElecYR);
assert(rv==-1);
rv = setCluster_elecYsum(ClLL2,3, ElecYR);
assert(rv==-1);
ClLL6 = newClusterLL(63);
Electrode elyr = newElectrode();
rv = setCluster_elecYR(&ClLL6,elyr);
assert(rv==0);
rv = setCluster_elecYsum(ClLL6, 2.1, ElecYR);
assert(rv==0);
int ElecZA = 1;
printf("Testing:setCluster_elecZsum\n");
rv = setCluster_elecZsum(ClLL, 2.9, ElecZA);
assert(rv==-1);
rv = setCluster_elecZsum(ClLL, -1.1, ElecZA);
assert(rv==-1);
rv = setCluster_elecZsum(NULL, 1, ElecZA);
assert(rv==-1);
rv = setCluster_elecZsum(ClLL2,9.1, ElecZA);
assert(rv==-1);
ClLL5 = newClusterLL(69);
Electrode elza = newElectrode();
rv = setCluster_elecZA(&ClLL5,elza);
assert(rv==0);
rv = setCluster_elecZsum(ClLL5, 1.1, ElecZA);
assert(rv==0);
printf("Testing:addToCluster_elecXsum\n");
rv = addToCluster_elecXsum(ClLL,-2,ElecXF);
assert(rv==-1);
rv = addToCluster_elecXsum(NULL,1,ElecXF);
assert(rv==-1);
rv = addToCluster_elecXsum(ClLL,1,ElecXF);
assert(rv==-1);
rv = addToCluster_elecXsum(ClLL2,1,ElecXF);
assert(rv==0);
printf("Testing:addToCluster_elecYsum\n");
rv = addToCluster_elecYsum(ClLL,-2, ElecYR);
assert(rv==-1);
rv = addToCluster_elecYsum(NULL,1, ElecYR);
assert(rv==-1);
rv = addToCluster_elecYsum(ClLL2,1, ElecYR);
assert(rv==-1);
rv = addToCluster_elecYsum(ClLL,1, ElecYR);
assert(rv==-1);
rv = addToCluster_elecYsum(ClLL6,1, ElecYR);
assert(rv==0);
printf("Testing:addToCluster_elecZsum\n");
rv = addToCluster_elecZsum(ClLL,-2, ElecZA);
assert(rv==-1);
rv = addToCluster_elecZsum(NULL,1, ElecZA);
assert(rv==-1);
rv = addToCluster_elecZsum(ClLL2,1, ElecZA);
assert(rv==-1);
rv = addToCluster_elecZsum(ClLL,1, ElecZA);
assert(rv==-1);
rv = addToCluster_elecZsum(ClLL5,1, ElecZA);
assert(rv==0);
printf("Testing:getCluster_elecXsum\n");
rvd = getCluster_elecXsum(NULL,ElecXF);
assert(rvd==-1);
rvd = getCluster_elecXsum(ClLL2,ElecXF);
assert(rvd==2.1);
printf("Testing:getCluster_elecYsum\n");
rvd = getCluster_elecYsum(NULL,ElecYR);
assert(rvd==-1);
rvd = getCluster_elecYsum(ClLL2,ElecYR);
assert(rvd==-1);
rvd = getCluster_elecYsum(ClLL6,ElecYR);
assert(rvd==3.1);
printf("Testing:getCluster_elecZsum\n");
rvd = getCluster_elecZsum(NULL,ElecZA);
assert(rvd==-1);
rvd = getCluster_elecZsum(ClLL2,ElecZA);
assert(rvd==-1);
rvd = getCluster_elecZsum(ClLL5,ElecZA);
assert(rvd==2.1);
printf("Testing:setCluster_id\n");
rv = setCluster_id(ClLL,-1);
assert(rv==-1);
rv = setCluster_id(NULL,2);
assert(rv==-1);
rv = setCluster_id(ClLL,80);
assert(rv==0);
rv = getCluster_id(ClLL);
assert(rv==80);
printf("Testing:getCluster_Sum\n");
rvd = getCluster_Sum(NULL);
assert(rvd==-1.0);
rvd = getCluster_Sum(ClLL);
assert(rvd==0);
printf("Testing:addToClusterSum\n");
rv = addToClusterSum(NULL,3.3);
assert(rv==-1);
rv = addToClusterSum(ClLL,-13);
assert(rv==-1);
rv = addToClusterSum(ClLL,32);
assert(rv==0);
rvd = getCluster_Sum(ClLL);
assert(rvd==32);
printf("Testing:setNextClusterLL\n");
rv = setNextClusterLL(NULL, ClLL2);
assert(rv==-1);
assert(ClLL2!=NULL);
rv = setNextClusterLL(ClLL, ClLL2);
assert(rv==0);
ClLL3 = getNextClusterLL(ClLL);
assert(ClLL3!=NULL);
assert(getCluster_id(ClLL2)==getCluster_id(ClLL3));
rv = setNextClusterLL(ClLL, NULL);
assert(rv==0);
ClLL3 = getNextClusterLL(ClLL);
assert(ClLL3==NULL);
deleteAllClusterLL(&ClLL);
deleteAllClusterLL(&ClLL2);
deleteAllClusterLL(&ClLL6);
deleteAllClusterLL(&ClLL5);
deleteElectrode(&elxf);
deleteElectrode(&elyr);
deleteElectrode(&elza);
//////////////////////////////////////////////////////////////////////
ClLL = newClusterLL(5);
rv = setCluster_elecXid(&ClLL, 0);
rv = setCluster_elecYid(&ClLL, 0);
rv = setCluster_elecZid(&ClLL, 0);
rv = setCluster_elecXid(&ClLL, 1);
rv = setCluster_elecYid(&ClLL, 1);
rv = setCluster_elecZid(&ClLL, 1);
rv = setCluster_elecXsum(ClLL, 1.1, ElecXF);
rv = setCluster_elecYsum(ClLL, 2.1, ElecYR);
rv = setCluster_elecZsum(ClLL, 2.9, ElecZA);
rv = addToCluster_elecXsum(ClLL,1,ElecXF);
rv = addToCluster_elecYsum(ClLL,1,ElecYR);
rv = addToCluster_elecZsum(ClLL,1, ElecZA);
rv = setCluster_id(ClLL,80);
rv = addToClusterSum(ClLL,32);
ClLL2 = newClusterLL(84);
Node nd4;
printf("Testing:getStartNode\n");
nd4 = getStartNode(ClLL);
assert(nd4==NULL);
nd4 = getStartNode(NULL);
assert(nd4==NULL);
NeighNode neighN;
printf("Testing:getStartNeigh\n");
neighN = getStartNeigh(ClLL);
assert(neighN==NULL);
neighN = getStartNeigh(NULL);
assert(neighN==NULL);
printf("Testing:getCluster_numNodes\n");
rv = getCluster_numNodes(NULL);
assert(rv==-1);
rv = getCluster_numNodes(ClLL);
assert(rv==0);
printf("Testing:setCluster_elecXsum\n");
deleteAllClusterLL(&ClLL);
ClLL = newClusterLL(32);
Electrode elxf2 = newElectrode();
setCluster_elecXF(&ClLL,elxf2);
rv = setCluster_elecXsum(ClLL, 3.3,ElecXF);
assert(rv==0);
rv = setCluster_elecXsum(ClLL, -1,ElecXF);
assert(rv==-1);
rv = setCluster_elecXsum(NULL,2.5,ElecXF);
assert(rv==-1);
rv = setCluster_elecXsum(ClLL2,2.3,ElecXF);
assert(rv==-1);
printf("Testing:setCluster_elecYsum\n");
deleteAllClusterLL(&ClLL);
ClLL = newClusterLL(82);
Electrode elyr2 = newElectrode();
setCluster_elecYR(&ClLL,elyr2);
rv = setCluster_elecYsum(ClLL, 3.3,ElecYR);
assert(rv==0);
rv = setCluster_elecYsum(ClLL, -1,ElecYR);
assert(rv==-1);
rv = setCluster_elecYsum(NULL,2.5,ElecYR);
assert(rv==-1);
rv = setCluster_elecYsum(ClLL2,2.3,ElecYR);
assert(rv==-1);
printf("Testing:setCluster_elecZsum\n");
deleteAllClusterLL(&ClLL);
ClLL = newClusterLL(102);
Electrode elza2 = newElectrode();
setCluster_elecZA(&ClLL,elza2);
rv = setCluster_elecZsum(ClLL, 3.3,ElecZA);
assert(rv==0);
rv = setCluster_elecZsum(ClLL, -1,ElecZA);
assert(rv==-1);
rv = setCluster_elecZsum(NULL,2.5,ElecZA);
assert(rv==-1);
rv = setCluster_elecZsum(ClLL2,2.3,ElecZA);
assert(rv==-1);
printf("Testing:getCluster_p\n");
rvd = getCluster_p(ClLL);
assert(rvd==0.0);
rvd = getCluster_p(NULL);
assert(rvd==-1.0);
printf("Testing:setCluster_p\n");
rv = setCluster_p(ClLL,1.1);
assert(rv==0);
rvd = getCluster_p(ClLL);
assert(rvd==1.1);
rv = setCluster_p(NULL,2.2);
assert(rv==-1);
rv = setCluster_p(ClLL,-1.3);
assert(rv==-1);
rvd = getCluster_p(ClLL);
assert(rvd==1.1);
printf("Testing:getCluster_elecXid\n");
deleteElectrode(&elxf2);
deleteAllClusterLL(&ClLL);
ClLL = newClusterLL(32);
elxf2 = newElectrode();
Electrode elxf3 = newElectrode();
setCluster_elecXB(&ClLL,elxf3);
setCluster_elecXF(&ClLL,elxf2);
rv = getCluster_elecXid(ClLL);
assert(rv==2);
rv = getCluster_elecXid(ClLL2);
assert(rv==-1);
rv = getCluster_elecXid(NULL);
assert(rv==-1);
printf("Testing:getCluster_elecYid\n");
deleteElectrode(&elyr2);
deleteAllClusterLL(&ClLL);
ClLL = newClusterLL(82);
elyr2 = newElectrode();
Electrode elyr3 = newElectrode();
setCluster_elecYL(&ClLL,elyr3);
setCluster_elecYR(&ClLL,elyr2);
rv = getCluster_elecYid(ClLL);
assert(rv==2);
rv = getCluster_elecYid(ClLL2);
assert(rv==-1);
rv = getCluster_elecYid(NULL);
assert(rv==-1);
printf("Testing:getCluster_elecZid\n");
deleteElectrode(&elza2);
deleteAllClusterLL(&ClLL);
ClLL = newClusterLL(102);
elza2 = newElectrode();
Electrode elza3 = newElectrode();
setCluster_elecZB(&ClLL,elza3);
setCluster_elecZA(&ClLL,elza2);
rv = getCluster_elecZid(ClLL);
assert(rv==2);
rv = getCluster_elecZid(ClLL2);
assert(rv==-1);
rv = getCluster_elecZid(NULL);
assert(rv==-1);
printf("Testing:getCluster_time\n");
rvd = getCluster_time(NULL);
assert(rvd==-1.0);
rvd = getCluster_time(ClLL);
assert(rvd==0.0);
deleteNode(nd4);
deleteAllClusterLL(&ClLL);
deleteAllClusterLL(&ClLL2);
deleteElectrode(&elxf2);
deleteElectrode(&elxf3);
deleteElectrode(&elyr2);
deleteElectrode(&elyr3);
deleteElectrode(&elza2);
deleteElectrode(&elza3);
//////////////////////////////////////////////////////////////////////
printf("Testing:addNodeEndClusterLL\n");
ClusterLL ClLL9 = newClusterLL(77);
Node nd11;
rv = addNodeEndClusterLL(NULL,2);
assert(rv==-1);
rv = addNodeEndClusterLL(ClLL9,-1);
assert(rv==-1);
rv = addNodeEndClusterLL(ClLL9,73);
assert(rv==0);
rv = getCluster_numNodes(ClLL9);
assert(rv==1);
nd11 = getStartNode(ClLL9);
assert(getNode_id(nd11)==73);
assert(getNextNode(nd11)==NULL);
rv = addNodeEndClusterLL(ClLL9,82);
assert(rv==0);
assert(getCluster_numNodes(ClLL9)==2);
assert(getNextNode(nd11)!=NULL);
nd11 = getNextNode(nd11);
assert(getNode_id(nd11)==82);
deleteAllClusterLL(&ClLL9);
deleteElectrode(&elxf2);
//////////////////////////////////////////////////////////////////////
ClLL = newClusterLL(5);
rv = setCluster_elecXid(&ClLL, 0);
rv = setCluster_elecYid(&ClLL, 0);
rv = setCluster_elecZid(&ClLL, 0);
rv = setCluster_elecXid(&ClLL, 1);
rv = setCluster_elecYid(&ClLL, 1);
rv = setCluster_elecZid(&ClLL, 1);
rv = setCluster_elecXsum(ClLL, 1.1, ElecXF);
rv = setCluster_elecYsum(ClLL, 2.1, ElecYR);
rv = setCluster_elecZsum(ClLL, 2.9, ElecZA);
rv = addToCluster_elecXsum(ClLL,1,ElecXF);
rv = addToCluster_elecYsum(ClLL,1,ElecYR);
rv = addToCluster_elecZsum(ClLL,1, ElecZA);
rv = setCluster_id(ClLL,80);
rv = addToClusterSum(ClLL,32);
printf("Testing:addNodeNewCluster\n");
mp2 = newMidPoint(-2, 1, 3, 298);
Node nd6;
ClusterLL ClLL22;
ClLL22=NULL;
ClusterLL ClLL4;
rv = addNodeNewCluster(&ClLL22,mp2);
assert(rv==-1);
rv = addNodeNewCluster(&ClLL,NULL);
assert(rv==-1);
rv = addNodeNewCluster(&ClLL,mp2);
assert(rv==0);
rv = getCluster_numNodes(ClLL);
assert(rv==0);
nd6 = getStartNode(ClLL);
assert(nd6==NULL);
ClLL4 = getNextClusterLL(ClLL);
rv = getCluster_numNodes(ClLL4);
assert(rv==2);
nd6 = getStartNode(ClLL4);
assert(getNode_id(nd6)==3);
nd6 = getNextNode(nd6);
assert(getNode_id(nd6)==298);
assert(getNextClusterLL(ClLL4)==NULL);
deleteMidPoint(mp2);
deleteAllClusterLL(&ClLL);
//////////////////////////////////////////////////////////////////////
printf("Testing:addNodeToCluster\n");
ClusterLL ClLL12 = newClusterLL(200);
assert(getCluster_id(ClLL12)==200);
ClusterLL ClLL13 ;
MidPoint mp22 = newMidPoint(-3,33,5,4);
Node nd13;
rv = addNodeToCluster( NULL, mp22);
assert(rv==-1);
rv = addNodeToCluster( ClLL12, NULL);
assert(rv==-1);
rv = addNodeToCluster( ClLL12, mp22);
assert(rv==0);
rv = getCluster_numNodes(ClLL12);
assert(rv==2);
nd13 = getStartNode(ClLL12);
assert(getNode_id(nd13)==5);
nd13 = getNextNode(nd13);
assert(getNode_id(nd13)==4);
deleteMidPoint(mp22);
MidPoint mp23 = newMidPoint(-3, 22, 8, 11);
rv = addNodeToCluster( ClLL12, mp23);
assert(rv==0);
rv = getCluster_numNodes(ClLL12);
assert(rv==2);
ClLL13 = getNextClusterLL(ClLL12);
assert(ClLL13!=NULL);
rv = getCluster_id(ClLL13);
assert(rv==201);
rv = getCluster_numNodes(ClLL13);
assert(rv==2);
deleteMidPoint(mp23);
MidPoint mp24 = newMidPoint(-3,33,5,4);
rv = addNodeToCluster(ClLL12, mp24);
assert(rv==-1);
assert(getCluster_numNodes(ClLL12)==2);
deleteMidPoint(mp24);
MidPoint mp25 = newMidPoint(-3,33,5,22);
rv = addNodeToCluster(ClLL12, mp25);
assert(rv==0);
assert(getCluster_numNodes(ClLL12)==3);
nd13 = getStartNode(ClLL12);
nd13 = getNextNode(nd13);
nd13 = getNextNode(nd13);
assert(getNode_id(nd13)==22);
deleteMidPoint(mp25);
MidPoint mp26 = newMidPoint(-3,33,8,28);
rv = addNodeToCluster(ClLL12, mp26);
assert(rv==0);
ClLL13 = getNextClusterLL(ClLL12);
assert(getCluster_numNodes(ClLL13)==3);
nd13 = getStartNode(ClLL13);
nd13 = getNextNode(nd13);
nd13 = getNextNode(nd13);
assert(getNode_id(nd13)==28);
deleteMidPoint(mp26);
MidPoint mp27 = newMidPoint(-3,33,22,28);
rv = addNodeToCluster(ClLL12,mp27);
assert(rv==0);
assert(getCluster_numNodes(ClLL12)==6);
assert(getNextClusterLL(ClLL12)==NULL);
deleteMidPoint(mp27);
nd13 = getStartNode(ClLL12);
assert(getNode_id(nd13)==5);
nd13 = getNextNode(nd13);
assert(getNode_id(nd13)==4);
nd13 = getNextNode(nd13);
assert(getNode_id(nd13)==22);
nd13 = getNextNode(nd13);
assert(getNode_id(nd13)==8);
nd13 = getNextNode(nd13);
assert(getNode_id(nd13)==11);
nd13 = getNextNode(nd13);
assert(getNode_id(nd13)==28);
nd13 = getNextNode(nd13);
assert(nd13==NULL);
deleteAllClusterLL(&ClLL12);
//////////////////////////////////////////////////////////////////////
ClLL = newClusterLL(5);
rv = setCluster_elecXid(&ClLL, 0);
rv = setCluster_elecYid(&ClLL, 0);
rv = setCluster_elecZid(&ClLL, 0);
rv = setCluster_elecXid(&ClLL, 1);
rv = setCluster_elecYid(&ClLL, 1);
rv = setCluster_elecZid(&ClLL, 1);
rv = setCluster_elecXsum(ClLL, 1.1, ElecXF);
rv = setCluster_elecYsum(ClLL, 2.1, ElecYR);
rv = setCluster_elecZsum(ClLL, 2.9, ElecZA);
rv = addToCluster_elecXsum(ClLL,1,ElecXF);
rv = addToCluster_elecYsum(ClLL,1,ElecYR);
rv = addToCluster_elecZsum(ClLL,1, ElecZA);
rv = setCluster_id(ClLL,80);
rv = addToClusterSum(ClLL,32);
mp2 = newMidPoint(-2, 1, 3, 298);
rv = addNodeNewCluster(&ClLL,mp2);
ClLL4 = getNextClusterLL(ClLL);
printf("Testing:addNeighNodeToCluster\n");
NeighNode NeighN7;
ClusterLL ClLL24 = NULL;
rv = addNeighNodeToCluster(&ClLL24,55);
assert(rv==-1);
ClusterLL ClLL8 = newClusterLL(99);
rv = addNeighNodeToCluster(&ClLL8,-1);
assert(rv==-1);
rv = addNeighNodeToCluster(&ClLL8,34);
assert(rv==0);
NeighN7 = getStartNeigh(ClLL8);
assert(getNeighNode_id(NeighN7)==34);
rv = getCluster_numNeigh(ClLL8);
assert(rv==1);
rv = addNeighNodeToCluster(&ClLL8,34);
printClusterLL(ClLL8);
assert(rv==-1);
rv = getCluster_numNeigh(ClLL8);
assert(rv==1);
NeighN7 = getStartNeigh(ClLL8);
assert(NeighN7!=NULL);
assert(getNextNeigh(NeighN7)==NULL);
rv = addNeighNodeToCluster(&ClLL8,82);
assert(rv==0);
rv = getCluster_numNeigh(ClLL8);
assert(rv==2);
NeighN7 = getStartNeigh(ClLL8);
NeighN7 = getNextNeigh(NeighN7);
assert(getNeighNode_id(NeighN7)==82);
assert(getNextNeigh(NeighN7)==NULL);
printf("Testing:addPvalClusterNode\n");
rv = addPvalClusterNode(NULL,1,3.4);
assert(rv==-1);
rv = addPvalClusterNode(ClLL,-1,34);
assert(rv==-1);
rv = addPvalClusterNode(ClLL,1,-89);
assert(rv==-1);
rv = addPvalClusterNode(ClLL,1,32);
assert(rv==-1);
rv = addPvalClusterNode(ClLL4,1,2.2);
assert(rv==-1);
rv = addPvalClusterNode(ClLL4,3, 5.5);
assert(rv==0);
rvd = getCluster_time(ClLL4);
assert(rvd==1/5.5);
nd6 = getStartNode(ClLL4);
assert(getNode_p(nd6)==5.5);
printf("Testing:addPvalClusterNeighNode\n");
ClusterLL ClLL54 = newClusterLL(92);
rv = addPvalClusterNeighNode(NULL, 34, 3.3);
assert(rv==-1);
rv = addPvalClusterNeighNode(ClLL8,-2, 3.3);
assert(rv==-1);
rv = addPvalClusterNeighNode(ClLL8,3, 3.3);
assert(rv==-1);
rv = addPvalClusterNeighNode(ClLL8, 34, -1);
assert(rv==-1);
rv = addPvalClusterNeighNode(ClLL54, 34, 3.3);
assert(rv==-1);
rv = addPvalClusterNeighNode(ClLL8, 34, 2.2);
assert(rv==0);
NeighN7 = getStartNeigh(ClLL8);
assert(NeighN7!=NULL);
assert(getNeighNode_p(NeighN7,1)==2.2);
deleteMidPoint(mp2);
deleteAllClusterLL(&ClLL);
deleteAllClusterLL(&ClLL8);
deleteAllClusterLL(&ClLL54);
return 0;
}
/** Loads a quad graph from a file.
* \param filename Name of the file to load.
*/
void QuadGraph::load(const std::string &filename)
{
const XMLNode *xml = file_manager->createXMLTree(filename);
if(!xml)
{
// No graph file exist, assume a default loop X -> X+1
// i.e. each quad is part of the graph exactly once.
// First create an empty graph node for each quad:
for(unsigned int i=0; i<QuadSet::get()->getNumberOfQuads(); i++)
m_all_nodes.push_back(new GraphNode(i, (unsigned int) m_all_nodes.size()));
// Then set the default loop:
setDefaultSuccessors();
computeDirectionData();
if (m_all_nodes.size() > 0)
{
m_lap_length = m_all_nodes[m_all_nodes.size()-1]->getDistanceFromStart()
+ m_all_nodes[m_all_nodes.size()-1]->getDistanceToSuccessor(0);
}
else
{
Log::error("Quad Graph", "No node in driveline graph.");
m_lap_length = 10.0f;
}
return;
}
// The graph file exist, so read it in. The graph file must first contain
// the node definitions, before the edges can be set.
for(unsigned int node_index=0; node_index<xml->getNumNodes(); node_index++)
{
const XMLNode *xml_node = xml->getNode(node_index);
// First graph node definitions:
// -----------------------------
if(xml_node->getName()=="node-list")
{
// A list of quads is connected to a list of graph nodes:
unsigned int from, to;
xml_node->get("from-quad", &from);
xml_node->get("to-quad", &to);
for(unsigned int i=from; i<=to; i++)
{
m_all_nodes.push_back(new GraphNode(i, (unsigned int) m_all_nodes.size()));
}
}
else if(xml_node->getName()=="node")
{
// A single quad is connected to a single graph node.
unsigned int id;
xml_node->get("quad", &id);
m_all_nodes.push_back(new GraphNode(id, (unsigned int) m_all_nodes.size()));
}
// Then the definition of edges between the graph nodes:
// -----------------------------------------------------
else if(xml_node->getName()=="edge-loop")
{
// A closed loop:
unsigned int from, to;
xml_node->get("from", &from);
xml_node->get("to", &to);
for(unsigned int i=from; i<=to; i++)
{
assert(i!=to ? i+1 : from <m_all_nodes.size());
addSuccessor(i,(i!=to ? i+1 : from));
//~ m_all_nodes[i]->addSuccessor(i!=to ? i+1 : from);
}
}
else if(xml_node->getName()=="edge-line")
{
// A line:
unsigned int from, to;
xml_node->get("from", &from);
xml_node->get("to", &to);
for(unsigned int i=from; i<to; i++)
{
addSuccessor(i,i+1);
//~ m_all_nodes[i]->addSuccessor(i+1);
}
}
else if(xml_node->getName()=="edge")
{
// Adds a single edge to the graph:
unsigned int from, to;
xml_node->get("from", &from);
xml_node->get("to", &to);
assert(to<m_all_nodes.size());
addSuccessor(from,to);
//~ m_all_nodes[from]->addSuccessor(to);
} // edge
else
{
Log::error("Quad Graph", "Incorrect specification in '%s': '%s' ignored.",
filename.c_str(), xml_node->getName().c_str());
continue;
} // incorrect specification
}
delete xml;
setDefaultSuccessors();
computeDistanceFromStart(getStartNode(), 0.0f);
computeDirectionData();
// Define the track length as the maximum at the end of a quad
// (i.e. distance_from_start + length till successor 0).
m_lap_length = -1;
for(unsigned int i=0; i<m_all_nodes.size(); i++)
{
float l = m_all_nodes[i]->getDistanceFromStart()
+ m_all_nodes[i]->getDistanceToSuccessor(0);
if(l > m_lap_length)
m_lap_length = l;
}
} // load
/** Sets all start positions depending on the quad graph. The number of
* entries needed is defined by the size of the start_transform (though all
* entries will be overwritten).
* E.g. the karts will be placed as:
* 1 \
* 2 +-- row with three karts, each kart is 'sidewards_distance'
* 3 / to the right of the previous kart, and
* 4 'forwards_distance' behind the previous kart.
* 5 The next row starts again with the kart being
* 6 'forwards_distance' behind the end of the previous row.
* etc.
* \param start_transforms A vector sized to the needed number of start
* positions. The values will all be overwritten with the
* default start positions.
* \param karts_per_row How many karts to place in each row.
* \param forwards_distance Distance in forward (Z) direction between
* each kart.
* \param sidewards_distance Distance in sidewards (X) direction between
* karts.
*/
void QuadGraph::setDefaultStartPositions(AlignedArray<btTransform>
*start_transforms,
unsigned int karts_per_row,
float forwards_distance,
float sidewards_distance,
float upwards_distance) const
{
// We start just before the start node (which will trigger lap
// counting when reached). The first predecessor is the one on
// the main driveline.
int current_node = m_all_nodes[getStartNode()]->getPredecessor(0);
float distance_from_start = 0.1f+forwards_distance;
// Maximum distance to left (or right) of centre line
const float max_x_dist = 0.5f*(karts_per_row-0.5f)*sidewards_distance;
// X position relative to the centre line
float x_pos = -max_x_dist + sidewards_distance*0.5f;
unsigned int row_number = 0;
for(unsigned int i=0; i<(unsigned int)start_transforms->size(); i++)
{
if (current_node == -1)
{
(*start_transforms)[i].setOrigin(Vec3(0,0,0));
(*start_transforms)[i].setRotation(btQuaternion(btVector3(0, 1, 0),
0));
}
else
{
// First find on which segment we have to start
while(distance_from_start > getNode(current_node).getNodeLength())
{
distance_from_start -= getNode(current_node).getNodeLength();
// Only follow the main driveline, i.e. first predecessor
current_node = getNode(current_node).getPredecessor(0);
}
const GraphNode &gn = getNode(current_node);
Vec3 center_line = gn.getLowerCenter() - gn.getUpperCenter();
center_line.normalize();
Vec3 horizontal_line = gn[2] - gn[3];
horizontal_line.normalize();
Vec3 start = gn.getUpperCenter()
+ center_line * distance_from_start
+ horizontal_line * x_pos;
// Add a certain epsilon to the height in case that the
// drivelines are beneath the track.
(*start_transforms)[i].setOrigin(start+Vec3(0,upwards_distance,0));
(*start_transforms)[i].setRotation(
btQuaternion(btVector3(0, 1, 0),
gn.getAngleToSuccessor(0)));
if(x_pos >= max_x_dist-sidewards_distance*0.5f)
{
x_pos = -max_x_dist;
// Every 2nd row will be pushed sideways by half the distance
// between karts, so that a kart can drive between the karts in
// the row ahead of it.
row_number ++;
if(row_number % 2 == 0)
x_pos += sidewards_distance*0.5f;
}
else
x_pos += sidewards_distance;
distance_from_start += forwards_distance;
}
} // for i<stk_config->m_max_karts
} // setStartPositions
/** Loads a drive graph from a file.
* \param filename Name of the quad file to load.
* \param filename Name of the graph file to load.
*/
void DriveGraph::load(const std::string &quad_file_name,
const std::string &filename)
{
XMLNode *quad = file_manager->createXMLTree(quad_file_name);
if (!quad || quad->getName() != "quads")
{
Log::error("DriveGraph : Quad xml '%s' not found.", filename.c_str());
delete quad;
return;
}
// Each quad is part of the graph exactly once now.
for (unsigned int i = 0; i < quad->getNumNodes(); i++)
{
const XMLNode *xml_node = quad->getNode(i);
if (xml_node->getName() != "quad")
{
Log::warn("DriveGraph: Unsupported node type '%s' found in '%s' - ignored.",
xml_node->getName().c_str(), filename.c_str());
continue;
}
// Note that it's not easy to do the reading of the parameters here
// in quad, since the specification in the xml can contain references
// to previous points. E.g.:
// <quad p0="40:3" p1="40:2" p2="25.396030 0.770338 64.796539" ...
Vec3 p0, p1, p2, p3;
getPoint(xml_node, "p0", &p0);
getPoint(xml_node, "p1", &p1);
getPoint(xml_node, "p2", &p2);
getPoint(xml_node, "p3", &p3);
bool invisible = false;
xml_node->get("invisible", &invisible);
bool ai_ignore = false;
xml_node->get("ai-ignore", &ai_ignore);
bool ignored = false;
std::string direction;
xml_node->get("direction", &direction);
if (direction == "forward" && race_manager->getReverseTrack())
{
ignored = true;
invisible = true;
ai_ignore = true;
}
else if (direction == "reverse" && !race_manager->getReverseTrack())
{
ignored = true;
invisible = true;
ai_ignore = true;
}
createQuad(p0, p1, p2, p3, m_all_nodes.size(), invisible, ai_ignore,
false/*is_arena*/, ignored);
}
delete quad;
const XMLNode *xml = file_manager->createXMLTree(filename);
if(!xml)
{
// No graph file exist, assume a default loop X -> X+1
// Set the default loop:
setDefaultSuccessors();
computeDirectionData();
if (m_all_nodes.size() > 0)
{
m_lap_length = getNode(m_all_nodes.size()-1)->getDistanceFromStart()
+ getNode(m_all_nodes.size()-1)->getDistanceToSuccessor(0);
}
else
{
Log::error("DriveGraph", "No node in driveline graph.");
m_lap_length = 10.0f;
}
return;
}
// The graph file exist, so read it in. The graph file must first contain
// the node definitions, before the edges can be set.
for(unsigned int node_index=0; node_index<xml->getNumNodes(); node_index++)
{
const XMLNode *xml_node = xml->getNode(node_index);
// Load the definition of edges between the graph nodes:
// -----------------------------------------------------
if (xml_node->getName() == "node-list")
{
// Each quad is part of the graph exactly once now.
unsigned int to = 0;
xml_node->get("to-quad", &to);
assert(to + 1 == m_all_nodes.size());
continue;
}
else if(xml_node->getName()=="edge-loop")
{
// A closed loop:
unsigned int from, to;
xml_node->get("from", &from);
xml_node->get("to", &to);
for(unsigned int i=from; i<=to; i++)
{
assert(i!=to ? i+1 : from <m_all_nodes.size());
addSuccessor(i,(i!=to ? i+1 : from));
//~ m_all_nodes[i]->addSuccessor(i!=to ? i+1 : from);
}
}
else if(xml_node->getName()=="edge-line")
{
// A line:
unsigned int from, to;
xml_node->get("from", &from);
xml_node->get("to", &to);
for(unsigned int i=from; i<to; i++)
{
addSuccessor(i,i+1);
//~ m_all_nodes[i]->addSuccessor(i+1);
}
}
else if(xml_node->getName()=="edge")
{
// Adds a single edge to the graph:
unsigned int from, to;
xml_node->get("from", &from);
xml_node->get("to", &to);
assert(to<m_all_nodes.size());
addSuccessor(from,to);
//~ m_all_nodes[from]->addSuccessor(to);
} // edge
else
{
Log::error("DriveGraph", "Incorrect specification in '%s': '%s' ignored.",
filename.c_str(), xml_node->getName().c_str());
continue;
} // incorrect specification
}
delete xml;
setDefaultSuccessors();
computeDistanceFromStart(getStartNode(), 0.0f);
computeDirectionData();
// Define the track length as the maximum at the end of a quad
// (i.e. distance_from_start + length till successor 0).
m_lap_length = -1;
for(unsigned int i=0; i<m_all_nodes.size(); i++)
{
float l = getNode(i)->getDistanceFromStart()
+ getNode(i)->getDistanceToSuccessor(0);
if(l > m_lap_length)
m_lap_length = l;
}
loadBoundingBoxNodes();
} // load
