예제 #1
0
		void TestVector::testCase1() {
			Vector<int, Alloc> myvec(8);
			assert(myvec.size() == 8);
			for (int i = 0; i < 8; i++)
				myvec[i] = i;
			myvec.push_back(9);
			myvec.push_back(10);
			myvec.insert(myvec.begin() + 8, 8);
			int i = 0;
			for (Vector<int>::constIterator it = myvec.begin();
					it != myvec.end(); ++it, ++i) {
				assert(*it == i);
			}
			i--;
			for (Vector<int>::constReverseIterator it = myvec.crbegin();
					it != myvec.crend(); ++it, --i) {
				assert(*it == i);
			}
			myvec.erase(myvec.end() - 3, myvec.end());
			i = 0;
			for (Vector<int>::constIterator it = myvec.begin();
					it != myvec.end(); ++it, ++i) {
				assert(*it == i);
			}
			std::cout << "case1 passed" << std::endl;
		}
예제 #2
0
/**
 * @brief Add elements to top and bottom of a vector
 *
 * This method is to expand a vector to add additional records for padding
 * purposes. The parameter ntop indicate the number to add to the top of the
 * vector. nbot indicates the number to add to the bottom
 *
 * Elements added to the top have the contents of the first element of the
 * input vector copied to it. Elements added to the bottom have the last
 * element copied to it.
 *
 * The new vector has the contents of the original copied to it place
 * immediately after the number of elements added to it.
 *
 * @author Kris Becker - 4/6/2011
 *
 * @param ntop Number of elements to add to the top
 * @param vec  number of elements to add to the bottom
 * @param vector Vector to add elements to
 *
 *  @return SpiceSegment::SVector Expanded vector
 */
