BFLWingedEdge.h

Go to the documentation of this file.

//                                                                   //
//authors: Costas Andreopoulos, Elias Athanasopoulos, George Tzanakos//
//                Physics Department, University of Athens           //
//                                                  October 28, 1999 //

//
//               __ INSERT _ DOCUMENTATION _ HERE __
//
//                                                      see NuMI-L-xxx

#ifndef BFLWINGEDEDGE_H
#define BFLWINGEDEDGE_H

#include <TObjArray.h>

#include "BField/BFLNode.h"
#include "BField/BFLVtx.h"
#include "BField/BFLEdge.h"
#include "BField/BFLPolyg.h"
#include "BField/BFLAnsysLookup.h"
#include "BField/TIntList.h"
#include "BField/BfldGrid.h"

const Int_t kStartEdgeID = 1;
const Int_t kStartVtxID = 1;
const Int_t kStartPolygID = 0;

const Int_t kALL      = 0;
const Int_t kEDGES    = 1;
const Int_t kVERTICES = 2;
const Int_t kPOLYGONS = 3;

class BFLNode;
class BFLVtx;
class BFLEdge;
class BFLPolyg;
class TIntList;

class BFLWingedEdge: public TObject
{
public:

  BFLWingedEdge(Long_t ngens = 0);
  ~BFLWingedEdge();
  virtual void SetGenerators(TObjArray * gens) { fGenerators = gens; } 
  
  Long_t Size(void);
  void Load(const Char_t * filename);
  void Save(const Char_t * filename = "default.vor");
  void LoadNodalSet(const Char_t * filename);
  void SaveNodalSet(const Char_t * filename = "default-nodes.vor");

  void LoadANSYSLookupTable(BfldGrid::Grid_t grid);
  
// getters

  virtual TObjArray * GetGenerators(void) { return fGenerators; } 

  virtual Int_t GetEdgeID(Int_t EdgeSlot) const {
    return ((BFLEdge *)fEdges->At(EdgeSlot))->GetEdgeID();
  }
  virtual Int_t GetRightPolyg(Int_t EdgeSlot) const {
    return ((BFLEdge *)fEdges->At(EdgeSlot))->GetRightPolyg(); 
  }  
  virtual Int_t GetLeftPolyg(Int_t EdgeSlot) const {
    return ((BFLEdge *)fEdges->At(EdgeSlot))->GetLeftPolyg(); 
  }  
  virtual Int_t GetStartVtx(Int_t EdgeSlot) const {
    return ((BFLEdge *)fEdges->At(EdgeSlot))->GetStartVtx(); 
  }  
  virtual Int_t GetEndVtx(Int_t EdgeSlot) const {
    return ((BFLEdge *)fEdges->At(EdgeSlot))->GetEndVtx(); 
  }  
  virtual Int_t GetCwPredecessor(Int_t EdgeSlot) const {
    return ((BFLEdge *)fEdges->At(EdgeSlot))->GetCwPredecessor();
  }  
  virtual Int_t GetCcwPredecessor(Int_t EdgeSlot) const {
    return ((BFLEdge *)fEdges->At(EdgeSlot))->GetCcwPredecessor(); 
  }  
  virtual Int_t GetCwSuccessor(Int_t EdgeSlot) const {
    return ((BFLEdge *)fEdges->At(EdgeSlot))->GetCwSuccessor(); 
  }  
  virtual Int_t GetCcwSuccessor(Int_t EdgeSlot) const {
    return ((BFLEdge *)fEdges->At(EdgeSlot))->GetCcwSuccessor(); 
  }  
  virtual Int_t GetPolygID(Int_t PolySlot) const {
    return ((BFLPolyg *)fPolygons->At(PolySlot))->GetPolygID();
  }
  virtual Int_t GetEdgeAroundPolyg(Int_t PolySlot) const {
    return ((BFLPolyg *)fPolygons->At(PolySlot))->GetEdgeAroundPolyg(); 
  }  
  virtual BFLNode * GetVtx(Int_t VtxSlot) const {
    return new BFLNode(GetX(VtxSlot),GetY(VtxSlot));
  }
  virtual Int_t GetVtxID(Int_t VtxSlot) const {
    return ((BFLVtx *)fVertices->At(VtxSlot))->GetVtxID();
  }
  virtual Int_t GetEdgeAroundVtx(Int_t VtxSlot) const {
    return ((BFLVtx *)fVertices->At(VtxSlot))->GetEdgeAroundVtx(); 
  }  
  virtual Bool_t GetWeight(Int_t VtxSlot) const {
    return ((BFLVtx *)fVertices->At(VtxSlot))->GetWeight(); 
  }  
  virtual Float_t GetX(Int_t VtxSlot) const {
    return ((BFLVtx *)fVertices->At(VtxSlot))->GetX(); 
  }  
  virtual Float_t GetY(Int_t VtxSlot) const {
    return ((BFLVtx *)fVertices->At(VtxSlot))->GetY(); 
  }  

