Photon 4 - Manual Eng (Draft)

versin 3.
0
Manual bsico v1.0
Revisin A
Febrero 2012
Tel +54 341 5680321 (+rot)

www.estudios-electricos.com
Ir al ndice
ndice
1 BEGINNING....................................................................................................................3
2 GUI (Graphical User Interface)..........................................................................................5
3 USE...............................................................................................................................8
3.1 Insertion of a block...................................................................................................9
3.1.1 Ports...............................................................................................................12
3.2 Block connections...................................................................................................12
3.3 Multiple selecting and editing...................................................................................13
4 PROGRAMMABLE CODE...................................................................................................15
4.1 Model initialization..................................................................................................17
4.2 Running the simulation............................................................................................18
4.3 Result presentation.................................................................................................19
4.4 Useful Paths...........................................................................................................20
5 EXAMPLES....................................................................................................................22
5.1 Make a first order system using blocks.......................................................................22
5.2 Make a subsystem...................................................................................................24
5.3 Automatic Voltage Regulator....................................................................................27
6 MAKING A LIBRARY BLOCK.............................................................................................30
7 LICENCES.....................................................................................................................34
7.1 Python...................................................................................................................34
7.1.1 History of the software......................................................................................34
7.1.2 Terms and conditions for accessing or otherwise using Python...............................35
7.2 wxPython...............................................................................................................38
7.3 Numpy..................................................................................................................38
7.4 Matplotlib...............................................................................................................39
7.4.1 License...........................................................................................................39
7.4.2 License agreement for matplotlib 1.1.0...............................................................39
7.5 Photon...................................................................................................................40
Manual bsico v1.0 rev:A
Copies of this document are not allowed without prior written authorization by
ESTUDIOS ELECTRICOS SRL
2/41
Tel +54 341 5680321 (+rot)

Ir al ndice
1 BEGINNING
_______________________________________________________
Photon is a tool for the simulation of general purpose dynamic systems to analyze
phenomena in different engineering fields, such as power systems, fluid dynamics, chemical
systems, electrical and electronic circuits, etc. It is designed to address some complex issues in a
simple way and whose analytical solution is hard to find or may not exist. Any system that can be
represented mathematically by differential, algebraic, linear or nonlinear equations, can be
simulated with this tool.
Photon is a simple, fast and effective way to build and simulate tailor-made dynamic
systems using block diagrams.
It presents the distinctive feature of using the powerful simulation engine FreeSim 3.0
developed by Estudios Elctricos. This calculation core is highly optimized with the goal of
maximizing the speed for the calculation process. FreeSim uses different methods and algorithms
to run a simulation in different threads and thus optimizes the use of the computing power
available on multicore PCs.
Photon can build block diagrams, as one would do with a pencil on a sheet of paper, from a
library of build-in blocks that perform almost all necessary operations. If a particular operation
was needed, it is feasible to create it by combining simple blocks from the library. If that was not
enough, the user could create a block in which their behavior is defined programmatically (using
programming language Python 2.x). This allows total flexibility when designing a block diagram.
The library has a dozens of blocks that are classified by categories:
Sources
Lineal
Non-Lineal
Input/Output
Filtering
Complex
Integer
Power System
3/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Within each of these categories there is a battery block that can be used in any diagram.
Photon uses internally the programming language Python 2.x to perform the simulation, and
writing portions of code by the user. For more information related to programming language
issues refer to www.python.org.
Photon can be installed on any PC where Python 2.x works. Some additional packages are
needed such as wxPython, numpy, matplotlib, etc. As a result, this software is multi-platform. It
has been successfully tested on various versions of Windows, Linux and Mac OS X.
4/41
Tel +54 341 5680321 (+rot)

Ir al ndice
2 GUI (Graphical User Interface)

_______________________________________________________
The interface is highly user-friendly and allows to generate a simple block diagram through
a few clicks.
When developing the software, special attention has been paid to the esthetics of the
diagrams. To this end, rounded shapes, shadows, colors and Bezier curves, which are widely used
by major vector drawing softwares, have been used. All these things combined lead to highdefinition and very pleasant graphics.
The main window has a minimalist design and consists of five areas:
1. Men
2. List of systems and subsystems
3. Canvas
4. Output window
5. Tool bar
Most actions can be performed directly on the canvas with the mouse pointer and using the
context menu. These actions are related to some combination of keys. Once familiarized with
them, the user can perform tasks faster.
5/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Figure 2.1 - User interface
The list in a tree form on the left side allows to navigate the system. The view of the sheet
corresponds to the selected item in the browser.
The output window shows the different kind of messages that arise during the use of the
software.
All blocks that may be required to generate the needed functionality can be added to the
canvas by simply using the context menu. Blocks "talk" to each other through connections linking
an output port (red) with an input port (green).
6/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Figure 2.2 - User interface
7/41
Tel +54 341 5680321 (+rot)

