Panel 


Table of Contents 

minLevel  2 

outline  true 

indent  30px 

type  flat 

separator  newline 



Code Block 

ModelInfo: {
File: dds3.ncdf //mesh file. It is the file converted using acdtool
BoundaryCondition: { //specify boundary conditions. The numbers here are sideset in cubit
Magnetic: 1, 2 //reference surfaces 1 and 2 are symmetric planes
Electric: 3 4 //set reference surfaces 3 and 4 to be electric boundary condition
Exterior: 6 //surface group 6 (maybe many surfaces) is metal
}
SurfaceMaterial: { //for each metal (exterior) surface group, list the sigma values
ReferenceNumber: 6
Sigma: 5.8e7
}
}
FiniteElement: {
Order: 2 //set the finite element basis function order to be used.
CurvedSurfaces: on
}
EigenSolver: {
NumEigenvalues: 1 //want to compute 1 mode
FrequencyShift: 10.e9 //the eigenfrequency of the mode should be above 10GHz
}

Once Omega3P run is successfully completed, eignvectors are stored in subdirectory <tt>eigens</tt>. User can convert them to mode files to be visualized using paraview. The following is the command to do that:
Code Block 

acdtool postprocess eigentomode eigens

Code Block 

ModelInfo: {
File: ./pillbox.ncdf
BoundaryCondition: {
Electric: 1,2,3,4
Exterior: 6
}
Material : {
Attribute: 1
Epsilon: 1.0
Mu: 1.0
}
Material : {
Attribute: 2
Epsilon: 1.0
Mu: 1.0
EpsilonImag: 0.2 //lossy material
}
}
FiniteElement: {
Order: 1
Curved Surfaces: off
}
EigenSolver: {
NumEigenvalues: 2
FrequencyShift: 5e9
}

Code Block 

ModelInfo: {
File: c026dspbc.ncdf
BoundaryCondition: {
Magnetic: 1 2
Periodic_M: 3 //master surface
Periodic_S: 4 //slave surface, the mesh should be exactly same as those on the master surface
Exterior: 6
Theta: 150 //phase
}
}
FiniteElement: {
Order: 2
CurvedSurfaces: on
}
EigenSolver: {
NumEigenvalues: 1
FrequencyShift: 10e9
}

Code Block 

ModelInfo: {
File: cell1fourth.ncdf
BoundaryCondition: {
Magnetic: 1,2,3,4
Exterior: 6
Waveguide: 7 //Automatic numerical waveguide port solution will be generated per default
//Absorbing: 7 //Firstorder absorbing boundary condition. Default cutoff is 0
}
}
FiniteElement: {
Order: 1
Curved Surfaces: on
}
EigenSolver: {
NumEigenvalues: 1
FrequencyShift: 9.e9
}
Port: {
ReferenceNumber: 7
NumberOfModes: 3 // this whole 'Port' container is only needed if you want to load more than 1 mode on a port
//CutoffFrequency: 5.6e9 // this is only for Absorbing boundary conditions specified above. Can be used to have the same cutoff as another waveguide mode for faster solution
}

Omega3p normally uses a numerical solution for each port but if you need to specify the polarization of the waveguide you can give an analytic solution instead.
From the last example we could have used:
Code Block 

Port: {
ReferenceNumber: 7 //this number should match surface groups in waveguide boundary condition.
Origin: 0.0, 0.0415, 0.0 //the origin of the 2D port in the 3D coordinate system
XDirection: 1.0, 0.0, 0.0 //the x axis of the 2D port in the 3D coordinate system
YDirection: 0.0, 0.0, 1.0 //the y axis of the 2D port in the 3D coordinate system
ESolver: {
Type: Analytic //analytic expression is used
Mode: {
WaveguideType: Rectangular //it is a rectangular waveguide
ModeType: TE 1 0 //load the TE10 mode
A: 0.028499 //dimension of the waveguide in x
B: 0.0134053 //dimension of the waveguide in y
}
}
}

Code Block 

Port: {
ReferenceNumber: 2
Origin: 0.0, 0.0, 0.011
ESolver: {
Type: Analytic
Mode: {
WaveguideType: Coax
ModeType: TEM
A: 0.0011 //smaller radius
B: 0.0033 //larger radius
}
}
}

Code Block 

Port: {
ReferenceNumber: 2
Origin: 0.0, 0.0, 0.1
XDirection: 1.0, 0.0, 0.0
YDirection: 0.0, 1.0, 0.0
ESolver: {
Type: Analytic
Mode: {
Waveguide type: Circular
Mode type: TE 1 1
A: 0.03
}
}
}

