Example #1
0
void mathFunction::calculateCurl(std::vector<ngl::Vec3> *_field, std::vector<ngl::Vec3> *curlField, std::vector<float> *curlMagnitude, int _noCells, float _cellSize)
{
  //Set up needed variables
  ngl::Vec3 field_i1jk;
  ngl::Vec3 field_i0jk;
  ngl::Vec3 field_ij1k;
  ngl::Vec3 field_ij0k;
  ngl::Vec3 field_ijk1;
  ngl::Vec3 field_ijk0;

  float dfxdy;
  float dfxdz;
  float dfydx;
  float dfydz;
  float dfzdx;
  float dfzdy;

  ngl::Vec3 resultCurl;

  for (int k=1; k<(_noCells-1); k++)
  {
    for (int j=1; j<(_noCells-1); j++)
    {
      for (int i=1; i<(_noCells-1); i++)
      {
        //Find values of field at (i+1,j,k), (i-1,j,k) etc.
        field_i1jk=_field->at(getVectorIndex(i+1, j, k, _noCells));
        field_i0jk=_field->at(getVectorIndex(i-1, j, k, _noCells));
        field_ij1k=_field->at(getVectorIndex(i, j+1, k, _noCells));
        field_ij0k=_field->at(getVectorIndex(i, j-1, k, _noCells));
        field_ijk1=_field->at(getVectorIndex(i, j, k+1, _noCells));
        field_ijk0=_field->at(getVectorIndex(i, j, k-1, _noCells));

        //Calculate approximate value for df_x/dy etc
        //df_x/dy=(1/2*cellSize)*(field(i+1,j,k)-field(i-1,j,k))
        dfxdy=(0.5/_cellSize)*(field_ij1k.m_x-field_ij0k.m_x);
        dfxdz=(0.5/_cellSize)*(field_ijk1.m_x-field_ijk0.m_x);
        dfydx=(0.5/_cellSize)*(field_i1jk.m_y-field_i0jk.m_y);
        dfydz=(0.5/_cellSize)*(field_ijk1.m_y-field_ijk0.m_y);
        dfzdx=(0.5/_cellSize)*(field_i1jk.m_z-field_i0jk.m_z);
        dfzdy=(0.5/_cellSize)*(field_ij1k.m_z-field_ij0k.m_z);

        //Curl is nabla crossed with velocity
        //Curl_x=df_z/dy - df_y/dz
        resultCurl.m_x=(dfzdy-dfydz);
        resultCurl.m_y=(dfxdz-dfzdx);
        resultCurl.m_z=(dfydx-dfxdy);

        //Set curl value to field
        curlField->at(getVectorIndex(i,j,k, _noCells))=resultCurl;

        //Calculate magnitude of curl
        curlMagnitude->at(getVectorIndex(i,j,k, _noCells))=resultCurl.length();
      }
    }
  }
}
Example #2
0
	void DB_Scores::Delete(int sid) {
		int vector_index = getVectorIndex(sid);

		if (vector_index >= 0) {
			score_data.erase(score_data.begin()+vector_index);
			record_change_count++;

			this->Write();
		}
	}
Example #3
0
void MainWindow::updateCheckboxArray(std::vector<std::string>& vector, unsigned int& counter, std::string instr, int arg){
    if (arg==0){//the checkbox was set to not checked
        vector.erase(vector.begin()+getVectorIndex(instr, vector));
        counter--;
    }else{//the checkbox was set to checked
        vector.push_back(instr);
        counter++;
    }
    ui->numGJF->setText(QVariant(std::to_string(methodCount*basisCount*jobtypeCount*solvCount).c_str()).toString());
}
Example #4
0
	void DB_Scores::Update(db_score_data score_data) {
		int vector_index = getVectorIndex(score_data.sid);

		if (vector_index >= 0) {
			this->Delete(score_data.sid);

			this->score_data.push_back(score_data);
			record_change_count++;

			this->Write();
		}
	}