Ir al ndice
3 USE
_______________________________________________________
When Photon is started, it has an empty page to start editing.

Most actions can be performed directly on the canvas with the mouse pointer. The context
menu on the worksheet contains almost all the operations you can perform.
Figure 3.1 - Context menu
The manipulation of the sheet is extremely simple. With the mouse wheel the user can
make zoom over the location at which the mouse pointer. The zoom effect is also achieved
through the key Ctrl and + / - but in this case the focus corresponds to the center of the visible
area of the sheet.
8/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Holding down the Shift key the mouse pointer changes to the classic "hand" with which is
possible to drag the sheet to desired position.
The creation of an executable system requires a few simple steps.
1. Inserting necessary blocks of the model.
2. Connecting blocks.
3. Model initialization.
4. Running simulation.
5. Viewing results.
3.1 Insertion of a block

The insertion of blocks is done via the context menu. Pressing right mouse button over the
empty place where is wanted to add a block, context menu will be displayed. The first menu item
is new block and there is the library of build-in blocks.
Here are the steps to create a Gain block. The main system is called MainSystem by default,
as indicated by the primary node of the list of blocks. All System is a container for other
elements, including other System. Within each project, there is one main system and is the one
containing the code execution. The other systems that may have are subsystems of main.
All blocks to be added will be children of MainSystem.
9/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Figure 3.3 - Insertiont of Gain block
Figure 3.2 - Insertion of Gain block
After inserting a block can be moved or resized. These actions are performed by dragging
the handles that appear at the corners of the block when it is selected.
Pressing the Ctrl key after starting the drag will appear two lines, one horizontal and one
vertical, that intersect at the original site where it was the handle and they are useful as a guide
to a movement in one direction. This feature is extensible to any handle either a block or line.
All blocks have parameters that characterize them. They are displayed when is selected the
Edit block... from context menu of the block (or double-clicking on the block).
In the case of a subsystem, the behavior before the event "double click" on it is different:
if the subsystem has not defined a mask -> "double click" enters the subsystem
if the subsystem has defined a mask -> "double click" open edit mask dialog
if the subsystem has defined a mask -> "Ctrl+doble click" enters the subsystem
The edit block window has four tabs:
10/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Figure 3.4 - Mask
Figure 3.5 - General
Figure 3.6 - Description
Figure 3.7 - Graphics
Within the Mask tab are displayed all editable parameters that are specific of the type of
block being edited.
Within the General tab are displayed the ID of the block (not editable) and the name of the
block. The name must be unique among all blocks belonging to a system. Attempting to use a
name already used, the software automatically adds a number as a suffix.
Within the Description tab is displayed the particular help of each block, indicating what is
the function.
Within the Graphics tab are displayed block parameters related to graphics issues. Both the
position and size of the block are given in pixels.
There are two controls of type "drop-down lists" that allow you to define whether the name
of the block is shown or not and whether the parameter list is shown or not on the sheet.
11/41
Tel +54 341 5680321 (+rot)

Ir al ndice
3.1.1 Ports
Ports define the interface of the block (along with its mask). They are define the input and
output signals of blocks.
Input ports are drawn as green circle. The output ports are red circles.
Every port has a unique number for the type that is (input or output type). For example, a
block can not have two input ports numbered with "0", but yes a port "0" as input and a "0" as
output.
Most of library blocks have their ports already defined and therefore can not be modified the
number or type.
Some blocks need to define certain characteristics of their ports. For example a Sum could
have some input ports suming and others subtracting, or more inputs than it has by default.
To add a port, if the block allows, it is used the contextual menu option in the block.
To edit a port is used the context menu on it or double click.
Figure 3.8 - context menu on a port
Figure 3.9 - Edit window of a port
Using the Edit window can be selected the type of port I / O, number, symbol, the side
where it will reside and a name and a description if necessary.
The data type is defined by the block type to which the port belongs.
In the case of subsystems, the type is selectable via a dropdown list.
3.2 Block connections
To create a line, simply by dragging with the mouse from an output port (red) to a free
input (green). When you release the mouse button on a free input port, automatically draws
Bezier type line. Several lines may start in an output port, but only one line can ends to a
input port.
12/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Figure 3.10 - arrastrando para conectar
Figure 3.11 - conexin creada
Handles can be selected and moved to change the look of the line. New handles can be
added by double-click on the line to generate different curvatures. As a recommendation, take a
few seconds "decorating" the block diagram and see how attractive it results.
3.3 Multiple selecting and editing

