public void writeNodePositions(Node[][] NodeArray)
{
try
{
SaveFileDialog saveFile = new SaveFileDialog();
saveFile.Filter = "CSV|*.csv";
saveFile.Title = "Save the data file:";
saveFile.DefaultExt = "*.csv";
saveFile.ShowDialog();
string directory = saveFile.FileName;
TextWriter dataWrite = new StreamWriter(directory);
dataWrite.WriteLine("Node ID" + "," + "XPOS" + "," + "YPOS" + "," + "Material");
//for (int i = 1; i < scanCount; i++)
// dataWrite.WriteLine(ampArraytoWrite[i] + "," + timeArray[i] + "," + tempArray[i] + "," + dTdt[i]);
foreach (Node[] node in NodeArray)
{
foreach (Node ind_node in node)
{
int node_Material = 0;
if (ind_node.Material == "Copper")
node_Material = 1;
else if (ind_node.Material == "BiTe")
node_Material = 2;
else if (ind_node.Material == "Ceramic")
node_Material = 3;
else if (ind_node.Material == "Air")
node_Material = 4;
dataWrite.WriteLine(ind_node.Node_ID + "," + ind_node.x_pos + "," + ind_node.y_pos + "," + node_Material);
}
}
dataWrite.Close();
}
catch
{
MessageBox.Show("Error saving file, or writing was canceled ", "Error!", MessageBoxButtons.OK);
}
}
/// <summary>
/// Constructor for BoundaryConditions class
/// </summary>
/// <param name="Nodal_Array">Node array with which to apply the boundary conditions to</param>
/// <param name="local_ErrorHandler">Errorhandler to pass messages to the Main UI</param>
/// <param name="T_Base">Constant temperature of the south face of the TEM in Kelvin</param>
/// <param name="h_Top">Heat transfer coefficient (initial) operating off of the top surface of the TEM</param>
/// <param name="T_inf">Ambient temperature utilized for the convective coefficient off of the top surface</param>
public BoundaryConditions(Node[][] Nodal_Array, ErrorHandler local_ErrorHandler, bool[] BC_CONVECTION, bool[] BC_CONST_T, bool[] BC_ADIABATIC, float[] h, float[] T_INFINITY, float[] T_CONST)
{
Nodes = Nodal_Array;
BC_ErrorHandler = local_ErrorHandler;
BC_h = BC_CONVECTION;
BC_T = BC_CONST_T;
BC_Adiabatic = BC_ADIABATIC;
h_Coefficient = h;
Constant_T = T_CONST;
T_inf = T_INFINITY;
Check_Boundary_Condition();
Apply_Boundary_Conditions();
}
// ListToJaggedArray
//
/// <summary>
/// When passed in a sorted NodeList, ListToJaggedArray arranges the nodes into a 2D jagged array
/// of Node[][]. This ensures that Node[0][0] is the least node in the (x,y) and Node[0][1] is just
/// to the right of it, etc.
/// </summary>
/// <param name="p_NodeList">Grouped nodes with which to convert to a jagged array for further analysis</param>
/// <returns></returns>
private Node[][] ListtoJaggedArray(IList<IGrouping<float, Node>> p_NodeList)
{
// Creates new jagged array to hold NodeList data
var result = new Node[p_NodeList.Count][];
for (var i = 0; i < p_NodeList.Count; i++)
{
result[i] = p_NodeList[i].ToArray();
}
Mesh_Errors.Post_Error("NOTE: Finished arranging node list into jagged array");
// Display Jagged Array to User
for (var i = 0; i < result[i].Count(); i++)
{
Mesh_Errors.Post_Error("NOTE: Final Array is Node[" + result.Count().ToString() + ", " + result[i].Count().ToString() + "]");
}
for (int i = 0; i < result.Count(); i++)
{
for (int j = 0; j < result[i].Count(); j++)
{
result[i][j].i = i;
result[i][j].j = j;
}
}
// Returns Node[][] to user
return result;
}
/// <summary>
/// Checks the passed in node to see if it is inside the layer bounds
/// </summary>
/// <param name="node">Current node object to inspect</param>
/// <param name="Current_Layer">Current layer in which the node object resides</param>
private void Check_Node(Node node, Layer Current_Layer)
{
if (node.x_pos > Current_Layer.Layer_xf)
Mesh_Errors.Post_Error("MESH ERROR: Node assignment outside of layer bounds {xf-" + Current_Layer.Layer_xf.ToString() + ", x_node-" + node.x_pos.ToString() + "}");
if (node.y_pos > Current_Layer.Layer_y0)
Mesh_Errors.Post_Error("MESH ERROR: Node assignment outside of layer bounds {y0-" + Current_Layer.Layer_y0.ToString() + ", y_node-" + node.y_pos.ToString() + "}");
if (node.y_pos < Current_Layer.Layer_yf)
Mesh_Errors.Post_Error("MESH ERROR: Node assignment outside of layer bounds {yf-" + Current_Layer.Layer_yf.ToString() + ", y_node-" + node.y_pos.ToString() + "}");
if (node.x_pos < Current_Layer.Layer_x0)
Mesh_Errors.Post_Error("MESH ERROR: Node assignment outside of layer bounds {x0-" + Current_Layer.Layer_x0.ToString() + ", x_node-" + node.x_pos.ToString() + "}");
}
public CSVWriter(Node[][] NodeArray)
{
writeNodePositions(NodeArray);
}
public Solver(ErrorHandler local_ErrorHandler, Node[][] NodeArray)
{
Solver_ErrorHandler = local_ErrorHandler;
Nodes = NodeArray;
}
/// <summary>
/// Constructor of the NodeInitializer Class.
/// </summary>
/// <param name="Nodes">Node Array of Numeric Model</param>
/// <param name="local_ErrorHandler">Error Handler for Message Passing</param>
/// <param name="Materials">Material Manager which holds all the material properties</param>
/// <param name="Layers">List of Layers holding material information for each node inside of it</param>
public NodeInitializer(Node[][] Nodes, ErrorHandler local_ErrorHandler, MaterialManager Materials, List<Layer> Layers, float dt, float Amps, bool is_Warming_Top)
{
this.dt = dt;
this.Amps = Amps;
this.is_Warming_Top = is_Warming_Top;
x_Max_DX = 0.0f;
y_Max_DY = 0.0f;
max_X = 0.0f;
max_Y = 0.0f;
foreach (Node[] node_array in Nodes)
{
foreach (Node node in node_array)
{
if (node.x_pos > x_Max_DX)
x_Max_DX = node.x_pos;
if (node.y_pos > y_Max_DY)
y_Max_DY = node.y_pos;
}
}
foreach (Layer layer in Layers)
{
if (layer.Layer_xf > max_X)
max_X = layer.Layer_xf;
if (layer.Layer_y0 > max_Y)
max_Y = layer.Layer_y0;
}
LayerList = Layers;
NodeArray = Nodes;
Node_I_ErrorHandler = local_ErrorHandler;
Mat_Manager = Materials;
x_MinpDX = Nodes[0][0].x_pos;
y_MinpDY = Nodes[0][0].y_pos;
Assign_Materials();
Calculate_DxDy();
Initialize_Heat_Generation(Amps, is_Warming_Top); // Passed in 5.0f value represents an initialization current... this needs to be fed in
Initialize_Influence_Coefficients(Nodes); // Must come after heat generation initialization
}
/// <summary>
/// Initializes influence coefficients for each node passed in
/// </summary>
/// <param name="Nodes">Jagged 2D array of nodes</param>
private void Initialize_Influence_Coefficients(Node[][] Nodes)
{
List<Node> BoundaryNodes = new List<Node>();
foreach (Node[] Node_Array in Nodes)
{
foreach (Node node in Node_Array)
{
node.Initialize_Influence_Coefficients(dt);
if (node.is_Boundary)
{
BoundaryNodes.Add(node);
}
}
}
int boundary_Counter = 0;
int s_boundary_Counter = 0;
List<Material> MaterialList = new List<Material>();
MaterialList = Mat_Manager.Material_List;
// Need to iterate through Boundary_Nodes, to find nearest material to boundary nodes
foreach (Node b_Node in BoundaryNodes)
{
if (LayerList[b_Node.Layer_ID].Layer_Material != b_Node.Boundary_Material && b_Node.Boundary_Material != "")
{
boundary_Counter++;
}
if (LayerList[b_Node.Layer_ID].Layer_Material == b_Node.Boundary_Material && b_Node.Boundary_Material != "")
{
s_boundary_Counter++;
}
b_Node.Initialize_Effective_Conductivities(MaterialList);
}
Node_I_ErrorHandler.Post_Error("NOTE: " + boundary_Counter.ToString() + " number of material boundaries detected with " + s_boundary_Counter.ToString() +
" boundary materials matching their own material");
Node_I_ErrorHandler.Post_Error("NOTE: Finished Initializing Influence Coefficients");
}
/// <summary>
/// Finds the closest boundary material for a given boundary node in the y direction (N or S)
/// </summary>
/// <param name="node">Node with which to assign the boundary material to</param>
/// <param name="N_Or_S">Flag value indicating whether to look in the North or South direction</param>
/// <returns>String value containing the name of the boundary material</returns>
private string get_Boundary_Material_Y(Node node, string N_Or_S)
{
float dy = 0.00000015f;
float y0 = 0.0f;
string material = LayerList[node.Layer_ID].Layer_Material;
y0 = node.y_pos;
if (N_Or_S == "N") // plus
{
while (material == LayerList[node.Layer_ID].Layer_Material)
{
y0 += dy;
if (y0 > max_Y)
break;
material = checkRectangle(node.x_pos, y0);
}
}
if (N_Or_S == "S") // minus
{
while (material == LayerList[node.Layer_ID].Layer_Material)
{
y0 -= dy;
if (y0 < 0.0000000f)
break;
material = checkRectangle(node.x_pos, y0);
}
}
return material;
}
/// <summary>
/// Finds the closest boundary material for a given boundary node in the x direction (E or W)
/// </summary>
/// <param name="node">Node with which to assign the boundary material to</param>
/// <param name="E_Or_W">Flag value indicating whether to look in the East or West direction</param>
/// <returns>String value containing the name of the boundary material</returns>
private string get_Boundary_Material_X(Node node, string E_Or_W)
{
float dx = 0.00000015f; // [m]
float x0 = 0.0f;
string material = LayerList[node.Layer_ID].Layer_Material;
x0 = node.x_pos;
if (E_Or_W == "E") // plus
{
while (material == LayerList[node.Layer_ID].Layer_Material)
{
x0 += dx;
if (x0 >= max_X)
break;
material = checkRectangle(x0, node.y_pos);
}
}
if (E_Or_W == "W") // minus
{
while (material == LayerList[node.Layer_ID].Layer_Material)
{
x0 -= dx;
if (x0 <= 0.0000000f)
break;
material = checkRectangle(x0, node.y_pos);
}
}
return material;
}
/// <summary>
/// Finds the closest boundary position (either vertical (Y) or horizontal (X)) to the passed
/// in node element
/// </summary>
/// <param name="node">Node object's position is used to calculate the distance from a list of positions</param>
/// <param name="Positions">List of positions to be checked</param>
/// <returns>Distance in meters of closest nodal boundary</returns>
private float FindClosestBoundary_Y(Node node, List<float> Positions)
{
float delta_Y = 100.0f;
Layer currentLayer = LayerList[node.Layer_ID];
foreach (float pos in Positions)
{
if (pos != node.y_pos)
{
if (pos < currentLayer.Layer_yf | pos > currentLayer.Layer_y0)
{
float val = Math.Abs(node.y_pos - pos);
if (val < delta_Y)
{
delta_Y = val;
}
}
}
}
if (delta_Y == 100.0f)
{
Node_I_ErrorHandler.Post_Error("NODE INITIALIZATION ERROR: DELTA_Y SET INCORRECTLY");
}
return delta_Y;
}
