コード例 #1
0
void StateRenderTest::Enter(beStateMachine* stateMachine)
{
	auto renderInterface = m_appData->renderInterface;
	auto shaderPack = m_appData->shaderPack;

	shaderPack->UpdateFrameBuffers(renderInterface, m_camera.GetViewMatrix()); // Set ortho matrix buffer
	m_font.Init(renderInterface, shaderPack, "tutefont.txt", "tutefont.dds");
	m_models.AddNew()->Init(renderInterface, shaderPack, "boar.dds");
	m_models.AddNew()->InitWithFilename(renderInterface, shaderPack, "zombie/obj/zombie.obj", "zombie/obj/zombie.mtl", beModel::LoadOptions::Swizzle(beModel::LoadOptions::swizZ, beModel::LoadOptions::swizX, beModel::LoadOptions::swizY));
	m_models.AddNew()->InitWithFilename(renderInterface, shaderPack, "cube.obj", "seafloor.dds", {});
	m_models.AddNew()->InitWithFilename(renderInterface, shaderPack, "cube2.obj",  "seafloor.dds", {});
	m_models.AddNew()->InitWithFilename(renderInterface, shaderPack, "teapot.obj", "seafloor.dds", {beRendering::Topology::TriangleList, true, 1.f,{0,2,1}});
	m_models.AddNew()->InitWithFilename(renderInterface, shaderPack, "boxes.obj", "barrels.dds", {beRendering::Topology::TriangleList, true, 0.1f,{0,2,1}});

	InitGrid(renderInterface);

	beTexture::LoadOptions textureLoadOptions;
	textureLoadOptions.height = 256;
	textureLoadOptions.width = 256;
	textureLoadOptions.format = beTextureFormat::R32G32B32_FLOAT;
	m_screenGrabTexture.InitAsTarget(renderInterface, textureLoadOptions);

	m_bitmapTexQuadNorm.Init(renderInterface, shaderPack, 0.2f, 0.2f, "boar.dds");
	m_bitmapTexQuadNorm.SetPosition(0.1f, 0.1f);
	m_bitmapTexQuadPixelCoord.Init(renderInterface, shaderPack, 128, 128, "bark.dds");
	m_bitmapTexQuadPixelCoord.SetPosition(-0.8f, -0.5f);

	m_bitmapTextDynamic.SetColour(Vec4(0.f, 1.f, 0.8f, 1.f));
	
	m_camera.AttachGamepad(m_appData->gamepad);
	m_camera.AttachMouse(m_appData->mouse);
	
}
コード例 #2
0
void MultiViewerMain::Connect(const char* a_strHost, const char* a_strPort, const char* a_strDBName, const char* a_strID, const char* a_strPassword, const char* a_strType)
{
#ifdef __CUBRID__SUPPORT__
	if(strncmp(a_strType, CURBRID_TYPENAME , strlen(CURBRID_TYPENAME)) == 0)
		m_pSQLReader = new CubridReader();

	else
		return;

	eDBReaderErr_t  eDBReaderErr = m_pSQLReader->Connect(a_strHost, a_strPort, a_strDBName, a_strID, a_strPassword, NULL);
	if(eDBReaderSuccess != eDBReaderErr )
	{
		ErrorDialog("Connect Error");
		return;
	}

	m_eProgramState = eStateFileOpened;
	InitSQLTableInfo();
	InitGrid(m_pTableDBDataGrid, true);
	m_bDirty = false;
#else
	ErrorDialog("This version not support this action");
	return;
#endif
}
コード例 #3
0
void MultiViewerMain::Restore(VecArray2D<wxString>* a_p2DTableData, vector<wxString>* a_pColName, wxGrid* a_pwxGrid ,int a_nStartRow, int a_nEndRow)
{
	int nStartRow = a_nStartRow;
	InitGrid(a_pwxGrid, true);
	unsigned int nRowTotal = a_nEndRow - a_nStartRow + 1;
	unsigned int nColTotal = a_p2DTableData->GetColSize();

	a_pwxGrid->AppendRows(nRowTotal);
	a_pwxGrid->AppendCols(nColTotal);

	SetColHeader(a_pwxGrid, a_pColName );

	unsigned int nCol = 0;

	unsigned int nRow = 0;
	for(nRow=0; nRow < nRowTotal ; nRow++ , nStartRow++)
	{

		for(nCol = 0; nCol < nColTotal ; nCol++)
		{
			wxString wstrData;
			wstrData = a_p2DTableData->GetData(nStartRow - 1, nCol);
			a_pwxGrid->SetCellValue(nRow, nCol, wstrData);
		}
		wxString wxstrRowNumber;
		wxstrRowNumber.Printf(_T("%d"), nStartRow);
    	a_pwxGrid->SetRowLabelValue(nRow , wxstrRowNumber);

	}
}
コード例 #4
0
ファイル: KSceneSettingDialogV2.cpp プロジェクト: viticm/pap2
BOOL KSceneSettingDialogV2::OnInitDialog()
{
	BOOL bRet = CDialog::OnInitDialog();
	///³õʼ»¯Grid
	/*{
		TypeGridCtrl::InitAppearanceStruct InitStruct;
		InitStruct.m_nRowCount = 10;
		InitStruct.m_nColumnCount = 2;
		InitStruct.m_nFixedRowCount = 1;
		InitStruct.m_nFixedColumnCount = 0;
		InitStruct.m_nDefColumnWidth = 100;
		InitStruct.m_nFixedColumnWidth = 100;
		InitStruct.m_nDefRowHeight = 15;
		InitStruct.m_bEditEnable = true;
		InitStruct.m_bInitBasicTitles = false;
		InitStruct.m_bEnableHightLighFixed = false;
		InitStruct.m_bSingleRowSelection = true;
		InitStruct.m_bSingleColomnSelection = true;
		InitStruct.m_bEnableRowResize = false;
		InitStruct.m_bEnableColResize = true;
		InitStruct.m_csCornerDescription = _T("");
		m_GridCtrl.InitAppearance(&InitStruct);
	}*/

	InitGrid();
	return bRet;
}
コード例 #5
0
ファイル: CurveEditor.cpp プロジェクト: wangyanxing/Demi3D
	CurveEditor::CurveEditor(MyGUI::Widget* _parent)
	{
        initialiseByAttributes(this, _parent);

        mEditTimeEditBox->setEditReadOnly(true);
        mEditValueEditBox->setEditReadOnly(true);

        mRangeMinEditBox->eventKeyLostFocus     += MyGUI::newDelegate(this, &CurveEditor::NotifyRangeLostFocus);
        mRangeMinEditBox->eventEditSelectAccept += MyGUI::newDelegate(this, &CurveEditor::NotifyRangeEditAccept);
        mRangeMaxEditBox->eventKeyLostFocus     += MyGUI::newDelegate(this, &CurveEditor::NotifyRangeLostFocus);
        mRangeMaxEditBox->eventEditSelectAccept += MyGUI::newDelegate(this, &CurveEditor::NotifyRangeEditAccept);

        MyGUI::PolygonalSkin::CreateLineSets = false;
        MyGUI::Widget* widget = mCurveCanvasWidget->createWidget<MyGUI::Widget>("PolygonalSkin",
            MyGUI::IntCoord(MyGUI::IntPoint(), mCurveCanvasWidget->getSize()), MyGUI::Align::Stretch);
        widget->setColour(MyGUI::Colour::Red);
        MyGUI::ISubWidget* main = widget->getSubWidgetMain();
        mCurveLines = main->castType<MyGUI::PolygonalSkin>();

        MyGUI::PolygonalSkin::CreateLineSets = true;
        widget = mCurveCanvasWidget->createWidget<MyGUI::Widget>("PolygonalSkin",
            MyGUI::IntCoord(MyGUI::IntPoint(), mCurveCanvasWidget->getSize()), MyGUI::Align::Stretch);
        widget->setColour(MyGUI::Colour::Red);
        main = widget->getSubWidgetMain();
        mCurveCanvas = main->castType<MyGUI::PolygonalSkin>();
        widget->eventMouseButtonPressed += MyGUI::newDelegate(this, &CurveEditor::NotifyMousePressed);
        MyGUI::PolygonalSkin::CreateLineSets = false;
        mCanvasWidget = widget;

        mCurveCanvas->setWidth(5.0f);
        std::vector<MyGUI::FloatPoint> mLinePoints;
        mLinePoints.push_back(MyGUI::FloatPoint(0, 0));
        mLinePoints.push_back(MyGUI::FloatPoint(0, 1));
        mCurveCanvas->setPoints(mLinePoints);
        mLinePoints.clear();
        mCurveCanvas->setPoints(mLinePoints); // todo fix it 

        mCurveLines->_setColour(MyGUI::Colour(0.2f, 0.2f, 0.2f));

        // default range
        mValueRange.x = 0;
        mValueRange.y = 10;
        mRangeMinEditBox->setCaption("0");
        mRangeMaxEditBox->setCaption("10");

        InitGrid();

        RefreshNumbers();

        MyGUI::Window* window = mMainWidget->castType<MyGUI::Window>(false);
        if (window != nullptr) 
            window->eventWindowButtonPressed += newDelegate(this, &CurveEditor::NotifyWindowButtonPressed);

        mSplineButton = mMainWidget->createWidget<MyGUI::Button>("CheckBox",
            MyGUI::IntCoord(15, 10, 95, 25),
            MyGUI::Align::Left | MyGUI::Align::Top);
        mSplineButton->setCaption("Use Spline");
        mSplineButton->eventMouseButtonClick += MyGUI::newDelegate(this, &CurveEditor::NotifySplineChecked);
    }