SpiceSegment::SVector SpiceSegment::expand(int ntop, int nbot,
                                           const SpiceSegment::SVector &vec)
                                           const {
  //  Add lines to matrix at top and bottom
  int ndim(vec.dim1());
  ntop = std::max(0, ntop);
  nbot = std::max(0, nbot);
  int nvals(ndim+ntop+nbot);
  SVector myvec(nvals);

  // Duplicate top elements to expanded elements
  for (int n = 0 ; n < ntop ; n++) {
    myvec[n] = vec[0];
  }

  // Copy elements from input vector to output
  for (int n = 0 ; n < vec.dim1() ; n++) {
    myvec[n+ntop] = vec[n];
  }


  // Duplicate bottom elements to expanded elements
  for (int n = 0 ; n < nbot ; n++) {
    myvec[nvals-1-n] = vec[ndim-1];
  }

  return (myvec);
}
예제 #3
0
// initialize opengl components event handler
void MyGLWidget::initializeGL() {
	displayClass = new DisplayClass();
	std::ifstream tracer;
	std::string ts;
	tracer.open(raytraceconfig);
	
	//output filename
	getline(tracer, ts);
	displayClass->rayOutputFile = new std::string(cut(ts));
	
	//resolution
	getline(tracer, ts);
	glm::vec3 v = getVec(cut(ts));
	displayClass->resoX = new float(v.x);
	displayClass->resoY = new float(v.y);

	displayClass->rayCamera = new Camera();
	//eye
	getline(tracer, ts);
	displayClass->rayCamera->eye = getVec(cut(ts));

	//view direction
	getline(tracer, ts);
	displayClass->rayCamera->center = getVec(cut(ts));

	//up vec
	getline(tracer, ts);
	displayClass->rayCamera->up = getVec(cut(ts));

	//fovy
	getline(tracer, ts);
	displayClass->rayCamera->fovy = getVec(cut(ts)).x;

	displayClass->rayLightPos = new std::vector<glm::vec3*>();
	displayClass->rayLightCol = new std::vector<glm::vec3*>();
	glm::vec3* lpos;
	glm::vec3* lcol;
	
	for (int lc = 0; lc < 3; lc++) {
		//lightpos
		getline(tracer, ts);
		lpos = new glm::vec3(getVec(cut(ts)));
		displayClass->rayLightPos->push_back(lpos);

		//lightcol
		getline(tracer, ts);
		lcol = new glm::vec3(getVec(cut(ts)));
		displayClass->rayLightCol->push_back(lcol);

	}
	//ambient color
	getline(tracer, ts);
	displayClass->rayAmbientCol = new glm::vec3(getVec(cut(ts)));
	*displayClass->rayAmbientCol = glm::clamp(*displayClass->rayAmbientCol, 0.0f, 1.0f);

	//mat1
	getline(tracer, ts);
	ts = cut(ts);
	std::istringstream myStream = static_cast<std::istringstream>(ts);
	float tem;
	displayClass->mtl1 = new float[8];
	int ml = 0;
	while (myStream >> tem) {
		displayClass->mtl1[ml] = tem;
		ml++;
	}

	//mat2
	getline(tracer, ts);
	ts = cut(ts);
	myStream = static_cast<std::istringstream>(ts);
	displayClass->mtl2 = new float[8];
	ml = 0;
	while (myStream >> tem) {
		displayClass->mtl2[ml] = tem;
		ml++;
	}

	//mat3
	getline(tracer, ts);
	ts = cut(ts);
	myStream = static_cast<std::istringstream>(ts);
	displayClass->mtl3 = new float[8];
	ml = 0;
	while (myStream >> tem) {
		displayClass->mtl3[ml] = tem;
		ml++;
	}

	displayClass->mtlf = new float[8];
	displayClass->mtlf[0] = 0.5f;
	displayClass->mtlf[1] = 0.5f;
	displayClass->mtlf[2] = 0.0f;
	displayClass->mtlf[3] = 5.0f;
	displayClass->mtlf[4] = 0.0f;
	displayClass->mtlf[5] = 0.0f;
	displayClass->mtlf[6] = 0.0f;
	displayClass->mtlf[7] = 0.0f;

	tracer.close();

	std::ifstream config;
	std::ifstream meshfile;
	config.open(filename);
	std::string reader;
	getline(config, reader);
	glm::vec3 vec = getVec(reader);
	int xSize = vec[0];
	int zSize = vec[1];
	int numItems = vec[2];
	std::vector<std::vector<Node*>> grid;
	for (int fn = 0; fn < xSize; fn++) {
		std::vector<Node*> col;
		for (int fx = 0; fx < zSize; fx++) {
			col.push_back(NULL);
		}
		grid.push_back(col);
	}
	int i = 0;
	glm::vec4 origin(((float) xSize)/-2.0f, -0.1f, ((float) zSize)/-2.0f, 1.0f);
	displayClass->graph = new SceneGraph();
	displayClass->floor = new Prism(1, xSize, 0.1f, -1 * zSize, origin);
	SceneGraph* sg = displayClass->graph;
	sg->rootNode = new Node(displayClass->floor, NULL, NULL, 0, 0);
	*sg->rootNode->mtl = 4;
	sg->rootNode->scale = new glm::mat4();//glm::scale(glm::mat4(), glm::vec3(xSize, 0.1f, zSize)));
	sg->rootNode->rotate = new glm::mat4();//glm::rotate(glm::mat4(), 0.1f, glm::vec3(0.0f, 1.0f, 0.0f)));
	sg->rootNode->translate = new glm::mat4();
	Furniture* currentPrimitive = NULL;
	Node* par;
	glm::mat4 transl;
	glm::mat4 rot;
	glm::mat4 scal;
	Node* thisNode;
	int xi;
	float* yi;
	int zi;
	int mtl;
	std::string myName;
	std::string meshparse;
	while (i < numItems) {
		currentPrimitive = NULL;
		Mesh* myMesh = NULL;
		getline(config, reader);
		getline(config, reader);
		myName = reader;
		if (myName == "table") {
			getline(config, reader);
			mtl = getVec(reader).x;
			currentPrimitive = new Table(mtl);
		} else if (myName == "chair") {
			getline(config, reader);
			mtl = getVec(reader).x;
			currentPrimitive = new Chair(mtl);
		} else if (myName == "cabinet") {
			getline(config, reader);
			mtl = getVec(reader).x;
			currentPrimitive = new Cabinet(mtl);
		} else if (myName == "lamp") {
			getline(config, reader);
			mtl = getVec(reader).x;
			currentPrimitive = new Lamp(mtl);
		} else if (myName == "multitable") {
			getline(config, reader);
			mtl = getVec(reader).x;
			currentPrimitive = new Table(mtl);
			*currentPrimitive->localTransforms->at(currentPrimitive->localTransforms->size() - 1) *= glm::scale(glm::mat4(), glm::vec3(2.0f, 1.0f, 1.0f));
			/*for (int n = 0; n < currentPrimitive->localTransforms->size(); n++) {
				*currentPrimitive->localTransforms->at(n) = glm::translate(glm::mat4(), glm::vec3(0.5f, 0.0f, 0.0f)) * *currentPrimitive->localTransforms->at(n);
			}*/
		} else if (myName == "mesh") {
			getline(config, reader);
			meshfile.open(reader);
			getline(config, reader);
			mtl = getVec(reader).x;
			getline(meshfile, meshparse);
			if (meshparse == "extrusion") {
				getline(meshfile, meshparse);
				vec = getVec(meshparse);
				float len = vec.x;
				getline(meshfile, meshparse);
				vec = getVec(meshparse);
				int numVerts = vec.x;
				std::vector<glm::vec3> verts;
				for (int w = 0; w < numVerts; w++) {
					getline(meshfile, meshparse);
					vec = getVec(meshparse);
					glm::vec3 myvec(vec.x, 0.0f, vec.y);
					verts.push_back(myvec);
				}
				myMesh = new Mesh(mtl, len, numVerts, verts);
			} else if (meshparse == "surfrev") {
				getline(meshfile, meshparse);
				vec = getVec(meshparse);
				int numSlices = vec.x;
				getline(meshfile, meshparse);
				vec = getVec(meshparse);
				int numVerts = vec.x;
				std::vector<glm::vec4> verts;
				for (int w = 0; w < numVerts; w++) {
					getline(meshfile, meshparse);
					vec = getVec(meshparse);
					if (vec.x < 0) {
						std::cerr << "Error: negative x value in surfrev" << std::endl;
						exit(1);
					}
					glm::vec4 myvec(vec.x, vec.y, 0.0f, 1.0f);
					verts.push_back(myvec);
				}
				myMesh = new Mesh(mtl, numSlices, numVerts, verts);
			}
			meshfile.close();
		}

		//colors
		//getline(config, reader);

		//translation
		getline(config, reader);
		vec = getVec(reader);
		xi = vec.x;
		yi = new float(0);
		zi = vec.y;

		//rotation
		getline(config, reader);
		vec = getVec(reader);
		rot = glm::rotate(glm::mat4(), vec.x, glm::vec3(0.0f, 1.0f, 0.0f));

		//scale
		getline(config, reader);
		vec = getVec(reader);
		scal = glm::scale(glm::mat4(), vec);
		
		thisNode = new Node(NULL, currentPrimitive, NULL, xi, zi);
		*thisNode->mtl = mtl;
		if (myName == "mesh") {
			thisNode->shape = myMesh;
			if (*myMesh->kind == 99) {
				//*yi = *myMesh->height/2.0f;
			} else if (*myMesh->kind == 100) {
				//*yi = *myMesh->height/2.0f;
			}
		}
		par = sg->rootNode;
		if (grid.at(xi).at(zi) != NULL) {
			par = grid.at(xi).at(zi);
			if (par->furniture == NULL) {
				if (par != sg->rootNode) {
					*yi += *par->shape->height;
				}
			} else {
				*yi += *par->furniture->height;
			}
		}
		thisNode->parent = par;
	    grid.at(xi).at(zi) = thisNode;
		if (myName == "multitable") {
			grid.at(xi + 1).at(zi) = thisNode;
		}

		//setPar(par, myPar, xi, yi, zi);
		transl = glm::translate(glm::mat4(), glm::vec3(xi + origin.x + 0.5, *yi, zi + origin.z + 0.5));
		if (myName == "multitable") {
			transl = glm::translate(glm::mat4(), glm::vec3(0.5f, 0.0f, 0.0f)) * transl;
		}
		if (thisNode->furniture != NULL) {
			*thisNode->furniture->height *= scal[1][1];
		} else {
			*thisNode->shape->height *= scal[1][1];
		}
		if (thisNode->parent != displayClass->graph->rootNode) {
			if (thisNode->furniture == NULL) {
				if (thisNode->parent->furniture == NULL) {
					*thisNode->shape->height += *thisNode->parent->shape->height;
				} else {
					*thisNode->shape->height += *thisNode->parent->furniture->height;
				}
			} else {
				if (thisNode->parent->furniture == NULL) {
					*thisNode->furniture->height += *thisNode->parent->shape->height;
				} else {
					*thisNode->furniture->height += *thisNode->parent->furniture->height;
				}
			}
		}
		thisNode->rotate = new glm::mat4(rot);// * *par->rotate);
		thisNode->translate = new glm::mat4(transl);
		thisNode->scale = new glm::mat4(scal);// * *par->scale);

		//add to parent's list of children
		par->children->push_back(thisNode);
		i++;
	}
	displayClass->selectedNode = displayClass->graph->rootNode;
}
예제 #4
0
int main(int argc, char* argv[]) {

#ifdef HAVE_MPI
  MPI::Init(argc, argv);
#endif
  RCP<MxComm> myComm = rcp(new MxComm());

#if 0
#ifdef HAVE_MPI
  MPI::Init(argc, argv);
  //MPI_Init(argc, argv);
  Epetra_MpiComm myComm(MPI_COMM_WORLD);
#else
  Epetra_SerialComm myComm;
#endif
#endif

// input file method
#if 1

  std::string inFile;

  Teuchos::CommandLineProcessor cmdp(false, true);
  cmdp.setOption("infile", &inFile, "XML format input file.");
  if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) {
    return -1;
  }

  if (inFile == "") {
    std::cout << "Please specify an input file using --infile=your_file.mx\n";
    exit(0);
  }

  // now read the input file with trilinos XML reader
  Teuchos::XMLObject xmlObj(Teuchos::FileInputSource(inFile).getObject());

  // get simulation dimension
  int dim = atoi(MxUtil::XML::getAttr("dim", xmlObj).c_str());
  if (dim < 1 or dim > 3) {
    std::cout << "Simulation dimension invalid or not given, using 3D.\n";
    dim = 3;
  }

  // get simulation type
  std::string domain = MxUtil::XML::getAttr("domain", xmlObj).c_str();
  if (domain != "frequency" and domain != "time") {
    std::cout << "Simulation domain invalid or not given, using frequency-domain.\n";
    domain = "frequency";
  }

  // create problem
  
  MxProblem<1> * prob1d;
  MxProblem<2> * prob2d;
  MxProblem<3> * prob3d;
  switch (dim) {
    case 1:
      prob1d = new MxProblem<1>(xmlObj, myComm);
      prob1d->solve();
      delete prob1d;
      break;
    case 2:
      prob2d = new MxProblem<2>(xmlObj, myComm);
      prob2d->solve();
      delete prob2d;
      break;
    case 3:
      prob3d = new MxProblem<3>(xmlObj, myComm);
      prob3d->solve();
      delete prob3d;
      break;
  }