There are situations where it is useful change any feature or particular parameter of several
blocks. For those cases, it can use the dialog box multiple selection in which is shown in a grid
all selected blocks. In this grid appear as columns, all properties that are shared by all selected
objects. It is important to note that the properties "id", "name", "hide", "showname",
"showParams", "x", "y", "w" and "h" are common to all blocks and therefore always appear in the
grid. The remaining columns added on the right will depend on what kind of blocks are selected.
Figure 3.12 three blocks selected have in their mask a parameter called "K" and therefore
the column K appears.
On this grid it can be performed actions to change as much as copy and paste.
The selection of blocks can be performed manually with the mouse (holding down the Ctrl
key) or by using Select by classes... from context menu.
13/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Figure 3.12 - Multiple selection
14/41
Tel +54 341 5680321 (+rot)

Ir al ndice
4 PROGRAMMABLE CODE
_______________________________________________________
To achieve a simulation, the software builds intermediately and transparent for the user a
script written in pure Python 2.x.
In this script there are parts which are customizable by the user. These customizable pieces
of code are identified as:
Execution code,
Post script,
Initial conditions,
module import,
Initial code,
class functions.
At this point it is needed to have basic knowledge of programming in Python (see

doc.python.org)
Figure 4.1 - Edit python code window
15/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Each of these six items mentioned above are represented by a tab in the window "Edit
Python Code" and the portion of code that is written there will be transcribed to the appropriate
place in the script generated by the software at the time of execution.
Below is shown the script template and places on it where every piece of code written by the
user will be transcribed. It is important to note that each of these parts have different scopes for
its variables.
Esqueleto de script
...
...
# Importacin de mdulos
class MainSystem(freesim.System):
def __init__(self, ....):
# Codigo inicial
(creacin de los objetos)
...
def calcInit(self):
# Condiciones iniciales
...
# Funciones de clase del usuario
def runScript(self, old=None, WorkSpace={}):

# Codigo de ejecucion
...
...
...
def postScript(self, old=None, WorkSpace={}):
# Post script
...
16/41
Tel +54 341 5680321 (+rot)

The code in class functions tab must be defined with the following structure:
Ir al ndice
def NombreDeFuncion1(self,...):
...
def NombreDeFuncion2(self,...):
...
def NombreDeFuncionN(self,...):
...
There is no limitation on the quantity of functions that can be created, depending on the
needs of problem to solve.
4.1 Model initialization

The initialization process requires the calculation of the values of state variables for the
model starts in balance.
It implies that given the boundary conditions of the system to be simulated, it will have a
steady state condition in which it could remain indefinitely. Under these conditions, the system
state variables take certain values that are needed to calculate at this stage of initialization.
The initial conditions of the blocks are in their masks as another parameter to be loaded.
For example in a block mask variable appears x0 that represents the initial condition of the
state variable of the integrator.
Figure 4.2 - Mask of Int
17/41
Tel +54 341 5680321 (+rot)

Ir al ndice
The most rudimentary form of initialization would be to write the value in the text box on
the mask.
In case It is needed to make some extra calculation can be performed in the Initial
Conditions tab in the edit window python code.
Within the Initial Conditions tab you can write code in Python 2.x. This portion of code is
part of the body of a class function called calcInit that receives a system reference called self.
Internally, the software builds a function as follows:
def calcInit(self):
(cdigo escrito por el usuario en la seccin Condiciones iniciales)
There is no methodical way to calculate initial conditions. The user must inspect the block
diagram and from there decide the methodology to apply in each case.
Typically, blocks with integrators require calculate their initial conditions.
For example, if the MainSystem has an integrator called Int, the initial condition it would be
forced to a value with the following line of code.
self.Int.x0 = (valor calculado)

self is a reference to the system.
Int is the name of the integrator block.
x0 is the parameter to be modified.
In general, any parameter of the mask can be modified in this way, in this particular case is
used to modify a parameter representing an initial condition.
Within the user-written code can incorporate any kind of expression supported by an
interpreter of Python 2.x. This allows complete flexibility because it has all the tools that has the
programming language, for example a file can be opened and some data can be read to initialize
the system in a certain condition or anything else that the user needs.
4.2 Running the simulation

Within the Execution code tab is possible to write code in Python 2.x. This portion of code
is part of the body of a class function called runScript that receives a system reference called
self and two arguments called old and WorkSpace.
Internally, the software builds a function as follows:
18/41
Tel +54 341 5680321 (+rot)

Ir al ndice
def runScript(self, old=None, WorkSpace={}):

(cdigo escrito por el usuario en la seccin Cdigo de ejecucin)
When you select the Run Script (F5) option the software processes the system developed,
built a script written in Python 2.x, and executes it. To execute an object created in memory of
the class host and executes it by calling the function runScript instance and then to PostScript
function. Since there are sequentially executed lines of code written by the user.
The argument old is a dictionary containing the previous simulation results. During the first
run is None as yet there is no previous simulation.
The argument WorkSpace is a dictionary whose contents persist between different
simulations made by the user. This feature can be used as a workspace where the user can store
useful things.
A typical structure of runScript could be as follows.
self.initSim(runstep=0.001)
self.run(10.0)
The above code initializes the simulation, define the integration step in 0.001 seconds and
simulate 10.0 seconds.
4.3 Result presentation