コード例 #6
0
ファイル: construct_grid.C プロジェクト: CoryXie/Graphite
void
ConstructLocalGrid (long my_id)
{
   Local[my_id].Local_Grid = InitGrid(my_id); /* Create the root box */
   InsertParticlesInTree(my_id, MY_PARTICLES, MY_NUM_PARTICLES,
			 Local[my_id].Local_Grid);
   /* Put all of your particles into your local tree */
}
コード例 #7
0
void MultiViewerMain::FileNew(const char* a_strFileName )
{
	
	m_pSQLReader->FileNew(a_strFileName );

	m_eProgramState = eStateFileOpened;
	InitSQLTableInfo();
	InitGrid(m_pTableDBDataGrid, true);
	m_bDirty = false;

}
コード例 #8
0
ファイル: grid.hpp プロジェクト: arnolda/scafacos
 Grid(const Grid& rhs) :
   index_translations(rhs.Indexing()),
   level(rhs.Level()),
   global(rhs.Global()),
   local(rhs.Local()),
   extent(rhs.Extent()),
   iterators(rhs.Iterators()),
   father(rhs.Father())
 {
   InitGrid();
   SetGrid(rhs);
 }
コード例 #9
0
void MultiViewerMain::FileOpen(const char* a_strFileName )
{
	if(m_eProgramState == eStateFileOpened && m_bDirty)
	{
//		wxMessageBox(_("Test"), _("OnMenuFileOpen"));

	}
	
	m_pSQLReader->FileOpen(a_strFileName );
	m_eProgramState = eStateFileOpened;
	InitSQLTableInfo();
	InitGrid(m_pTableDBDataGrid, true);
	m_bDirty = false;
}
コード例 #10
0
ファイル: grid.hpp プロジェクト: arnolda/scafacos
 Grid(const GlobalIndices& global_,
      const LocalIndices& local_,
      const SpatialExtent& extent_,
      int level_ = 0,
      Multigrid* father_ = NULL) :
   index_translations(this),
   level(level_),
   global(global_),
   local(local_),
   extent(extent_),
   iterators(local_),
   father(father_)
 {
   InitGrid();
 }