#endif


#if 0

  // epetra stuff test
  MxMap map(10, 0, myComm);
  Epetra_CrsMatrix mat(Copy, map, 0);
  int ind = 2;
  double val = 0;
  mat.InsertGlobalValues(1, 1, &val, &ind);
  ind = 3;
  val = 4;
  mat.InsertGlobalValues(1, 1, &val, &ind);
  mat.FillComplete(map, map);

  Epetra_Vector myvec(map);
  myvec.Random();

  std::cout << myvec;
  mat.Apply(myvec, myvec);
  std::cout << myvec;

  Epetra_CrsMatrix copy(mat);

  std::cout << mat;
  MxUtil::Epetra::stripZeros(mat);
  std::cout << mat;

  //throw 1;
#endif

  typedef MxDimVector<double, 3> vecd3;
  typedef MxDimVector<int, 3> veci3;

  vecd3 midPt(0);

#if 0
  //std::cout << "Crab cavity setup:\n";

  int crabNumCells = 4;
  double crabCellLen = 2.0 * 0.0192; //meters
  double crabCavRad = 0.04719;
  double crabIrisRad = 0.015;
  double crabCavRho = 0.0136;
  double crabIrisRho = 0.00331;

  int crabCellRes = 40;
  int padCells = 2;
  int cnx, cny, cnz;
  double clx, cly, clz;
  double cox, coy, coz;

  double crabDelta = crabCellLen / double(crabCellRes);

  cnz = crabNumCells * crabCellRes + 2 * padCells;
  clz = double(cnz) * crabDelta;
  coz = -0.5 * clz;

  cny = cnx = 2 * (int(ceil(crabCavRad / crabDelta)) + padCells);
  cly = clx = double(cnx) * crabDelta;
  coy = cox = -0.5 * clx;
  
  veci3 crabN; crabN[0] = cnx; crabN[1] = cny; crabN[2] = cnz;
  vecd3 crabL; crabL[0] = clx; crabL[1] = cly; crabL[2] = clz;
  vecd3 crabO; crabO[0] = cox; crabO[1] = coy; crabO[2] = coz;
  //crabN.print();
  //crabL.print();
  //crabO.print();
  
  MxGrid<3> crabGrid(crabO, crabN, crabL, &myComm);
  crabGrid.print();

  MxCrabCav crabCav(midPt, crabNumCells, crabCellLen, crabIrisRad, crabCavRad, crabIrisRho, crabCavRho);

  crabCav.save(crabGrid);

  Teuchos::ParameterList crabList;
  crabList.set("geo-mg : levels", 1);
  crabList.set("geo-mg : smoothers : sweeps", 5);
  crabList.set("amg : smoothers : sweeps", 1);
  crabList.set("amg : smoothers : type", "Chebyshev");
  crabList.set("eigensolver : output", 2);
  crabList.set("eigensolver : nev", 15);
  crabList.set("eigensolver : tol", 1.e-8);
  crabList.set("eigensolver : block size", 2);
  crabList.set("eigensolver : num blocks", 30);
  crabList.set("eigensolver : spectrum", "LM");
  crabList.set("wave operator : invert", true);
  crabList.set("wave operator : invert : tol", 1.e-10);
  //crabList.set("wave operator : invert : shift", 1000.0);
  crabList.set("wave operator : invert : max basis size", 40);

  MxEMSim<dim> crabSim;
  crabSim.setGrid(&crabGrid);
  crabSim.setPEC(&crabCav);
  //crabSim.setGrid(&sphGrid);
  //crabSim.setPEC(&ell);
  crabSim.setParameters(crabList);
  crabSim.setup();

  MxSolver<dim> * solver;
  solver = new MxSolver<dim>(&crabSim, crabList);
  solver->solve();

  delete solver;

  //return 1;