The result presentation is part of the tasks to be performed after simulation. For this reason
all code related to the post-processing of the simulation must be located in the PostScript tab.
For the presentation of the results is necessary to put Scope blocks connected to the signals
to be registered. The name of a Scope is used to call the recorded signal results in a dictionary.
The way to get results is to "ask" the system the dictionary of simulation. This is done by
getSimuDict() function. The keys of the dictionary are the names of all Scopes in the system.
Additionally there is 't' key corresponding to simulation time.
This dictionary is actually a Mdict class object which behaves exactly like a native Python
dictionary with the difference that it can be get some of their keys like an attribute. This means
that the call d['t'] and d.t are similar, to avoid putting lots of quotes and brackets.
An additional way to view results is through DummyIn blocks and DummyOut blocks. These
blocks displayed on the screen the value of the input or output to which are connected
respectively after simulation ends.
19/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Within the namespace where the PostScript function is executed are defined the following
aliases:
plt for matplotlib.pyplot
np for numpy
matplotlib.pyplot is a module that provides functions to generate high quality graphics.

The syntax of the plot function contained inside plt module is very simple, it must be passed as a
parameter the x-axis array, the y-axis array, optionally adds color and line type. For more
information about matplotlib module refer to website http://matplotlib.sourceforge.net/
numpy is a module that contains all kinds of mathematical functions that are commonly
used. For more information http://numpy.scipy.org/ .
For example if there is a Scope block called 'out' could be generated a figure in the following
manner:
d = self.getSimuDict()
plt.plot(d.t, d.out,'b')
plt.grid()
plt.show()
The last line of code is required to show the figure in a window.
Post Script section can be run independently of the simulation as many times as desired, if
at least once has been run whole simulation. This allows make changes to present the results
without need of re-simulate. Is important to note that changes in block parameters, connections,
etc. cause need of re-simulate to make valid the observed results.
4.4 Useful Paths
There is a configuration file called "config.txt" which contains some important paths in XML
format and is located in the same folder as the application.
If Photon is run and this file is not found, it will be automatically created with some default
values. Then the user could edit the file with any text editor and change it.
The path section might look as follows:
<PATHS>
<PATH key="$APPPATH$" value="C:\Python27\Lib\site-packages\Photon"/>
<PATH key="$LIBPATH$" value="C:\Python27\Lib\site-packages\Photon\Libreria"/>
<PATH key="$UTILSPATH$" value="C:\Python27\Lib\site-packages\Photon\utils"/>
20/41
Tel +54 341 5680321 (+rot)

Ir al ndice
</PATHS>
The keys $LIBPATH$, $APPPATH$ y $UTILSPATH$ could be used to create paths relative to
them.
For example if it is wanted to open a file called ejemplo.ph3, inside a subsystem block,
that is located in the folder defined as Libreria, it could be use for the property file on the
General tab of the subsystem:
C:\Python27\Lib\site-packages\Photon\Libreria\ejemplo.ph3
or
$LIBPATH$\ejemplo.ph3
Likewise other defined paths in config.txt could be used.

The key $UTILSPATHS also has the peculiarity that is automatically imported during the
execution of the script, so it could generate a custom function module located within that folder,
for example misFunciones.py, and used then simply adding the following line in section module
import
import misFunciones
21/41
Tel +54 341 5680321 (+rot)

Ir al ndice
5 EXAMPLES
_______________________________________________________
5.1 Make a first order system using blocks.
Figure 5.1 - block diagram
The initial condition of the integrator called Int is defined equal to zero. This value can be
directly loaded in the block mask.
The execution code could be as follows:
self.initSim(0.001)
self.run(10.0)
The post-script code could be as follows:
d = self.getSimuDict()
plt.plot(d.t, d.inp,'g', d.t, d.output,'b')
plt.grid()
plt.xlabel('t [seg]')
22/41
Tel +54 341 5680321 (+rot)

Ir al ndice
plt.ylabel('input and output')

plt.show()
Figure 5.2 - Results
To automate the calculation of the initial condition of the integrator, following line could be
added in the initial conditions section.
self.Int.x0 = self.Step.value1
In this way the initial condition of Int always be the initial value of Step.
23/41
Tel +54 341 5680321 (+rot)

Ir al ndice
5.2 Make a subsystem.
Figure 5.4 - content of subsystem

Figure 5.3 - MainSystem
In the figure 5.4 is shown the content of subsystem. The green block represents an input
and red one is an output.
When a block type System is added to MainSystem, it does not have any ports. They should
be added using the context menu.
Figure 5.5 - Add ports
Each System contains a sheet in which new blocks can add.

