public void propertyChange(PropertyChangeEvent pce) { Object source = pce.getSource(); if (source == posSlider_x) { double posX = ((Double) pce.getNewValue()).doubleValue(); posDisk.x = posX; Disk.setNode3D(ShapeNodeDisk); Disk.setPosition(posDisk); PlaceBNVectors(); } else if (source == posSlider_y) { double posY = ((Double) pce.getNewValue()).doubleValue(); posDisk.y = posY; Disk.setNode3D(ShapeNodeDisk); Disk.setPosition(posDisk); PlaceBNVectors(); } else if (source == angDisk) { angleDisk = ((Double) pce.getNewValue()).doubleValue(); double angDisk_rad = angleDisk * Math.PI / 180.; double compx = Math.cos(angDisk_rad); double compy = Math.sin(angDisk_rad); Disk.setNode3D(ShapeNodeDisk); Disk.setDirection(new Vector3d(compx, compy, 0.)); flux_plot.setNormalDisk(new Vector3d(compx, compy, 0.)); PlaceBNVectors(); } else if (source == radDisk) { radiusDisk = ((Double) pce.getNewValue()).doubleValue(); ShapeNodeDisk.setGeometry(Cylinder.makeGeometry(32, radiusDisk, heightDisk)); Disk.setNode3D(ShapeNodeDisk); arrowScale = arrowScaleInitial * radiusDisk / radiusDiskInitial; flux_plot.setRadiusDisk(radiusDisk); PlaceBNVectors(); } else { super.propertyChange(pce); } }
public GaussLawMagDipoleDisk() { super(); // INITIALIZATION OF OBJECTS AND PARAMETERS // title = "Gauss's Law For A Magnetic Dipole and a Disk"; setID(title); // change some features of the lighting, background color, etc., from the default values, if // desired setBackgroundColor(new Color(180, 180, 180)); ///// Set properties on the SimEngine ///// // Bounding area represents the characteristic size (physical extent) of the simulation space. theEngine.setBoundingArea(new BoundingSphere(new Point3d(), 6)); // setDeltaTime() sets the time step of the simulation. theEngine.setDeltaTime(deltaTime); // setDamping() sets the generalized, velocity-based damping on the system. theEngine.setDamping(0.); // theEngine.setGravity(new Vector3d(0.,0.,0.)); // create the Disk using teal.render.geometry and add to the scene posDisk = new Vector3d(0., 0., 0); ShapeNodeDisk.setGeometry(Cylinder.makeGeometry(32, radiusDisk, heightDisk)); ShapeNodeDisk.setTransparency(0.5f); Disk.setNode3D(ShapeNodeDisk); Disk.setColor(new Color(170, 170, 0)); Disk.setPosition(posDisk); Disk.setDirection(new Vector3d(0., 1., 0.)); Disk.setDrawn(true); addElement(Disk); ///// Initialization of the MagneticDipole ///// // MagneticDipole constructor. mag = new MagneticDipole(); // setMu() sets the strength of the MagneticDipole. mag.setMu(1.0); // setPosition() sets the position of the MagneticDipole. mag.setPosition(new Vector3d(0., 0., 0.)); // setDirection() sets the direction (orientation) of the MagneticDipole. mag.setDirection(new Vector3d(0, -1., 0)); // setPickable() determines whether or not this object will be pickable in the Viewer with the // mouse. // Setting an object's pickable property to TRUE is a prerequisite for being able to interact // with it // using the mouse. mag.setPickable(false); // setRotable() determines whether or not this object is free to rotate. In this case, we want // the MagneticDipole // to be aligned with the y-axis. mag.setRotable(false); // setMoveable() determines whether or not this object is free to move (translate). In this // case, we want // the MagneticDipole fixed at the origin. mag.setMoveable(false); // setLength() sets the length of the MagneticDipole. For a MagneticDipole, length has no // physical // significance, and is merely a property of it's rendered model (for an LineMagneticDipole, on // the // other hand, setLength() does have physical significance). mag.setLength(0.75); // The following two properties are associated with computations required to calculate the // induced current // in a RingOfCurrent from this MagneticDipole. // mag.setAvoidSingularity(true); // mag.setAvoidSingularityScale(1.); mag.setIntegrating(false); // create the magnetic field and normal vectors on the top of the disk theFieldDiskTop = new FieldVector[numAziTopDisk][numRadDisk]; theNormalDiskTop = new GeneralVector[numAziTopDisk][numRadDisk]; for (int j = 0; j < numRadDisk; j++) { for (int i = 0; i < numAziTopDisk; i++) { theFieldDiskTop[i][j] = new FieldVector(); theFieldDiskTop[i][j].setFieldType(1); theFieldDiskTop[i][j].setPosition(new Vector3d(0, 0, 0)); theFieldDiskTop[i][j].setColor(Teal.DefaultBFieldColor); theFieldDiskTop[i][j].setArrowScale(arrowScale); theFieldDiskTop[i][j].setDrawn(true); addElement(theFieldDiskTop[i][j]); theNormalDiskTop[i][j] = new GeneralVector(); theNormalDiskTop[i][j].setPosition(new Vector3d(0, 0, 0)); theNormalDiskTop[i][j].setColor(Color.gray); theNormalDiskTop[i][j].setArrowScale(arrowScale); theNormalDiskTop[i][j].setDrawn(true); addElement(theNormalDiskTop[i][j]); } } ///// Initializing Imported Models ///// // The following block loads external models built in 3ds max and/or extra geometry not // associated with any // simulation objects. ///// if (useModels) { // Generate a Rendered object to hold the first model, load the model, and transform it // appropriately. // This will be the wooden base holding the magnet. modelBase = new Rendered(); TNode3D node = new Loader3DS().getTNode3D(URLGenerator.getResource("models/Main_Base_at_Zero.3DS")); node.setScale(metricScale); modelBase.setNode3D(node); modelBase.setPosition(new Vector3d(0., -2.45, 0.)); addElement(modelBase); // Here we load an external model and set it to be the model used by the RingOfCurrent. // This is a model of a coil of wire that replaces the generic "torus" that is used as the // model by default. // Here we create a Rendered object to hold a disk that we generate internally. // This will be the wooden disk that the magnet rests on. modelMagBase = new Rendered(); TShapeNode cylN = (TShapeNode) new ShapeNode(); cylN.setGeometry(Cylinder.makeGeometry(16, 0.3, 2.0)); modelMagBase.setNode3D(cylN); modelMagBase.setColor(new Color(160, 140, 110)); modelMagBase.setPosition(new Vector3d(0, -1.30, 0)); addElement(modelMagBase); // Here we load an external model and set it to be the model used by the MagneticDipole. // This is a model of a magnet (a silver chamfered disk) that replaces the generic disk used // by default. TNode3D node3 = new Loader3DS().getTNode3D(URLGenerator.getResource("models/Magnet_At_Zero.3DS")); node3.setScale(metricScale); mag.setNode3D(node3); mag.setModelOffsetPosition(new Vector3d(0., -0.5, 0.)); } addElement(mag); ///// END INITIALIZATION OF SIMULATION OBJECTS AND PARAMETERS ///// // INITIALIZATION OF FIELD VISUALIZATION ELEMENTS // // In this section we create and initialize field visualization elements such as fieldlines, // vector field grids, and DLIC // generators. These elements will be added to the simulation by way of the GUI, which also // creates controls for // interacting with them. // Here we create a FieldDirectionGrid, which is a vector field grid represented in the Viewer // as a grid of arrows // that point in the direction of their local field. // FieldDirectionGrid constructor. fv = new FieldDirectionGrid(); // setType() sets the type of field (electric, magnetic, etc.) that this vector field grid // should measure. fv.setType(Field.B_FIELD); // Here we add fieldlines to the simulation, which are often associated with specific simulation // objects. // First, we create a FieldLineManager, which manages groups of FieldLines. // FieldLineManager constructor. fmanager = new FieldLineManager(); // setSymmetryCount() determines the symmetry of the fieldlines. If the field in question is // symmetric about a // given axis, we can save an enormous amount of calculation time by calculating ONE FieldLine, // and then transforming // it several times around the axis of symmetry for a three dimensional representation. In this // case, we set the // default symmetry count to 40. This means that each FieldLine will be transformed and rotated // 40 times around // the axis of symmetry (the default axis of symmetry is the y-axis). fmanager.setSymmetryCount(40); fmanager.setID("fieldLineManager test name"); // setElementManager() this associates the FieldLineManager with this simulation. This is // necessary for the // FieldLineManager to be able to add it it's FieldLines to the simulation. fmanager.setElementManager(this); // Here we create two FluxFieldLines and add them to the manager. See FluxFieldLine/FieldLine // documentation for // details on how FluxFieldLines work. // Here we create several more FluxFieldLines and add them to the manager. The first one below // represents a // FieldLine with a very small arclength, so we need to make some slight adjustments to it's // default parameters. // FluxFieldLine constructor FluxFieldLine fl = new FluxFieldLine(15.0, mag, true, false); // setSArc() sets the individual step size of the FieldLine. In this case, since we know the // arclength will be small, // we want a smaller than usual step size. fl.setSArc(0.1); // setKMax() sets the maximum number of steps taken along the FieldLine. Since we have used a // step size that is // roughly one half the default, we increase the number of steps slightly to compensate, and to // make sure the line // is long enough at all times during the simulation. fl.setKMax(400); // setMinDistance() see FieldLine for details. This sets the minimum distance from it's // starting point that the // FieldLine will terminate. This is primarily used to terminate FieldLines "closed" FieldLines // that loop back // around on to themselves. fl.setMinDistance(maxDist); fmanager.addFieldLine(fl); fmanager.addFieldLine(new FluxFieldLine(25.0, mag, true, false)); fmanager.addFieldLine(new FluxFieldLine(100.0, mag, true, false)); // Here we set a few more properties of the FieldLines by way of the FieldLineManager. // setIntegrationMode() sets the integration mode used to calculate the FieldLines. Options are // currently EULER or // RUNGE_KUTTA. fmanager.setIntegrationMode(FieldLine.RUNGE_KUTTA); // setColorMode() sets method by which the FieldLines are colored. Currently there are // effectively two modes, one // which colors the FieldLine by vertex, and one that gives them a flat color at all points. // COLOR_VERTEX is the // by-vertex method, where the color at each vertex is determined by the magnitude of the field // at that point. fmanager.setColorMode(FieldLine.COLOR_VERTEX); // setColorScale() determines the rate of interpolation of colors in the COLOR_VERTEX coloring // mode. fmanager.setColorScale(0.01); // GUI SETUP & INITIALIZATION // // At this point we should add the GUI elements necessary to control our simulation. These can // be buttons, // sliders, checkboxes, etc.. Such GUI elements are first created and initialized, and then // added to Groups // that function as "sub-windows" on the GUI panel. // Here we create a ControlGroup that will contain the sliders we created to control specific // parameters of the // simulation. // ControlGroup constructor. ControlGroup controls = new ControlGroup(); // setText() sets the text label of this Group. controls.setText("Parameters"); // add() adds a created GUI element (slider, etc.) to this Group. // addElement() adds the Group to the application. addElement(controls); // Here we create a VisualizationControl Group. This Group automatically creates controls for // manipulating the // visualization elements we created above. // VisualizationControl constructor. visControl = new VisualizationControl(); // setFieldLineManager() sets the FieldLineManager associated with this Group. This is the // manger we created above. visControl.setFieldLineManager(fmanager); // setFieldVisGrid sets the FieldDirectionGrid associated with this Group. This is the grid we // created above. // visControl.setFieldVisGrid(fv); // setFieldConvolution() sets the FieldConvolution associated with this Group. This is the // convolution we created above. // visControl.setFieldConvolution(mDLIC); // setConvolutionModes() sets the types of convolutions we want to access from this generator. // In this case we // want to be able to generate magnetic field images (DLIC_FLAG_B) and magnetic potential images // (DLIC_FLAG_BP). // visControl.setConvolutionModes(DLIC.DLIC_FLAG_B | DLIC.DLIC_FLAG_BP); // addElement() adds the VisualizationControl Group to the application. addElement(visControl); // Here we create a graph based on simulation data, and add it to the GUI. This involves // creating a graph, // adding a "plot" to it (which defines the quantities being plotted), and adding it to the GUI // in it's own // Group. // Graph constructor. flux_graph = new Graph(); // setSize() sets the size of the graph, in pixels. flux_graph.setSize(150, 250); // setXRange() sets the x-axis range of the graph. flux_graph.setXRange(0., 2.); // setYRange() sets the y-axis range of the graph. flux_graph.setYRange(-3., 3.); // setWrap() determines whether the graph should wrap around to the left side once the plot // exceeds the width of // the graph. flux_graph.setWrap(true); // setClearOnWrap() determines whether the graph should clear itself before wrapping. If this // is set to false, // new data will be plotted on top of old data. flux_graph.setClearOnWrap(true); // setXLabel() sets the text label of the x-axis. flux_graph.setXLabel("Time"); // setYLabel() sets the text label of the y-axis. flux_graph.setYLabel("Flux"); // Here we create the PlotItem being drawn by this graph. This defines the properties being // plotted. In this case // we want to plot flux through disk versus time, so we use a FluxThroughDiskDueToDipolePlot // written for this purpose. // FluxThroughDiskDueToDipolePlot constructor. flux_plot = new FluxThroughDiskDueToDipolePlot(); // setRing() --The FluxThroughDiskDueToDipolePlot assumes the flux being plotted is due to the // dipole. This sets the // dipole from which to retrieve flux data. flux_plot.setMagneticDipole(mag); flux_plot.setShapeNode(ShapeNodeDisk); // setTimeAutoscale() determines whether the graph should dynamically rescale the independent // axis (time) to fit // more data. This is the alternative to enabling "wrapping". flux_plot.setRadiusDisk(radiusDisk); flux_plot.setTimeAutoscale(false); // setCurrentAutoscale() determines whether the graph should dynamically rescale the dependent // axis (current) to // fit more data. flux_plot.setFluxAutoscale(false); // addPlotItem() adds the supplied PlotItem to the graph. flux_graph.addPlotItem(flux_plot); // Here we create a new Group for the graph, and add the graph to that Group. ControlGroup graphPanel = new ControlGroup(); graphPanel.setText("Graphs"); graphPanel.addElement(flux_graph); addElement(graphPanel); // Here we set some parameters on the Viewer. // setFogEnabled() determines whether fog should be enabled in the Viewer. Setting this here, // on the Viewer, // overrides any settings on the specific objects above. theScene.setFogEnabled(true); // setFogTransformFrontScale() sets distance in FRONT of the camera target at which to start fog // interpolation. theScene.setFogTransformFrontScale(0.0); // setFogTransformBackScale() sets the distance BEHIND the camera target at which to end fog // interpolation. // Positions beyond this point are "fully fogged". theScene.setFogTransformBackScale(0.35); // addActions() adds some GUI elements as described in the addActions() method below. addActions(); // mSEC.init() initializes the Simulation Model Controls. These are the controls for the // simulation itself // (ie. play, pause, stop, rewind, etc.) mSEC.init(); // resetCamera() resets the transform of the camera to the transfrom described by the // resetCamera() method below. resetCamera(); // reset() resets simulation parameters to the values described in the reset() method below. reset(); // initFogTransform() must be called after setting the fog parameters, if they are different // than the the defaults. // mViewer.initFogTransform(); // create the two sliders for the disk position posSlider_x.setText("X Position"); posSlider_x.setMinimum(-5.); posSlider_x.setMaximum(5.0); posSlider_x.setPaintTicks(true); posSlider_x.addPropertyChangeListener("value", this); posSlider_x.setValue(0.); posSlider_x.setVisible(true); posSlider_y.setText("Y Position "); posSlider_y.setMinimum(-5.); posSlider_y.setMaximum(5.0); posSlider_y.setPaintTicks(true); posSlider_y.addPropertyChangeListener("value", this); posSlider_y.setValue(3.); posSlider_y.setVisible(true); // create the angle orientation slider for the disk, where angle is the angle from the x axis angDisk.setText("Rotation Angle"); angDisk.setMinimum(-180.); angDisk.setMaximum(180.0); angDisk.setPaintTicks(true); angDisk.addPropertyChangeListener("value", this); angDisk.setValue(90.); angDisk.setVisible(true); // create the radius slider for the disk radDisk.setText("Radius of Disk"); radDisk.setMinimum(1.); radDisk.setMaximum(6.); radDisk.setPaintTicks(true); radDisk.addPropertyChangeListener("value", this); radDisk.setValue(1.); radDisk.setVisible(true); // add the sliders to the control group and add the control group to the scene ControlGroup controls1 = new ControlGroup(); controls1.setText("Disk Position Radius & Orientation"); controls1.add(posSlider_y); controls1.add(posSlider_x); controls1.add(angDisk); controls1.add(radDisk); addElement(controls1); PlaceBNVectors(); // set initial state theEngine.requestRefresh(); mSEC.setVisible(true); reset(); resetCamera(); } // end of GaussLawMagDipoleDisk
public WireNode(double len, double rad) { // super(2); // // setGeometry(0,Cylinder.makeGeometry(24,rad,len).getIndexedGeometryArray(),0); super(); Shape3D wire = new Shape3D(); initShape(wire); wire.setGeometry(Cylinder.makeGeometry(24, rad, len).getIndexedGeometryArray()); Appearance app = Node3D.makeAppearance(new Color3f(new Color(154, 105, 0)), .8f, 0.5f, false); TransparencyAttributes ta = new TransparencyAttributes( TransparencyAttributes.NICEST, 0.5f); // app.getTransparencyAttributes(); // ta.setTransparency(0.5f); app.setTransparencyAttributes(ta); wire.setAppearance(app); mContents.addChild(wire); ////////////////////////////////////////////////////////////////////// /* txt = new Text2D("This is a Text2D!!", new Color3f(0.f,0.f,0.f),"SansSerif",70,Font.PLAIN); txt.setCapability(Shape3D.ALLOW_APPEARANCE_WRITE); txt.setCapability(Shape3D.ALLOW_APPEARANCE_READ); txt.setCapability(Shape3D.ALLOW_GEOMETRY_READ); txt.setCapability(Shape3D.ALLOW_GEOMETRY_WRITE); Appearance a = txt.getAppearance(); a.setCapability(Appearance.ALLOW_TEXTURE_READ); a.setCapability(Appearance.ALLOW_TEXTURE_WRITE); txt.setAppearance(a); TransformGroup bbtg = new TransformGroup(); bbtg.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE); Transform3D t = new Transform3D(); t.setScale(50.); bbtg.setTransform(t); bbtg.addChild(txt); Billboard bb = new Billboard(bbtg,Billboard.ROTATE_ABOUT_POINT,new Point3f(0.f,0.f,0.f)); bb.setSchedulingBounds(new BoundingSphere(new Point3d(0.,0.,0.), 100.)); bbtg.addChild(bb); mContents.addChild(bbtg); */ /////////////////////////////////////////////////////////////////////// Shape3D line = new Shape3D(); initShape(line); // line.setGeometry(sLine); Geometry stem = teal.render.j3d.geometry.Cylinder.makeGeometry(20, 0.05, 1, 0.5) .getIndexedGeometryArray(true); line.setGeometry(stem); Cone fatcone = new Cone(0.2f, 0.25f); Shape3D cone = new Shape3D(); initShape(cone); cone.setGeometry(fatcone.getShape(Cone.BODY).getGeometry()); cone.addGeometry(fatcone.getShape(Cone.CAP).getGeometry()); TransformGroup translated_cone = new TransformGroup(); Transform3D tran = new Transform3D(); // tran.set( new Vector3f(0.f,0.95f,0.f)); tran.set(new Vector3f(0.f, 1.f, 0.f)); translated_cone.addChild(cone); translated_cone.setTransform(tran); arrow.setCapability(TransformGroup.ALLOW_TRANSFORM_READ); arrow.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE); // arrow.addChild(line); // arrow.addChild(translated_cone); Appearance arrowAppearance = Node3D.makeAppearance(new Color3f(new Color(154, 105, 0)), 0.f, 0.f, false); line.setAppearance(arrowAppearance); cone.setAppearance(arrowAppearance); arrow.addChild(line); arrow.addChild(translated_cone); Transform3D tran2 = new Transform3D(); // tran2.set(new Vector3f(0.f,-0.5f,0.f)); tran2.setScale(4.); arrow.setTransform(tran2); mContents.addChild(arrow); }