#endif

// optimized phc cavity
#if 0
  double rodRad = 0.003175; // meters
  const int numRods = 24;
  double rodx[numRods] = {0.0158406582694, 0.0551748491968, 0.0209567636489, 
                          0.0384658321918, 0.00792032913471, 0.0338604938991,
                          0.00477355412058, 0.00485955186622, -0.00792032913471,
                          -0.0213143552977, -0.0161832095283, -0.0336062803256,
                          -0.0158406582694, -0.0551748491968, -0.0209567636489,
                          -0.0384658321918, -0.00792032913471, -0.0338604938991,
                          -0.00477355412058, -0.00485955186622, 0.00792032913471,
                          0.0213143552977, 0.0161832095283, 0.0336062803256};
  double rody[numRods] = {0.0, -0.00724351649877, 0.006587367621, 
                    0.0165969314144, 0.013718412474, 0.044161062805,
                    0.0214427735115, 0.041610853563, 0.013718412474,
                    0.0514045793038, 0.0148554058905, 0.0250139221487,
                    1.9399211446e-18, 0.00724351649877, -0.006587367621,
                    -0.0165969314144, -0.013718412474, -0.044161062805,
                    -0.0214427735115, -0.041610853563, -0.013718412474,
                    -0.0514045793038, -0.0148554058905, -0.0250139221487};

  std::vector<MxShape<3> *> rods;
  MxShapeUnion<3> rodsShape;
  vecd3 rodPos;
  vecd3 zhat(0); zhat[2] = 1.0;
  for (int i = 0; i < numRods; i++) {
    rodPos[0] = rodx[i];
    rodPos[1] = rody[i];
    rodPos[2] = 0.0;
    rods.push_back(new MxCylinder(rodPos, zhat, rodRad));
    rodsShape.add(rods[i]);
  }

  MxDimMatrix<double, 3> sapphEps(0);
  sapphEps(0, 0) = 9.3;
  sapphEps(1, 1) = 9.3;
  sapphEps(2, 2) = 11.5;

  MxDielectric<3> phcDiel;
  phcDiel.add(&rodsShape, sapphEps);

  // conducting cavity
  double cavLen = 0.019624116824498831;
  double cavRad = 0.1;
  MxCylinder cavCyl(0, zhat, cavRad);
  MxSlab<3> cavCaps(0, zhat, cavLen);
  MxShapeIntersection<3> phcCav;
  phcCav.add(&cavCyl);
  phcCav.add(&cavCaps);

  // setup grid
  int rodDiaCells = 6;
  int pad = 2;
  double delta = 2.0 * rodRad / double(rodDiaCells);

  veci3 phcN;
  phcN[0] = phcN[1] = int(2.0 * cavRad / delta) + 2 * pad;
  phcN[2] = int(cavLen / delta) + 2 * pad;

  vecd3 phcL;
  phcL[0] = phcL[1] = delta * double(phcN[0]);
  phcL[2] = delta * double(phcN[2]);

  vecd3 phcO;
  phcO[0] = phcO[1] = -0.5 * phcL[0];
  phcO[2] = -0.5 * phcL[2];

  MxGrid<3> phcGrid(phcO, phcN, phcL, &myComm);
  phcGrid.print();

  Teuchos::ParameterList phcList;
  phcList.set("geo-mg : levels", 1);
  phcList.set("geo-mg : smoothers : sweeps", 5);
  phcList.set("eigensolver : output", 2);
  phcList.set("eigensolver : nev", 15);
  phcList.set("eigensolver : tol", 1.e-8);
  phcList.set("eigensolver : block size", 1);
  phcList.set("eigensolver : num blocks", 30);
  phcList.set("eigensolver : spectrum", "LM");
  phcList.set("wave operator : invert", true);
  phcList.set("wave operator : invert : tol", 1.e-8);
  //phcList.set("wave operator : invert : shift", 1000.0);
  phcList.set("wave operator : invert : max basis size", 40);

  MxEMSim<dim> phcSim;
  phcSim.setGrid(&phcGrid);
  //phcSim.setPEC(&phcCav);
  phcSim.setDielectric(&phcDiel);
  phcSim.setParameters(phcList);
  phcSim.setup();

  MxSolver<dim> * solver;
  solver = new MxSolver<dim>(&phcSim, phcList);
  solver->solve();

  delete solver;

  for (int i = 0; i < numRods; i++)
    delete rods[i];

