Example #1
0
        public void validate_deserialized_class_is_correct_when_using_FileIO()
        {
            var i = new MultiEllipsoidTissueInput(new ITissueRegion[]
            {
                new EllipsoidTissueRegion(new Position(0, 0, 1), 0.5, 0.5, 0.5,
                                          new OpticalProperties(0.05, 1.0, 0.8, 1.4)),
                new EllipsoidTissueRegion(new Position(0, 1, 0), 0.25, 0.25, 0.25,
                                          new OpticalProperties(0.05, 1.0, 0.8, 1.4))
            }, new ITissueRegion[]
            {
                new LayerTissueRegion(
                    new DoubleRange(double.NegativeInfinity, 0.0),
                    new OpticalProperties(0.0, 1e-10, 1.0, 1.0)),
                new LayerTissueRegion(
                    new DoubleRange(0.0, 100.0),
                    new OpticalProperties(0.01, 1.0, 0.8, 1.4)),
                new LayerTissueRegion(
                    new DoubleRange(100.0, double.PositiveInfinity),
                    new OpticalProperties(0.0, 1e-10, 1.0, 1.0))
            }
                                                  );

            i.WriteToJson("MultiLayerTissue.txt");
            var iCloned = FileIO.ReadFromJson <MultiEllipsoidTissueInput>("MultiLayerTissue.txt");

            Assert.AreEqual(iCloned.EllipsoidRegions[1].RegionOP.Mus, i.EllipsoidRegions[1].RegionOP.Mus);
            Assert.AreEqual(iCloned.Regions[1].RegionOP.Mus, i.Regions[1].RegionOP.Mus);
        }
Example #2
0
        public void validate_deserialized_class_is_correct()
        {
            var i = new MultiEllipsoidTissueInput(new ITissueRegion[]
            {
                new EllipsoidTissueRegion(new Position(0, 0, 1), 0.5, 0.5, 0.5,
                                          new OpticalProperties(0.05, 1.0, 0.8, 1.4)),
                new EllipsoidTissueRegion(new Position(0, 1, 0), 0.25, 0.25, 0.25,
                                          new OpticalProperties(0.05, 1.0, 0.8, 1.4))
            }, new ITissueRegion[]
            {
                new LayerTissueRegion(
                    new DoubleRange(double.NegativeInfinity, 0.0),
                    new OpticalProperties(0.0, 1e-10, 1.0, 1.0)),
                new LayerTissueRegion(
                    new DoubleRange(0.0, 100.0),
                    new OpticalProperties(0.01, 1.0, 0.8, 1.4)),
                new LayerTissueRegion(
                    new DoubleRange(100.0, double.PositiveInfinity),
                    new OpticalProperties(0.0, 1e-10, 1.0, 1.0))
            }
                                                  );

            var iCloned = i.Clone();

            Assert.AreEqual(iCloned.EllipsoidRegions[1].RegionOP.Mus, i.EllipsoidRegions[1].RegionOP.Mus);
            Assert.AreEqual(iCloned.Regions[1].RegionOP.Mus, i.Regions[1].RegionOP.Mus);
        }
Example #3
0
        /// <summary>
        /// Assign region values to smesh[].Region variable
        /// </summary>
        /// <param name="smesh">spatial mesh</param>
        /// <param name="np">number of nodes</param>
        /// <param name="tissueInput">tissue input</param>
        public static void AssignRegions(ref SpatialMesh[] smesh, int np, MultiEllipsoidTissueInput tissueInput)
        {
            int    i, j, k;
            double x, z;

            int nLayers     = tissueInput.LayerRegions.Length;
            int nInclusions = tissueInput.EllipsoidRegions.Length;

            for (i = 0; i <= np; i++)
            {
                for (j = 0; j < smesh[i].Np; j++)
                {
                    x = smesh[i].P[j][0];
                    z = smesh[i].P[j][1];

                    for (k = 1; k < nLayers - 1; k++)
                    {
                        if ((z >= ((LayerTissueRegion)tissueInput.LayerRegions[k]).ZRange.Start) &&
                            (z <= ((LayerTissueRegion)tissueInput.LayerRegions[k]).ZRange.Stop))
                        {
                            smesh[i].Region[j] = k - 1;
                        }
                    }

                    for (k = 0; k < nInclusions; k++)
                    {
                        double dx = ((EllipsoidTissueRegion)tissueInput.EllipsoidRegions[k]).Dx;
                        double dz = ((EllipsoidTissueRegion)tissueInput.EllipsoidRegions[k]).Dz;

                        Position center = ((EllipsoidTissueRegion)tissueInput.EllipsoidRegions[k]).Center;

                        double func = ((x - center.X) * (x - center.X) / (dx * dx)) + ((z - center.Z) * (z - center.Z) / (dz * dz));
                        if (func <= 1)
                        {
                            smesh[i].Region[j] = nLayers - 2 + k;
                        }
                    }
                }
            }
        }
Example #4
0
        /// <summary>
        /// Create an angular mesh
        /// </summary>
        /// <param name="amesh"></param>
        /// <param name="aLevel"></param>
        /// <param name="tissueInput"> </param>
        public static void CreateAnglularMesh(ref AngularMesh[] amesh, int aLevel, MultiEllipsoidTissueInput tissueInput)
        {
            int i, j, k, l;
            int nLayerRegions     = tissueInput.LayerRegions.Length;
            int nInclusionRegions = tissueInput.EllipsoidRegions.Length;
            int nRegions          = nLayerRegions + nInclusionRegions - 2;


            for (i = 0; i <= aLevel; i++)
            {
                amesh[i].Ns  = (int)Math.Pow(2.0, (double)(i + 1));
                amesh[i].Ang = new double[amesh[i].Ns][];
                amesh[i].W   = new double[amesh[i].Ns][][];
                for (j = 0; j < amesh[i].Ns; j++)
                {
                    amesh[i].Ang[j] = new double[3];
                    amesh[i].W[j]   = new double[amesh[i].Ns][];
                    for (k = 0; k < amesh[i].Ns; k++)
                    {
                        amesh[i].W[j][k] = new double[nRegions];
                    }
                }

                for (j = 0; j < amesh[i].Ns; j++)
                {
                    for (l = 0; l < nLayerRegions - 2; l++)
                    {
                        Weight_2D(amesh[i].W, amesh[i].Ang, amesh[i].Ns, tissueInput.LayerRegions[l + 1].RegionOP.G, l);
                    }

                    for (l = 0; l < nInclusionRegions; l++)
                    {
                        Weight_2D(amesh[i].W, amesh[i].Ang, amesh[i].Ns, tissueInput.EllipsoidRegions[l].RegionOP.G,
                                  l + nLayerRegions - 2);
                    }
                }
            }
        }