Example #5
0
float mathFunction::trilinearInterpFloat(std::vector<float> *_function, int _index0_X, int _index0_Y, int _index0_Z, int _index1_X, int _index1_Y, int _index1_Z, ngl::Vec3 _indexActual, int _noCells)
{
  float result=0.0;

  //Calculate differences to be used in the interpolation
  //Don't need to divide by anything as indices and hence index1-index0 would give 1
  float x_diff=_indexActual.m_x-(float)_index0_X;
  float y_diff=_indexActual.m_y-(float)_index0_Y;
  float z_diff=_indexActual.m_z-(float)_index0_Z;

  //Find indices to be used when finding values of the function
  int index_000=getVectorIndex(_index0_X, _index0_Y, _index0_Z, _noCells);
  int index_100=getVectorIndex(_index1_X, _index0_Y, _index0_Z, _noCells);
  int index_001=getVectorIndex(_index0_X, _index0_Y, _index1_Z, _noCells);
  int index_101=getVectorIndex(_index1_X, _index0_Y, _index1_Z, _noCells);
  int index_110=getVectorIndex(_index1_X, _index1_Y, _index0_Z, _noCells);
  int index_010=getVectorIndex(_index0_X, _index1_Y, _index0_Z, _noCells);
  int index_011=getVectorIndex(_index0_X, _index1_Y, _index1_Z, _noCells);
  int index_111=getVectorIndex(_index1_X, _index1_Y, _index1_Z, _noCells);

  //Find function values for the various indices
  float function_000=_function->at(index_000);
  float function_100=_function->at(index_100);
  float function_010=_function->at(index_010);
  float function_001=_function->at(index_001);
  float function_110=_function->at(index_110);
  float function_101=_function->at(index_101);
  float function_011=_function->at(index_011);
  float function_111=_function->at(index_111);

  //Interpolate along x
  float interpX_00=((1-x_diff)*function_000)+(x_diff*function_100);
  float interpX_10=((1-x_diff)*function_010)+(x_diff*function_110);
  float interpX_01=((1-x_diff)*function_001)+(x_diff*function_101);
  float interpX_11=((1-x_diff)*function_011)+(x_diff*function_111);

  //Interpolate along y
  float interpY_0=((1-y_diff)*interpX_00)+(y_diff*interpX_10);
  float interpY_1=((1-y_diff)*interpX_01)+(y_diff*interpX_11);

  //Interpolate along z
  float interpZ=((1-z_diff)*interpY_0)+(z_diff*interpY_1);

  //Return result
  result=interpZ;
  return result;
}
float Grid::trilinearInterpFloat(std::vector<float> *_function, int _index0_X, int _index0_Y, int _index0_Z, int _index1_X, int _index1_Y, int _index1_Z, ngl::Vec3 _indexActual)
{
  float result=0;

  //Calculate differences to be used in the interpolation
  float x_diff=(_indexActual.m_x-_index0_X)/(_index1_X-_index0_X);
  float y_diff=(_indexActual.m_y-_index0_Y)/(_index1_Y-_index0_Y);
  float z_diff=(_indexActual.m_z-_index0_Z)/(_index1_Z-_index0_Z);

  //Find indices to be used when finding values of the function
  int index_000=getVectorIndex(_index0_X, _index0_Y, _index0_Z);
  int index_100=getVectorIndex(_index1_X, _index0_Y, _index0_Z);
  int index_001=getVectorIndex(_index0_X, _index0_Y, _index1_Z);
  int index_101=getVectorIndex(_index1_X, _index0_Y, _index1_Z);
  int index_110=getVectorIndex(_index1_X, _index1_Y, _index0_Z);
  int index_010=getVectorIndex(_index0_X, _index1_Y, _index0_Z);
  int index_011=getVectorIndex(_index0_X, _index1_Y, _index1_Z);
  int index_111=getVectorIndex(_index1_X, _index1_Y, _index1_Z);

  //Find function values for the various indices
  float function_000=_function->at(index_000);
  float function_100=_function->at(index_100);
  float function_001=_function->at(index_001);
  float function_101=_function->at(index_101);
  float function_110=_function->at(index_110);
  float function_010=_function->at(index_010);
  float function_011=_function->at(index_011);
  float function_111=_function->at(index_111);

  //Interpolate along x
  float interpX_00=((1-x_diff)*function_000)+(x_diff*function_100);
  float interpX_01=((1-x_diff)*function_001)+(x_diff*function_101);
  float interpX_10=((1-x_diff)*function_010)+(x_diff*function_110);
  float interpX_11=((1-x_diff)*function_011)+(x_diff*function_111);

  //Interpolate along y
  float interpY_0=((1-y_diff)*interpX_00)+(y_diff*interpX_10);
  float interpY_1=((1-y_diff)*interpX_01)+(y_diff*interpX_11);

  //Interpolate along z
  float interpZ=((1-z_diff)*interpY_0)+(z_diff*interpY_1);

  //Return result
  result=interpZ;
  return result;
}
Example #7
0
	void DB_Scores::Update(vector<db_score_data> score_data) {
		int vector_index;
		for (int i = 0; i < (int) score_data.size(); i++) {
			vector_index = getVectorIndex(score_data[i].sid);

			if (vector_index >= 0) {
				this->Delete(score_data[i].sid);

				this->score_data.push_back(score_data[i]);
				record_change_count++;
			} else {
				this->Insert(score_data);
			}

			this->Write();
		}
	}