#endif

#if 0
  double sphR = 0.37;
  int sphN = 64;
  MxEllipsoid ell(0.0, sphR);

  MxGrid<3> sphGrid(-0.5, sphN, 1.0, &myComm);
  sphGrid.print();

  MxDimMatrix<double, 3> rotSapphEps(0);
  rotSapphEps(0, 0) = 10.225;
  rotSapphEps(1, 1) = 10.225;
  rotSapphEps(2, 2) = 9.95;
  rotSapphEps(0, 1) = rotSapphEps(1, 0) = -0.825;
  rotSapphEps(0, 2) = rotSapphEps(2, 0) = -0.67360967926537398;
  rotSapphEps(1, 2) = rotSapphEps(2, 1) = 0.67360967926537398;

  MxDielectric<3> phcDiel;
  phcDiel.add(&ell, rotSapphEps);

  vecd3 ell2Loc(0); ell2Loc[0] = 0.6;
  vecd3 ell3Loc(0); ell3Loc[0] = 0.3; ell3Loc[2] = 0.3;
  MxEllipsoid ell2(ell2Loc, sphR);
  MxEllipsoid ell3(ell3Loc, sphR);

  MxShapeUnion<3> shUnion;
  shUnion.add(&ell);
  shUnion.add(&ell2);
  shUnion.add(&ell3);
  //shUnion.save(sphGrid);

  MxShapeIntersection<3> shInt;
  shInt.add(&ell);
  shInt.add(&ell2);
  shInt.add(&ell3);
  //shInt.save(sphGrid);

  MxShapeSubtract<3> shSub;
  shSub.setBaseShape(&ell);
  shSub.subtractShape(&ell2);
  shSub.subtractShape(&ell3);
  //shSub.save(sphGrid);

  MxDielectric<3> dielEll;
  MxDimMatrix<double, 3> epsEll(vecd3(10.0)); // isotropic eps = 10
  dielEll.add(&ell, epsEll);

  Teuchos::ParameterList sphList;
  sphList.set("geo-mg : levels", 1);
  sphList.set("geo-mg : smoothers : sweeps", 4);
  sphList.set("eigensolver : output", 2);
  sphList.set("eigensolver : nev", 12);
  sphList.set("eigensolver : tol", 1.e-8);
  sphList.set("eigensolver : block size", 1);
  sphList.set("eigensolver : num blocks", 30);
  sphList.set("eigensolver : spectrum", "LM");
  sphList.set("wave operator : invert", true);
  sphList.set("wave operator : invert : tol", 1.e-8);
  //sphList.set("wave operator : invert : shift", -0.1);
  sphList.set("wave operator : invert : shift", 1.0);
  sphList.set("wave operator : invert : max basis size", 40);

  MxEMSim<dim> sphSim;
  sphSim.setGrid(&sphGrid);
  //sphSim.setDielectric(&dielEll);
  sphSim.setDielectric(&phcDiel);
  //sphSim.setPEC(&sphCav);
  //sphSim.setPEC(&ell);
  sphSim.setParameters(sphList);
  sphSim.setup();

  MxSolver<dim> * solver;
  solver = new MxSolver<dim>(&sphSim, sphList);
  solver->solve();

  delete solver;

#endif


#ifdef HAVE_MPI
  MPI::Finalize();
  //MPI_Finalize();
#endif

  return 0;

}
예제 #5
0
//#include <vector>
void foo3() {
    std::vector<int> myvec(1);
    for (auto itr = myvec.cbegin(); itr != myvec.cend(); ++itr) {
    }
}