コード例 #11
0
ファイル: AstarPathfind.cpp プロジェクト: blazetrinity/SP3
void AstarPathfind::GenerateGrid(CMap* map)
{
	grid.resize(map->GetNumOfTiles_MapHeight());

	for(int i = 0; i < map->GetNumOfTiles_MapHeight(); ++i)
	{
		grid[i].resize(map->GetNumOfTiles_MapWidth());

		for(int j = 0; j < map->GetNumOfTiles_MapWidth(); ++j)
		{
			PositionNode* positionNode = new PositionNode;
			grid[i][j] = positionNode;
		}
	}

	InitGrid(map);
}
コード例 #12
0
ファイル: pigaleCanvas.cpp プロジェクト: beauby/pigale
void GraphEditor::load(bool initgrid) 
// by default initgrid = true
// when editing (erasing edges, vertices,reorienting) initgrid = false
  {
  if(!is_init) //MAC
    {gwp->canvas->setSceneRect(0,0,contentsRect().width(),contentsRect().height());
    is_init=true;
    }
  //if(!is_init)return;
  clear();// delete all items
  if(gwp->pGG->nv() > staticData::MaxND)
      {Tprintf("Too big graph nv= %d (>%d)",gwp->pGG->nv(),staticData::MaxND);return;}
  GeometricGraph & G = *(gwp->pGG);

  if(initgrid)
      {Normalise();
      InitGrid(current_grid);
      }
  DrawGrid(current_grid);
  if(ShowGrid)showGrid(true);

  Prop<NodeItem *> nodeitem(G.Set(tvertex()),PROP_CANVAS_ITEM,(NodeItem *)NULL);
  Prop<EdgeItem *> edgeitem(G.Set(tedge()),PROP_CANVAS_ITEM,(EdgeItem *)NULL);
  nodeitem.SetName("nodeitem");edgeitem.SetName("edgeitem");

  for(tvertex v = 1;v <= G.nv();v++)
      nodeitem[v] =  CreateNodeItem(v,gwp);
  for(tedge e = 1;e <= G.ne();e++)
      edgeitem[e] = CreateEdgeItem(e,gwp); 

  if(staticData::ShowExtTbrin())
      {tedge e = G.extbrin().GetEdge();
      EdgeItem *edge = (G.extbrin() > 0) ? edgeitem[e]  : edgeitem[e]->opp;
      edge->SetColor(color[Green],false);
      } 

  Prop<bool> eoriented(G.Set(tedge()),PROP_ORIENTED,false);
  CreateColorItems(gwp,color_node,color_edge);
  G.vcolor.definit(color_node);
  G.vlabel.definit(0L);
  G.elabel.definit(0L);
  CreateThickItems(gwp,width_edge);
  G.ewidth.definit(width_edge);
  }