float Grid::calcDivergenceVec3(std::vector<ngl::Vec3> *_field, int _index_X, int _index_Y, int _index_Z)
{
  float result;

  ngl::Vec3 fieldValue_i1jk=_field->at(getVectorIndex((_index_X+1), _index_Y, _index_Z));
  ngl::Vec3 fieldValue_i0jk=_field->at(getVectorIndex((_index_X-1), _index_Y, _index_Z));
  ngl::Vec3 fieldValue_ij1k=_field->at(getVectorIndex(_index_X, (_index_Y+1), _index_Z));
  ngl::Vec3 fieldValue_ij0k=_field->at(getVectorIndex(_index_X, (_index_Y-1), _index_Z));
  ngl::Vec3 fieldValue_ijk1=_field->at(getVectorIndex(_index_X, _index_Y, (_index_Z+1)));
  ngl::Vec3 fieldValue_ijk0=_field->at(getVectorIndex(_index_X, _index_Y, (_index_Z-1)));

  float dfxdx=fieldValue_i1jk.m_x-fieldValue_i0jk.m_x;
  float dfydy=fieldValue_ij1k.m_y-fieldValue_ij0k.m_y;
  float dfzdz=fieldValue_ijk1.m_z-fieldValue_ijk0.m_z;

  float constant=0.5/m_cellSize;

  result=constant*(dfxdx+dfydy+dfzdz);

  return result;
}
ngl::Vec3 Grid::calcDivergenceFloat(std::vector<float> *_field, int _index_X, int _index_Y, int _index_Z)
{
  ngl::Vec3 result;

  float fieldValue_i1jk=_field->at(getVectorIndex((_index_X+1), _index_Y, _index_Z));
  float fieldValue_i0jk=_field->at(getVectorIndex((_index_X-1), _index_Y, _index_Z));
  float fieldValue_ij1k=_field->at(getVectorIndex(_index_X, (_index_Y+1), _index_Z));
  float fieldValue_ij0k=_field->at(getVectorIndex(_index_X, (_index_Y-1), _index_Z));
  float fieldValue_ijk1=_field->at(getVectorIndex(_index_X, _index_Y, (_index_Z+1)));
  float fieldValue_ijk0=_field->at(getVectorIndex(_index_X, _index_Y, (_index_Z-1)));

  float dfdx=fieldValue_i1jk-fieldValue_i0jk;
  float dfdy=fieldValue_ij1k-fieldValue_ij0k;
  float dfdz=fieldValue_ijk1-fieldValue_ijk0;

  float constant=0.5/m_cellSize;

  result=ngl::Vec3(dfdx, dfdy, dfdz);
  result=constant*result;

  return result;

}
Example #10
0
void mathFunction::linearSystemSolveFloat(std::vector<float> *result, std::vector<float> *_initField, std::vector<float> *_b, float _Aii, float _Aij, int _iterations, int _noCells, float _setMinimumValue)
{
  ///To do: Check for convergence
  /// Fix issue of less than minimum values

  //Set up variables
  float p_ijk;
  float p_i1jk;
  float p_i0jk;
  float p_ij1k;
  float p_ij0k;
  float p_ijk1;
  float p_ijk0;

  int index;

  float sumNeighbours;
  float newValue;


  //Loop over iterations
  for (int iterationCount=0; iterationCount<_iterations; iterationCount++)
  {
    //Loop over non-boundary cells
    for (int k=1; k<(_noCells-1); k++)
    {
      for (int j=1; j<(_noCells-1); j++)
      {
        for (int i=1; i<(_noCells-1); i++)
        {
          //Get index for current cell (i,j,k)
          index=getVectorIndex(i,j,k, _noCells);

          //Find initField of itself and 6 nearest neighbours
          p_ijk=_initField->at(index);
          p_i1jk=_initField->at(getVectorIndex(i+1,j,k, _noCells));
          p_i0jk=_initField->at(getVectorIndex(i-1,j,k, _noCells));
          p_ij1k=_initField->at(getVectorIndex(i,j+1,k, _noCells));
          p_ij0k=_initField->at(getVectorIndex(i,j-1,k, _noCells));
          p_ijk1=_initField->at(getVectorIndex(i,j,k+1, _noCells));
          p_ijk0=_initField->at(getVectorIndex(i,j,k-1, _noCells));

          //Add nearest neighbour pressures
          sumNeighbours=_Aij*(p_i1jk + p_i0jk + p_ij1k + p_ij0k + p_ijk1 + p_ijk0);

          //Subtract from b to find new pressure at (i,j,k)
          newValue=(1.0/_Aii)*(_b->at(index)-sumNeighbours);

          //Set result at (i,j,k) to this new pressure value
          ///Clamp to minimum value.
          /// This should probably not be necessary, and shows a problem with the linear solver/parameters passed in
          if (newValue>=_setMinimumValue)
          {
            result->at(index)=newValue;
          }
          else
          {
            result->at(index)=_setMinimumValue;
          }
          ///This is probably what should be used
//          result->at(index)=newValue;

        }
      }
    }

    //Set values found to initField so they will be used as guess for the next iteration
    _initField=result;
  }

}
void Grid::linearSystemSolve(std::vector<float> *result, std::vector<float> *_initField, std::vector<float> *_b, float _Aii, float _Aij, int _iterations)
{
  //Set up variables
  float p_ijk;
  float p_i1jk;
  float p_i0jk;
  float p_ij1k;
  float p_ij0k;
  float p_ijk1;
  float p_ijk0;

  int index;

  float sumNeighbours;
  float newValue;


  //Loop over iterations
  for (int iterationCount=0; iterationCount<_iterations; iterationCount++)
  {
    //Loop over i,j,k
    for (int k=1; k<(m_noCells-1); k++)
    {
      for (int j=1; j<(m_noCells-1); j++)
      {
        for (int i=1; i<(m_noCells-1); i++)
        {
          //Get index for this cell (i,j,k)
          index=getVectorIndex(i,j,k);

          //Find initField of itself and 6 nearest neighbours
          p_ijk=_initField->at(index);
          p_i1jk=_initField->at(getVectorIndex(i+1,j,k));
          p_i0jk=_initField->at(getVectorIndex(i-1,j,k));
          p_ij1k=_initField->at(getVectorIndex(i,j+1,k));
          p_ij0k=_initField->at(getVectorIndex(i,j-1,k));
          p_ijk1=_initField->at(getVectorIndex(i,j,k+1));
          p_ijk0=_initField->at(getVectorIndex(i,j,k-1));

          //Add nearest neighbour pressures
          sumNeighbours=_Aij*(p_i1jk + p_i0jk + p_ij1k + p_ij0k + p_ijk1 + p_ijk0);

          //Subtract from b to find new pressure at (i,j,k)
//          newValue=(1.0/_Aii)*(_b->at(index)-sumNeighbours);
          newValue=(1.0/_Aii)*(sumNeighbours+p_ijk);

          //Set result at (i,j,k) to this new pressure value
          result->at(index)=newValue;

        }

      }
    }

    //Check for convergence?

    //Set values found to start for next iteration
    _initField=result;
  }

}