Example #1
0
int main(){

  //PARTICLE pd,pnd;
  PARTICLE *p,*pn;
  p=malloc(sizeof(PARTICLE)); //need to allocate memory to pointer

  tVertex v;

  ReadVertices(p);
  ReadEdges(p);

 
    float     x0, y0, z0, x1, y1, z1;
    tEdge   e;
    
    e = p->edges;
    do{
        x0=e->endpts[0]->v[X];
        y0=e->endpts[0]->v[Y];
        z0=e->endpts[0]->v[Z];
        x1=e->endpts[1]->v[X];
        y1=e->endpts[1]->v[Y];
        z1=e->endpts[1]->v[Z];
        printf("%.2f  %.2f  %.2f  %.2f  %.2f  %.2f\n",x0,y0,z0,x1,y1,z1);
        e=e->next;
    } while(e != p->edges);

/*
	double dDelta,t,tmax;
  int i;
  dDelta=0.01;
  t=0;
  tmax=15;

  vecZero(p->r);
  vecSet(p->v,0.5,0.,0);
  vecZero(p->a);
  p->mass=1.;
  p->rad=0.5;

  while (t<tmax){

		  //printf("%f  %f  %f  %f\n",t,p->r[0],p->r[1],p->r[2]);
  
    for (i=0;i<3;i++){
      p->v[i]=p->v[i]+(0.5*dDelta*p->a[i]); //kick
    }

    for (i=0;i<3;i++){
  	  p->r[i]=p->r[i]+(dDelta*p->v[i]); //drift
    }
    
    for (i=0;i<3;i++){
      p->v[i]=p->v[i]+(0.5*dDelta*p->a[i]); //kick
    }
    t+=dDelta;
  }
*/
  return 0;
}
Example #2
0
void DryadSubGraphVertex::Initialize(UInt32 numberOfInputChannels,
                                     UInt32 numberOfOutputChannels)
{
    DrError err;

    DryadMetaData* metaData = GetMetaData();

    if (metaData == NULL)
    {
        ReportError(DryadError_VertexInitialization,
                    "No MetaData In Start Command");
        return;
    }

    DryadMetaDataRef graphData;
    err = metaData->LookUpMetaData(DryadTag_GraphDescription, &graphData);
    if (err != DrError_OK)
    {
        ReportError(DryadError_VertexInitialization,
                    "No GraphDescription Tag");
        return;
    }

    ReadVertices(graphData);

    if (NoError() == false)
    {
        return;
    }

    ReadEdges(graphData);
}
Example #3
0
        // \brief Read segments (and general MeshGraph) given TiXmlDocument.
        void MeshGraph2D::ReadGeometry(TiXmlDocument &doc)
        {
            // Read mesh first
            MeshGraph::ReadGeometry(doc);
            TiXmlHandle docHandle(&doc);

            TiXmlElement* mesh = NULL;

            /// Look for all geometry related data in GEOMETRY block.
            mesh = docHandle.FirstChildElement("NEKTAR").FirstChildElement("GEOMETRY").Element();

            ASSERTL0(mesh, "Unable to find GEOMETRY tag in file.");
            
            ReadCurves(doc);
            ReadEdges(doc);
            ReadElements(doc);
            ReadComposites(doc);
            ReadDomain(doc);
        }