It is important to differentiate the interface of a subsystem of the contents. The interface
contains the information of how the block is linked with the rest of the blocks, ie, the ports.
The link with the outside is done by port number. This means that the Sum in Figure 5.4
will take the value of the output of Step of Figure 5.3 and the Int output of Figure 5.4 will be
24/41
Tel +54 341 5680321 (+rot)

Ir al ndice
recorded by the Scope of Figure 5.3 called output. Graphically, one might think that linking occurs
as follows:
Figure 5.6 - links
The Spy out option in context menu automatically builds the external interface of
subsystem from its content. This means that for every Input block and Output block inside the
subsystem will be created a corresponding external port.
Obviously the result of the simulation is exactly the same as in the example of point 5.1 .
Script tabs would be as follows.
Figure 5.7 - script
25/41
Tel +54 341 5680321 (+rot)

Ir al ndice
The concept of subsystems allows to create libraries. All subsystems that share the interface
(or part of it depending on the case) may be interchangeable.
26/41
Tel +54 341 5680321 (+rot)

Ir al ndice
5.3 Automatic Voltage Regulator

This example shows the development of an automatic voltage regulator whose connection
interface and mask is as follows.
Figure 5.8 - Ports

Figure 5.9 - Mask
It begins with the design of the block diagram on a blank sheet inside of a subsystem. After
adding necessary blocks should looks like Figure 5.10.
Figure 5.10 - block diagram
To construct the mask of Figure 5.9 the Edit Mask window should look like this:
27/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Figure 5.11 - Edit mask
The text box "Description" contains the text that will appears as help on Description tab
when editing the model.
The next step is to define how initial conditions are calculated
Figure 5.12 - initial conditions AC4A model
In this case it is considered that the output "0" (Efd) and the entries "0" (Ug), "2" (Ifd) and
"3" (Vuel) are fixed values from the outside and they are considered as boundary conditions of
28/41
Tel +54 341 5680321 (+rot)

Ir al ndice
the block. From these are calculated the appropriate values for the system state variables and the
input value "1" (Vref).
After that it is necessary to make ports visible from outside of block. One way to do that is
manually one by one, or using the "Spy out" option.
Figure 5.13 - Spy out option
Finally AC4A block is ready to be connected to other blocks.

To calculate the initial conditions of MainSystem where AC4A block is used, It will be need
to put in appropriate order the following line of code:
self.AC4A.calcInit()
The appropriate order is which ensure that the values of the output "0" (Efd) and the inputs
"0" (Ug), "2" (Ifd) and "3" (Vuel) have been calculated previously.
29/41
Tel +54 341 5680321 (+rot)

Ir al ndice
6 MAKING A LIBRARY BLOCK

_______________________________________________________
Library blocks are useful to reuse models already made and saved into a file. A library block
could be any System which has defined a mask and an automated way to calculate the initial
conditions of all the internal states, and those of the required inputs and outputs.
It is possible to reuse existing block diagrams by including a System block which get its
contents from a previously saved file.
To create a subsystem that works as a library block, it should works correctly regardless of
where it is located. For that, it is necessary make the mask and calculate correctly the initial
conditions in terms of boundary conditions.
Steps:
1. Make the subsystem: as example is used the subsistem shown in figure 5.3.
2. Make the mask: it is considered that time constant is configurable.
Figure 6.1 - Context menu
Figure 6.2 - Edit mask window
Add an item with the '+' button and edit it to make it as shown in following figure
30/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Figure 6.3 - Add an item to the mask
3. Now, variable "T" can be used inside the subsystem and take the value that is
entered in the mask. Then modify Cond block and replace the value 0.5 with the
variable name "T".
Figure 6.5 - Cambio de 0.5 por T
Figure 6.4 - Mscara externa
Masks variables are passed as arguments to the constructor of the object at run
time. If the value of "T" is needed at runtime, for example in the initialization code,
31/41
Tel +54 341 5680321 (+rot)

Ir al ndice
one should use the following expression: self.Cond.gain. This is because the value
"0.5" assigned to "T" is redirected to the parameter "gain" of "Cond" block.
4. The next step is to initialize the subsystem. Assume that the input is fixed by the
host and then it is a known value. It could have happened that the output value is
known, but that case was not referred to in this example.
Figure 6.6 - Initial condition of subsystem
It is important to note that the line of code forces the initial condition of the
integrator to take the value of the input 0 of the subsystem.
There are some useful functions:
- self.GetInput(n port) : gets the value of the given input port
- self.GetOutput(n port) : gets the value of the given output port
- self.SetInput(n port, value) : sets the value of the given input port
- self.SetOutput(n port, value) : sets the value of the given output port
5. From MainSystem (who is the father of subsystem) is necessary to call calcInit()
function of subsystem after ensuring that the value of its input is fixed.
self.subsystem.SetInput(0, self.Step.value1)
self.subsystem.calcInit()
The first line set the correct value of the input subsystem. The second line asks for
calculate the initial conditions of the subsystem shown in figure 6.6.
32/41
Tel +54 341 5680321 (+rot)