int main( int argc, char *argv[])    /* FinalApplication */
{

   time_t t0, t1, t_inter;
   
   time(&t0);
   fprintf(stdout,"Starting at: %s", asctime(localtime(&t0)));
   
   time(&t_inter);
   InitGrid("Particles.inp");
   time(&t1);
   
   fprintf(stdout,"time spent on InitGrid(): %lf\n seconds",difftime(t1,t_inter));

   // GenFieldGrid initialization
   printf("GeneratingField...\n");
   time(&t_inter);
   GeneratingField(&GenFieldGrid,MaxIters);
   time(&t1);
   fprintf(stdout,"time spent on GeneratingField(): %lf\n seconds",difftime(t1,t_inter));
   
   // Particle population initialization
   printf("ParticleGeneration...\n");
   time(&t_inter);
   ParticleGeneration(GenFieldGrid, ParticleGrid, &Particles);
   time(&t1);
   fprintf(stdout,"time spent on ParticleGeneration(): %lf\n seconds",difftime(t1,t_inter));
   
   // Compute evolution of the particle population
   printf("SystemEvolution...\n");
   time(&t_inter);
   SystemEvolution(&ParticleGrid, &Particles, MaxSteps);
   time(&t1);
   fprintf(stdout,"time spent on SystemEvolution(): %lf\n seconds",difftime(t1,t_inter));
   
   time(&t1);
   fprintf(stdout,"Ending   at: %s", asctime(localtime(&t1)));
   fprintf(stdout,"Computations ended in %lf seconds\n",difftime(t1,t0));

   fprintf(stdout,"End of program!\n");

   return(0);
}  // end FinalApplication
コード例 #14
0
void CNetworkControllView::OnInitialUpdate()
{
	
	CFormView::OnInitialUpdate();
	if(g_NetWorkLevel==1)
	{
		CAfxMessageDialog dlg;
		CString strPromption;
		strPromption.LoadString(IDS_STRNOPRIVILEGE);
		dlg.SetPromtionTxt(strPromption);
		dlg.DoModal();
	}
	GetDlgItem(IDC_MacSTATIC)->ShowWindow(SW_HIDE);
	GetDlgItem(IDC_MACEDIT)->ShowWindow(SW_HIDE);

	GetDlgItem(IDC_GETBTN)->ShowWindow(SW_HIDE);
	GetDlgItem(IDC_SAVEBTN)->ShowWindow(SW_HIDE);
	GetDlgItem(IDC_FARCALLIP_BTN)->ShowWindow(SW_HIDE);
	/*
	GetDlgItem(IDC_GETBTN)->ShowWindow(SW_HIDE);
	GetDlgItem(IDC_SAVEBTN)->ShowWindow(SW_HIDE);
	GetDlgItem(IDC_REBOOTBTN)->ShowWindow(SW_HIDE);
	GetDlgItem(IDC_FARCALLBTN)->ShowWindow(SW_HIDE);
	GetDlgItem(IDC_FARCALLIP_BTN)->ShowWindow(SW_HIDE);
	*/

	SetTimer(1,20000,NULL);
	// TODO: Add your specialized code here and/or call the base class

	//////////////////////////////////////////////////////////////////////////
	// init timesever combobox
	initTimeServerList();


	InitGrid();

	

}
コード例 #15
0
ファイル: fempre.c プロジェクト: jkjuopperi/elmerfem
int main(int argc, char *argv[])
{
  int i,j,k,l,inmethod,outmethod,info,errorstat;
  int nogrids,nomeshes,nofile,dim,elementsredone=0;
  int nodes3d,elements3d,showmem;
  Real mergeeps;
  char prefix[MAXFILESIZE];
  struct GridType *grids;
  struct CellType *cell[MAXCASES];
  struct FemType data[MAXCASES];
  struct BoundaryType *boundaries[MAXCASES];
  struct ElmergridType eg;

  showmem = TRUE;

  printf("\nStarting program Elmergrid\n");

  InitParameters(&eg);

  grids = (struct GridType*)malloc((size_t) (MAXCASES)*sizeof(struct GridType));     
  InitGrid(grids);
  info = TRUE;

  if(argc <= 1) {
    errorstat = LoadCommands(argv[1],&eg,grids,argc-1,info);     
    Instructions();
    if(errorstat) Goodbye();
  }
  if(argc == 2) {
    errorstat = LoadCommands(argv[1],&eg,grids,argc-1,info);     
    if(errorstat) Goodbye();
  }
  else if(argc < 4) {
    Instructions();
    Goodbye();
  } 
  else {
    errorstat = InlineParameters(&eg,argc,argv);
    if(errorstat) Goodbye();
  }


  if(!eg.outmethod || !eg.inmethod) {
    printf("Please define the input and output formats\n");
  }
  if(eg.inmethod != 1) {
    if(eg.outmethod == 1 || eg.outmethod == 8 || eg.outmethod == 9 || eg.outmethod == 10) {
      printf("input of type %d can't create output of type %d\n",
	     eg.inmethod,eg.outmethod);
      errorstat++;
      Goodbye();
    }
  }
#if 0
  if(eg.inmethod != 8 && eg.outmethod == 5) {
    printf("To write Easymesh format you need to read easymesh format!\n");
    errorstat++;
  }
#endif

  if(eg.timeron) timer_activate(eg.infofile);

  /**********************************/
  printf("\nElmergrid loading data:\n");
  printf(  "-----------------------\n");

  dim = eg.dim;
  nofile = 0;
  nomeshes = 0;
  nogrids = 0;
  inmethod = eg.inmethod;
  outmethod = eg.outmethod;


 read_another_file:    

  timer_show();
  
  switch (inmethod) {

  case 1:        
    if(LoadElmergrid(&grids,&nogrids,eg.filesin[nofile],eg.relh,info) == 1) {   
      if(dim == 3) ExampleGrid3D(&grids,&nogrids,info);
      if(dim == 2) ExampleGrid2D(&grids,&nogrids,info);
      if(dim == 1) ExampleGrid1D(&grids,&nogrids,info);
      SaveElmergrid(grids,nogrids,eg.filesin[nofile],info); 
      printf("Because file %s didn't exist, it was created for you.\n",eg.filesin[nofile]);
      Goodbye();
    }
    LoadCommands(eg.filesin[nofile],&eg,grids,2,info); 
    break;

  case 2: 
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if(LoadElmerInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],info))
      Goodbye();
    nomeshes++;
    break;

  case 3: 
    if(LoadSolutionElmer(&(data[nofile]),TRUE,eg.filesin[nofile],info)) 
      Goodbye();
    nomeshes++;
    break;

  case 4:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    if(LoadAnsysInput(&(data[0]),boundaries[0],eg.filesin[nofile],info)) 
      Goodbye();
    nomeshes++;
    break;

  case 5: 
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if(LoadAbaqusInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE)) 
      Goodbye();
    nomeshes++;
    break;

  case 6:
    if(LoadAbaqusOutput(&(data[nofile]),eg.filesin[nofile],TRUE))
      Goodbye();
    nomeshes++;
    break;

  case 7:
    if(LoadFidapInput(&(data[nofile]),eg.filesin[nofile],TRUE))
      Goodbye();
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if(0 && !eg.usenames) data[nofile].boundarynamesexist = data[nofile].bodynamesexist = FALSE;
    ElementsToBoundaryConditions(&(data[nofile]),boundaries[nofile],FALSE,TRUE);
    RenumberBoundaryTypes(&data[nofile],boundaries[nofile],TRUE,0,info);
  
    nomeshes++;
    break;

  case 8:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if (LoadUniversalMesh(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
      Goodbye();
    nomeshes++;
    break;

 case 9:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
   
    if(LoadComsolMesh(&(data[nofile]),eg.filesin[nofile],info)) 
      Goodbye();
    ElementsToBoundaryConditions(&(data[nofile]),boundaries[nofile],FALSE,TRUE);
    nomeshes++;
    break;

  case 10:
    if(LoadFieldviewInput(&(data[nofile]),eg.filesin[nofile],TRUE))
      Goodbye();
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	    
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    ElementsToBoundaryConditions(&(data[nofile]),boundaries[nofile],FALSE,TRUE);
    nomeshes++;
    break;

  case 11:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if (LoadTriangleInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
      Goodbye();
    nomeshes++;
    break;

  case 12:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if (LoadMeditInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
      Goodbye();
    nomeshes++;
    break;

  case 13:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if (LoadGidInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
      Goodbye();
    nomeshes++;
    break;

  case 14:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if (LoadGmshInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
      Goodbye();
    nomeshes++;
    break;

  case 15: 
    if(info) printf("Partitioned solution is fused on-the-fly therefore no other operations may be performed.\n");
    FuseSolutionElmerPartitioned(eg.filesin[nofile],eg.filesout[nofile],eg.decimals,eg.partjoin,
				 eg.saveinterval[0],eg.saveinterval[1],eg.saveinterval[2],info);
    if(info) printf("Finishing with the fusion of partitioned Elmer solutions\n");
    Goodbye();
    break;

#if 0
  case 16: 
    InitializeKnots(&(data[nofile]));
    if( Easymesh(argc,argv,&data[nofile].noknots,
		 &data[nofile].noelements,&sides)) 
      Goodbye();	
    
    data[nofile].dim = 2;
    data[nofile].coordsystem = COORD_CART2;
    data[nofile].maxnodes = 3;
    
    AllocateKnots(&(data[nofile]));
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if(EasymeshCopy(&(data[nofile]),boundaries[nofile]))
      Goodbye();    
    nomeshes++;
    break;
#endif

  case 17:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if (LoadNastranInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
      Goodbye();
    nomeshes++;
    break;

  case 18:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
   
    if(LoadCGsimMesh(&(data[nofile]),eg.filesin[nofile],info))
       Goodbye();
    nomeshes++;
    break;

  case 19:
    boundaries[nofile] = (struct BoundaryType*)
      malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
    for(i=0;i<MAXBOUNDARIES;i++) {
      boundaries[nofile][i].created = FALSE; 
      boundaries[nofile][i].nosides = 0;
    }
    if (LoadGeoInput(&(data[nofile]),boundaries[nofile],eg.filesin[nofile],TRUE))
      Goodbye();
    nomeshes++;
    break;

  default:
    Instructions();
    Goodbye();
  }  

  nofile++;
  if(nofile < eg.nofilesin) {
    printf("\nElmergrid loading data from another file:\n");
    goto read_another_file;
  }

  /***********************************/


 redoelements:

  printf("\nElmergrid creating and manipulating meshes:\n");
  printf(  "-------------------------------------------\n");
  timer_show();


  if(nogrids > nomeshes && outmethod != 1) { 

    nomeshes = nogrids;
    for(k=0;k<nogrids;k++) {

      CreateCells(&(grids[k]),&(cell[k]),info);  
      CreateKnots(&(grids[k]),cell[k],&(data[k]),0,0);

      boundaries[k] = (struct BoundaryType*)
	malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 

      for(j=0;j<MAXBOUNDARIES;j++) {
	boundaries[k][j].created = FALSE;
	boundaries[k][j].nosides = FALSE;
      }

      if(grids[k].noboundaries > 0) {
	for(j=0;j<grids[k].noboundaries;j++) {
	  if(grids[k].boundsolid[j] < 4) {
	    CreateBoundary(cell[k],&(data[k]),&(boundaries[k][j]),
			   grids[k].boundext[j],grids[k].boundint[j],
			   1,grids[k].boundtype[j]);  
	  } 
	  else { 
	    CreatePoints(cell[k],&(data[k]),&(boundaries[k][j]),
			 grids[k].boundext[j],grids[k].boundint[j],
			 grids[k].boundsolid[j],grids[k].boundtype[j]); 	    
	  }
	}
      }
    }
  }

  /* In some formats the dimension for curved 2D meshes seems to be set to 2.
     This should fix the problem for all input types. */
  if( data->dim < 3 ) {
    data->dim = GetCoordinateDimension(data,info);
  }

 
  /* Make the discontinous boundary needed, for example, in poor thermal conduction */
  for(k=0;k<nomeshes;k++) {
    if(!eg.discont) {
      for(j=0;j<grids[k].noboundaries;j++) 
	if(grids[k].boundsolid[j] == 2) {
	  eg.discontbounds[eg.discont] = grids[k].boundtype[j];
	  eg.discont++;	  
	}
    }
    if(eg.discont) {
      for(i=1;i<=eg.discont;i++) 
	SetDiscontinuousBoundary(&(data[k]),boundaries[k],eg.discontbounds[i-1],2,info);
    }
  }


  /* Divide quadrilateral meshes into triangular meshes */
  for(k=0;k<nomeshes;k++) 
    if(nogrids && (eg.triangles || grids[k].triangles == TRUE)) {
      Real criticalangle;
      criticalangle = MAX(eg.triangleangle , grids[k].triangleangle);
      ElementsToTriangles(&data[k],boundaries[k],criticalangle,info);
    }


  /* Make a boundary layer with two different methods */
  if(eg.layers > 0) 
    for(k=0;k<nomeshes;k++) 
      CreateBoundaryLayer(&data[k],boundaries[k],eg.layers,
			  eg.layerbounds, eg.layernumber, eg.layerratios, eg.layerthickness,
			  eg.layerparents, eg.layermove, eg.layereps, info);

  else if(eg.layers < 0) 
    for(k=0;k<nomeshes;k++) 
      CreateBoundaryLayerDivide(&data[k],boundaries[k],abs(eg.layers),
				eg.layerbounds, eg.layernumber, eg.layerratios, eg.layerthickness,
				eg.layerparents, info);

  /* Take up the infor on rotation */
  for(k=0;k<nogrids;k++) 
    if( grids[k].rotatecurve ) {
      eg.rotatecurve = TRUE;
      eg.curvezet = grids[k].curvezet;
      eg.curverad = grids[k].curverad;
      eg.curveangle = grids[k].curveangle;
    }


  if(outmethod != 1 && dim != 2 && eg.dim != 2) { 
    j = MAX(nogrids,1);


    for(k=0;k<j;k++) {
      if(grids[k].dimension == 3 || grids[k].rotate) {

	boundaries[j] = (struct BoundaryType*)
	  malloc((size_t) (MAXBOUNDARIES)*sizeof(struct BoundaryType)); 	
	
	for(i=0;i<MAXBOUNDARIES;i++) 
	  boundaries[j][i].created = FALSE;

	CreateKnotsExtruded(&(data[k]),boundaries[k],&(grids[k]),
			    &(data[j]),boundaries[j],info);

	if(nogrids) {
	  elements3d = MAX(eg.elements3d, grids[k].wantedelems3d);
	  nodes3d = MAX(eg.nodes3d, grids[k].wantednodes3d);

	  if(elements3d) {
	    if( abs(data[j].noelements - elements3d) / (1.0*elements3d) > 0.01 && elementsredone < 5 ) {
	      grids[k].wantedelems *= pow(1.0*elements3d / data[j].noelements, (2.0/3.0));
	      elementsredone++;
	    }
	    else elementsredone = 0;
	  }
	  else if(nodes3d) {
	    if( abs(data[j].noknots - nodes3d) / (1.0*nodes3d) > 0.01 && elementsredone < 5 ) {
	      grids[k].wantedelems *= pow(1.0*nodes3d / data[j].noknots, (2.0/3.0));
	      elementsredone++;
	    }
	    else elementsredone = 0;
	  }

	  if(elementsredone) {
	    nomeshes = 0;
	    for(i=0;i < nogrids;i++) SetElementDivision(&(grids[i]),eg.relh,info);
	    
	    DestroyKnots(&data[j]);
	    DestroyKnots(&data[k]);
	    free(cell[k]);
	    
	    if(info) printf("Iteration %d of elements number targiting %d in 2D\n",
			    elementsredone,grids[k].wantedelems);
	    goto redoelements;
	  }
	}	

	data[k] = data[j];
	boundaries[k] = boundaries[j];
      }
    }
  }

  /* If the original mesh was given in polar coordinates make the transformation into cartesian ones */
  for(k=0;k<nomeshes;k++) {
    if(eg.polar || data[k].coordsystem == COORD_POLAR) {
      if(!eg.polar) eg.polarradius = grids[k].polarradius;
      PolarCoordinates(&data[k],eg.polarradius,info);
    }
  }

  /* If the original mesh was given in cylindrical coordinates make the transformation into cartesian ones */
  for(k=0;k<nomeshes;k++) {
    if(eg.cylinder || data[k].coordsystem == COORD_CYL) {
      CylinderCoordinates(&data[k],info);
    }
  }

  if(1) for(k=0;k<nomeshes;k++) 
    RotateTranslateScale(&data[k],&eg,info);


  /* Rotate may apply to 2d and 3d geometries as well */
  for(k=0;k<nomeshes;k++) 
    if(eg.rotatecurve) 
      CylindricalCoordinateCurve(&data[k],eg.curvezet,eg.curverad,eg.curveangle);

  /* Unite meshes if there are several of them */
  if(eg.unitemeshes) {
    for(k=1;k<nomeshes;k++)
      UniteMeshes(&data[0],&data[k],boundaries[0],boundaries[k],info);
    nomeshes = nogrids = 1;
  }
  
  if(eg.clone[0] || eg.clone[1] || eg.clone[2]) {
    for(k=0;k<nomeshes;k++) {
      CloneMeshes(&data[k],boundaries[k],eg.clone,eg.clonesize,FALSE,info);
      mergeeps = fabs(eg.clonesize[0]+eg.clonesize[1]+eg.clonesize[2]) * 1.0e-8;
      MergeElements(&data[k],boundaries[k],eg.order,eg.corder,mergeeps,TRUE,TRUE);
    }
  }

  if(eg.mirror[0] || eg.mirror[1] || eg.mirror[2]) {
    for(k=0;k<nomeshes;k++) {
      MirrorMeshes(&data[k],boundaries[k],eg.mirror,FALSE,eg.clonesize,eg.mirrorbc,info);
      mergeeps = fabs(eg.clonesize[0]+eg.clonesize[1]+eg.clonesize[2]) * 1.0e-8;
      MergeElements(&data[k],boundaries[k],eg.order,eg.corder,mergeeps,FALSE,TRUE);
    }
  }

  /* Naming convection for the case of several meshes */
  if(nomeshes > 1) {
    strcpy(prefix,eg.filesout[0]);
    for(k=0;k<nomeshes;k++)
      sprintf(eg.filesout[k],"%s%d",prefix,k+1);
  }

  for(k=0;k<nomeshes;k++) {
    if(nogrids && grids[k].reduceordermatmax) {
      eg.reduce = TRUE;
      eg.reducemat1 = grids[k].reduceordermatmin;
      eg.reducemat2 = grids[k].reduceordermatmax;
    }
    if(eg.reduce) 
      ReduceElementOrder(&data[k],eg.reducemat1,eg.reducemat2);
  }

  for(k=0;k<nomeshes;k++) 
    if(eg.increase) IncreaseElementOrder(&data[k],TRUE);
 
  for(k=0;k<nomeshes;k++) {
    if(eg.merge) 
      MergeElements(&data[k],boundaries[k],eg.order,eg.corder,eg.cmerge,FALSE,TRUE);
    else if(eg.order == 3) 
#if PARTMETIS 
      ReorderElementsMetis(&data[k],TRUE);
#else
      printf("Cannot order nodes by Metis as it is not even compiled!\n");
#endif    
    else if(eg.order) 
      ReorderElements(&data[k],boundaries[k],eg.order,eg.corder,TRUE);
    
    if(eg.isoparam) 
      IsoparametricElements(&data[k],boundaries[k],TRUE,info);
  }  
コード例 #16
0
ファイル: bb_sudoku.c プロジェクト: Aykut-/plb
/************\ 
**  Solver  *****************************************************\ 
**                                                              ** 
**    Solver runs the sudoku solver.  Input puzzle is in the    ** 
**    buffer array, and somewhat controlled by a number of      ** 
**    globals (see the globals at the top of the main program   ** 
**    for globals and meanings).                                ** 
**                                                              ** 
\****************************************************************/ 
int bb_solver(unsigned *puzzle) 
{ register unsigned i; 

  PuzSolCnt = 0; 

  InitGrid(); 

  for (i = 0; i < 81; i++) 
     if (puzzle[i]) 
        PushSingle((char)(i), V2B[puzzle[i]]); 

  // Loop through the puzzle solving routines until finished 
  while (Changed) 
  { // If No Solution possible, jump straight to the backtrack routine 
    if (!No_Sol) 
    { // Check if any Singles to be propogated 
      if (SingleCnt) 
      { 
#ifdef CALC_STATS 
        SCnt++; 
#endif 
        if (SingleCnt > 2)               // If multiple singles 
          ProcessInitSingles();          //   process them all at once 
        if (SingleCnt)                   // otherwise 
          ProcessSingles();              //   process them one at a time 
        if (!Gp->CellsLeft) 
        { if (!No_Sol) 
          { PuzSolCnt++; 
            if (PuzSolCnt > 1) break; 
          } 
          No_Sol = Changed = 1; 
          continue; 
        } 
      } 

      // If nothing has changed, apply the next solver 
      if (Changed) 
      { 
#ifdef CALC_STATS 
        HCnt++; 
#endif 
        FindHiddenSingles(); if (SingleCnt) continue; 
//        if (use_methods & USE_LOCK_CAND) 
          { 
#ifdef CALC_STATS 
         LCCnt++; 
#endif 
         FindLockedCandidates(); if (Changed) continue; } 
      } 
    } 

    //If nothing new found, just make a guess 
#ifdef CALC_STATS 
   GCnt++; 
#endif 
   MakeGuess(); 
    if (No_Sol) break; 
//    if (!initp && (MaxDepth < PIdx)) MaxDepth = PIdx; 
//    if (PIdx > 62) { printf ("Max Depth exceeded, recompile for more depth.\n\n"); exit(0); } 
  } 

#ifdef CALC_STATS 
  TSCnt   += SCnt;    // Update Stats 
  THCnt   += HCnt; 
  TGCnt   += GCnt; 
  TLCCnt  += LCCnt; 
  TSSCnt  += SSCnt; 
  TFCnt   += FCnt; 
  TOneCnt += OneCnt; 
  TTwoCnt += TwoCnt; 
#endif 
  return PuzSolCnt; 
} 
コード例 #17
0
ファイル: gridapptry.c プロジェクト: ElBaha/CS-444
int main(int argc, char **argv)
{


	int nthreads = 0;
	pthread_t threads[MAXTHREADS];
	grain_type rowGranularity = NONE;
	long initSum = 0, finalSum = 0;
	int i;

	
	if (argc > 3)
	{
		gridsize = atoi(argv[1]);					
		if (gridsize > MAXGRIDSIZE || gridsize < 1)
		{
			printf("Grid size must be between 1 and 10.\n");
			return(1);
		}
		nthreads = atoi(argv[2]);
		if (nthreads < 1 || nthreads > MAXTHREADS)
		{
			printf("Number of threads must be between 1 and 1000.");
			return(1);
		}

		if (argv[3][1] == 'r' || argv[3][1] == 'R')
			rowGranularity = ROW;
		if (argv[3][1] == 'c' || argv[3][1] == 'C')
			rowGranularity = CELL;
		if (argv[3][1] == 'g' || argv[3][1] == 'G')
		  rowGranularity = GRID;
			
	}
	else
	{
		printf("Format:  gridapp gridSize numThreads -cell\n");
		printf("         gridapp gridSize numThreads -row\n");
		printf("         gridapp gridSize numThreads -grid\n");
		printf("         gridapp gridSize numThreads -none\n");
		return(1);
	}

	printf("Initial Grid:\n\n");
	initSum =  InitGrid(grid, gridsize);
	PrintGrid(grid, gridsize);
	printf("\nInitial Sum:  %d\n", initSum);
	printf("Executing threads...\n");

	/* better to seed the random number generator outside
	   of do swaps or all threads will start with same
	   choice
	*/
	srand((unsigned int)time( NULL ) );
	
	time(&start_t);
	for (i = 0; i < nthreads; i++)
	{
		if (pthread_create(&(threads[i]), NULL, do_swaps, (void *)(&rowGranularity)) != 0)
		{
			perror("thread creation failed:");
			exit(-1);
		} 
	}

	


	for (i = 0; i < nthreads; i++)
		pthread_detach(threads[i]);


	while (1)
	{
		sleep(2);
		if (threads_left == 0)
		  {
		    fprintf(stdout, "\nFinal Grid:\n\n");
		    PrintGrid(grid, gridsize);
		    finalSum = SumGrid(grid, gridsize); 
		    fprintf(stdout, "\n\nFinal Sum:  %d\n", finalSum);
		    if (initSum != finalSum){
		      fprintf(stdout,"DATA INTEGRITY VIOLATION!!!!!\n");
		    } else {
		      fprintf(stdout,"DATA INTEGRITY MAINTAINED!!!!!\n");
		    }
		    fprintf(stdout, "Secs elapsed:  %g\n", difftime(end_t, start_t));

		    exit(0);
		  }
	}	
	
	
	return(0);
	
}
コード例 #18
0
int main(int argc, char* argv[])
{
    int** grid;            // grid containing the cells and whether they are alive or dead
    
    // set up curses for displaying the grid
#ifdef USE_CURSES
    initscr();
    if(has_colors())
    {
        start_color();
        init_pair(1, COLOR_BLACK, COLOR_WHITE);
        init_pair(2, COLOR_WHITE, COLOR_CYAN);
    }
#endif
    
    // allocate the grid
    grid = AllocateGrid();
    if(grid == NULL)
    {
        printf("ERROR: Could not allocate memory for grid\n");
        return -1;
    }
    
    // initialize and print the grid
    InitGrid(grid);
#ifdef PRINT_GRID
    PrintGrid(grid);
#endif
    
    for(int time = 1; time <= TIME_STEPS; ++time)
    {
        // sleep to observe updates
#ifdef PRINT_GRID
        usleep(SLEEP_TIME);
#endif
        
        // allocate temporary grid for storing the simultaneous update
        int** tempGrid = AllocateGrid();
        if(tempGrid == NULL)
        {
            printf("ERROR: Could not allocate memory for grid\n");
            return -1;
        }
    
        for(int i = 0; i < GRID_SIZE; ++i)
        {
            for(int j = 0; j < GRID_SIZE; ++j)
            {
                int numNeighborAlive = 0;
            
                for(int k = -1; k <= 1; ++k)
                {
                    for(int l = -1; l <= 1; ++l)
                    {
                        int row = (i + k) % GRID_SIZE;
                        int col = (j + l) % GRID_SIZE;
                        
                        if(row == -1)
                            row = GRID_SIZE - 1;
                        if(col == -1)
                            col = GRID_SIZE - 1;
                    
                        if( (row != i) || (col != j) )
                            numNeighborAlive += grid[row][col];
                    }
                }
                
                switch(numNeighborAlive)
                {
                case 2:
                    tempGrid[i][j] = grid[i][j];
                    break;
                    
                case 3:
                    tempGrid[i][j] = 1;
                    break;
                    
                default:
                    tempGrid[i][j] = 0;
                }
            }
        }
        
        free(grid);
        grid = tempGrid;
        
#ifdef USE_CURSES
        move(0, 0);
#endif
#ifdef PRINT_GRID
    PrintGrid(grid);
#endif
    }
    
    CountLive(grid);
    
#ifdef USE_CURSES
    printw("\nPress any key to continue...");
    refresh();
    getchar();
#endif
    
    free(grid);
#ifdef USE_CURSES
    endwin();
#endif

    return 0;
}
コード例 #19
0
ファイル: square_grid.cpp プロジェクト: Delcaran/Tabletop
	SquareGrid::SquareGrid(unsigned int x, unsigned int y, const bool north_south = false, const bool east_west = false)
		: size_x_(x), size_y_(y), linked_north_south_(north_south), linked_east_west_(east_west) 
	{ 
		InitGrid(); 
	};
コード例 #20
0
ファイル: square_grid.cpp プロジェクト: Delcaran/Tabletop
	SquareGrid::SquareGrid() 
		: size_x_(1), size_y_(1) 
	{ 
		InitGrid(); 
	};
コード例 #21
0
ファイル: gridapp.c プロジェクト: sparkhoom/gridapp
int main(int argc, char **argv)
{
    
    
	int nthreads = 0;
	#ifdef UNIX
	pthread_t threads[MAXTHREADS];
	#endif UNIX	
	grain_type rowGranularity = NONE;
	#ifdef WINDOWS
	HANDLE threads[MAXTHREADS];
	#endif
	long initSum = 0, finalSum = 0;
	int i;
	
	
	if (argc > 3)
	{
		gridsize = atoi(argv[1]);
		if (gridsize > MAXGRIDSIZE || gridsize < 1)
		{
			printf("Grid size must be between 1 and 10.\n");
			return(1);
		}
		nthreads = atoi(argv[2]);
		if (nthreads < 1 || nthreads > MAXTHREADS)
		{
			printf("Number of threads must be between 1 and 1000.");
			return(1);
		}
        
		if (argv[3][1] == 'r' || argv[3][1] == 'R')
			rowGranularity = ROW;
		if (argv[3][1] == 'c' || argv[3][1] == 'C')
			rowGranularity = CELL;
		if (argv[3][1] == 'g' || argv[3][1] == 'G')
            rowGranularity = GRID;
        
	}
	else
	{
		printf("Format:  gridapp gridSize numThreads -cell\n");
		printf("         gridapp gridSize numThreads -row\n");
		printf("         gridapp gridSize numThreads -grid\n");
		printf("         gridapp gridSize numThreads -none\n");
		return(1);
	}
    
	printf("Initial Grid:\n\n");
	initSum =  InitGrid(grid, gridsize);
	PrintGrid(grid, gridsize);
	printf("\nInitial Sum:  %d\n", initSum);
	printf("Executing threads...\n");
    

    //initialize all the mutex we need
	#ifdef UNIX
	init_row_mutex(row_mutex, gridsize);
    init_cell_mutex(cell_mutex, gridsize);
	#endif
	#ifdef WINDOWS
	init_row_mutex(row_mutex, gridsize);
    init_cell_mutex(cell_mutex, gridsize);
	#endif

	/* better to seed the random number generator outside
     of do swaps or all threads will start with same
     choice
     */
	srand((unsigned int)time( NULL ) );

	time(&start_t);
	for (i = 0; i < nthreads; i++)
	{
		//create thread
		#ifdef UNIX
		if (pthread_create(&(threads[i]), NULL, do_swaps, (void *)(&rowGranularity)) != 0)
		{
			perror("thread creation failed:");
			exit(-1);
		}
		#endif	

		#ifdef WINDOWS
		threads[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)do_swaps,(void*)(&rowGranularity), 0, NULL);
		#endif
	}
    
    
	for (i = 0; i < nthreads; i++)
	{
		#ifdef UNIX
		pthread_detach(threads[i]);
		#endif
		#ifdef WINDOWS
		for (i = 0; i < nthreads; i++)
		CloseHandle(threads[i]);
		#endif
	}
    
    
	while (1)
	{
		#ifdef UNIX
		sleep(2);
		#endif
		#ifdef WINDOWS
		_sleep(2000);
		#endif
		if (threads_left == 0)
        {
		    fprintf(stdout, "\nFinal Grid:\n\n");
		    PrintGrid(grid, gridsize);
		    finalSum = SumGrid(grid, gridsize);
		    fprintf(stdout, "\n\nFinal Sum:  %d\n", finalSum);
		    if (initSum != finalSum){
                fprintf(stdout,"DATA INTEGRITY VIOLATION!!!!!\n");
		    } else {
                fprintf(stdout,"DATA INTEGRITY MAINTAINED!!!!!\n");
		    }
			#ifdef UNIX
		    fprintf(stdout, "Secs elapsed:  %g\n", difftime(end_t, start_t));
			#endif
			#ifdef WINDOWS
			printf("secs elapsed: %d\n", end_t - start_t);
			getchar();
			#endif
            
		    exit(0);
        }
	}	
	
	//destroy the mutex we have created 
#ifdef UNIX
    pthread_mutex_destroy(&grid_mutex);
    pthread_mutex_destroy(&row_mutex);
    pthread_mutex_destroy(&lock_enter);
    pthread_mutex_destroy(&lock_exit);
    pthread_mutex_destroy(&cell_mutex);
#endif
#ifdef WIINDOWS
	CloseHandle(grid_mutex);
	CloseHandle(row_mutex);
	CloseHandle(lock_enter);
	CloseHandle(lock_exit);
	CloseHandle(cell_mutex);
#endif
	system("pause");
	return(0);
	
}