Example #4
0
void CreateCandidateSet()
{
    GainType Cost, MaxAlpha, A;
    Node *Na;
    int CandidatesRead = 0, i;
    double EntryTime = GetTime();

    Norm = 9999;
    if (C == C_EXPLICIT) {
        Na = FirstNode;
        do {
            for (i = 1; i < Na->Id; i++)
                Na->C[i] *= Precision;
        }
        while ((Na = Na->Suc) != FirstNode);
    }
    if (Distance == Distance_1 ||
        (MaxTrials == 0 &&
         (FirstNode->InitialSuc || InitialTourAlgorithm == SIERPINSKI ||
          InitialTourAlgorithm == MOORE))) {
        CandidatesRead = ReadCandidates(MaxCandidates) ||
            ReadEdges(MaxCandidates);
        AddTourCandidates();
        if (ProblemType == HCP || ProblemType == HPP)
            Ascent();
        goto End_CreateCandidateSet;
    }
    if (TraceLevel >= 2)
        printff("Creating candidates ...\n");
    if (MaxCandidates > 0 &&
        (CandidateSetType == QUADRANT || CandidateSetType == NN)) {
        ReadPenalties();
        if (!(CandidatesRead = ReadCandidates(MaxCandidates) ||
              ReadEdges(MaxCandidates)) && MaxCandidates > 0) {
            if (CandidateSetType == QUADRANT)
                CreateQuadrantCandidateSet(MaxCandidates);
            else if (CandidateSetType == NN) {
                if ((CoordType == TWOD_COORDS
                     && Distance != Distance_TOR_2D)
                    || (CoordType == THREED_COORDS
                        && Distance != Distance_TOR_3D))
                    CreateNearestNeighborCandidateSet(MaxCandidates);
                else
                    CreateNNCandidateSet(MaxCandidates);
            }
        }
        AddTourCandidates();
        if (CandidateSetSymmetric)
            SymmetrizeCandidateSet();
        goto End_CreateCandidateSet;
    }
    if (!ReadPenalties()) {
        /* No PiFile specified or available */
        Na = FirstNode;
        do
            Na->Pi = 0;
        while ((Na = Na->Suc) != FirstNode);
        CandidatesRead = ReadCandidates(MaxCandidates) ||
            ReadEdges(MaxCandidates);
        Cost = Ascent();
        if (Subgradient && SubproblemSize == 0) {
            WritePenalties();
            PiFile = 0;
        }
    } else if ((CandidatesRead = ReadCandidates(MaxCandidates) ||
                ReadEdges(MaxCandidates)) || MaxCandidates == 0) {
        AddTourCandidates();
        if (CandidateSetSymmetric)
            SymmetrizeCandidateSet();
        goto End_CreateCandidateSet;
    } else {
        if (CandidateSetType != DELAUNAY &&
            CandidateSetType != POPMUSIC &&
            MaxCandidates > 0) {
            if (TraceLevel >= 2)
                printff("Computing lower bound ... ");
            Cost = Minimum1TreeCost(0);
            if (TraceLevel >= 2)
                printff("done\n");
        } else {
            if (CandidateSetType == DELAUNAY)
                CreateDelaunayCandidateSet();
            else
                Create_POPMUSIC_CandidateSet(AscentCandidates);
            Na = FirstNode;
            do {
                Na->BestPi = Na->Pi;
                Na->Pi = 0;
            }
            while ((Na = Na->Suc) != FirstNode);
            if (TraceLevel >= 2)
                printff("Computing lower bound ... ");
            Cost = Minimum1TreeCost(1);
            if (TraceLevel >= 2)
                printff("done\n");
            Na = FirstNode;
            do {
                Na->Pi = Na->BestPi;
                Cost -= 2 * Na->Pi;
            }
            while ((Na = Na->Suc) != FirstNode);
        }
    }
    LowerBound = (double) Cost / Precision;
    if (TraceLevel >= 1) {
        printff("Lower bound = %0.1f", LowerBound);
        if (Optimum != MINUS_INFINITY && Optimum != 0)
            printff(", Gap = %0.2f%%",
                    100.0 * (Optimum - LowerBound) / Optimum);
        if (!PiFile)
            printff(", Ascent time = %0.2f sec.",
                    fabs(GetTime() - EntryTime));
        printff("\n");
    }
    MaxAlpha = (GainType) fabs(Excess * Cost);
    if ((A = Optimum * Precision - Cost) > 0 && A < MaxAlpha)
        MaxAlpha = A;
    if (CandidateSetType == DELAUNAY ||
        CandidateSetType == POPMUSIC ||
        MaxCandidates == 0)
        OrderCandidateSet(MaxCandidates, MaxAlpha, CandidateSetSymmetric);
    else
        GenerateCandidates(MaxCandidates, MaxAlpha, CandidateSetSymmetric);

  End_CreateCandidateSet:
    if (ExtraCandidates > 0) {
        AddExtraCandidates(ExtraCandidates,
                           ExtraCandidateSetType,
                           ExtraCandidateSetSymmetric);
        AddTourCandidates();
    }
    ResetCandidateSet();
    if (MaxTrials > 0 ||
        (InitialTourAlgorithm != SIERPINSKI &&
         InitialTourAlgorithm != MOORE)) {
        Na = FirstNode;
        do {
            if (!Na->CandidateSet || !Na->CandidateSet[0].To) {
                if (MaxCandidates == 0)
                    eprintf
                        ("MAX_CANDIDATES = 0: Node %d has no candidates",
                         Na->Id);
                else
                    eprintf("Node %d has no candidates", Na->Id);
            }
        }
        while ((Na = Na->Suc) != FirstNode);
        if (!CandidatesRead && SubproblemSize == 0)
            WriteCandidates();
    }
    if (C == C_EXPLICIT) {
        Na = FirstNode;
        do
            for (i = 1; i < Na->Id; i++)
                Na->C[i] += Na->Pi + NodeSet[i].Pi;
        while ((Na = Na->Suc) != FirstNode);
    }
    if (TraceLevel >= 1) {
        CandidateReport();
        printff("Preprocessing time = %0.2f sec.\n",
                fabs(GetTime() - EntryTime));
    }
}