  virtual Int_t GetNofPolygons(void) { return fPolygons->GetEntries(); }
  virtual Int_t GetNofVertices(void) { return fVertices->GetEntries(); }
  virtual Int_t GetNofEdges(void) { return fEdges->GetEntries(); }

  virtual TObjArray * GetPolygons(void) { return fPolygons; }
  virtual TObjArray * GetVertices(void) { return fVertices; }
  virtual TObjArray * GetEdges(void) { return fEdges; }

  virtual BFLPolyg * GetPolygObj(Int_t slot) { 
     return (BFLPolyg *) fPolygons->At(slot);
  }
  virtual BFLVtx * GetVtxObj(Int_t slot) {
     return (BFLVtx *) fVertices->At(slot);
  }
  virtual BFLEdge * GetEdgeObj(Int_t slot) {
     return (BFLEdge *) fEdges->At(slot);
  }

  virtual BFLAnsysLookup GetAnsysLookupTable(void) { return *fANSYSTable; }
  
  virtual Int_t GetLastPolygID(void) { return fPolygons->GetLast(); }
  virtual Int_t GetLastVtxID(void) { return fVertices->GetLast(); }
  virtual Int_t GetLastEdgeID(void) { return fEdges->GetLast(); }    

  virtual Int_t PolygonToGenerator(Int_t polygon) const { return polygon; }
  virtual Int_t GeneratorToPolygon(Int_t generator) const { return generator; }

  virtual Float_t GetGeneratorX(Int_t igen) const {
    return ((BFLNode *)(fGenerators->At(igen-1)))->GetX();
  }
  virtual Float_t GetGeneratorY(Int_t igen) const {
    return ((BFLNode *)(fGenerators->At(igen-1)))->GetY();
  }
  virtual Int_t GetGeneratorID(Int_t igen) const {
    return ((BFLNode *)(fGenerators->At(igen-1)))->GetNodeID();
  }

// setters

  void SetEdge(Int_t edge) { 
    fEdges->AddAtAndExpand(new BFLEdge(edge), edge); 
  }  
  virtual void SetPolyg(Int_t polyg) { 
    fPolygons->AddAtAndExpand(new BFLPolyg(polyg), polyg); 
  }  
  virtual void SetVtx(Int_t vtx) { 
    fVertices->AddAtAndExpand(new BFLVtx(vtx), vtx); 
  }  