Code Block 

Port: {
Reference number: 9 // FPC
Origin: 0.0, 0.198907, 0.4479152585
XDirection: 1.0, 0.0, 0.0
YDirection: 0.0, 0.0, 1.0
ESolver: {
Type: Analytic
Mode: {
WaveguideType: Rectangular
ModeType: TE 1 1
A: 0.1348935946
B: 0.024973714999999970
}
}
}
Port: {
Reference number: 9 // FPC
Origin: 0.0, 0.198907, 0.4479152585
XDirection: 1.0, 0.0, 0.0
YDirection: 0.0, 0.0, 1.0
ESolver: {
Type: Analytic
Mode: {
WaveguideType: Rectangular
ModeType: TE 2 0
A: 0.1348935946
B: 0.024973714999999970
}
}
}

Code Block 

LinearSolver options in EigenSolver container

 The first option is that user does not provide anything. The EigenSolver container in the input file looks like:
Code Block 

EigenSolver: {
NumEigenvalues: 1
FrequencyShift: 10.e9
Tolerance: 1.e8
}

In this case, Omega3P will use the default option for linear solver for solving shifted linear systems
 The second option is to use float version of the sparse direct solver.
Code Block 

EigenSolver: {
NumEigenvalues: 1
FrequencyShift: 10.e9
Preconditioner: MUMPSFLOAT //use the float version. memory usage reduced into half.
}

 The third option is to use Krylov subspace method with different preconditioner.
Code Block 

EigenSolver: {
NumEigenvalues: 1
FrequencyShift: 10.e9
Preconditioner: MP //this use pversion of multilevel preconditioner.
}

The code will choose either CG (real matrices) or GMRES (complex matrices) and the pversion
of multilevel precondtioner as the solver for shifted linear systems.
There are two ways to do so. Each way has its advantage and disadvantage.
 Inside ModelInfo.BoundaryCondition define a set of boundary surfaces as Exterior.
For each of the boundary surfaces, have a corresponding SurfaceMaterial container inside ModelInfo.
For example: Code Block 

ModelInfo: {
File: .dds3.ncdf
BoundaryCondition: {
Magnetic: 1, 2, 3, 4
Exterior: 6 // sideset 6 is defined as Exterior BC.
}
SurfaceMaterial: { // have a separate for each number in Exterior BC
ReferenceNumber: 6 //the corresponding sideset in Exterior BC
Sigma: 5.8e7 //electrical conductivity of the material
}
}

After you run omega3p with the input file, you will get a file called "output" under the same directory. Inside the file, it has a summary of results such as: Code Block 

Mode : {
TotalEnergy : 4.4270939088102e12
QualityFactor : 6478.5096350252
File : ./dds.l0.1.144469E+10.m0
PowerLoss : 4.9139118623939e05
Frequency : 11444685657.626
}

The number after QualityFactor is the one you are looking for. This method uses perturbation theory and has advantage that it is very simple. The computation associated with it is minimal.  Inside ModelInfo.BoundaryCondition, define the set of surfaces as Impedance (instead of Exterior in method 1).
Set the HFormulation to be 1 (this is very important). Also, have a set of corresponding SurfaceMaterials inside ModelInfo as those in method 1. For example: Code Block 

ModelInfo: {
File: dds3.ncdf
BoundaryCondition: {
HFormulation: 1
Magnetic: 1, 2, 3, 4
Impedance: 6
}
SurfaceMaterial: {
ReferenceNumber: 6
Sigma: 5.8e7
}
}

After you run omega3p with the input, in the output file, you will see Code Block 

Mode = {
TotalEnergy = { 6.2827077634198e07, 0 },
ExternalQ = 6579.1486638005,
QualityFactor = inf,
File = './dds.l0.R1.144619E+10I8.698837E+05.m0',
PowerLoss = 0,
Frequency = { 11446188331.641, 869883.69746227 }
}

The number after ExternalQ is the wall loss Q you are looking for. During the omega3p run, it should also print out the Q information such as Code Block 

COMMIT MODE: 0 FREQ = (11446188331.64141,869883.6974622669) k = (239.8943683519209,0.01823141417003215) Q = 6579.148663800495

Note that this method set an impedance boundary condition on those surfaces and make the eigenvalue problem complex and nonlinear. It takes more time and memory to solve the problem. But the field will be in the right phase (even close to the boundary surfaces).
Both methods should give you converged Q results if mesh is dense enough.