Ir al ndice
6. To create a library block from this subsystem must save the system from the context
menu.
Figure 6.7 - Save subsystem
Assuming that the file was saved with the name sub_PT1.ph3, this file becomes in
a library block because it can be used anywhere, simply adding a subsystem block
and indicating that the content comes from sub_PT1.ph3 file.
The content of any subsystem that is linked to a file is read only and the only
way to be modified is by opening itself as main system.
7. From this moment "file" property of the subsystem and its content is linked to the
selected file. Empty file property to unlink.
33/41
Tel +54 341 5680321 (+rot)

Ir al ndice
7 LICENCES
_______________________________________________________
7.1 Python
7.1.1 History of the software

Python was created in the early 1990s by Guido van Rossum at Stichting Mathematisch Centrum (CWI,
see http://www.cwi.nl/) in the Netherlands as a successor of a language called ABC. Guido remains Pythons
principal author, although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for National Research Initiatives (CNRI,
seehttp://www.cnri.reston.va.us/) in Reston, Virginia where he released several versions of the software.
In May 2000, Guido and the Python core development team moved to BeOpen.com to form the BeOpen
PythonLabs team. In October of the same year, the PythonLabs team moved to Digital Creations (now Zope
Corporation;
see http://www.zope.com/).
In
2001,
the
Python
Software
Foundation
(PSF,
see http://www.python.org/psf/) was formed, a non-profit organization created specifically to own Python-related
Intellectual Property. Zope Corporation is a sponsoring member of the PSF.
All Python releases are Open Source (see http://www.opensource.org/ for the Open Source Definition).
Historically, most, but not all, Python releases have also been GPL-compatible; the table below summarizes the
various releases.
Release
Derived from
Year
Owner
GPL compatible?
0.9.0 thru 1.2
n/a
1991-1995
CWI
yes
1.3 thru 1.5.2
1.2
1995-1999
CNRI
yes
1.6
1.5.2
2000
CNRI
no
2.0
1.6
2000
BeOpen.com no
1.6.1
1.6
2001
CNRI
no
2.1
2.0+1.6.1
2001
PSF
no
2.0.1
2.0+1.6.1
2001
PSF
yes
2.1.1
2.1+2.0.1
2001
PSF
yes
2.2
2.1.1
2001
PSF
yes
2.1.2
2.1.1
2002
PSF
yes
2.1.3
2.1.2
2002
PSF
yes
2.2.1
2.2
2002
PSF
yes
2.2.2
2.2.1
2002
PSF
yes
2.2.3
2.2.2
2002-2003
PSF
yes
2.3
2.2.2
2002-2003
PSF
yes
2.3.1
2.3
2002-2003
PSF
yes
2.3.2
2.3.1
2003
PSF
yes
2.3.3
2.3.2
2003
PSF
yes
2.3.4
2.3.3
2004
PSF
yes
34/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Release
Derived from
Year
Owner
GPL compatible?
2.3.5
2.3.4
2005
PSF
yes
2.4
2.3
2004
PSF
yes
2.4.1
2.4
2005
PSF
yes
2.4.2
2.4.1
2005
PSF
yes
2.4.3
2.4.2
2006
PSF
yes
2.4.4
2.4.3
2006
PSF
yes
2.5
2.4
2006
PSF
yes
2.5.1
2.5
2007
PSF
yes
2.5.2
2.5.1
2008
PSF
yes
2.5.3
2.5.2
2008
PSF
yes
2.6
2.5
2008
PSF
yes
2.6.1
2.6
2008
PSF
yes
2.6.2
2.6.1
2009
PSF
yes
2.6.3
2.6.2
2009
PSF
yes
2.6.4
2.6.3
2010
PSF
yes
2.7
2.6
2010
PSF
yes
Note
GPL-compatible doesnt mean that were distributing Python under the GPL. All Python licenses, unlike the GPL,
let you distribute a modified version without making your changes open source. The GPL-compatible licenses
make it possible to combine Python with other software that is released under the GPL; the others dont.
Thanks to the many outside volunteers who have worked under Guidos direction to make these releases
possible.
7.1.2 Terms and conditions for accessing or otherwise using Python
PSF LICENSE AGREEMENT FOR PYTHON 2.7.2
1. This LICENSE AGREEMENT is between the Python Software Foundation (PSF), and the Individual or
Organization (Licensee) accessing and otherwise using Python 2.7.2 software in source or binary form
and its associated documentation.
2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a
nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display
publicly, prepare derivative works, distribute, and otherwise use Python 2.7.2 alone or in any derivative
version, provided, however, that PSFs License Agreement and PSFs notice of copyright, i.e., Copyright
2001-2010 Python Software Foundation; All Rights Reserved are retained in Python 2.7.2 alone or in
any derivative version prepared by Licensee.
3. In the event Licensee prepares a derivative work that is based on or incorporates Python 2.7.2 or any
part thereof, and wants to make the derivative work available to others as provided herein, then
Licensee hereby agrees to include in any such work a brief summary of the changes made to Python
2.7.2.
4. PSF is making Python 2.7.2 available to Licensee on an AS IS basis. PSF MAKES NO
REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT
LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF
35/41
Tel +54 341 5680321 (+rot)

Ir al ndice
5.
6.
7.
8.
MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF

PYTHON 2.7.2 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.7.2 FOR ANY
INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING,
DISTRIBUTING, OR OTHERWISE USING PYTHON 2.7.2, OR ANY DERIVATIVE THEREOF, EVEN IF
ADVISED OF THE POSSIBILITY THEREOF.
This License Agreement will automatically terminate upon a material breach of its terms and conditions.
Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or
joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF
trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee,
or any third party.
By copying, installing or otherwise using Python 2.7.2, Licensee agrees to be bound by the terms and
conditions of this License Agreement.
BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
1. This LICENSE AGREEMENT is between BeOpen.com (BeOpen), having an office at 160 Saratoga
Avenue, Santa Clara, CA 95051, and the Individual or Organization (Licensee) accessing and
otherwise using this software in source or binary form and its associated documentation (the Software).
2. Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants
Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or
display publicly, prepare derivative works, distribute, and otherwise use the Software alone or in any
derivative version, provided, however, that the BeOpen Python License is retained in the Software, alone
or in any derivative version prepared by Licensee.
3. BeOpen is making the Software available to Licensee on an AS IS basis. BEOPEN MAKES NO
LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF
MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE
SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING,
MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF
5. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of
California, excluding conflict of law provisions. Nothing in this License Agreement shall be deemed to
create any relationship of agency, partnership, or joint venture between BeOpen and Licensee. This
License Agreement does not grant permission to use BeOpen trademarks or trade names in a
trademark sense to endorse or promote products or services of Licensee, or any third party. As an
exception, the BeOpen Python logos available at http://www.pythonlabs.com/logos.html may be used
according to the permissions granted on that web page.
36/41
Tel +54 341 5680321 (+rot)

Ir al ndice
7. By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and
CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an
office at 1895 Preston White Drive, Reston, VA 20191 (CNRI), and the Individual or Organization
(Licensee) accessing and otherwise using Python 1.6.1 software in source or binary form and its
associated documentation.
2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a
nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display
publicly, prepare derivative works, distribute, and otherwise use Python 1.6.1 alone or in any derivative
version, provided, however, that CNRIs License Agreement and CNRIs notice of copyright, i.e.,
Copyright 1995-2001 Corporation for National Research Initiatives; All Rights Reserved are retained
in Python 1.6.1 alone or in any derivative version prepared by Licensee. Alternately, in lieu of CNRIs
License Agreement, Licensee may substitute the following text (omitting the quotes): Python 1.6.1 is
made available subject to the terms and conditions in CNRIs License Agreement. This Agreement
together with Python 1.6.1 may be located on the Internet using the following unique, persistent identifier
(known as a handle): 1895.22/1013. This Agreement may also be obtained from a proxy server on the
Internet using the following URL: http://hdl.handle.net/1895.22/1013.
3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6.1 or any
part thereof, and wants to make the derivative work available to others as provided herein, then
Licensee hereby agrees to include in any such work a brief summary of the changes made to Python
1.6.1.
4. CNRI is making Python 1.6.1 available to Licensee on an AS IS basis. CNRI MAKES NO
LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF
MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY
INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING,
DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE THEREOF, EVEN IF
7. This License Agreement shall be governed by the federal intellectual property law of the United States,
including without limitation the federal copyright law, and, to the extent such U.S. federal law does not
apply, by the law of the Commonwealth of Virginia, excluding Virginias conflict of law provisions.
Notwithstanding the foregoing, with regard to derivative works based on Python 1.6.1 that incorporate
non-separable material that was previously distributed under the GNU General Public License (GPL), the
law of the Commonwealth of Virginia shall govern this License Agreement only as to issues arising
under or with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this License
Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between
CNRI and Licensee. This License Agreement does not grant permission to use CNRI trademarks or
37/41
Tel +54 341 5680321 (+rot)

Ir al ndice
trade name in a trademark sense to endorse or promote products or services of Licensee, or any third
party.
8. By clicking on the ACCEPT button where indicated, or by copying, installing or otherwise using Python
1.6.1, Licensee agrees to be bound by the terms and conditions of this License Agreement.
ACCEPT
CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
Copyright 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands. All rights reserved.
Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without
fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting documentation, and that the name of Stichting
Mathematisch Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software
without specific, written prior permission.
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE
7.2 wxPython
7.3 Numpy
Copyright (c) 2005, NumPy Developers
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the NumPy Developers nor the names of any contributors may be used to endorse
or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
38/41
Tel +54 341 5680321 (+rot)

Ir al ndice
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
7.4 Matplotlib
7.4.1 License
Matplotlib only uses BSD compatible code, and its license is based on the PSF license. See the Open
Source Initiative licenses page for details on individual licenses. Non-BSD compatible licenses (eg LGPL) are
acceptable in matplotlib Toolkits. For a discussion of the motivations behind the licencing choice, see Licenses.
7.4.2 License agreement for matplotlib 1.1.0
1. This LICENSE AGREEMENT is between John D. Hunter (JDH), and the Individual or Organization
(Licensee) accessing and otherwise using matplotlib software in source or binary form and its associated
documentation.
2. Subject to the terms and conditions of this License Agreement, JDH hereby grants Licensee a
nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly,
prepare derivative works, distribute, and otherwise use matplotlib 1.1.0 alone or in any derivative version,
provided, however, that JDHs License Agreement and JDHs notice of copyright, i.e., Copyright (c) 2002-2009
John D. Hunter; All Rights Reserved are retained in matplotlib 1.1.0 alone or in any derivative version prepared
by Licensee.
3. In the event Licensee prepares a derivative work that is based on or incorporates matplotlib 1.1.0 or any
part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby
agrees to include in any such work a brief summary of the changes made to matplotlib 1.1.0.
4. JDH is making matplotlib 1.1.0 available to Licensee on an AS IS basis. JDH MAKES NO
LIMITATION, JDH MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF
MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
1.1.0 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
5. JDH SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB 1.1.0 FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING,
DISTRIBUTING, OR OTHERWISE USING MATPLOTLIB 1.1.0, OR ANY DERIVATIVE THEREOF, EVEN IF
39/41
Tel +54 341 5680321 (+rot)

Ir al ndice
7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or
joint venture between JDH and Licensee. This License Agreement does not grant permission to use JDH
trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any
third party.
8. By copying, installing or otherwise using matplotlib 1.1.0, Licensee agrees to be bound by the terms and
7.5 Photon
El programa se distribuye bajo licencia de Estudios Elctricos S.R.L. de Argentina (EE). No est permitido
revender el programa ni redistribuirlo sin el previo consentimiento de EE. El cdigo fuente del programa, los
algoritmos de clculo, etc, estn protegidos por las leyes de propiedad intelectual, si bien el programa est
desarrollado con herramientas de libre distribucin no est permitido el uso de ningn mtodo de ingeniera
inversa para obtener dicho cdigo fuente.
40/41
Tel +54 341 5680321 (+rot)

Ir al ndice
Esta pgina ha sido intencionalmente dejada en blanco
41/41

Photon 4 - Manual Eng (Draft)

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Photon 4 - Manual Eng (Draft)

Hochgeladen von

Copyright:

Verfügbare Formate

versin 3.

Tel +54 341 5680321 (+rot)

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

Tel +54 341 5680321 (+rot)

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

2 GUI (Graphical User Interface)

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

Figure 2.1 - User interface

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

Figure 2.2 - User interface

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

When Photon is started, it has an empty page to start editing.

Figure 3.1 - Context menu

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

3.1 Insertion of a block

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

Figure 3.3 - Insertiont of Gain block

Figure 3.2 - Insertion of Gain block

The edit block window has four tabs:

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

Figure 3.4 - Mask

Figure 3.5 - General

Figure 3.6 - Description

Figure 3.7 - Graphics

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

Figure 3.8 - context menu on a port

Figure 3.9 - Edit window of a port

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

Figure 3.10 - arrastrando para conectar

Figure 3.11 - conexin creada

3.3 Multiple selecting and editing

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

Figure 3.12 - Multiple selection

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

At this point it is needed to have basic knowledge of programming in Python (see

Figure 4.1 - Edit python code window

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

def runScript(self, old=None, WorkSpace={}):

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

4.1 Model initialization

Figure 4.2 - Mask of Int

Manual bsico v1.0 rev:A

Tel +54 341 5680321 (+rot)

self.Int.x0 = (valor calculado)

4.2 Running the simulation

Tel +54 341 5680321 (+rot)

def runScript(self, old=None, WorkSpace={}):

4.3 Result presentation

Manual bsico v1.0 rev:A