  virtual void SetEdgeID(Int_t EdgeSlot, Int_t EdgeID) {
    ((BFLEdge *)fEdges->At(EdgeSlot))->SetRightPolyg(EdgeID); 
  }
  virtual void SetRightPolyg(Int_t EdgeSlot, Int_t rpolyg) {
    ((BFLEdge *)fEdges->At(EdgeSlot))->SetRightPolyg(rpolyg); 
  }  
  virtual void SetLeftPolyg(Int_t EdgeSlot, Int_t lpolyg) {
    ((BFLEdge *)fEdges->At(EdgeSlot))->SetLeftPolyg(lpolyg); 
  }  
  virtual void SetStartVtx(Int_t EdgeSlot, Int_t svtx) {
    ((BFLEdge *)fEdges->At(EdgeSlot))->SetStartVtx(svtx); 
  }  
  virtual void SetEndVtx(Int_t EdgeSlot, Int_t evtx) {
    ((BFLEdge *)fEdges->At(EdgeSlot))->SetEndVtx(evtx); 
  }  
  virtual void SetCwPredecessor(Int_t EdgeSlot, Int_t cwpred) {
    ((BFLEdge *)fEdges->At(EdgeSlot))->SetCwPredecessor(cwpred); 
  }  
  virtual void SetCcwPredecessor(Int_t EdgeSlot, Int_t ccwpred) {
    ((BFLEdge *)fEdges->At(EdgeSlot))->SetCcwPredecessor(ccwpred); 
  }  
  virtual void SetCwSuccessor(Int_t EdgeSlot, Int_t cwsucc) {
    ((BFLEdge *)fEdges->At(EdgeSlot))->SetCwSuccessor(cwsucc); 
  }  
  virtual void SetCcwSuccessor(Int_t EdgeSlot, Int_t ccwsucc) {
    ((BFLEdge *)fEdges->At(EdgeSlot))->SetCcwSuccessor(ccwsucc); 
  }  
  virtual void SetPolygID(Int_t PolySlot,Int_t PolyID) { 
    ((BFLPolyg *)fPolygons->At(PolySlot))->SetPolygID(PolyID);
  }  
  virtual void SetEdgeAroundPolyg(Int_t PolySlot, Int_t edge) {
    ((BFLPolyg *)fPolygons->At(PolySlot))->SetEdgeAroundPolyg(edge);
  }  
  virtual void SetVtxID(Int_t VtxSlot, Int_t VtxID) { 
    ((BFLVtx *)fVertices->At(VtxSlot))->SetVtxID(VtxID);  
  }  
  virtual void SetEdgeAroundVtx(Int_t VtxSlot, Int_t edge) {
    ((BFLVtx *)fVertices->At(VtxSlot))->SetEdgeAroundVtx(edge);
  }  
  virtual void SetWeight(Int_t VtxSlot, Bool_t weight) {
    ((BFLVtx *)fVertices->At(VtxSlot))->SetWeight(weight);
  }  
  virtual void SetX(Int_t VtxSlot, Float_t x) {
    ((BFLVtx *)fVertices->At(VtxSlot))->SetX(x);
  }  
  virtual void SetY(Int_t VtxSlot, Float_t y) {
    ((BFLVtx *)fVertices->At(VtxSlot))->SetY(y);
  }

  virtual void SetPolygObj(BFLPolyg * polyg, Int_t slot) { 
     fPolygons->AddAt(polyg,slot);
  }
  virtual void SetVtxObj(BFLVtx * vtx, Int_t slot) {
     fVertices->AddAt(vtx,slot);
  }
  virtual void SetEdgeObj(BFLEdge * edge, Int_t slot) {
     fEdges->AddAt(edge,slot);
  }

  void AddEdge(Int_t EdgeSlot);
  void AddPolyg(Int_t PolySlot);
  void AddVtx(Int_t VtxSlot);

  virtual void DeleteVtx(Int_t vtx) 
  {
    delete (BFLVtx *) fVertices->At(vtx); 
    fVertices->RemoveAt(vtx); 
  }
  virtual void DeleteEdge(Int_t edge) 
  { 
    delete (BFLEdge *) fEdges->At(edge);
    fEdges->RemoveAt(edge); 
  } 
  virtual void DeletePolygon(Int_t polyg) 
  {
    delete (BFLPolyg *) fPolygons->At(polyg);
    fPolygons->RemoveAt(polyg); 
  }

  void PrintVoronoi(Int_t PrintWhat);
  void PrintPolygons(void); 
  void PrintVertices(void); 
  void PrintEdges(void);         
  void Plot(void);

  void AddAvailableEdgeID(Int_t id);
  void AddAvailableVtxID(Int_t id);
  Int_t FirstAvailableVtxID(void) const;
  Int_t FirstAvailableEdgeID(void) const;
  void DeleteFirstAvailableVtxID(void);
  void DeleteFirstAvailableEdgeID(void);
  Int_t MaxAvailableEdgeID(void) const; 
  Int_t MaxAvailableVtxID(void) const; 
  
private:
  Int_t           fNEdges;
  Int_t           fNVertices;
  Int_t           fNPolygons;
  TObjArray*      fEdges;
  TObjArray*      fVertices;
  TObjArray*      fPolygons;
  TObjArray*      fGenerators;
  TIntList*       fAvailableVtxIDs;
  TIntList*       fAvailableEdgeIDs;
  BFLAnsysLookup* fANSYSTable;
  
  ClassDef(BFLWingedEdge,0)  // MINOS Voronoi diagram class  
};  


#endif

---