APLICACIÓN JAVA
3
CAPÍTULO 2. APLICACIÓN JAVA
El objetivo de este proyecto es el diseño de una aplicación java que pueda servir como herramienta para la estimación del número de colectores solares planos para producción de ACS. Siguiendo el método de cálculo de CENSOLAR [1], calcula el número de colectores teórico para cubrir la demanda energética anual en función de la radiación solar anual por m2, calculada para una inclinación dada y en la provincia seleccionada. Con este resultado, el usuario decide el número de colectores que quiere instalar y, en función de la superficie resultante, el programa calcula la aportación solar anual y el déficit energético anual. Por otro lado, para los mismos datos de consumo de ACS, el programa aplica el método F-chart y calcula la cobertura solar anual con el mismo número de colectores decidido tras los resultados del método anterior.
El programa permite cambiar el valor de las variables que intervienen en los dos métodos y ver
de forma gráfica como influyen en el resultado. Hay variables que solo se emplean en uno de los dos métodos, por eso, no se trata de comparar el resultado de los dos métodos de cálculo sino de tener dos referencias a la hora de estimar la aportación solar de una instalación para la producción de ACS, mediante colector solar plano, para unas condiciones de consumo y localización dadas.
Para este proyecto hemos creado una aplicación JavaSE desarrollada con los programas
NetBeans IDE 7.2.1, iReport-5.1.0 para los informes de resultados, y conexión con base de datos Access para almacenar resultados y realizar los informes. Para las gráficas de los informes utiliza librerías de JFreeChart .
El presente capítulo se compone de las siguientes partes:
2.1. Memoria descriptiva 2.1.1. Programación 2.1.2. Diagramas de flujo 2.1.3. Acceso a la base de datos desde java 2.1.4. Informes
2.2. Memoria de cálculos
En "Memoria de cálculos" se exponen los cálculos principales que se realizan en el programa, las variables que intervienen en cada operación y el código java para cada uno. En "Memoria descriptiva" se trata de mostrar de forma breve y gráfica las partes que componen la aplicación Java. En "Diagramas de flujo" se muestra de forma esquemática la relación entre las distintas partes de la aplicación. En el apartado "Programación" se describen todos los componentes de la aplicación indicando el tipo de objeto y su evento correspondiente. En Acceso a la base de datos se describe como se accede a la base de datos desde la aplicación java. En "Informes" se presentan los informes que se pueden generar con esta aplicación.
Dentro de este proyecto, en el documento Apéndice I. "Ejemplos", se presenta un ejemplo con
los informes que puede generar el programa y que podemos sacar por impresora. En el documento Apéndice II "Códigos", se muestra todo el código java programado para cada una de las clases creadas para este proyecto.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
5
2.1. Memoria descriptiva 2.1.1. Programación
Para el desarrollo del proyecto se ha utilizado el entorno de desarrollo integrado (IDE) de
NetBeans. El IDE NetBeans es una herramienta pensada para escribir, compilar, depurar y ejecutar programas. Está escrito en Java aunque puede servir para cualquier otro lenguaje de programación. Soporta el desarrollo de todos los tipos de aplicación Java y, además, es un producto libre y gratuito sin restricciones de uso.
El lenguaje de programación Java creado por Sun Microsystems a mediados de la década de
los 90, es una plataforma de desarrollo de aplicaciones. La plataforma se divide en tres grandes bloques. Uno de ellos, Java SE (anteriormente conocido como J2SE) es lo más parecido a un lenguaje de programación estándar. Proporciona una sintaxis para un lenguaje de programación, un entorno de ejecución para las aplicaciones creadas en dicho lenguaje y un extenso conjunto de librerías en las cuales se pueden apoyar dichas aplicaciones.Presentaremos brevemente cuáles son las principales características del lenguaje de programación Java.
� Sencillo. Elimina la complejidad de otros leguajes. � Orientado a objetos. La filosofía de programación orientada a objetos facilita la creación y
mantenimiento de programas. � Independiente de la arquitectura y portable. Al compilar un programa en Java, el código
resultante es un tipo de código binario conocido como Java Bytecode. Este código es interpretado por diferentes computadoras de igual manera. Como el código compilado de Java es interpretado, un programa compilado de Java puede ser utilizado por cualquier computadora que tenga implementado el intérprete de Java.
� Robusto. Java simplifica la gestión de la memoria. � Multitarea. Java puede ejecutar diferentes líneas de código al mismo tiempo. � Dinámico. En java no es necesario cargar completamente el programa en memoria, sino
que las clases compiladas pueden ser cargadas bajo demanda en tiempo de ejecución. Para desarrollar aplicaciones Java es necesario un "Java Development Kit" o JDK. Existen
múltiples JDKs, desarrollados por compañías diferentes, o desarrollados como proyectos de software libre. En nuestro caso hemos empleado el que distribuye de modo gratuito Sun Microsystems, que se puede descargar desde http://java.sun.com. La implementación de Java de Sun suele ser la más actualizada y, es software libre. No obstante se podría emplear cualquier otro JDK ya que la portabilidad del lenguaje garantiza que todos funcionarán del mismo modo. El JDK viene a ser el kit de desarrollo de Java, un conjunto de herramientas , utilidades, documentación y ejemplos para desarrollar aplicaciones Java.
El entorno JDK no es el más adecuado para el desarrollo de aplicaciones Java, debido a que
funciona única y exclusivamente mediante comandos de consola. Hoy en día la programación se suele ayudar de entornos visuales, como Netbeans, que facilitan enormemente la tarea. Netbeans es un excelente entorno de desarrollo, completamente gratuito y se distribuyen bajo licencia libre. Puede descargarse desde http://netbeans.org . Netbeans es un entorno de desarrollo integrado (IDE) que permite editar programas en java, compilarlos, ejecutarlos, depurarlos,
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
6
construir rápidamente el interfaz gráfico de una aplicación eligiendo los componentes de una paleta, etc. El IDE de NetBeans es gratuito, y de codigo abierto para desarrolladores de software.
Para este proyecto hemos utilizado: � NetBeans IDE 7.2.1 � Java Development Kit Version Version 6 Update 20 from Sun Microsystems. A continuación se explica de forma breve las características de Java que han sido más
utilizadas en la realización de la aplicación.
2.1.1.1. POO programación orientada a objetos
Un Objeto es un elemento que tiene una serie de características llamadas “propiedades”. Por
otro lado, al objeto se le pueden dar órdenes que cumplirá de inmediato. A dichas órdenes se les denomina “métodos”.
Los métodos se pueden dividir básicamente en tres tipos: � Para cambiar las propiedades del objeto (Métodos set) � Para pedir información al objeto (Métodos get) � Para dar órdenes al objeto. Todo objeto pertenece a una CLASE. La CLASE nos permite declarar objetos y construirlos:
Declaración: CLASE nombreobjeto; LocalizacionACS pueblo;
Construcción: nombreobjeto = new CLASE();
ejemplo: pueblo = new LocalizacionACS();
Declaración y Construcción en una misma línea: CLASE nombreobjeto = new CLASE();
LocalizacionACS pueblo = new LocalizacionACS(); En la construcción de un objeto se asignan unas propiedades (características) por defecto al
objeto que se construye, aunque luego, estas características pueden ser cambiadas por el programador.
Se pueden añadir a un proyecto Java clases programadas por uno mismo. Al hacer esto, en el mismo proyecto podemos crear objetos de dichas clases y usarlos para
hacer el programa.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
7
En general, un proyecto java está constituido por un grupo de clases, algunas de las cuales serán de creación propia. En el programa usaremos objetos derivados de dichas clases. 2.1.1.2. Herencia
La Herencia consiste en crear una clase que obtenga todas las características de otra. Esta clase a su vez tendrá también características propias.
La clase inicial se denomina clase Base y la clase nueva creada a partir de la clase base se
llama clase Derivada: Se puede hacer que una clase de creación propia derive o herede de otra ya existente añadiendo
en la línea de creación de la clase: “extends NombreClaseBase”
public class Cuadro extends javax.swing.JFrame La clase creada “cuadro” obtendrá características de la clase “Jframe” de la que hereda. Aparte, esta clase tendrá métodos propios añadidos por el programador.
2.1.1.3. Bibliotecas y reutilización de código
En NetBeans podemos abrir varios proyectos y copiar los ficheros de clases de uno a otro. Si un proyecto tiene muchas clases, interesa agruparlas en carpetas.
figura 1. ficheros de clases en la carpeta “paquete”
CLASE BASE
CLASE DERIVADA
Herencia
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
8
figura 2. ficheros de clases[3], en la carpeta “gráficos” que serán utilizadas en la clase HistogramaACS, la cual está en “paquete”. Con la orden import llamamos a los ficheros de clases que estén en otras carpetas.
Es interesante reunir las clases que más usemos en un solo proyecto de tipo biblioteca, para
poder acceder a ellas fácilmente. Una biblioteca se puede compactar en un solo fichero de tipo .JAR . Al asociar un fichero de biblioteca .JAR a un proyecto, hacemos que en dicho proyecto se puedan usar las clases contenidas en dicha biblioteca.
figura 3. ficheros de bibliotecas .jar empleadas en este proyecto.
Todas estas ideas hacen efectiva la reutilización de código, es decir, el aprovechar lo ya programado, para no tener que volverlo a programar.
2.1.1.4. El bloque de control de errores, try{}catch(){}
La estructura try{} encierra entre las llaves el código que puede producir una excepción (un error grave) que debe ser manejado por el bloque catch(Exception ex){}, en este caso solo capturamos la excepción que puede surgir.
Ejemplo :
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
9
private void comboInclinacion_DDSActionPerformed(java.awt.event.ActionEvent evt) { try { Cambia_Inclinacion("inicio");} catch (Exception e) {JOptionPane.showMessageDialog(null, "Seleccione una inclinación"); }}
2.1.1.5. Variables globales
Las variables globales, también llamadas propiedades de la clase, son variables que pueden ser usadas desde cualquier evento del programa. Estas variables mantienen su valor hasta que otro evento lo modifique.
Las variables globales se declaran justo después de la línea public class. La inicialización de estas variables se realiza en el constructor. Por ejemplo, creamos la
variable “pueblo” objeto de la clase “LocalizaciónACS” como variable global en la clase “Cuadro”.
public class Cuadro extends javax.swing.JFrame { LocalizacionACS pueblo; String Nombre_Ciudad; ... public Cuadro() { initComponents(); ... pueblo = new LocalizacionACS();
...}}
2.1.1.6. Variables locales Son las variables utilizadas para un procedimiento concreto cuyos valores solo sirven dentro de dicho procedimiento. Se declaran e inician detro del evento donde intervienen. Ejemplo:
private void btnSeleccionaTodosActionPerformed(java.awt.event.ActionEvent evt) { int i; for (i = 0; i < 12; i++) { if (chMeses[i].isSelected()) { } else { chMeses[i].setSelected(true); } }}
2.1.1.7. Centralizar código
En java se pueden programar procedimientos que luego puedan ser llamados desde distintos evento. Por ejemplo, para presentar los resultados con tres decimales programamos el siguiente método:
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
10
public void ConTresDecimales() { DecimalFormatSymbols simbolo = new DecimalFormatSymbols(); simbolo.setDecimalSeparator('.'); formateador = new DecimalFormat("#####.###", simbolo); //variable formateador declarada como global }
Se puede llamar a un mismo procedimiento desde distintos eventos, evitando así la repetición
de código. Por ejemplo double feo = Double.parseDouble(txtf_comprueba_bcol.getText()) + incremento; ConTresDecimales(); feo = Double.valueOf(formateador.format(feo));
el resultado “feo” tendrá tres decimales sin tener que repetir todo el código anterior.
2.1.1.8. Eventos desde código. La ventana de diseño de NetBeans nos permite crear cada componente, colocarlo en la ventana
y asignarle los eventos que necesitemos para programar en ellos las acciones que se tengan que realizar. Sin embargo, si el diseño se ha realizado directamente desde código, será necesario crear también desde código los distintos eventos a usar y asociarlos al componente correspondiente.
Para programar eventos hay que tener en cuenta que un evento pertenece a un objeto “Oyente”
(Listener) o a un objeto “Adaptador” (Adapter)
El objeto oyente/adaptador hay que asociarlo al elemento sobre el que sucede el evento. Los eventos usados son del tipo "Eventos de Acción": � ActionPerformed:Activar un componente (pulsación de botón, enter en un cuadro de texto)
Para programar desde código un evento es necesario conocer lo siguiente: � El nombre del evento / eventos del mismo grupo. � El oyente/adaptador al que pertenece el evento / eventos. � El método para asignar el oyente/adaptador al componente sobre el que actúa el evento. � El tipo de datos de objeto recibido como parámetro por el evento. Conociendo estos datos, la programación siempre se hace igual: Componente.MetodoParaAñadirOyente(new NombreOyenteAdaptador() { public void nombreEvento1(TipoDatoParametro evt) { LlamadaAProcedimientoEvento1(evt);} public void nombreEvento2(TipoDatoParametro evt) { LlamadaAProcedimientoEvento2(evt);} });
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
11
Ejemplo:
v_txt_ocupacionn[i].addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) {
pasar_focoDmesActionPerformed(evt); } }); 2.1.1.9. Aplicación Java
Para este proyecto hemos creado una Java SE aplication. Para el diseño de la aplicación, Java proporciona dos paquetes gráficos: AWT y Swing. La
diferencia fundamental entre AWT y Swing es que Swing proporciona gran cantidad de controles y componentes para el desarrollo de interfaces gráficas que enriquecen la interfaz del programa. Es por ello que, en este proyecto se ha utilizado el paquete gráfico Swing. Swing proporciona, también, muchas clases prefabricadas para facilitar el diseño gráfico. A continuación se explica de forma breve las características que han sido más utilizadas en la realización de la interfaz :
� JFrame: es el componente básico para implementar una interfaz visual con la librería Swing.
Se ha utlilizado para crear la clase “Cuadro” la cual hereda de la clase JFrame. � JTabbedPane: es un componente que permite al usuario cambiar entre un grupo de
componentes haciendo click sobre la pestaña correspondiente. Se ha utilizado para seleccionar los paneles.
� JTextField: es un elemento que permite la entrada de texto por parte del usuario. Se ha
utilizado para introducir los parámetros . � JPanel: es un objeto de los llamados "contenedores". Es así porque sirve para agrupar y
organizar otros elementos de la interfaz. De esta forma, actúa como una caja donde se van metiendo elementos de la interfaz para poder manejarlos como una agrupación. Es una clase fundamental que se ha utilizado para dar un diseño atractivo e intuitivo.
� JLabel: es una etiqueta de texto. En este proyecto se ha utilizado para informar al usuario a
qué variable corresponden cada uno de los JTextFields y también para mostrar resultados y gráficos.
� JButton: se trata de un elemento que actúa como un pulsador al que se le pueden asignar
acciones una vez pulsado. Se ha utilizado para numerosos controles en la aplicación. � JComboBox: es un componente que permite seleccionar entre una serie de valores
previamente definidos. Se ha utilizado, por ejemplo, para seleccionar la inclinación entre los distintos valores disponibles en el programa.
� JRadioButton: es un elemento que puede ser seleccionado o no. Se ha utilizado en opciones
de cálculos y para seleccionar datos por defecto.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
12
� JCheckBox: es un elemento que puede ser seleccionado o no. Actúa como un botón de estado en el que la información que recogemos es, si está seleccionado, cierta, y en caso contrario, falsa. Se ha utilizado en opciones de cálculos .
� JDialog: Los Cuadros de Diálogo son ventanas simplificadas que muestran distintas opciones
al usuario. Los objetos JDialog son los que permiten la creación y uso de cuadros de diálogo en un proyecto java. Existen dos tipos de cuadros de diálogo: los modales y no modales. Los cuadros de diálogo modales no permiten que se active otra ventana hasta que el cuadro de diálogo no se haya cerrado. Los cuadros de diálogo no modales permiten trabajar con otra ventana a pesar de que el propio cuadro de diálogo no haya sido cerrado.
figura 4. elementos más usados en la aplicación
2.1.1.10. Instalación de la aplicación Java
Una vez que se ha finalizado el programa, en Netbeans, debemos prepararlo para la instalación en cualquier otro ordenador. Para ello, es necesario tener en cuenta todos aquellos ficheros externos cuyos contenidos intervienen en la aplicación: base de datos, imágenes, informes, etc... Procedemos de la siguiente manera:
JRadioButton JComboBox
JLabel
JTextField
JButton
JPanel
JDialog
JCheckBox
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
13
� En Netbeans, ejecutamos la orden Limpiar y construir proyecto principal. Esta orden compila el programa y crea una carpeta llamada dist dentro de la carpeta del proyecto, la cual será la carpeta “distribuible”.
� Dentro de la carpeta dist se crea un fichero con extensión .jar. Este fichero se puede decir que
es el “ejecutable” del programa. El fichero .jar contiene todas las clases que hemos programado en el proyecto. En nuestro caso se ha generado el fichero Simulacion_ACS_1_1.jar
� Los programas java pueden ejecutarse en cualquier entorno, pero para que un ejecutable .jar
pueda ser ejecutado en un determinado sistema, debe estar instalado en él la máquina virtual de java.
� Además del fichero ejecutable (.jar) con el nombre del proyecto, se crea también una carpeta
lib. Esta carpeta contiene las librerías adicionales que se hayan incluido en el proyecto.
figura 5. librerías adicionales incluidas en el proyecto.
� Bases de datos. Es necesario copiar el archivo base de datos en la carpeta dist. En nuestro caso hemos creado la carpeta “Base” para la base de datos, entonces copiamos la carpeta “Base” en la carpeta distribuible. � Imágenes (para la presentación, los iconos de los botones de las barras de herramientas, etc.)
, también tenemos que introducir los ficheros de estas imágenes dentro de la carpeta distribuible.
� Informes. Es necesario que los ficheros de estos estén dentro de la carpeta del distribuible.
Los ficheros de informes necesarios para el funcionamiento del programa son los ficheros compilados .jasper. Estos ficheros están dentro de una carpeta llamada “informesireport” , así que copiamos la carpeta con los informes dentro de la carpeta del distribuible.
� Imágenes de informes. Como los informes del programa usan imágenes, la situación de estas
en la carpeta distribuible depende de la forma en que haya configurado dichas imágenes en el iReport. Para este proyecto las imágenes se guardan en la capeta “Gráficas” que también copiamos en la carpeta dist.
� Una vez incluidos todos estos elementos ya tenemos la carpeta distribuible completada.
Para la instalación de la aplicación en otro ordenador, solo hay que copiar en una misma carpeta todos los elementos que intervienen, es decir:
� Archivo ejecutable "Simulacion_ACS_1_1.jar" � carpeta "lib"
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
14
� capeta "Base" � carpeta "Graficas" � carpeta "informesireport"
El ordenador de destino tiene que tener instalada la máquina virtual de java, propia del sistema operativo que utilice, para que el proyecto pueda ejecutarse.
2.1.1.11. Componente de la aplicación.
A continuación presentamos cada uno de los componentes de la clase principal "Cuadro.java" de la aplicación Java desarrollada para este proyecto.
figura 6. Componentes de la aplicación. Ventana de diseño NetBeans
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
15
Componente JFrame Form Cuadro:
Componente 1. Paneles [JTabbedPane] Componente 1.1. panel_datos [JPanel] . "INICIO"
figura 7. panel_datos, aplicación Java
C1.1.1. “Nuevo proyecto” componente: btnNuevoproyecto [JButton] descripción: Botón de inicio de los cálculos.
Abre el cuadro de dialogos “dialogodatos_nuevoproyecto” para introducir los datos de un proyecto nuevo y borra los del anterior si lo hubiera.
evento: private void btnNuevoproyectoActionPerformed(java.awt.event.ActionEvent evt) { Cancelar_Todo(); dialogodatos_nuevoproyecto.setSize(400, 400); dialogodatos_nuevoproyecto.setLocation(300, 300); dialogodatos_nuevoproyecto.setTitle("Localización"); comboDDNPloc.setSelectedIndex(0); etiDDNPloc.setText("");
dialogodatos_nuevoproyecto.setVisible(true);}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
16
C1.1.2. dialogodatos_nuevoproyecto [JDialog]
figura 8. cuadro de diálogo “dialogodatos_nuevoproyecto”
C1.1.2.1. “Provincia”
componente: comboDDNPloc [JComboBox] descripción: Combo para seleccionar el nombre de la provincia donde se localiza el proyecto.
Escribe el nombre de la provincia seleccionada en la etiqueta etiDDNPloc. Todos los datos estarán referidos a la capital de dicha provincia.
evento: private void comboDDNPlocActionPerformed(java.awt.event.ActionEvent evt) { String loc = comboDDNPloc.getSelectedItem().toString();
etiDDNPloc.setText(loc);} C1.1.2.2. "Nueva localización" componente: txtDDNPloc [JTextField] descripción: Campo de texto donde podemos escribir un nombre que aparecerá en la etiqueta
etiDDNP_nombreciudad y que se almacenará como nombre de la localización del proyecto.
evento: private void txtDDNPnuevalocKeyReleased(java.awt.event.KeyEvent evt) { String loc = txtDDNPnuevaloc.getText(); etiDDNP_nombreciudad.setText(loc);}
C1.1.2.3. "Cancelar"
componente: btnDDNPCancelaloc [JButton] descripción: Botón que cierra el cuadro de diálogo y cancela el inicio del nuevo proyecto. evento: private void btnDDNPCancelalocActionPerformed(java.awt.event.ActionEvent evt) {
Cancela_Nuevo(); dialogodatos_nuevoproyecto.dispose(); }
C1.1.2.4. "Calcula todo" componente: btnDDNP_CalculaTodo [JButton] descripción: Realiza todos los cálculos del programa para la provincia seleccionada con los
datos iniciales de un ejemplo tomados como valores por defecto. evento: private void btnDDNP_CalculaTodoActionPerformed(java.awt.event.ActionEvent evt) {
Boton_Gordo();}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
17
C1.1.2.5. "Aceptar"
componente: btnDDNPAceptaloc [JButton] descripción: Acepta el nombre de la provincia y abre el cuadro de diálogo dialogo_datosdelsitio
[JDialog]. evento: private void btnDDNPAceptalocActionPerformed(java.awt.event.ActionEvent evt) {
Acepta_Nuevo("continuar"); }
C1.1.3. dialogo_datosdelsitio [JDialog]. "Datos generales"
figura 9. dialogo_datosdelsitio [JDialog]
C1.1.3.1. "Valores por defecto"
componente: Rbtn_datosDefecto [JRadioButton] descripción: Rellena los campos de texto con los datos de un ejemplo tomado por defecto. Cada
campo de texto se puede rellenar con los valores que queramos. En la figura 9 podemos ver los datos por defecto.
evento: private void Rbtn_datosDefectoActionPerformed(java.awt.event.ActionEvent evt) { double[] DG = new double[12]; if (Rbtn_datosDefecto.isSelected()) { // DG[0]=45; DG[1] = 0; DG[2] = 1.05; DG[3] = 0.15; DG[4] = 32; DG[5] = 40; DG[6] = 2.01; DG[7] = 0.83; DG[8] = 4.8; DG[9] = 45; DG[10] = 0.94; DG[11] = 0.12; } else { Cancela_Datos_Generales(0);}
Introduce_Datos_Generales(DG);}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
18
C1.1.3.2. "Volver"
componente: btnVolver_Datosdelsitio [JButton] descripción: Anula los datos, cierra la ventana y abre el dialogodatos_nuevoproyecto. evento: private void btnVolver_DatosdelsitioActionPerformed(java.awt.event.ActionEvent evt) {
Cancela_Datos_Generales(0); if (Rbtn_datosDefecto.isSelected()) {Rbtn_datosDefecto.setSelected(false);} dialogo_datosdelsitio.dispose();
dialogodatos_nuevoproyecto.setVisible(true);}
C1.1.3.3. "Cancelar"
componente: btnCancelar_Datosdelsitio [JButton] descripción: Anula los datos para poder introducirlos de nuevo. evento: private void btn_CancelarDatosdelsitioActionPerformed(java.awt.event.ActionEvent evt) {
Cancela_Datos_Generales(0); if (Rbtn_datosDefecto.isSelected()) {Rbtn_datosDefecto.setSelected(false); }}
C1.1.3.4. "Continuar"
componente: btnContinuar_Datosdelsitio [JButton] descripción: Cierra el dialogo_datosdelsitio, rellena los campos de texto del panel_datos con
los valores introducidos y abre el cuadro de diálogo dialogo_datosmensuales. evento: private void btn_ContinuarDatosdelsitioActionPerformed(java.awt.event.ActionEvent evt) {
Continuar_Datosdelsitio();}
C1.1.4. dialogo_datosmensuales [JDialog]. "Datos mensuales"
figura 10. dialogo_datosmensuales
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
19
C1.1.4.1. "Valores por defecto"
componente: RbtnDatosmensuales [JRadioButton] descripción: Rellena los campos de texto según la provincia seleccionada y la inclinación
(fuente Censolar[2]). Cada campo de texto se puede rellenar con los valores que queramos. En la figura 10 podemos ver los datos por defecto para Badajoz.
evento: private void RbtnDatosmensualesActionPerformed(java.awt.event.ActionEvent evt) { if (RbtnDatosmensuales.isSelected()) { Introduce_Datos_Mensuales_pordefecto();}
else { Cancela_Datos_Mensuales();} }
C1.1.4.2. "Volver"
componente: btnVolverDatosMensuales [JButton] descripción: Anula los datos, cierra la ventana y abre el dialogodatos_datosdelsitio. evento: private void btnVolverDatosMensualesActionPerformed(java.awt.event.ActionEvent evt) {
// Cancela_Datos_Generales(); if (RbtnDatosmensuales.isSelected()) {RbtnDatosmensuales.setSelected(false); } dialogo_datosmensuales.dispose(); // Cancela_Datos_Generales(1);Cancela_Datos_Mensuales();
dialogo_datosdelsitio.setVisible(true); }
C1.1.4.3. "Cancelar"
componente: btnCancelarDatosMensuales [JButton] descripción: Anula los datos para poder introducirlos de nuevo. evento: private void btnCancelarDatosMensualesActionPerformed(java.awt.event.ActionEvent evt) {
Cancela_Datos_Mensuales(); if (RbtnDatosmensuales.isSelected()) {
RbtnDatosmensuales.setSelected(false); }
C1.1.4.4. "Continuar"
componente: btnContinuarDatosMensuales [JButton] descripción: Cierra el dialogo_datosmensuales y pasa al panel panel_calculos. evento: private void btnContinuardatosmensualesActionPerformed(java.awt.event.ActionEvent evt) {
Continuar_Datosmensuales();}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
20
Componente 1.2. panel_calculos [JPanel] . "CÁLCULOS"
figura 11. panel_calculos [JPanel]
C1.2.1. subpanelCVM [JPanel]
figura 6. subpanelCVM [JPanel]
C1.2.1.1. "Seleccionar todos"
componente: btnSeleccionaTodos [JButton] descripción: Selecciona para los cáculos todos los meses del año evento: private void btnSeleccionaTodosActionPerformed(java.awt.event.ActionEvent evt) {
int i; for (i = 0; i < 12; i++) { if (chMeses[i].isSelected()) {}
else {chMeses[i].setSelected(true);} }}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
21
C1.2.1.2. "Cancelar"
componente: btnCancelaSeleccion [JButton] descripción: Anula la selección de todos los meses evento: private void btnCancelaSeleccionMesesActionPerformed(java.awt.event.ActionEvent evt) {
int i; for (i = 0; i < 12; i++) {
if (chMeses[i].isSelected()) { chMeses[i].setSelected(false); } else { } }} C1.2.1.3. "Calcular"
componente: btnCalcula_porcuadros [JButton] descripción: Calcula la energía necesaria en MJ (neMJ) para calentar el agua y la energía neta
disponible por m2 (ENDmes) en cada mes seleccionado. Los resultados los muestra en el panel "panel_resultados". Figura 12.
evento: private void btnCalcula_porcuadrosActionPerformed(java.awt.event.ActionEvent evt) { if (pueblo.Nombre.equals("")) { JOptionPane.showMessageDialog(null, "Debe introducir los datos necesarios"); }// Nuevo_Proyecto(); if (pueblo.Tuso == 0) { JOptionPane.showMessageDialog(null, "Debe introducir los datos necesarios"); }//Nuevo_Datos_DelSitio(); if (pueblo.vH[1] == 0) { JOptionPane.showMessageDialog(null, "Debe introducir los datos necesarios"); }// Nuevo_Datos_Mensuales(); Aceptar_DatosdeEntrada(); Calculo_mensual_porcuadro(); Vaciar_resultados_porcuadro(); Vaciar_subpaneldatosyresultados(); Paneles.setSelectedComponent(panel_resultados);
}
figura 12. resultados del botón btnCalcula_porcuadros
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
22
C1.2.2. subpanelcalculo1 [JPanel]
figura 13. subpanelcalculo1
C1.2.2.1. "mes"
componente: combocalculosmes [JComboBox] descripción: Selecciona el mes en el que queramos consultar los resultados. evento: private void combocalculosmesActionPerformed(java.awt.event.ActionEvent evt) {
Introduce_datos_calculosporcombomes(); }
C1.2.2.2. "Consultar"
componente: btncalculosConsultar [JButton] descripción: Calcula el mes seleccionado y muestra los resultados. (figura 13) evento: private void btncalculosConsultarActionPerformed(java.awt.event.ActionEvent evt) {
Consulta_calculosporcombomes(); }
C1.2.2.3. "Modificar datos"
componente: btncalculosModificarDatos [JButton] descripción: Abre el dialogo_datosdelsitio para modificar los datos que queramos antes de
continuar. evento: private void btncalculosModificarDatosActionPerformed(java.awt.event.ActionEvent evt) {
Reiniciar_subpanelesResultados(); dialogo_datosdelsitio.setSize(500, 400); dialogo_datosdelsitio.setLocation(300, 300); dialogo_datosdelsitio.setVisible(true);
}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
23
Componente 1.3. panel_resultados [JPanel] . "RESULTADOS"
figura 14. panel_resultados
C1.3.1. "Calcular"
componente: btnresultadosNCteorico [JButton] descripción: Calcula y muestra los resultados de la demanda de energía anual, la energía anual
por m2, la superficie teórica necesaria (método Censolar[1]) y el número de colectores necesarios para dicha supeficie según los datos que pusimos al inicio.
evento: private void btnresultadosNCteoricoActionPerformed(java.awt.event.ActionEvent evt) { Calculo_resultadosNC_porcuadro();}
C1.3.2. "Calcular Superficie resultante"
componente: btnresultadosSC [JButton] descripción: Calcula la superficie resultante según el número de colectores que queramos
asignar al proyecto. Es dato de diseño necesario para continuar con los cálculos. En el campo de texto superior escribimos el valor elegido y la superficie resultante se mostrará en la etiqueta inferior (figura 9)
evento: private void btnresultadosSCActionPerformed(java.awt.event.ActionEvent evt) { Calcula_Superficieresultante(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
24
C1.3.3. "Resultados"
componente: btnresultadosCostes [JButton] descripción: Calcula y muestra los resultados de la energía neta total en cada mes según la
superficie resultante (ENTotalmes), el cociente de la energía neta y la demanda de cada mes (Sustitución), la demanda no cubierta por energía solar (Déficit), el coste de la energía eléctrica para toda la demanda (Coste kwh), el coste del déficit (Coste Aux), la diferencia entre el coste total y el auxiliar (Ahorro) y la cobertura solar (método Censolar) para cada mes. Además calcula los valores anuales de Aportación solar %, déficit energético, coste eléctrico de la demanda, coste eléctrico del déficit y ahorro.
evento: private void btnresultadosCostesActionPerformed(java.awt.event.ActionEvent evt) { Calcula_panelresultados();}
Componente 1.4. panel_datosyresultados [JPanel]. "DATOS&RESULTADOS"
figura 15. panel_datosyresultados
C1.4.1. "Consultar"
componente: btndatosyresultados_Consultar [JButton] descripción: Muestra los valores mensuales de ocupación (%usuarios), temperatura del agua de
red, H, k, E, horas de sol, I, temperatura ambiente, rendimiento de los colectores y consumo de ACS.
evento: private void btndatosyresultados_ConsultarActionPerformed(java.awt.event.ActionEvent evt) { Ver_Datos_y_Resultados(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
25
Componente 1.5. panel_acumulador [JPanel] . "ACUMULADOR"
figura 16. panel_acumulador
C1.5.1. "Calcular"
componente: btnacuCalculaVolumen [JButton] descripción: Calcula el volumen en litros del acumulador en función de la superficie de
colectores, por defecto considera 70 l/m2 aunque este valor lo podemos cambiar en el campo de texto “Acumulación por m2”.
evento: private void btnacuCalculaVolumenActionPerformed(java.awt.event.ActionEvent evt) { Calcula_VolumenAcu(); }
C1.5.2. "Comprobar Volumen"
componente: btnacuCompruebavolumen [JButton] descripción: Conprueba el volumen que pongamos como dato del proyecto según el criterio
0.8<=V/M<=1.2 donde V/M es el cociente entre el volumen teórico y el volumen proyectado.
evento: private void btnacuCompruebavolumenActionPerformed(java.awt.event.ActionEvent evt) { Calcula_PruebaAcu(); //ventana resultados
VerResultados();}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
26
C1.5.3. "Volumen proyectado +"
componente: btnf_Mas_VolAcu [JButton] descripción: Aumenta 100 litros el volumen del acumulador y recalcula todos las operaciones
donde interviene. El botón (-) hace lo mismo pero disminuyendo 100 litros. evento: private void btnf_Mas_VolAcuActionPerformed(java.awt.event.ActionEvent evt) {
Cambia_VolumenAcumulacion(100); Cambia_KgAcumulacion_fchart(100);//Aumenta 100Kg Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1());
CambiayGrafica_fchart();}
Componente 1.6. panel_histogramas [JPanel] . "GRÁFICAS"
figura 17. panel_histogramas Muestra los valores mensuales de: � Rendimiento de los colectores. � Aportación solar relativa. Compara la aportación solar de cada mes respecto al mes de
mayor aportación. � Sustitución. Porcentage de energía solar respecto a la energía total necesaria cada mes. Cada vez que se entra el el panel se redibujan las gráficas. Evento:
private void panel_histogramasMouseReleased(java.awt.event.MouseEvent evt) { Dibuja_Histogramas_RendiAporSustitucion(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
27
Componente 1.7. panel_FCHART [JPanel]. "F-Chart"
figura 18. panel_FCHART
C1.7.1. panel_fQa [JPanel] “Cargas caloríficas”
figura 19. panel_fQa y dialogo_fQa
C1.7.1.1. "Datos"
componente: btn_datos_fQa [JButton] descripción: Abre el cuadro de diálogo dialogo_fQa (figura 19) para introdudir los valores de
calor específico (del agua por defecto), el número de usuarios, el consumo de agua diario y la temperatura de uso del ACS. Cada vez que le damos anula los datos anteriores.
evento: private void btn_datos_fQaActionPerformed(java.awt.event.ActionEvent evt) { dialogo_fQa.setSize(400, 400); dialogo_fQa.setVisible(true);
Vacia_Cargas_fchart(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
28
C1.7.1.2. "Valores por defecto"
componente: Rbtn_fQa_valorespordefecto [JRadioButton] descripción: Introduce los valores de calor específico del agua y los valores iniciales que
pusimos de número de usuarios, consumo diario por usuario y temperatura del ACS. Estos valores se pueden modificar en los campos de texto donde aparecen a través del teclado. Si estamos conforme con los valores continuamos presionando “Aceptar”.
evento: private void Rbtn_fQa_valorespordefectoActionPerformed(java.awt.event.ActionEvent evt) { Valoresdefecto_Carga_fchart();}
C1.7.1.3. "Aceptar"
componente: btn_fQa_ Aceptar [JButton] descripción: Acepta los datos para calcular las cargas térmicas (Qa) de cada mes y cierra el
dialogo_fQa. evento: private void btnfQa_AceptarActionPerformed(java.awt.event.ActionEvent evt) {
AceptaDatos_Qa_fchart(); dialogo_fQa.dispose();}
C1.7.1.4. "Calcular Qa"
componente: btn_calcular_fQa [JButton] descripción: Calcula la carga térmica (Qa) en cada mes y muestra en la tabla de abajo los
resultados. Además muestra los valores de la temperatura del agua de red con los que se ha calculado Qa cada mes. (Figura 20)
evento: private void btn_calcular_fQaActionPerformed(java.awt.event.ActionEvent evt) { if (etifQa_Ce.getText().isEmpty()) { dialogo_fQa.setSize(400, 400); dialogo_fQa.setVisible(true);
} else { Calcula_Cargas_fchart(); } }
figura 20. temperatura del agua de red (tr) y cargas térmicas(Qa) para el método f-chart
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
29
C1.7.2. panel_fEa [JPanel]. "Energía absorbida"
figura 21. panel_fEa y dialogo_fEa C1.7.2.1 "Datos"
componente: btn_datos_fEa [JButton] descripción: Abre el cuadro de diálogo dialogo_fEa (figura 21) para introdudir los valores de
factor de eficiencia óptica, el factor de modificación del ángulo de incidencia, el factor captador-intercambiador, el número de paneles y la superficie de un panel. Cada vez que le damos anula los datos anteriores.
evento: private void btn_datos_fEaActionPerformed(java.awt.event.ActionEvent evt) { dialogo_fEa.setSize(400, 400); dialogo_fEa.setVisible(true);
Vacia_Eabsorbida_fchart();} C1.7.2.2. "Valores por defecto" componente: Rbtn_fEa_valorespordefecto [JRadioButton] descripción: Introduce los valores que pusimos al inicio de los cáculo. Estos valores se pueden
modificar en los campos de texto donde aparecen a través del teclado. Si estamos conforme con los valores continuamos presionando “Aceptar”.
evento: private void Rbtn_fEa_valorespordefectoActionPerformed(java.awt.event.ActionEvent evt) { ValoresDefecto_Eabsorbida_fchart();}
C1.7.2.3. "Aceptar"
componente: btn_fEa_ Aceptar [JButton] descripción: Acepta los datos para calcular la energía absorbida (Ea) de cada mes y cierra el
dialogo_fEa. evento: private void btnfEa_AceptarActionPerformed(java.awt.event.ActionEvent evt) {
AceptaDatos_Ea_fchart(); dialogo_fEa.dispose();}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
30
C1.7.2.4. "Calcular Ea"
componente: btn_calcular_fEa [JButton] descripción: Calcula la radiación incidente (Ri) y la energía absorbida por los colectores (Ea)
en cada mes y muestra en la tabla de abajo los resultados (figura 22). evento: private void btn_Calcula_fEaActionPerformed(java.awt.event.ActionEvent evt) {
if (etifEa_FEO.getText().isEmpty()) { dialogo_fEa.setSize(400, 400); dialogo_fEa.setVisible(true);
} else { Calcula_Eabsorbida_fchart(); } }
figura 22. Energía absorbida, método f-chart
C1.7.3. panel_fEp [JPanel] . "Energía perdida"
figura 23. panel_fEp y dialogo_fEp
C1.7.3.1. "Datos"
componente: btn_datos_fEp [JButton] descripción: Abre el cuadro de diálogo dialogo_fEp (figura 23) para introdudir los valores del
coeficiente global de pérdidas (factor m de los colectores), kg de acumulación (volumen de agua en litros del acumulador) y la temperatura mínima del ACS. Cada vez que le damos anula los datos anteriores.
evento: private void btn_datos_fEpActionPerformed(java.awt.event.ActionEvent evt) { dialogo_fEp.setSize(400, 400); dialogo_fEp.setVisible(true);
Vacia_Eperdida_fchart();}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
31
C1.7.3.2. "Valores por defecto"
componente: Rbtn_fEp_valorespordefecto [JRadioButton] descripción: Introduce los valores que pusimos al inicio de los cáculos. Estos valores se
pueden modificar en los campos de texto donde aparecen a través del teclado. Si estamos conforme con los valores continuamos presionando “Aceptar”.
evento: private void Rbtn_fEp_valorespordefectoActionPerformed(java.awt.event.ActionEvent evt) { ValoresDefecto_Eperdida_fchart();}
C1.7.3.3. "Aceptar"
componente: btn_fEa_ Aceptar [JButton] descripción: Acepta los datos y calcula el factor k1 para calcular la energía perdida (Ea) de
cada mes y cierra el dialogo_fEa. evento: private void btnfEp_AceptarActionPerformed(java.awt.event.ActionEvent evt) {
AceptaDatos_Ea_fchart(); dialogo_fEp.dispose();}
C1.7.3.4. "Calcular Ep"
componente: btn_calcular_fEp [JButton] descripción: Calcula el intervalo de tiempo en segundos (Dts), el factor k2 y la energía perdida
(Ep) en cada mes y muestra en la tabla de abajo los resultados (figura 24). evento: private void btn_Calcula_fEpActionPerformed(java.awt.event.ActionEvent evt) {
if (etifEp_CGP.getText().isEmpty()) { dialogo_fEp.setSize(400, 400); dialogo_fEp.setVisible(true);
} else { Calcula_Eperdida_fchart(); }}
figura 24. Cálculo de la energía perdida, método f-chart
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
32
C1.7.4. "Calcular f"
componente: btn_Calcula_fchart [JButton] descripción: Calcula los valores D1 y D2 para calcular el factor f de cada mes según la
expresión f=1.029·D1-0.065·D2-0.2453D1^2+0.0018·D2^2+0.0215·D1^3. Además calcula la energía útil (Qu) y la cobertura solar anual (CSA). Los resultados los muestra en la tabla de abajo (figura 25). Cada vez que calcula nos da la opción de guardar los resultados en una tabla que luego podremos consultar y que describiremos más adelante.
evento: private void btn_Calcula_fchartActionPerformed(java.awt.event.ActionEvent evt) { try{Calcula_fchart(); VerResultados(); Almacena_simulacion_sinverlo(); }catch(Exception e){}
}
figura 25. Cálculo f-chart
Componente 1.8. panel_graficas-fchart [JPanel]. “Graficas f-chart”
figura 26. panel_graficas_fchart
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
33
C1.8.1. panel_graf [JPanel]
figura 27. panel_graf y panel_valores_grafica_fchart A la izquierda, en el panel_graf dibuja una curva azul que une los valores del factor f de cada
mes y una línea roja que representa el valor de la cobertura solar anual (CSA) caluladas con el método f-chart. A la derecha, en el panel_valores_grafica_fchart se muestran los valores calculados de f y CSA. Tanto las curvas como los valores se actualizan cada vez que varían los datos del proyecto.
C1.8.2. panel_comprobacion_fk1 [JPanel]
figura 28.- panel_comprobacion_fk1
C1.8.2.1. "Comprobar"
componente: btn_Comprobark1 [JButton] descripción: Comprueba si el valor calculado k1 cumple con la condición de diseño 37.5< kg
acumulación / m2 captadores <300 y muestra el resultados indicando si cumple o no. Esta comprobación se realiza cada vez que cambiemos los valores de kg y número de paneles con los botones “+,-“. También no da la opción de guardar los resultados.
evento: private void btnf_ComprobarK1ActionPerformed(java.awt.event.ActionEvent evt) { Comrobar_K1_fchart();
Almacena_simulacion_sinverlo();}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
34
C1.8.2.2. "kg acumulación +"
componente: btnf_Mas_kg [JButton] descripción: Aumenta en 100 kg los kg de acumulación y con el nuevo valor recalcula k1, los
factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btn_menos_kg disminuye 100 kg y realiza los mismos eventos.
evento: private void btnf_Mas_kgActionPerformed(java.awt.event.ActionEvent evt) { Cambia_KgAcumulacion_fchart(100);//Aumenta 100Kg Cambia_VolumenAcumulacion(100); Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart(); VerResultados();
Almacena_simulacion_sinverlo(); }
C1.8.2.3. "Número de paneles +"
componente: btnf_Mas_paneles [JButton] descripción: Aumenta en 1 el número de captadores y con el nuevo valor recalcula k1, los
factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. Además recalcula todos los valores obtenidos anteriormente en los que interviene el número de paneles. El botón btnf_menos_paneles disminuye 1 y realiza los mismos eventos.
evento: private void btnf_Mas_panelesActionPerformed(java.awt.event.ActionEvent evt) { Cambia_NumeroPaneles_fchart(1);//incrementa el numero de paneles en 1 Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart(); Cambia_NumeroColectores(1);
Almacena_simulacion_sinverlo();}
C1.8.2.4. "b +"
componente: btnf_Mas_bcol [JButton] descripción: Incrementa 0.01 el valor del factor de eficiencia óptica (parámetro b de los
paneles) y con el nuevo valor recalcula el rendimiento de los paneles, el k1, los factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menos_bcol disminuye 0.01 y realiza los mismos eventos.
evento: private void btnf_Mas_bcolActionPerformed(java.awt.event.ActionEvent evt) { Cambia_FEObcol_fchart(0.01); Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart(); //nuevo Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados
Almacena_simulacion_sinverlo();}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
35
C1.8.2.5. "m +"
componente: btnf_Mas_mcol [JButton] descripción: Incrementa 0.1 el valor del coeficiente global de pérdidas (parámetro m de los
paneles) y con el nuevo valor recalcula el rendimiento de los paneles, el k1, los factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menos_mcol disminuye 0.1 y realiza los mismos eventos.
evento: private void btnf_Mas_mcolActionPerformed(java.awt.event.ActionEvent evt) { Cambia_CGPmcol_fchart(0.1); Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart(); Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados
Almacena_simulacion_sinverlo();} C1.8.2.6. "factor intercambiador +"
componente: btnf_Mas_factorIntercambiador [JButton] descripción: Incrementa 0.01 el valor del factor del intercambiador y con el nuevo valor
recalcula el k1, los factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menos_factorIntercambiador disminuye 0.01 y realiza los mismos eventos.
evento: private void btnf_Mas_factorIntercambiadorActionPerformed(java.awt.event.ActionEvent evt) { Cambia_FCCI_fchart(0.01); Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart();
Almacena_simulacion_sinverlo();} C1.8.3. panelf_MasMenos [JPanel]
figura 29. panelf_MasMenos
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
36
C1.8.3.1. "Iniciar"
componente: btnf_Graficar_fchart [JButton] descripción: Con los datos iniciales del proyecto rellena los campos de texto con los valores de
ocupación, consumo diario, temperatura del ACS e inclinación de los paneles. Actualiza los resultados y las gráficas.
evento: private void btnf_Graficar_fchartActionPerformed(java.awt.event.ActionEvent evt) { Cancela_cambios_fchart(); Cancela_cambios_fchart(); Ver_Datos_y_Resultados();//actualiza casillas ocu y consu del panel datos y resultados
Almacena_simulacion_sinverlo(); }
C1.8.3.2. "todos"
componente: btnf_todos_Mn [JButton] descripción: Selecciona todos los meses marcando todas las casillas de selección (figura29). evento: private void btnf_todos_MmActionPerformed(java.awt.event.ActionEvent evt) {
Selecciona_mesesTodos_Mm();}
C1.8.3.3. "Ocupación +"
componente: btnf_Masocupacion [JButton] descripción: Aumenta un 5% la ocupación (número de usuarios) de los meses marcados en las
casillas de selección y con los nuevos valores actualiza los resultados y las gráficas. El valor máximo es 100. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menosocupacion disminuye un 5% y realiza los mismos eventos.
evento: private void btnf_Masocupacion_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Ocupacion_Mm(5);//incrementa un 5% Ver_Datos_y_Resultados();//actualiza casillas ocu y consu del panel datos y resultados
Almacena_simulacion_sinverlo();}
C1.8.3.4. "Litros /día usuario +"
componente: btnf_Maslitrosdia [JButton] descripción: Aumenta 5 litros el consumo diario de ACS por usuario de los meses marcados en
las casillas de selección y con los nuevos valores actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menoslitrosdia disminuye 5 litros y realiza los mismos eventos.
evento: private void btnf_Masliitrosdia_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_LitrosDia_Mm(5);//incrementa en 5 Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados
Almacena_simulacion_sinverlo(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
37
C1.8.3.5. "Tuso +"
componente: btnf_Mastuso [JButton] descripción: Aumenta 5ºC la temperatura del ACS de los meses marcados en las casillas de
selección y con los nuevos valores actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menostuso disminuye 5ºC y realiza los mismos eventos.
evento: private void btnf_Mastuso_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Tuso_Mm(5);//incrementa en 5 Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados
Almacena_simulacion_sinverlo(); }
C1.8.3.6. "Inclinación +"
componente: btnf_MasInclinacion [JButton] descripción: Aumenta un 5º la inclinación de los paneles de los meses marcados en las casillas
de selección y con los nuevos valores actualiza los resultados y las gráficas. El valor máximo es 65º y el mínimo 35º. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menosocupacion disminuye 5º y realiza los mismos eventos.
evento: private void btnf_MasInclinacion_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Inclinacion_Mm(5); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados
Almacena_simulacion_sinverlo(); } C1.8.3.7. "Cancelar"
componente: btnf_Cancelar_Mn descripción: Cancela todos los cambios repecto a los datos iniciales de ocupación, consumo
diario, temperatura de uso e inclinación. Elimina las marcas de todos los meses. Rellena los campos con los datos iniciales del proyecto y actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla.
evento: private void btnf_Cancelar_MmActionPerformed(java.awt.event.ActionEvent evt) { Cancela_Cambios_Mn(); // Cancela_cambios_fchart(); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados
Almacena_simulacion_sinverlo(); }
C1.8.4. "Ver resultados"
componente: btnVerresultados_fchart [JButton] descripción: Abre la ventana BD_Resultados [JDialog] (figura 30) evento: private void btnVerresultados_fchartActionPerformed(java.awt.event.ActionEvent evt) {
VerResultados_enJTable(1); VervariacionesFchartAnual_enJTable(1); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
38
figura 30. ventana BD_Resultados En esta ventana podemos ver los resultados que hemos guardado y realizar informes y
guardarlos en archivo o imprimirlos.
C1.8.5. "Guardar"
componente: btnGuardar_fchart descripción: Guarda los resultados con los datos que tengamos en ese momento y abre la
ventana BD_Resultados [JDialog] (figura 25) que describiremos más adelante. evento: private void btnGuadar_fchartActionPerformed(java.awt.event.ActionEvent evt) {
Guardar_Resultados_finales(); GuardarResultadosACS(1);
GuardarVariacionAnual(1); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
39
Componente 1.9. panel_GRAF2 [JPanel] . “Gráficas demanda-aportación”
figura 31. panel_GRAF2 Evento:
private void panel_GRAF2MouseReleased(java.awt.event.MouseEvent evt) { GraficayDibuja_DemandaAporatacion_Masmenos(); }
C1.9.1. panhistoDemandaAportacion [JPanel]
figura 32. gráficas demanda-aportación Compara la demanda de energía para calentar el agua cada mes calculado (barras de de color
amarillo) con la aportación solar de los paneles disponibles cada mes (barras de color rojo).
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
40
C1.9.2. panel_comprobacion_DAlitrosm2 [JPanel]. “Superficie colectora calculada”
figura 33. panel_comprobacion_DAlitrosm2
C1.9.2.1. "Nº de colectores +"
componente: btnDA_Mas_colectores [JButton] descripción: Aumenta en 1 el número de captadores y con el nuevo valor recalcula y actualiza
las gráficas. Comprueba la condición de diseno 60<=C/A<=100 , cociente entre el consumo diario por usuario y la superficie de captadores. Finalmente nos da la opción de guardar los resultados en una tabla. Además recalcula todos los valores obtenidos anteriormente en los que interviene el número de paneles. El botón btnDA_menos_colectores disminuye 1 y realiza los mismos eventos.
evento: private void btnDA_Mas_colectoresActionPerformed(java.awt.event.ActionEvent evt) { Cambia_NumeroColectores(1); GraficayDibuja_DemandaAporatacion_Masmenos(); Cambia_NumeroPaneles_fchart(1);//ventana resultados Calculo_resultadosNC_porcuadro(); Cambia_NumeroColectores(0);
VerResultados(); Almacena_simulacion_sinverlo();}
C1.9.3. panelDA_MasMenos [JPanel]
figura 34.- panelDA_MasMenos
C1.9.3.1. "INICIO" componente: btnInicio_Graf2 [JButton] descripción: Con los datos iniciales del proyecto rellena los campos de texto con los valores de
ocupación, consumo diario, temperatura del ACS e inclinación de los paneles. Actualiza los resultados y las gráficas.
evento: private void btnInicio_Graf2ActionPerformed(java.awt.event.ActionEvent evt) { Cancela_cambios_DA(); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados
Almacena_simulacion_sinverlo(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
41
C1.9.3.2. "todos"
componente: btnDA_todos_Mm [JButton] descripción: Selecciona todos los meses marcando todas las casillas de selección (figura34). evento: private void btnDA_todos_MmActionPerformed(java.awt.event.ActionEvent evt) {
Selecciona_mesesTodos_Mm(); }
C1.9.3.3 "Ocupación +"
componente: btnDA_Masocupacion_Mm [JButton] descripción: Aumenta un 5% la ocupación (número de usuarios) de los meses marcados en las
casillas de selección y con los nuevos valores actualiza los resultados y las gráficas. El valor máximo es 100. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnDA_menosocupacion_Mm disminuye un 5% y realiza los mismos eventos.
evento: private void btnDA_Masocupacion_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Ocupacion_Mm(5);//incrementa un 5% Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados
Almacena_simulacion_sinverlo(); }
C1.9.3.4. "Litros/día usuario +"
componente: btnDA_Maslitrosdia_Mm [JButton] descripción: Aumenta 5 litros el consumo diario de ACS por usuario de los meses marcados en
las casillas de selección y con los nuevos valores actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnDA_menoslitrosdia_Mm disminuye 5 litros y realiza los mismos eventos.
evento: private void btnDA_Masliitrosdia_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_LitrosDia_Mm(5);// incrementa 5 litros Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados
Almacena_simulacion_sinverlo(); }
C1.9.3.5. "Tuso +"
componente: btnDA_Mastuso_Mm [JButton] descripción: Aumenta 5ºC la temperatura del ACS de los meses marcados en las casillas de
selección y con los nuevos valores actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnDA_menostuso_Mm disminuye 5ºC y realiza los mismos eventos.
evento: private void btnDA_Mastuso_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Tuso_Mm(5);//incrementa en 5 Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados
Almacena_simulacion_sinverlo(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
42
C1.9.3.6. "Inclinación +"
componente: btnDA_MasInclinacion_Mm [JButton] descripción: Aumenta un 5º la inclinación de los paneles de los meses marcados en las casillas
de selección y con los nuevos valores actualiza los resultados y las gráficas. El valor máximo es 65º y el mínimo 35º. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnDA_menosocupacion_Mm disminuye 5º y realiza los mismos eventos
evento: private void btnDA_MasInclinacion_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Inclinacion_Mm(5); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados
Almacena_simulacion_sinverlo(); }
C1.9.3.6. "Cancelar"
componente: btnDA_Cancelar_Mm descripción: Cancela todos los cambios repecto a los datos iniciales de ocupación, consumo
diario, temperatura de uso e inclinación. Elimina las marcas de todos los meses. Rellena los campos con los datos iniciales del proyecto y actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla.
evento: private void btnDA_Cancelar_MmActionPerformed(java.awt.event.ActionEvent evt) { Cancela_Cambios_Mn(); // Cancela_cambios_DA(); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados
Almacena_simulacion_sinverlo(); }
C1.9.4. "ver resultados"
componente: btnVerResultados_G2 [JButton] descripción: Abre la ventana BD_Resultados [JDialog] (figura 35) evento: private void btnVerResultados_G2ActionPerformed(java.awt.event.ActionEvent evt) {
VerResultados_enJTable(1); VervariacionesFchartAnual_enJTable(1); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
43
figura 35. ventana BD_Resultados En esta ventana podemos ver los resultados que hemos guardado y realizar informes y
guardarlos en archivo o imprimirlos.
C1.9.5. "Guardar"
componente: btnGuardar_graf2 descripción: Guarda los resultados con los datos que tengamos en ese momento y abre la
ventana BD_Resultados [JDialog] (figura 35) que describiremos más adelante. evento: private void btnGuardar_graf2ActionPerformed(java.awt.event.ActionEvent evt) {
Guardar_Resultados_finales(); GuardarResultadosACS(1);
GuardarVariacionAnual(1); }
Componente 1.10. panel_proyectos [JPanel]. “Proyectos guardados”
figura 36. panel_proyectos Muestra datos y resultados de los proyectos calculados durante una sesión. Al comenzar una
nueva sesión no habrá ningún dato en este panel.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
44
C1.10.1. "Guardar"
componente: btnGuardarResultados [JButton] descripción: Guarda los datos y resultados en el panel_proyecto (figura 30) y en las tablas de la
base de datos a la que está conectado el programa. evento: private void btnGuardarResultadosActionPerformed(java.awt.event.ActionEvent evt) {
//para todos los botones guardar Guardar_Resultados_finales();//en el panel proyectos guardados GuardarResultadosACS(1);//En BD y en la JTable
GuardarVariacionAnual(1); } C1.10.2. "Borrar anterior"
componente: btnBorra_GuardarResultados [JButton] descripción: Elimina el contenido de la última fila que esté almacenada en el panel_proyectos. evento: private void btnBorra_GuardarResustadosActionPerformed(java.awt.event.ActionEvent evt) {
JLabel[][] dATOSgr = {DatosGR_1, DatosGR_2, DatosGR_3, DatosGR_4, DatosGR_5, DatosGR_6,DatosGR_7, DatosGR_8, DatosGR_9, DatosGR_10, DatosGR_11, DatosGR_12, DatosGR_13};
int numfilas = dATOSgr.length; int numcolumnas = dATOSgr[0].length; for (int j = 0; j < numfilas - 1; j++) { if (dATOSgr[j + 1][0].getText().isEmpty()) {
for (int i = 0; i < numcolumnas; i++) { dATOSgr[j][i].setText(""); dATOSgr[j][i].setBackground(Color.GRAY); } } } for (int i = 0; i < numcolumnas; i++) { dATOSgr[12][i].setText(""); dATOSgr[12][i].setBackground(Color.GRAY);
} }
Componente 1.11. panel_JFreechart [JPanel]. "Gráficas JFree"
Con el uso de librerías de JFreechart se dibujan la gráficas que se emplearán como imagen en
los informes iReport.
C1.11.1."Ver gráficas RenApoSus"
componente: btnVergraf_RenAporSus [JButton] descripción: Dibuja las gráficas de rendimiento, aportación relativa y sustitución y las muestra
en la ventana Dialogo_graf_RenaporSus_JFC [JDialog] (figura 36). Estas gráficas pueden guardarse como archivos de imagen y son utilizadas en los informes.
evento: private void btnVergraf_RenAporSusActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_RenAporSus_JFC.setSize(950,650); dialogo_graf_RenAporSus_JFC.setResizable(true); dialogo_graf_RenAporSus_JFC.setVisible(true);
Dibuja_RenAporSus_JFC(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
45
figura 36. gráficas de rendimiento, aportación solar relativa y sustitución con JFreechart
C1.11.2. "Ver gráficas DA"
componente: btnVergraf_DA [JButton] descripción: Dibuja las gráficas de demanda de energía y aportación solar y las muestra en la
ventana Dialogo_graf_DemApor_JFC [JDialog] (figura 37). Estas gráficas pueden guardarse como archivos de imagen y son utilizadas en los informes.
evento: private void btnVergraf_DAActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_DemApor_JFC.setSize(700,650); dialogo_graf_DemApor_JFC.setResizable(true); dialogo_graf_DemApor_JFC.setVisible(true);
Dibuja_DemandaAportacion_JFC(); }
figura 37. gráfica Demanda-Aportación con JFreechart
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
46
C1.11.3. "Ver gráfica f-chart"
componente: btnVergraf_fchart [JButton] descripción: Dibuja las gráficas de f-chart y cobertura solar anual y las muestra en la ventana
Dialogo_graf_fchar_JFC [JDialog] (figura 38). Estas gráficas pueden guardarse como archivos de imagen y son utilizadas en los informes.
evento: private void btnVergrar_fchartActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_fchar_JFC.setSize(700,650); dialogo_graf_fchar_JFC.setResizable(true); dialogo_graf_fchar_JFC.setVisible(true);
Dibuja_fChart_JFC(); }
figura 38. gráficas fchart con JFreechart
C1.11.3. "Guardar gráficas en archivo"
componente: btnGuardarGraficas_enArchivo [JButton] descripción: dibuja y guarda las graficas para el informe evento: private void btnGuardarGraficas_enArchivoActionPerformed(java.awt.event.ActionEvent evt) {
//dibuja y guarda las graficas para el informe Dibuja_y_Guarda_enArchivo(); }
C1.11.4. "Ver paneles en imagen"
componente: btn_Ver_dialogo_graf_paneles [JButton] descripción: abre la ventana dialogo_graf_paneles [JDialog]. evento: private void btn_Ver_dialogo_graf_panelesActionPerformed(java.awt.event.ActionEvent evt) {
dialogo_graf_paneles.setSize(1100,850); dialogo_graf_paneles.setResizable(true);
dialogo_graf_paneles.setVisible(true); }
C1.11.5. "Ver tabla variaciones"
componente: btn_verTablavariaciones [JButton] descripción: Abre la ventana BD_Variacion_anual [JDialog]. (figura 39) evento: private void btn_verTablavariacionesActionPerformed(java.awt.event.ActionEvent evt) {
GuardarVariacionAnual(1); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
47
figura 39. tabla para los informes de variaciones
C1.11.6. "ver gráficas variaciones"
componente: btnVergraf_variaciones [JButton] descripción: Abre la ventana dialogo_graf_variaciones_JFC [JDialog] en la que podemos
dibujar la variaciones de la aportación solar anual (método Censolar [1]) y la CSA (método F-chart) en función de la variable que seleccionemos. Los datos los obtiene de los que se han ido guardando en la tabla variaciones. (figura 40)
evento: private void btnVergraf_variacionesActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_variaciones_JFC.setSize(700,650); dialogo_graf_variaciones_JFC.setResizable(true);
dialogo_graf_variaciones_JFC.setVisible(true); }
figura 40. dialogo_graf_variaciones_JFC
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
48
C1.11.7. "ver gráfica informe general"
componente: btn_Vergrafinfo_general [JButton] descripción: Abre la ventana dialogo_graf_InformeGeneral [JDialog] en la que muestra los
valores anuales de demanda, MJ/m2, aportación solar (método Censolar) y CSA para cada provincia para los mismos datos de entrada. Guarda como archivo de imagen y realiza y guarda el informe general.
evento: private void btn_VergrafInfo_generalActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_InformeGeneral.setSize(1200,850); dialogo_graf_InformeGeneral.setResizable(true); dialogo_graf_InformeGeneral.setVisible(true);
DibujayGuarda_InformeGeneral_JFC(); }
C1.11.8. "Ver tabla mensual"
componente: btn_verTablamensual [JButton] descripción: Abre la ventana BD_tablamensual [JDialog] y guarda los datos y resultados
mensuales que se emplearán en el informe mensual. evento: private void btn_verTablamensualActionPerformed(java.awt.event.ActionEvent evt) {
GuardarTablamensual(); VerTablamensual_enJTable(1); }
Componente 1.12. panel_rendimiento [JPanel]. “Rendimiento”
Muestra la gráfica del rendimiento de los colectores cada mes y permite ver como varía en
función del factor de eficiencia óptica (b), el coeficiente general de pérdidas (m) y la temperatura del ACS.
figura 41. panel_Rendimiento_JFC
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
49
C1.12.1. "Inicio"
componente: btnRen_Inicio_JFC [JButton] descripción: Dibuja la gráfica de los valores mensuales del rendimiento de los paneles y
muestra los valores de b,m y T (figura 41). evento: private void btnRen_Inicio_JFCActionPerformed(java.awt.event.ActionEvent evt) {
etiRen_b.setText(""+pueblo.bcol); etiRen_m.setText(""+pueblo.mcol); etiRen_Temp.setText(txtf_tuso_Mm[0].getText()); Grafica_JFC grafica=new Grafica_JFC(); grafica.Dibuja_Linea_JFree(pueblo.vRendimiento,panRenJFC_graficas,
etiRenJFC_graficas,"rendimiento","mes","rendimiento"); for(int i=0;i<b.length;i++){for(int j=0; j<12;j++){b[i][j]=0;}};//cero[j];}}; }
C1.12.2. "b +"
componente: btnRen_Mas_bcol [JButton] descripción: Aumenta 0.05 el valor de b y dibuja la gráfica con el nuevo valor. Nos da la
opción de guardar los datos en una tabla. Además aparece en la gráfica una leyenda con el color de la línea y los valores (b,m,T) empleados (figura 42). El botón btnRen_menos_bcol disminuye b 0.05 y realiza los mismos eventos.
evento: private void btnRen_Mas_bcolActionPerformed(java.awt.event.ActionEvent evt) { Cambia_FEObcol_fchart(0.05);
dibuja_lineasderendimiento(); } C1.12.3. "m +"
componente: btnRen_Mas_mcol [JButton] descripción: Aumenta 0.5 el valor de m y dibuja la gráfica con el nuevo valor. Nos da la
opción de guardar los datos en una tabla. Además aparece en la gráfica una leyenda con el color de la línea y los valores (b,m,T) empleados (figura 42). El botón btnRen_menos_mcol disminuye m 0.5 y realiza los mismos eventos.
evento: private void btnRen_Mas_mcolActionPerformed(java.awt.event.ActionEvent evt) { Cambia_CGPmcol_fchart(0.5);
dibuja_lineasderendimiento(); }
C1.12.4. "T +"
componente: btnRen_Mas_Temp [JButton] descripción: Aumenta 5ºC el valor de T y dibuja la gráfica con el nuevo valor. Nos da la
opción de guardar los datos en una tabla. Además aparece en la gráfica una leyenda con el color de la línea y los valores (b,m,T) empleados. El botón btnRen_menos_mcol disminuye T 5ºC y realiza los mismos eventos.
evento: private void btnRen_Mas_TempActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Tuso_Mm(5);
dibuja_lineasderendimiento(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
50
figura 42. variaciones del rendimiento de los colectores
C1.12.5. "Imprimir"
componente: btnImprime_graficaRendimiento descripción: Permite sacar por impresora la gráfica que tengamos el el panel_rendimiento_JFC evento: private void btnImprime_graficaRendimientoActionPerformed(java.awt.event.ActionEvent evt) {
Imprimegrafica_VariacionesRendimiento(); }
figura 43. opción imprimir la gráfica del rendimiento de los paneles para distintos valores de b,m y T.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
51
Componente 2. subpanelesresultados_2 [JPanel] A la derecha de la pantalla irá apareciendo un resumen de los valores de los principales datos y
resultados conforme intervienen en los cálculos. Cada vez que se modifica un dato aprarece su valor y los resultados actualizados. De esta forma vemos como influye la variación del valor de una variable en los resultados finales independientemente de la pestaña [JPanel] en que estemos operando.
figura 44. subpanelresultados_2 método: public void VerResultados() { try { //subpanelresultados2_8 etiresultadosDA3.setText("" + pueblo.getDemandaAnual()); etiresultadosENanual3.setText("" + pueblo.getENDañoM2()); etiresultadosSCteorica3.setText("" + pueblo.getSCteorica()); etiresultadosNCteorico3.setText("" + pueblo.getNCteorico()); etiresultadosCAm5.setText("" + pueblo.getConsumoanualACSm3()); //subpanelresultados2_9 etiresultadosAportacionAnual2.setText("" + pueblo.getaportacionAnual()); etiresultadosDeficitAnual2.setText("" + pueblo.getdeficitEnergeticoAnual()); etiresultadosCEanual2.setText("" + pueblo.getCosteEanual()); etiresultadosCAuxanual2.setText("" + pueblo.getCosteAuxAnual()); etiresultadosAhorroanual2.setText("" + pueblo.getAhorroAnual()); etiresultadosCSA2.setText("" + pueblo.getCoberturaSA()); //subpanelresultados2_10 etiresultadosSCresultante2.setText("" + pueblo.getSCresultante()); etiresultadosVolumen2.setText("" + pueblo.VolAcuDiseño); etiresultadosbcol2.setText("" + pueblo.getbcol()); etiresultadosmcol2.setText("" + pueblo.getmcol()); etiresultadosFCCI2.setText("" + pueblo.getFCCI()); Prueba_Resultados(); } catch (Exception ex) { } }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
52
Componente 2.1. subpanelresultados2_8 [JPanel] � "Demanda anual": energía necesaria para calentar el agua. � "Energía anual/m2": energía solar disponible por m2 � "Superficie teórica m2": superficie (m2) necesaria para la demanda calculada según el
método de Censolar [1]. � "Nº colectores teóricos": número de colectores según los datos del proyecto para la superficie
teórica. � "Consumo ACS m3 año": consumo anual según los datos del proyecto (ocupación, usuarios
y litros/día)
figura 45.- subpanelresultados2_8
Componente 2.2. subpanelresultados2_9 [JPanel] � "Aportación solar %": Aportación solar anual calculada por el método de Censolar [1]. � "Déficit energético": Parte de la demanda no cubierta por energía solar. � "Coste Energía anual": coste en € de la energía eléctrica, para cubrir la toda la demanda
anual, según el precio del kwh que pongamos como dato al inicio del proyecto. � "Coste Auxiliar anual": coste en € de la energía eléctrica para demanda no cubierta por
energía solar. � "Ahorro anual": diferencia entre los dos costes anteriores. � "CSA f-chart": Cobertura Solar Anual calculada por el método de F-Chart.
figura 46. subpanelesresultados2_9
Componente 2.3. subpanelresultados2_10 [JPanel] � "Superficie resultante m2": superficie calculada con el número de paneles que asignemos al
proyecto. Este valor es el que se emplea en los cáculos. � "Volumen acumulador": volumen en litros del acumulador que asignemos al proyecto. Este
valor es el que se emplea en los cálculos. � "b": factor de eficiencia óptica de los colectores. � "m": coeficiente de pérdidas de los colectores. � "FCCI": factor del intercambiador. � Condiciones de diseño. Cada botón(?) [JButton] nos muestra cada condición.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
53
• "V/M": volumen del acumulador respecto al volumen recomendado (por defecto 70 l/m2 de panel.)
• "C/A": litros diarios respecto a la superficie total (m2) de paneles. • "M/A": volumen del acumulador del proyecto respecto a la superficie total (m2) de
paneles.
figura 47. subpanelesresultados2_10
Componentes 3. Other Components
figura 48. Elementos del grupo Other Components del Form cuadro
C3.1. dialogodatos_nuevoproyecto [JDialog] Se abre con el botón “Nuevo proyecto” de panel “Inicio” (figura 7). A partir de aquí podemos
seguir presionando “Aceptar” o “Calcula todo” (figura 8). “Aceptar” cierra esta ventana y abre dialogo_datosdelsitio [JDialog] (figura 9). “Calcular todo” realiza todos los cálculos de una sola vez y con los datos por defecto de la
provincia seleccionada y los valores que nos pide del número de colectores y volumen del acumulador (figura 49).
figura 49. Datos necesarios para “Calcular todo"
C3.2. dialogo_datosdelsitio [JDialog] Se abre con el botón “Aceptar” de la ventana dialogodatos_nuevoproyecto (figura 8). Después
de introducir los datos seguimos con el botón “Continuar” (figura 9) que cerrará esta ventana y abrirá el dialogo_datosmensuales [JDialog] (figura 10).
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
54
C3.3. dialogo_datosmensuales [JDialog] Se abre después de aceptar los datos de la ventana dialogo_datosdelsitio[JDialog]. Después de introducir los datos seguimos con el botón “Continuar” (figura 10) que cerrará esta
ventana y nos lleva al panel_calculos [JPanel] (figura 11).
C3.4. dialogo_fQa [JDialog] Se abre con el botón “Datos” del panel_fQa [JPanel] (figura 19)
C3.5. dialogo_fEa [JDialog]
Se abre con el botón “Datos” del panel_fEa [JPanel] (figura 21)
C3.6. dialogo_fEp [JDialog] Se abre con el botón “Datos” del panel_fEp [JPanel] (figura 23)
C3.7. dialogo_graf_RenAportSus_JFC [JDialog] Se abre con el botón “Ver gráficas RenAporSus” del panel_JFreeChart [JPanel] (figura 36)
C3.8. dialogo_graf_DemApor_JFC [JDialog] Se abre con el botón “Ver gráficas DA” del panel_JFreeChart [JPanel] (figura 37)
C3.9. dialogo_graf_fchart_JFC [JDialog] Se abre con el botón “Ver gráfica f-chart” del panel_JFreeChart [JPanel] (figura 38)
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
55
C3.10. dialogo_graf_paneles [JDialog] Se abre con el botón “Ver paneles en imagen” del panel_JFreeChart [JPanel] (figura 38)
figura 46. imagen del panel Datos y Resultados dibujado en dialogo_graf_paneles C3.10.1. "Dibuja panel"
componente: btn_dibuja_paneles [JButton] descripción: El botón “Dibuja panel” captura como imagen el panel que señalemos en el
“combo” y la pinta en el panel de arriba. Además guarda la imagen como archivo .jpg en la carpeta “Graficas” del programa. Este archivo se emplea como imagen para los informes iReport.
evento: private void btn_dibuja_panelesActionPerformed(java.awt.event.ActionEvent evt) { Imagen_panel dibujo=new Imagen_panel();
String nom=cbo_dibuja_paneles.getSelectedItem().toString(); JPanel panel=new JPanel(); String nA="";//nombre que le daremos al archivo imagen en la carpeta Graficas try{ if(nom=="paneles"){JOptionPane.showMessageDialog(null,"Selecione un panel");} else{if(nom.equals("Datos")){nA="panel_datos";panel=panel_datos;} if(nom.equals("Resultados")){nA="panel_resultados";panel=panel_resultados;} if(nom.equals("Datos y Resultados")){Ver_Datos_y_Resultados(); nA="panel_datosyresultados";panel=panel_datosyresultados;} if(nom.equals("Acumulador")){nA="panel_acumulador";panel=panel_acumulador;} if(nom.equals("Calculo FChart")){nA="panel_FCHART";panel=panel_FCHART;}
if(nom.equals("Variaciones FChart")){nA="panel_grafica_fchart";panel=panel_grafica_fchart;} if(nom.equals("Demanda Aportacion")){nA="panel_GRAF2";panel=panel_GRAF2;} dibujo.Archiva_Imagem_jpg(nA,panel); dibujo.Pinta_arcivo_enJLabel(nA, eti_graf_paneles);}
}catch(Exception e){JOptionPane.showMessageDialog(null,"algo no va bien, puede que: "+e); } }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
56
figura 47. archivos de imagen guardados en la carpeta “Graficas” del programa.
C3.11. dialogo_graf_variaciones_JFC [JDialog]
Se abre con el botón “ver gráficas variaciones” del panel_JFreeChart [JPanel] (figura 39)
C3.12. dialogo_graf_InformeGeneral [JDialog]
Se abre con el botón “ver gráfica informe general “ del panel_JFreeChart [JPanel] (figuras 39) Muestra la imagen que aparecerá en el “informe general”.
C3.13. BD_Resultados [JDialog]
Se abre con los botones “Guardar” y “Ver resultados” y con el botón “Resultados” del panel “INICIO”.
figura 48. BD_Resultados [JDialog]
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
57
C13.1. tablaResultadosACS [JTable]
Muestra los datos y resultados que se guardan en la tabla de la base de datos del programa. Estos valores se pueden consultar en los informes que genera el programa.
C3.13.2. "Eliminar"
componente: btnEliminar_RegistroBD [JButton] descripción: Elimina los datos de la fila seleccionada de la tabla. Una vez eliminado no se
puede recuperar. evento: private void btnEliminar_RegistroBDActionPerformed(java.awt.event.ActionEvent evt) {
EliminaFila(); }
C3.13.3. "Eliminar todo"
componente: btn_Elimina_todo_tablaResultados [JButton] descripción: Elimina todos los registros de la tabla. Una vez eliminados no se recuperan. evento: private void btn_Elimina_todo_tablaResultadosActionPerformed(java.awt.event.ActionEvent
evt) { EliminaFilaResultados_todas(); }
C3.13.4. "Elimina filas entre"
componente: btneliminaVariasFilas1 [JButton] descripción: Elimina las filas con varlor id comprendido entre los valores que pongamos en los
campos de texto “fila nº ”. evento: private void btneliminaVariasFilas1ActionPerformed(java.awt.event.ActionEvent evt) {
EliminaFilaResultados_selecionadas(); }
C3.13.5. panel_Informes_BD_Resultados [JPanel]
figura 49. panel_Informes_BD_Resultados Cada botón de este panel abre una ventana donde podemos ver el tipo de informe generado con
los datos de tabla Resultados almacenados en la base de datos del programa y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora. A continuación veremos los eventos que se ejecutan con cada botón.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
58
C3.13.5.1. "Informe"
componente: btnInforme_BDResultados [JButton] descripción: Abre una ventana donde podemos ver el informe generado con todos los
resultados,ordenados por provincia, que se han ido guardando en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.
evento: private void btnInforme_BDResultadosActionPerformed(java.awt.event.ActionEvent evt) { try{ String rutainforme="Informesireport\\Informeagosto13.jasper"; //fichero jasper generado con ireport dentro del proyecto netbean JasperPrint informe=JasperFillManager.fillReport(rutainforme,null,conexion); JasperViewer ventanavisor=new JasperViewer(informe,false); ventanavisor.setTitle("INFORME DE PRUEBA"); ventanavisor.setVisible(true);} catch(Exception e){JOptionPane.showMessageDialog(null,"Error al mostrar informe"+e);
} } C3.13.5.2. "Informe general"
componente: btnInformeGeneral [JButton] descripción: Abre una ventana donde podemos ver el "informe general" con los resultados para
todas las provincias, almacenados en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.
evento: private void btnInformeGeneralActionPerformed(java.awt.event.ActionEvent evt) { //informe para 10paneles 1500 litros y 45º de inclinacion y 45ºC dialogo_graf_InformeGeneral.setSize(1200,850); dialogo_graf_InformeGeneral.setResizable(true); dialogo_graf_InformeGeneral.setVisible(true); DibujayGuarda_InformeGeneral_JFC(); dialogo_graf_InformeGeneral.dispose(); try{ String rutainforme="Informesireport\\Informegeneral.jasper";//fichero jasper generado
con ireport dentro del proyecto netbean JasperPrint informe=JasperFillManager.fillReport(rutainforme,null,conexion); JasperViewer ventanavisor=new JasperViewer(informe,false); ventanavisor.setTitle("INFORME GENERAL");
ventanavisor.setVisible(true);} catch(Exception e){JOptionPane.showMessageDialog(null,"Error al mostrar informe"+e); } //para las gráficas try{ String rutainforme1="Informesireport\\info_graf_general_demanda.jasper"; String rutainforme2="Informesireport\\info_graf_general_MJm2anual.jasper"; String rutainforme3="Informesireport\\info_graf_general_aportacion.jasper"; String rutainforme4="Informesireport\\info_graf_general_CSA.jasper"; //fichero jasper generado con ireport dentro del proyecto netbean JasperPrint informe1=JasperFillManager.fillReport(rutainforme1,null,conexion); JasperPrint informe2=JasperFillManager.fillReport(rutainforme2,null,conexion); JasperPrint informe3=JasperFillManager.fillReport(rutainforme3,null,conexion);
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
59
JasperPrint informe4=JasperFillManager.fillReport(rutainforme4,null,conexion); JasperViewer ventanavisor1=new JasperViewer(informe1,false); JasperViewer ventanavisor2=new JasperViewer(informe2,false); JasperViewer ventanavisor3=new JasperViewer(informe3,false); JasperViewer ventanavisor4=new JasperViewer(informe4,false); ventanavisor1.setTitle("INFORME GENERAL gráfica demanda"); ventanavisor1.setVisible(true); ventanavisor2.setTitle("INFORME GENERAL gráfica MJm2anual"); ventanavisor2.setVisible(true); ventanavisor3.setTitle("INFORME GENERAL gráfica aportación"); ventanavisor3.setVisible(true); ventanavisor4.setTitle("INFORME GENERAL gráfica CSA"); ventanavisor4.setVisible(true);} catch(Exception e){JOptionPane.showMessageDialog(null,"Error al mostrar informe"+e); }
}
C3.13.5.3. "Informe gráfico"
componente: btnInformegrafico [JButton] descripción: Genera un archivo que muestran las graficas de rendimiento,
aportación,sustitución, Demanda-Aportación y fchart. El contenido del informe se muestra en una ventana desde la cual podemos imprimirlo.
evento: private void btnInformegraficoActionPerformed(java.awt.event.ActionEvent evt) { try{//Guarda en la tabla los datos del proyecto //En la JTable GuardarResultadosACS(1); //dibuja las graficas y las archiva Dibuja_y_Guarda_enArchivo(); //se coloca en el ultimo registro y captura el número de proyecto String consulta="select * from resultadosACS order by Numero"; ResultSet r=sentencia.executeQuery(consulta); r.last();
int np=Integer.parseInt(r.getString("Numero"));//es un dato numérico String rutainforme="Informesireport\\Informe grafico.jasper";//numeproye es el nombre que le
dimos al parametro en ireport Map parametros=new HashMap(); parametros.put("numeproye",np); JasperPrint informe=JasperFillManager.fillReport(rutainforme,parametros,conexion); JasperViewer ventanavisor=new JasperViewer(informe,false); ventanavisor.setTitle("INFORME GRAFICO Instalación solar térmica para ACS en
"+r.getString("provincia")); ventanavisor.setVisible(true);
}catch(Exception e){JOptionPane.showMessageDialog(null,"Error en el informe"+" "+ e);}}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
60
C3.13.5.4. "Informe por provincias"
componente: btnInformeProvincia [JButton] descripción: Abre una ventana donde podemos ver el informe generado con los datos de tabla
mensual, almacenados en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.
evento: private void btnInformeProvincia_BDResultadosActionPerformed(java.awt.event.ActionEvent evt) {
try{ String rutainforme="Informesireport\\InformeACS_con_parametros.jasper"; //Localizacion es el nombre que le dimos al parametro en ireport Map parametros=new HashMap(); String prov=cboInformeProvincia_BDResultados.getSelectedItem().toString(); if(prov=="provincia"){JOptionPane.showMessageDialog(null,"Seleccione una provincia"); }else{ parametros.put("Localizacion",prov); JasperPrint informe=JasperFillManager.fillReport(rutainforme,parametros,conexion); JasperViewer ventanavisor=new JasperViewer(informe,false); ventanavisor.setTitle("INFORME DE PROVINCIA"); ventanavisor.setVisible(true);} }catch(Exception e){JOptionPane.showMessageDialog(null,"Error en el informe"+" "+ e); }
} C3.13.5.5. "Informe por paneles"
componente: btnInformeppaneles [JButton] descripción: Abre una ventana donde podemos ver el informe generado con los JPanel
seleccionados . En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.
evento: private void btnInformeppanelesActionPerformed(java.awt.event.ActionEvent evt) { Informa_por_paneles("Informesireport\\Informepp_entradaycalculos.jasper"); Informa_por_paneles("Informesireport\\Informepp_datosyresultados.jasper"); Informa_por_paneles("Informesireport\\Informepp_CalculoFchart.jasper");
}
C3.13.6. "Cerrar"
componente: btnCerrar_Resultados [JButton] descripción: Cierra esta ventana. evento: private void btnCerrar_ResultadosActionPerformed(java.awt.event.ActionEvent evt) {
BD_Resultados.dispose(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
61
C3.14. BD_Variacion_anual [JDialog]
Se abre con los botones “Guardar” y “Ver resultados” y con el botón “Resultados” del panel “INICIO” después de cerrar la ventana BD_Resultados.
figura 50. BD_Variaciones_anual
C3.14.1. tablaVariacion_anual [JTable]
Muestra los datos y resultados que se guardan en la tabla de la base de datos del programa. Estos valores se pueden consultar en los informes que genera el programa.
C3.14.2. "Eliminar fila"
componente: btnEliminarRegistro_variaciones [JButton] descripción: Elimina los datos de la fila seleccionada de la tabla. Una vez eliminado no se
puede recuperar. evento: private void btn_EliminaRegistro_variacionesActionPerformed(java.awt.event.ActionEvent evt)
{ EliminaFilaVariaciones(); }
C3.14.3. "Eliminar todo"
componente: btn_Eliminatodo_tablaVariacion [JButton] descripción: Elimina todos los registros de la tabla. Una vez eliminados no se recuperan. evento: private void btn_Eliminatodo_tablaVariacionActionPerformed(java.awt.event.ActionEvent evt) {
EliminaFilaVariaciones_todas(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
62
C3.14.4. "Elimina filas entre"
componente: btneliminaVariasFilas [JButton] descripción: Elimina las filas con varlor id comprendido entre los valores que pongamos en los
campos de texto “fila nº ”. evento: private void btneliminaVariasFilasActionPerformed(java.awt.event.ActionEvent evt) {
EliminaFilaVariaciones_selecionadas(); }
C3.14.5. "Informes"
componente: btnInforme_variaciones descripción: Abre una ventana donde podemos ver el informe generado con los datos de tabla
Variaciones, almacenados en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora. En el comboInfo_Variaciones [JComboBox] se marca la variable que define el informe.
evento: private void btnInforme_variacionesActionPerformed(java.awt.event.ActionEvent evt) { int info=comboInfo_Variacion.getSelectedIndex(); if(info==0){JOptionPane.showMessageDialog(null,"Seleccione una variable");} else{ dialogo_graf_variaciones_JFC.setSize(950,650); dialogo_graf_variaciones_JFC.setResizable(true); dialogo_graf_variaciones_JFC.setVisible(true); if(info==1){DibujayGuarda_Grafica_Variaciones("consumo"); Info_Variable("consumo","INFORME VARIACIONES CON EL CONSUMO DE ACS");} if(info==2){DibujayGuarda_Grafica_Variaciones("tempACS"); Info_Variable("tempACS","INFORME VARIACIONES CON LA TEMPERATURA DEL
ACS");} if(info==3){DibujayGuarda_Grafica_Variaciones("inclinacion"); Info_Variable("inclinacion","INFORME VARIACIONES CON LA INCLINACIÓN DE
LOS PANELES");} if(info==4){DibujayGuarda_Grafica_Variaciones("acumulacion"); Info_Variable("acumulacion","INFORME VARIACIONES CON EL VOLUMEN DEL
ACUMULADOR");} if(info==5){DibujayGuarda_Grafica_Variaciones("superficie"); Info_Variable("superficie","INFORME VARIACIONES CON LA SUPERFICIE DE
CAPTADORES");} if(info==6){DibujayGuarda_Grafica_Variaciones("b"); Info_Variable("b","INFORME VARIACIONES CON EL FACTOR DE EFICIENCIA
ÓPTICA (b)");} if(info==7){DibujayGuarda_Grafica_Variaciones("m"); Info_Variable("m","INFORME VARIACIONES CON EL m DE LOS COLECTORES");} if(info==8){DibujayGuarda_Grafica_Variaciones("FCCI"); Info_Variable("FCCI","INFORME VARIACIONES CON EL FCCI factor
intercambiador");} if(info==9){DibujayGuarda_Grafica_Variaciones("MAI"); Info_Variable("MAI","INFORME MAI ángulo de incidencia");}
dialogo_graf_variaciones_JFC.dispose();} }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
63
C3.14.6. "Resultados mensuales"
componente: btnVertablamensual_BDVA descripción: Guarda los datos y resultados mensuales en la tablamensual y abre la ventana
BD_tablamensual [JDialog] (figura 51) evento: private void btnVertablamensual_BDVAActionPerformed(java.awt.event.ActionEvent evt) {
GuardarTablamensual(); VerTablamensual_enJTable(1);}
C3.14.7. "Cerrar"
componente: btnCerrar_Variaciones descripción: Cierra esta ventana evento: private void btnCerrar_VariacionesActionPerformed(java.awt.event.ActionEvent evt) {
BD_Variacion_anual.dispose(); }
C3.15. BD_tablamensual [JDialog]
Se abre con el botón “Resultados mensuales” de la ventana BD_Variacion_anual [JDialog] y con el botón “Ver tabla mensual” del panel “Graficas JFree”.
figura 51. BD_tablamensual
C3.15.1. tablamensual [JTable] Muestra los datos y resultados mensuales que se guardan en la tabla de la base de datos del
programa. Estos valores se pueden consultar en los informes que genera el programa.
C3.15.2. "Eliminar grupo"
componente: btnEliminagrupoTablamensual [JButton] descripción: Elimina los datos de las filas con igual número “Id” al de la provincia seleccionada
seleccionada de la tabla. Una vez eliminado no se puede recuperar. evento: private void btnEliminagrupoTablamensualActionPerformed(java.awt.event.ActionEvent evt) {
EliminaFilasTablamensual(); }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
64
C3.15.3. "Informe mensual"
componente: btnInformemensual [JButton] descripción: Abre una ventana donde podemos ver el informe generado con los datos de tabla
mensual, almacenados en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.
evento: private void btnInformemensualActionPerformed(java.awt.event.ActionEvent evt) { Informe_mensual(); }
C3.15.4. "Cerrar"
componente: btnCerrarTablamensual [JButton] descripción: Cierra esta ventana. evento: private void btnCerrarTablamensualActionPerformed(java.awt.event.ActionEvent evt) {
BD_tablamensual.dispose(); } Cerrar el programa
Al cerrar el programa se cierra tambien la conexión con la base de datos. Los datos y resultados guardados durante la sesión quedarán almacenados en las tablas de la base de datos y podrán consultarse y emplearse en los informes en otras sesiones posteriores.
figura 52. Salir y cerrar la conexión con la base de datos.
cerrar
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo
65
2.1.2. Diagramas de flujo
Aceptar Calcula todo
Diálogo datos generales
Volver
Datos del sitio
Cancelar Continuar
Diálogo datos mensuales
Volver
Datos mensuales
Cancelar Continuar
CÁLCULOS
Nuevo proyecto
Diálogo nuevo proyecto
Cancelar provincia
INICIO
Inclinación : Desviación N-S (β): Corrección de H: Pérdidas globales: Nº de usuarios: Litros/día·usuario: Área de colector: Parámetros b y m : Corrección de b: Temperatura de uso: Precio del kw·h : €
Ocupación %mes Temperatura de red Radiacción H Factor k (inclinación) Horas sol Temperatura ambiente
Nº colectores
Volumen acumulador
por defecto
por defecto
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo
66
CÁLCULOS
Seleccionar meses
Seleccionar todos
Calcular Cancelar
mes
Consultar
Modificar datos
Datos del sitio
RESULTADOS
Calcular
Nº de colectores a instalar
Resultados
Calcular superficie resultante
DATOS& RESULTADOS
ACUMULADOR GRÁFICAS Gráficas
demanda-aportación
Consultar Modificar datos
Calcular
Volumen proyectado
Comprobar volumen
+ -
Acumulación por m2
F-Chart
Rendimiento
Inicio
b, m
+ -
inclinación
+ -
Temperatura
+ -
Imprimir
Resultados mensuales: Consumo ACS m3 Salto térmico Demanda termias Demanda MJ H corregida Energía neta incidente Intensidad incidente Energía neta disponible MJ/m2 Rendimiento colector Aportación solar por m2
Demanda MJ/mes Energía neta disponible MJ/m2
Demanda anual: MJ Energía/año·m2 : MJ Superficie colectora teórica: m2 Número de colectores teórico:
Superficie colectora resultante (A)
Resultados mensuales: Demanda MJ Energía neta disponible MJ/m2 Sustitución % Déficit de energía Coste eléctrico de la demanda Coste eléctrico del déficit Ahorro
Resultados anuales: Demanda anual: MJ Energía/año·m2 : MJ Aportación solar: % Déficit energético: MJ Ahorro anual : € Coste energía auxiliar: €
Datos y Resultados mes: Ocupación %mes Temperatura de red H corregida Factor k (inclinación) Energía neta incidente
Rendimiento mes Aportación solar relativa Sustitución mes
Demanda MJ/mes Energía neta total MJ/mes
0.8 < V/M <1.2
V
M
...Calcula todo
Horas sol Intensidad incidente Temperatura ambiente Rendimiento colector Consumo ACS m3
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo
67
Diálogo BD_variacion_anual
Informe por provincias
Informe gráfico
Informe por paneles
Informe general
Temperatura ACS Consumo m3/año Demanda MJ/año
Temperatura ACS Consumo m3/año b,m, inclinación superficie total acumulador
DATOS: Provincia (todas) Demanda MJ MJ/m2 año Aportación CSA
Imagen JPanel
Provincia Temperatura ACS Consumo m3/año Demanda MJ superficie total b,m, inclinación acumulador MJ/m2 año Aportación CSA Gráficas de : Rendimiento Ap.solar realtiva Sustitución Demanda-Aport CSA f-chart
Gráficas demanda-aportación
variaciones Base de datos de resultados
Nº de colectores
+ -
Inicio
Selaccionar mes Cancelar todos
Ocupación
+ -
Litros/día·ud
+ -
Temperatura
+ -
Inclinación
+ -
Ver resultados
Resultados anteriores
Guardar
Guardar resultado actual
Diálogo BD_Resultados
¿guardar? no sí Tabla variacionesFchartAnual* Tabla resultadosACS
eliminar
Eliminar Eliminar todo Informes
Cerrar
Eliminar filas entre
Localización Provincia Temp ACS Consumo ACS Demanda MJ Superf m2 Paneles b m FCCI* MAI* inclinación acumulación MJ/m2 año Aportación año CSA V/M M/A C/A
60< C/A <100
provincia panel
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo
68
Diálogo BD_variacion_anual
eliminar
Eliminar
Eliminar todo
Informes
Cerrar
Eliminar filas entre variable
Informes
Resultados mensuales
tabla_mensual
Diálogo BD_tablamensual
eliminar
Eliminar grupo Cerrar Informe mensual
provincia mes ocupación Consumo ACS Temp red Temp ambiente Temp ACS inclinación horas sol rendimiento Demanda MJ Aportación MJ Sustitución Qa Ea Ep f
Consumo ACS Temp ACS Acumulador superficie inclinación b m FCCI MAI
provincia Demanda MJ MJ/m2 año Aportación CSA V/M M/A C/A
provincia mes ocupación Consumo ACS Temp red Temp ambiente Temp ACS inclinación horas sol rendimiento Demanda MJ Aportación MJ Sustitución Qa Ea Ep f-chart
Consumo ACS Acumulador superficie b m FCCI MAI Demanda MJ MJ/m2 año Aportación CSA V/M M/A C/A
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo
69
F-Chart
Cargas caloríficas
Energía absorbida
Energía perdida
Datos Datos Datos
Diálogo fQa
aceptar
Diálogo fEa
aceptar
Diálogo fEp
aceptar
Calcula Qa Calcula Ea Calcula Ep
Calcular f
¿guardar? no sí Tabla variacionesFchartAnual
Tabla resultadosACS
Calor específico Nº usuarios: Litros/día·ud Temp ACS Temp red
bFCCI MAI
Temp ACSNº colectores
m kg acumulad(M) Temp mínima del ACS
Consumo de ACS litros/día Carga calorífica mensual (Qa)
Superficie resultante (A) Radiación incidente/m2 Energía solar absorbida
Factor F’rUL Factor k1 Factor k2 Dt (segundos) Energía perdida mensual
D1 D2
f Qu
CSA
f = 1.029*D1-0.065*D2-0.245*D12 + 0.0018* D22+0.0215* D13
Qa = Ce*C*N*(tac-tred) Ea = Sc*F’r*(τα)*Ri*N Ep = Sc*F’r*UL*(100-ta)*Dt*k1*k2 D1= Ea/Qa D2 = Ep/Qa Qu = f*Qa
por defecto
...Calcula todo
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo
70
Gráficas f-chart
variaciones Base de datos de resultados
Nº de colectores
+ -
Inicio
Selaccionar mes Cancelar todos
Ocupación
+ -
Litros/día·ud
+ -
Temperatura
+ -
Inclinación
+ -
Ver resultados
Resultados anteriores
Diálogo BD_Resultados
Guardar
Guardar resultado actual
¿guardar? no sí
Tabla variacionesFchartAnual*
Tabla resultadosACS
kg de acumulación
+ -
b
+ - + - + -
m
FCCI
Comprobar
37.5< M/A<300
FCCI* MAI* inclinación acumulación (M) MJ/m2 año Aportación año CSA V/M M/A C/A
Localización Provincia Temp ACS Consumo ACS Demanda MJ Superf m2 (A) Paneles b m
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo
71
Gráficas JFree
Guardar gráficas en archivo Ver gráficas RenAporSus Ver paneles en imagen
Ver tabla variaciones Ver gráficas DA Ver gráficas variaciones
Ver tabla mensual Ver gráfica f-chart Ver gráficas informe general
Diálogo BD_VariacionAnual
Diálogo BD_tablamensual
Carpeta “gráficas”
dialogo_graf_
RenAporSus_JFC DemApor_JFC fchart_JFC paneles_JFC variaciones_JFC InformeGeneral_JFC
paneles variable
Dibuja panel Dibuja gráfica
Consumo m3/año Consumo litros/dia Temperatura ACS Superficie m2 Inclinación Acumulador litros b m FCCI MAI
Datos Resultados Datos y resultados Acumulador Cálculo f-chart Variaciones f-chart Demanda-Aportación
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos
73
2.1.3. Acceso a Base de Datos desde nuestra aplicación Java. Para que nuestro programa Java pueda usar la base de datos ha sido necesario realizar los
siguientes pasos:
paso1. Colocar el fichero de base de datos en una subcarpeta de la carpeta del proyecto java. Para nuestra aplicación hemos creado el fichero “baseResultadosACS.mdb” dode se
almacenará toda la información que necesitemos gestionar para crear los “informes”. Es decir, hemos creado un fichero de base de datos. Este fichero se incluirá dentro del programa java en la carpeta “Base”. Nuestro programa java accederá a este fichero continuamente para añadir nuevos datos, eliminar datos, o extraer datos según lo ordene el usuario del programa.
paso2. Crear los objetos conexión (Connection) y sentencia (Statement) Primero definimos estos objetos como globales en la clase “Cuadro”, para así poderlos usar
desde cualquier lado. Además será necesario indicar el import para las clases Connection y Statement. Estos import son respectivamente: java.sql.Connection y java.sql.Statement
paso3. Método: controlador, conexión y sentencia. Una vez definidos los objetos conexión y sentencia, para que nuestro programa pueda acceder
a la base de datos “baseResultadosACS” creamos el método “PrepararBaseDatos” al que llamaremos desde el constructor.
paso3.1. Cargar el controlador del tipo de base de datos a usar El controlador define el tipo de base de datos que se va a usar (base de datos de Access, o de
MySQL, o de cualquier otro gestor de base de datos) En nuestro caso, tendremos que indicar el controlador para base de datos de Access.
String controlador = "sun.jdbc.odbc.JdbcOdbcDriver";
paso3.2. Crear el objeto conexión indicando el fichero de la base de datos.
Para crear la conexión es necesario añadir (import) la clase DriverManager. El objeto “conexion” es el que efectúa la conexión real con la base de datos. Para construir este
objeto hacen falta tres datos: � El nombre del usuario que manipulará la base de datos. En el caso de Access no necesitamos
indicar ningún nombre de usuario.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos
74
� El password del usuario que manipulará la base de datos. En el caso de Access tampoco necesitaremos ningún password.
� La DSN de la base de datos. DSN significa “nombre del origen de datos” y es una cadena de
texto que contiene información sobre el fichero de base de datos que queremos usar. En el código, la creación de la DSN será:
String DSN = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ="+ "Base\\resultadosACS.mdb ";
Con estos datos creamos el objeto "conexion" con la instrucción :
conexion=DriverManager.getConnection(DSN,user,password);
paso3.3. Crear el objeto sentencia a partir del objeto conexión
El objeto “sentencia” será el que nos permita ejecutar órdenes SQL sobre la base de datos. Es
decir, el objeto que nos permite actuar y manipular la base de datos. El objeto sentencia se crea a partir del objeto conexión creado en el paso anterior, usando la
siguiente instrucción:
sentencia=conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
Se usará el objeto “sentencia” para ejecutar consultas SQL en la base de datos. Dichas
consultas se almacenan en objetos del tipo “ResultSet” los cuales permiten seleccionar el registro de una tabla de la base de datos y extraer el datos de un campo en concreto.
paso4. Finalmente debemos programar el evento “windowClosing” de la ventana principal de forma que se cierre la conexión al salir del programa.
Esta preparación se debe realizar en el momento en que se ejecuta el programa, por lo cual
hemos introducido este código en el constructor. A continuación mostramos la parte del código, de nuestra aplicación java, donde aparecen los elementos descritos para acceder a la base de datos que se utiliza en dicha aplicación.
* * @author Eduardo */ ... import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.Statement; ... public class Cuadro extends javax.swing.JFrame { ...
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos
75
//varibles globales para acceso a Base de datos access Connection conexion; Statement sentencia; DefaultTableModel mt,mtv,mtmes; ... public Cuadro() { initComponents(); PrepararBaseDatos();// llamada al método PrepararTablaResultados(); PrepararTablaVariacion_anual(); PrepararTabla_mensual(); ...}}... //Método para acceso a base de datos //1.-creamos carpeta Base con el archivo Access baseResultadosACS.mdb //2.-Variables globales para la conexión y sentencia //3.-Cargar controlador, crear objetos conexión y sentencia "PrepararBaseDatos()","Cerrar_la_conexion()" //4.-JTable "tablaResultadosACS" donde visualizar los datos,"PrepararTablaResultados()" //5.-Método para guardar los resultados "GuardarResultadosACS()" public void PrepararBaseDatos(){ try {//1.-Cargar el controlador de Access=sun.jdbc.odbcOdbcDriver, segun el tipo de basedeDatos //en MySQL se usa la cadena: com.mysql.jdbc.Driver String controlador = "sun.jdbc.odbc.JdbcOdbcDriver"; Class.forName(controlador).newInstance();//para activar el controlador } catch (Exception e) { JOptionPane.showMessageDialog(null, "Error en la carga del controlador --"+e); } //2.-Creamos el objeto conexion conection try { //String DNS="jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ="+"carpeta en este
proyecto\\nombreArchivo.MDB"; String DNS = "jdbc:odbc:Driver={Microsoft Access Driver(*.mdb)}; DBQ="+"Base\\baseResultadosACS.mdb"; String user = ""; String password = ""; conexion = DriverManager.getConnection(DNS,user,password); } catch (Exception e) { JOptionPane.showMessageDialog(null, "Error en la conexión "+e); } //3.-Creamos el objeto sentencia try{ sentencia=(Statement) conexion.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY );} catch(Exception e){JOptionPane.showMessageDialog(null,"Error en la sentencia "+e); Cerrar_la_conexion();} } void Cerrar_la_conexion(){//cuando cerremos la ventana try{conexion.close();} catch(Exception e){JOptionPane.showMessageDialog(null,"No se pudo cerrar la conexión "+e);} }
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos
76
2.1.3.2. Métodos para guardar datos y resultados en nuestra base de datos
public void GuardarResultadosACS(int loveo){... } public void GuardarVariacionAnual(int loveo){...} public void Almacena_simulacion_sinverlo(){...} public void guardar_variacionesycomprobaciones(){...} public void GuardarTablamensual(){...} public void PonerFila_enBlanco(){...} public void PonerFilaVariaciones_enBlanco(){...}
2.1.3.3. Métodos para borrar datos de una tabla de nuestra base de datos public void EliminaFila(){...} public void EliminaFilaVariaciones(){...} public void EliminaFilasTablamensual(){...} public void EliminaFilaVariaciones_todas(){...} public void EliminaFilaResultados_todas(){...} public void EliminaFilaVariaciones_selecionadas(){...} public void EliminaFilaResultados_selecionadas(){...} public void Eliminar_fila_enBlanco(String tabla){...}
2.1.3.4. Representación de tablas de la base de datos en un JTable El objeto JTable nos permite introducir tablas en nuestras aplicaciones.En estos objetos
podemos mostrar el contenido de una tabla de la base de datos o del resultado de una consulta. Para extraer datos de la base de datos realizamos una consulta SQL de tipo SELECT cuyo
resultado se almacena en un objeto ResultSet. Un ResultSet básicamente es una tabla almacenada en memoria (y por tanto no visible). Podemos trasladar el contenido de un ResultSet a un JTable para que el usuario lo pueda visualizar dentro de nuestra aplicación java.
Agregamos, como variables globales al proyecto, los objetos “modelo de tabla”
(DefaultTableModel), para cada una de las tres tablas que utilizamos, llamados mt, mtv y mtmes. También añadiremos en el constructor una llamada los métodos PrepararTablaResultados(),PrepararTablaVariacion_anual(),PrepararTabla_mensual() y programamos dichos métodos.
public void PrepararTablaResultados(){... } public void PrepararTablaVariacion_anual(){... } public void PrepararTabla_mensual(){... }
El proceso básicamente el siguiente: Base de Datos � ResultSet � Vector � Modelo de Tabla � JTable � De la base de datos extraemos datos a un ResultSet. (Esto se hace ejecutando una consulta
SQL de tipo SELECT a través del objeto sentencia)
� Del ResultSet extraemos los datos a un modelo de tabla. (Esto se hace recorriendo el ResultSet y almacenando cada registro en un vector)
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos
77
� Almacenamiento del vector en el modelo de tabla. (Cada vector extraido del ResultSet se inserta como fila en el modelo de tabla)
� Se asigna el modelo de tabla al objeto JTable. (Al hacer esto el objeto JTable muestra el contenido del modelo)
Los métodos creados son:
public void VerResultados_enJTable(int loveo){... } public void VervariacionesFchartAnual_enJTable(int loveo){...} public void VerTablamensual_enJTable(int loveo){...}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
79
2.1.4. Informes
Una vez creado el programa, surgió la necesidad de imprimir documentos tales como listados
de datos y resultados, gráficos, etc. Estos documentos se rellenan con datos tomados directamente desde la base de datos de nuestro programa. A estos documentos los llamaremos “ informes” . Para crear estos documentos necesitamos usar un programa de creación de informes. En nuestro caso, hemos usado un programa gratuito llamado Ireport que hemos descargado de la página http://www.jasperforge.org/sf/projects/ireport. Este programa permite definir la estructura general del informe (sin tener en cuenta los datos).
Es necesario indicar la conexión a la base de datos y la consulta SQL para extraer los datos que
aparecerán en el informe. Una vez creado el informe, este se enlaza con nuestra aplicación, de forma que cuando el
usuario pulse la opción de imprimir, el informe se rellene con los datos de la base de datos y luego sea enviado a la impresora.
2.1.4.1. Conexión con Informes desde Java Cuando creamos un informe con iReport, se genera un fichero del tipo .jasper. Los ficheros
.jasper son informes compilados, de forma que puedan ser usados en aplicaciones java. Para que nuestro programa sea capaz de presentar informes, hemos creado una carpeta llamada
“informesireport” dentro de la carpeta de nuestro programa. Y dentro de dicha carpeta hemos copiado los ficheros .jasper de los informes que queremos utilizar.
En nuestra aplicación, el informe aparece en una ventana (el visor de informes, objeto
JasperViewer) que tiene una pequeña barra de herramientas. En esta barra podrá imprimir el informe o cambiar su zoom, entre otras opciones.
Los ficheros que contienen las librerías necesarias para el programa iReport son los siguientes:
commons-collections-2.1, commons-logging-1.0.2 y jasperreports-2.0.1. Gracias a la inclusión de estos ficheros, nuestro proyecto ya dispone de las librerías de clases que contienen a las clases que necesitamos ( JasperPrint, JasperFillManager, JasperViewer). Una vez agregadas estas librerías, el proceso para imprimir un informe es el siguiente:
� Crear un objeto del tipo JasperPrint (el informe) � Crear un objeto visor (JasperViewer) que permita visualizar el informe o bien imprimir
directamente el informe con un objeto JasperPrintManager. Cuando un informe tiene una instrucción SQL fija, siempre mostrará los mismos datos. En
otros casos parte de la instrucción SQL del informe puede variar, de forma que extrae distinta información según el dato que varía. Estos datos variantes se denominan parámetros. El parámetro debe ser sustituido por un valor que es proporcionado desde la aplicación java, y es entonces cuando la instrucción SQL se completa y se ejecuta. En la aplicación java es necesario
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
80
crear un objeto de tipo Map que contenga los distintos parámetros con los valores de cada uno para luego enviar este objeto al informe que se quiere mostrar.
2.1.4.2. Informes en nuestro programa.
Informe 1. Informe por paneles Informe 2. Informe mensual Informe 3. Informe gráfico Informe 4. Informe por variables Informe 5. Informe general
Para los informes se emplean los datos alamacenados en las tablas del archivo
“baseResultadosACS.mdb” de la carpeta “Base” del programa y los archivos .jasper de la carpeta “informesireport” del programa. Dichas tablas son:
� resultadosACS � variacionesFchartAnual � tabla_mensual
A continuación describiremos brevemente los principales informes que se pueden generar con el programa.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
81
Informe 1. “Informe por paneles“
Permite imprimir y guardar como archivo pdf todos los paneles [Jpanel] principales del programa con los datos y resultados del proyecto en curso.
Botón btnInformeppaneles [JButton] (figuras 48 y 49) Origen de datos Tabla resultadosACS Archivo .jasper Informepp_entradaycalculos.jasper
Informepp_datosyresultados.jasper Informepp_CalculoFchart.jasper
evento public void Informa_poe_paneles(String rutainforme){...} private void btnInformeppanelesActionPerformed(java.awt.event.ActionEvent evt) { Informa_por_paneles("Informesireport\\Informepp_entradaycalculos.jasper"); Informa_por_paneles("Informesireport\\Informepp_datosyresultados.jasper");
Informa_por_paneles("Informesireport\\Informepp_CalculoFchart.jasper"); }
figura 53.- Informe por paneles
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
82
Informe 2. “Informe mensual“
Permite imprimir y guardar como archivo pdf los datos y resultados mensuales del proyecto en curso.
Botón btnInformemensual [JButton] (figura51) Origen de datos Tabla variacionesFchartAnual
Tabla tabla_mensual Archivo .jasper Subinforme_mensual2.jasper
Informe_mensual2.jasper evento public void Informe_mensual(){...}
private void btnInformemensualActionPerformed(java.awt.event.ActionEvent evt) {
Informe_mensual(); }
figura 54.- Informe mensual
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
83
Informe 3. “Informe gráfico“ Permite imprimir y guardar como archivo pdf las graficas de rendimiento, sustitución,
aportación solar relativa, demanda-aportación y F-Chart, del proyecto en curso, en una página.
Botón btnInformegrafico [JButton] (figuras 48 y 49) Origen de datos Tabla resultadosACS Archivo .jasper Informe grafico.jasper evento private void btnInformegraficoActionPerformed(java.awt.event.ActionEvent evt) {...}
figura 55.- Informe gráfico
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
84
Informe 4. “Informes“ (variable) Permite imprimir y guardar como archivo pdf los datos y resultados anuales del proyecto en
curso para distintos valores de una de las siguientes variables: Ocupación (consumo), Temperatura ACS, Inclinación, Acumulación, Superficie, b, m, FCCI,
MAI. Para cada variable se genera un informe en el que, manteniendo fijas las demás, se muestra en forma de gráficas como varían los resultados anuales de Aportación y CSA. Además se muestra en forma de de tabla los resultados de demanda, MJm2 y condiciones de diseño para cada valor de la variable en estudiada.
Botón BtnInforme_variaciones [JButton] (figura50) Origen de datos Tabla variacionesFchartAnual Archivo .jasper Info_Variable_”variable”.jasper, hay un archivo .jasper para cada variable evento public void Info_Variable(String var,String titulo){...}
public void DibujayGuarda_Grafica_Variaciones(String varX){...} private void btnInforme_variacionesActionPerformed(java.awt.event.ActionEvent evt) { int info=comboInfo_Variacion.getSelectedIndex(); if(info==0){JOptionPane.showMessageDialog(null,"Seleccione una variable");} else{ dialogo_graf_variaciones_JFC.setSize(950,650); dialogo_graf_variaciones_JFC.setResizable(true); dialogo_graf_variaciones_JFC.setVisible(true); if(info==1){DibujayGuarda_Grafica_Variaciones("consumo"); Info_Variable("consumo","INFORME VARIACIONES CON EL CONSUMO DE
ACS");} ... dialogo_graf_variaciones_JFC.dispose();}
}
figura 56.- Informe variaciones con el consumo de ACS.
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
85
Informe 5. “Informe general“ Genera los siguientes informes: 5.1. INFORME GENERAL Permite imprimir y guardar como archivo pdf los datos y resultados anuales de todos los
proyecto guardados el la tabla resultados ACS. El objeto de este informe es ver como varián los resultados anuales según la localización del proyecto.
5.2. INFORME GENERAL gráfica demanda Permite imprimir y guardar como archivo pdf la gráfica de los valores de la demanda anual de
energía para cada provincia de España fijando los demás datos. 5.3. INFORME GENERAL gráfica MJm2 anual Permite imprimir y guardar como archivo pdf la gráfica de los valores de MJm2 anual en cada
provincia de España fijando los demás datos. 5.4. INFORME GENERAL gráfica aportacion Permite imprimir y guardar como archivo pdf la gráfica de los valores de la aportación solar
anual de energía para cada provincia de España fijando los demás datos. 5.5. INFORME GENERAL gráfica CSA Permite imprimir y guardar como archivo pdf la gráfica de los valores de la CSA para cada
provincia de España fijando los demás datos.
Botón btnInformeGeneral [JButton] (figuras 48 y 49) Origen de datos Tabla resultadosACS Archivo .jasper Informegeneral.jasper
info_graf_general_demanda.jasper info_graf_general_MJm2anual.jasper info_graf_general_aportacion.jasper info_graf_general_CSA.jasper
evento private void btnInformeGeneralActionPerformed(java.awt.event.ActionEvent evt) {...}
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
86
figura 57.- página 1 de INFORME GENERAL
figura 58.- INFORME GENERAL gráfica demanda y MJm2anual
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
87
figura 59.- INFORME GENERAL gráfica aportación y CSA
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
89
2.2. Memoria de cálculos Siguiendo el método de cálculo de CENSOLAR [1], calcula el número de colectores teórico
para cubrir la demanda energética anual en función de la radiación solar anual por m2, calculada para una inclinación dada y en la provincia seleccionada. Con este resultado el usuario decide el número de colectores que quiere instalar y, en función de la superficie resultante, el programa calcula la aportación solar anual y el déficit energético anual. Por otro lado, para los mismos datos de consumo de ACS, el programa aplica el método F-chart y calcula la cobertura solar anual con el mismo número de colectores decidido tras los resultados del método anterior.
El programa permite cambiar el valor de las variables que intervienen en los dos métodos y ver
de forma gráfica como influyen en el resultado. Como hay variables que se emplean en uno y en el otro no, no se trata de comparar el resultado de los dos métodos de cálculo sino de tener dos referencias a la hora de estimar la aportación solar de una instalación para la producción de ACS, mediante colector solar plano, para unas condiciones de consumo y localización dadas.
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
90
El presente apartado se compone de las siguientes partes: 2.2.1. Datos y resultados 2.2.2. Datos por defecto 2.2.3. Cálculo de las cargas de consumo de ACS 2.2.4. Dimensionado de la superficie de colectores
2.2.4.1. Justificación de cálculos 2.2.5. Código java para los cálculos
2.2.5.1. Consumo mensual de ACS 2.2.5.2. Salto térmico 2.2.5.3. Necesidades energéticas mensuales 2.2.5.4. Radiación media sobre superficie horizontal 2.2.5.5. Radiación media sobre superficie inclinada 2.2.5.6. Intensidad media útil de radiación solar 2.2.5.7. Rendimiento del colector solar plano 2.2.5.8. Aportación solar por m2 2.2.5.9. Energía neta disponible 2.2.5.10. Superficie colectora 2.2.5.11. Energía total obtenida 2.2.5.12. Aportación de energía solar 2.2.5.13. Déficit de energía 2.2.5.14. Aportación solar anual
2.2.6. Método F-chart 2.2.7. Código java para los cálculos (F-chart)
2.2.7.1. Estimación de la carga calorífica 2.2.7.2. Estimación de la energía absorbida y perdida 2.2.7.3. Cálculo del parámetro de ganancia D1 2.2.7.4. Cálculo del parámetro de pérdidas D2 2.2.7.5. Cobertura solar mensual f 2.2.7.6. Cobertura solar anual CSA 2.2.7.7. Volumen de acumulación
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
91
2.2.1. Datos y resultados Partiendo de los datos de la columna de izquierda el programa calcula los de la derecha. Método 1: basado en CENSOLAR [1]
DATOS RESULTADOS Inclinación : Desviación N-S (β): 0 Corrección de H: Pérdidas globales: Nº de usuarios: Litros/día·usuario: Área de colector: Parámetros b y m del colector: Corrección de b: Temperatura de uso: Precio del kw·h : € Ocupación %mes Datos mensuales
Temperatura de red Radiación H Factor k (inclinación) Horas sol Temperatura ambiente
Nº colectores a instalar
Resultados mensuales: Consumo ACS m3 Salto térmico Demanda termias Demanda MJ H corregida Energía neta incidente Intensidad incidente Energía neta disponible MJ/m2 Energía neta total MJ/mes Rendimiento de un colector Aportación solar por m2 Sustitución % Déficit de energía Coste eléctrico de la demanda Coste eléctrico del déficit Ahorro
Resultados anuales: Demanda anual: MJ Energía/año·m2 : MJ Aportación solar: % Déficit energético: MJ Ahorro anual : € Coste energía auxiliar: €
Superficie colectora teórica: m2 Número de colectores teórico: Superficie colectora resultante (A) Condición de diseño: 60<C/A<100
VARIACIONES (*) Ocupación Litros/día·usuario Temperatura de uso Inclinación Número de colectores
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
92
Método 2 basado en F-Chart
DATOS RESULTADOS Inclinación : Desviación N-S (β): 0 Corrección de H: Pérdidas globales: Nº de usuarios: Litros/día·usuario: Área de colector: Parámetros b y m del colector: Corrección de b: Temperatura de uso: Ocupación %mes Datos mensuales
Temperatura de red Radiación H Factor k (inclinación) Horas sol Temperatura ambiente
Nº colectores a instalar Calor específico Modificación del ángulo de incidencia Factor captador-intercambiador Acumulación por m2 Volumen de acumulación (M) Temperatura mínima del ACS
Consumo de ACS litros/día Carga calorífica mensual Superficie resultante (A) Energía solar absorbida mensual Factor F’rUL Factor k1 corrección por acumulación Factor k2 corrección por Energía perdida mensual Variable D1 para f Variable D2 para f Fracción solar mensual f Energía solar útil mensual Fracción solar anual CSA volumen de acumulación teórico (V) Condiciones de diseño
0.8<=V/M<=1.2 37.5<=M/A<=300
VARIACIONES(*) Ocupación Litros/día·usuario Temperatura de uso Inclinación Número de colectores Kg de acumulación b m Factor captador-intercambiador Modificación ángulo de incidencia (**)
(**) no tiene botones "+-" (*) Denominamos "variaciones" a las variables para las cuales el programa dispone de
"botones +-" con los que podemos ver las variaciones de los resultados en función del incremento de estás variables. Cada vez que pulsamos "+" o "-" aumenta o disminuye, en una cantidad fijada, el valor de la variable correspondiente y se recalculan todas las operaciones y se dibujan las gráficas con los nuevos valores y resultados. Las variaciones afectan a los dos métodos y variarán los resultados según influyan o no.
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
93
Además de estas variaciones, podemos cambiar cualquier otro dato introduciendo su valor, mediante teclado, en el campo de texto correspondiente.
2.2.2. Datos por defecto. El programa tiene la opción de introducir los siguientes valores por defecto: Inclinación : 45 Desviación N-S (β): 0 0 Corrección de H: 1.05 Pérdidas globales: 0.15 Nº de usuarios: 32 Litros/día·usuario: 40 Área de colector: 2.01 Parámetros b y m del colector: 0.83 y 4.8 Corrección de b: 0.94 Temperatura de uso: 45 Precio €/kwh 0.12 Ocupación %mes 100 Temperatura de red Según provincia Radiación H Según provincia Factor k (inclinación) Según provincia Horas sol Según provincia Temperatura ambiente Según provincia Calor específico 4184 J/kgºC Modificación ángulo de incidencia 0.96 Factor captador-intercambiador 0.95 Acumulación por m2 70 litros Temperatura mínima del ACS 45 Valores mensuales por defecto. En función de la provincia y la inclinación seleccionadas el programa introduce los valores
para cada mes de: � Temperatura de red � Radiación H � Factor k (inclinación) � Horas sol � Temperatura ambiente
(fuente CENSOLAR [2]) Con cada opción de "Valores por defecto" el programa introduce los valores por defecto
correspondientes al evento que se esté ejecutando en ese momento.
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
94
El programa incorpora un botón llamado "Calcula todo" con el cual, una vez seleccionada la provincia, nos pide que indiquemos el número de colectores y el volumen del acumulador. Con estos dos datos y tomando todos los "valores por defecto" anteriores realiza todas las operaciones a la vez. Esta opción se diseñó para ofrecer una forma rápida de comparar los resultados en función de la provincia seleccionada manteniendo todos los demás datos iguales.
A continuación describiremos cómo se realizan los cálculos necesarios en el programa.
2.2.3. Cálculo de la carga de consumo Una vez seleccionada la localización del proyecto, el programa nos pedirá los siguientes datos: � Inclinación: Ángulo que formarán los colectores respecto a la superficie horizontal. Por
defecto, toma el valor de 45º pero tenemos la opción de tomar los valores 35,40,45,50,55 y 60. (ventana datos generales)
� Desviación N-S: por defecto 0º, todos los datos en el programa están referidos a este valor.
� Corrección de H: factor que modifica el valor de la radiación media diaria sobre superficie horizontal (H), por defecto el programa toma un valor de 1.05, (valor para niveles de contaminación atmosférica muy bajos).
� Pérdidas globales: por defecto toma un valor de 0.15 como valor recomendado (CENSOLAR[1]), cuando no se dispone de datos para estimar las pérdidas de calor, que dependen del aislamiento y del tipo de consumo.
� Nº de usuarios: Número máximo de usuarios, en un mes, para los que se calcula la instalación.
� Litros/día·usuario: Consumo diario estimado para cada usuario. Por defecto, 40 litros.
� Área del colector: superficie útil en m2 del colector que el proyectista decida instalar. Por defecto toma 2.01 m2.
� Parámetro b: factor de eficiencia óptica de los colectores, por defecto b=0.83.
� Parámetro m: Coeficiente de pérdidas de los colectores, por defecto m=4.8.
� Temperatura de uso: temperatura de uso del ACS, por defecto 45ºC.
� Precio del kwh: por defecto, energía eléctrica, 0.12€/kwh. Todos estos datos se introducen en la ventana "Datos generales", podemos seleccionar los
valores por defecto o introducir el valor que queramos por teclado.
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
95
figura 1. ventana Datos generales Pulsando "Continuar" el programa asigna estos datos al proyecto y partir de aquí podemos
calcular las necesidades energéticas para cada mes, para lo cual necesitamos conocer los siguientes datos mensuales:
� Ocupación: es el porcentaje del número máximo de usuarios que cada mes utilizará la
instalación. Por defecto tiene un valor del 100% todos los meses, podemos cambiarlo en la ventana "Datos mensuales" y con los botones +- en los paneles "Gráficas f-chart" y "Gráficas demanda-aportación".
� Consumo mensual (m3): es el consumo total de ACS cada mes, en m3.
� Temperatura media del agua red: Por defecto el programa toma los valores de la capital de la provincia seleccionada en el proyecto (fuente CENSOLAR[1]), podemos consultarlos en el panel "DATOS&RESULTADOS".
� Salto térmico: Diferencia entre la temperatura de uso y la temperatura de red.
� Demanda energética : energía necesaria para calentar el agua desde la temperatura de red hasta la de consumo. El valor calculado aparece en la columna neMJ del el panel "CÁLCULOS".
2.2.4. Dimensionado de la superficie de colectores
Se calculará una superficie colectora "teórica", siguiendo el método de CENSOLAR[1],
dividiendo la necesidad energética anual entre la disponible por metro cuadrado de superficie expuesta a la radiación solar.
En el programa java, primero se calcula la demanda de energía anual (DemandaAnual)
sumando la demanda de cada mes (vDemanndaMJme[i]), después calcula la energía neta disponible por m2 al año (ENDañoM2) sumando la energía disponible cada mes (vENDmes[i]) , dividiendo estos dos valores obtiene la superficie SCteorica. Con el dato de la superficie de un colector (Acol), que toma de las datos de inicio, calcula el número de colectores necesarios (Ncteorico) para cubrir dicha superficie. Para todo esto necesitamos conocer los siguiente datos:
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
96
Justificación de cálculos: � Necesidad energética diaria en MJ.
� H = Energía incidente en un m2 horizontal (MJ), su valor mensual aparecerá en la ventana
"Datos mensuales" para la provincia seleccionada.(fuente CENSOLAR[2])
� Valor de H corregido: por defecto, multiplica H por el factor 1.05 (valor para zona de sierra de atmósfera limpia), su valor resultante puede consultarse en el panel "DATOS&RESULTADOS".
� Coeficiente de corrección k para una latitud de la provincia seleccionada y la inclinación
tomada como dato, su valor para cada mes aparece en la ventana "Datos mensuales". (fuente CENSOLAR[2])
� Energía neta incidente (MJ/m2): E=0.94kH. Considera que un 6% de la energía incidente no
se aprovecha debido a los momentos en que la intensidad es menor del valor umbral 200 W/m2 (CENSOLAR[1])
� Nº de horas de sol útiles, sus valores dependen de la provincia seleccionada y puede
consultarse en el panel "DATOS&RESULTADOS" . (fuente CENSOLAR[2])
� Intensidad media útil I, en W/m2, se obtiene dividiendo E (previamente pasada a julios) por las horas de sol útiles (pasada a segundos). "DATOS&RESULTADOS"
� Temperatura ambiente durante las horas de sol: sus valores dependen de la provincia
seleccionada y puede consultarse en el panel "DATOS&RESULTADOS" . (fuente CENSOLAR[2])
� Rendimiento de los colectores. Por defecto, considera un colector con cubierta y destinado a
la obtención de ACS, el factor b se corrige multiplicándolo por 0.94. Su valor resultante puede consultarse en el panel "DATOS&RESULTADOS".
� Aportación solar por m2: Se obtiene multiplicando la energía neta incidente (E) por el
rendimiento de los colectores. Su valor mensual se puede consultar en el panel "CÁLCULOS".
� Energía neta disponible al día por m2: corregimos la Aportación con el factor 0.85 a fin de considerar las pérdidas producidas en el acumulador (15%).
� Energía neta disponible al mes por m2: multiplica por el número de días de cada mes. Su valor puede consultarse en el panel "CÁCULOS" y en la columna ENDmes del panel "RESULTADOS".
� Superficie colectora necesaria. Para ello dividimos la demanda energética total entre la energía neta disponible por m2.
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
97
Una vez decidido el número de colectores a instalar, el programa continúa realizando los siguientes cálculos. � Energía solar disponible: Se obtiene multiplicando la superficie proyectada por la energía
neta por m2 � Sustitución: representa la fracción de consumo energético que es satisfecha por la energía
solar. � Déficit energético: Representa la energía auxiliar que hay que aportar los meses en que la
energía solar no basta por sí sola para cubrir el 100% de las necesidades.
� Coste de la energía eléctrica ( € por kwh) para cubrir el 100% de la demanda.
� Coste de la energía eléctrica para cubrir el déficit.
� Ahorro en el coste de energía eléctrica.
2.2.5. Código java para los cálculos
A continuación veremos como se realizan todos estos cálculos en el programa java.
2.2.5.1. Cálculo del consumo mensual de agua
Multiplica los litros/día·usuarios (LitrosDia) por el número de usuarios (NunUsu), por el
número de días del mes correspondiente (vDias[i]) y por el porcentaje de ocupación del mes calculado vOcupacion[i].
El programa nos da la opción de recalcular el consumo cambiando la ocupación y los litros
diarios y así observar como varían los demás resultados en función de estas variables. Para esto, en el método se incluyen los vectores vDAporceocupacion[i] y vDAporcelitros[i]. Son vectores de 12 componente que representan, para cada mes, la fracción entre el valor inicial y el nuevo valor. Inicialmente todos tienen valor 1. Así, cuando cambiamos, con los botones +-, el valor de estas variables el programa calcula el porcentaje de variación y lo aplica al cálculo, en función de donde intervenga dicha variable (en este caso en el consumo). De esta manera podemos recuperar el resultado inicial haciendo que estos vectores tomen el valor 1 en todos sus componentes (Botón "Cancelar" en los paneles "Gráficas f-chart" y "Gráficas demanda-aportación").
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
98
En el programa java:
clase: LocalizacionACS objeto: pueblo variables: VConsumo[i] : resultado del consumo de ACS en el mes [i]
LitrosDia : dato del consumo de ACS por día y usuario NumUsu : dato del número de usuarios vDias[i] : dato del número de días del mes [i] vOcupación: dato del % de usuarios en el mes [i] vDAporceocupacion[i]: porcentaje de la nueva ocupación respecto a la ocupación inicial en el mes [i] vDAporcelitros[i]: porcentaje del nuevo litros/día·usuario respecto a su valor inicial en el mes [i]
método: public void Calcula_vConsumo(){ for(int i=0;i<12;i++){ vConsumo[i]=(LitrosDia*NumUsu*vDias[i]*vOcupacion[i])/100000; vConsumo[i]=vConsumo[i]*vDAporceocupacion[i];//para calculo variando ocupacion en DA vConsumo[i]=vConsumo[i]*vDAporcelitros[i];//para los calculo variando los litros en DA ConTresDecimales();
vConsumo[i]=Double.valueOf(formateador.format(vConsumo[i])); } } Los valores calculados podemos consultarlos en el panel "DATOS&RESULTADOS"
2.2.5.2. Cálculo del salto térmico ( ∆T )
El salto térmico es la diferencia de temperatura entre, la temperatura de la red de distribución
de agua y la temperatura de uso o consumo del agua caliente sanitaria, producida en la instalación. Por defecto, los datos incluidos en el programa están referidos a la capital de la provincia seleccionada en cada proyecto pero también tenemos la opción de introducir los valores que queramos en la tabla de la ventana "datos mensuales".
De este salto térmico depende, la cantidad de energía que será necesario aportar mediante el
sistema de agua caliente sanitaria por energía solar, y el rendimiento de la instalación. El valor de la temperatura de uso, por defecto de 45 ºC, podemos modificarlo en la ventana de
"datos de entrada" y con los botones "Masmenos" de los paneles[JPanel] "Grafica demanda-aportación" y "F-chart".
En el programa java:
clase LocalizacionACS objeto pueblo variables vSalto[i] : resultado del salto térmico en el mes [i]
Tuso : dato de la temperatura de uso del ACS VTred [i]: dato temperatura del agua red, para provincia seleccionada, en el mes [i]
método public void Calcula_vSalto(){ for(int i=0;i<12;i++){ vSalto[i]=Tuso-vTred[i]; } }
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
99
Los valores resultantes podemos consultarlos en el panel "CALCULOS" con el botón "consultar".
2.2.5.3. Cálculo de las necesidades energéticas mensuales (neMJ) Estos cálculos se realizarán calculando la energía necesaria para calentar, los litros de agua
calculados en el consumo, desde la temperatura de red de distribución hasta la temperatura de consumo durante todos los días de cada mes. Los cálculos se realizan según la siguiente ecuación:
Q = m * Cp * ( ∆T )* N° días En donde:
� m es la cantidad de agua a calentar cada día. � Cp es el calor especifico del agua 4.184 KJ / litro � ∆T es el incremento de temperatura que del agua ºC � Q es la necesidad energética mensual MJ / mes � N° días es el número de días de cada mes.
El programa nos da la opción de recalcular la demanda energética cambiando la ocupación, litros diarios y la temperatura de uso y así observar como varían los demás resultados en función de estas variables. Para esto, en el método se incluyen los vectores vDAporceocupacion[i] y vDAporcelitros[i], descritos anteriormente y el vector vDAporcetuso[i] para las variaciones de la temperatura de uso respecto al valor inicial del proyecto en que se esté calculando.
En el programa java:
clase LocalizacionACS objeto pueblo variables vDemandaMJmes[i] : resultado de la demanda energética en el mes [i]
vConsumo[i] : consumo mensual de ACS en el mes [i], descrito anteriormente vSalto[i]: salto térmico en el mes [i], descrito anteriormente vDAportetuso [i]: porcentaje de variación de la temperatura de uso respecto a su valor inicial en el mes [i]
método public void Calcula_vDemandaMJmes(){ for(int i=0;i<12;i++){ vConsumo[i]=(LitrosDia*NumUsu*vDias[i]*vOcupacion[i])/100000; vSalto[i]=Tuso-vTred[i]; vConsumo[i]=vConsumo[i]*vDAporceocupacion[i];//para los calculo variando la ocupac en DA vConsumo[i]=vConsumo[i]*vDAporcelitros[i];//para los calculo variando los litros en DA vSalto[i]=Tuso*vDAporcetuso[i]-vTred[i];//para los calculo variando la Tuso en DA vDemandaMJmes[i]=vConsumo[i]*vSalto[i]*4.184;//MJ/mes ConTresDecimales();
vDemandaMJmes[i]=Double.valueOf(formateador.format(vDemandaMJmes[i])); } }
Los resultados se pueden consultar en el panel "CÁLCULOS" y en la columna "neMJ" del panel "RESULTADOS".
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
100
2.2.5.4. Cálculo de la radiación media diaria sobre superficie horizontal para cada mes ( H ) El programa contiene los datos de radiación solar de las tablas de CENSOLAR[2]. Las
unidades de partida son MJ / m2 por día medio de cada mes. Una vez seleccionada la provincia, los valores de radiación aparecen, por defecto, en la ventana "Datos mensuales". Para los cálculos, este valor se corrige multiplicándolo por el factor "CorH" según condiciones ambientales de la localización del proyecto (1.05 para atmósferas muy limpias y 0.95 para atmósferas contaminadas). Estos valores se pueden consultar en el panel "DATOS&RESULTADOS".
En el programa java:
clase LocalizacionACS objeto pueblo variables vHcor[i]: resultado de la radiación media diaria, corregida, sobre superficie
horizontal, en la provincia seleccionada, para el mes [i] vH[i]: dato de la radiación media diaria sobre superficie horizontal, en la provincia seleccionada, para el mes [i] CorH : dato del factor de corrección de H, por defecto 1.05.
método public void Calcula_vHcor(){ for(int i=0;i<12;i++){ vHcor[i]=vH[i]*CorH; ConTresDecimales(); vHcor[i]=Double.valueOf(formateador.format(vHcor[i]));
} }
2.2.5.5. Cálculo de la radiación media diaria sobre superficie inclinada para cada mes Según la inclinación de los colectores, se calcula la radiación media incidente, por m2 de
superficie colectora, multiplicando el valor de la radiación sobre superficie horizontal (vHcor[i]) por el factor "k" (vCork[i]) que depende la inclinación, del mes y de la localización (latitud) del proyecto. El programa contiene los valores de "k" para cada provincia y para las inclinaciones de 35,40,45,50,55 y 60º. En función del valor de inclinación con el que estemos operando los valores de k, para cada mes, aparecen en la ventana "Datos mensuales" y pueden consultarse en el panel "DATOS&RESULTADOS".
Por tratarse de un sistema de aprovechamiento térmico de la energía solar, se considerarán
unas pérdidas del 6% debido a los momentos en que, debido a la poca altura del sol, la intensidad de irradiación es menor del valor umbral de 200 w/m2. Por eso, además se corrige el resultado multiplicando por el factor 0.94 . De esta forma tendremos el valor efectivo de la energía aprovechable por los colectores.
En el programa java:
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
101
clase LocalizacionACS objeto pueblo variables vE[i]: resultado de la radiación aprovechable que incide un día medio sobre cada m2
de superficie inclinada de colectores en el mes [i] vHcor [i]: resultado de la irradiación horizontal media para el mes [i] en la provincia seleccionada. vCork [i]: dato del factor de corrección "k" para el mes [i], para la inclinación y la provincia seleccionada. 0.94 : dato del factor resultante de estimar un 6% de pérdida de la energía incidente debido a los momentos en que la altura del sol es pequeña resultando que la intensidad es menor del valor umbral de 200 w/m2
método public void Calcula_vE(){ Calcula_vHcor(); for(int i=0;i<12;i++){ vE[i]=0.94*vCork[i]*vHcor[i]; ConTresDecimales();
vE[i]=Double.valueOf(formateador.format(vE[i])); } } Los resultados pueden consultarse en el panel "DATOS&RESULTADOS"
2.2.5.6. Cálculo de la intensidad media útil de radiación solar (vI) La intensidad media útil de la radiación solar, es la es la intensidad con que incide la radiación
de forma instantánea en un día medio de cada mes. Esta intensidad se mide en W / m2, por ello se transformaran las unidades de radiación diaria media de cada mes en unidades de radiación instantánea, dividiendo la radiación diaria media entre el número de horas medias de cada mes, obteniendo la intensidad media útil para cada mes según la siguiente ecuación:
I = H*106 / n° horas * 3600 =(MJ * 106 J/ MJ ) / m2 día * n° horas *3600 s / h =W / m 2
El programa asigna un número de horas sol útil, a cada mes, para cada provincia. Estos valores
son los que emplea para calcular la Intensidad y pueden ser consultados en el panel "DATOS&RESULTADOS". Los resultados obtenidos son de gran importancia ya que serán utilizados para calcular el rendimiento del colector solar plano de la instalación.
En el programa java:
clase LocalizacionACS objeto pueblo variables vI[i]: resultado de la intensidad media útil de radiación solar para el mes [i]
vE[i]: 277.778 : resultado del factor de conversión de MJ/m2·día a W/m2 vHorasSolUtil[i]: dato del número de horas sol el mes [i], en provincia seleccionada
método public void Calcula_vI(){ Calcula_vE(); for(int i=0;i<12;i++){ vI[i]=277.778*vE[i]/vHora sSolUtil[i]; ConTresDecimales();
vI[i]=Double.valueOf(formateador.format(vI[i])); } }
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
102
Los resultados se pueden consultar el panel "CÁLCULOS" y en el panel "DATOS&RESULTADOS".
2.2.5.7. Cálculo del rendimiento del colector solar plano.
Los colectores solares planos se ensayan generalmente siguiendo un procedimiento que
consiste en hacerlos funcionar en un banco de pruebas bajo unas condiciones estables de radiación solar, velocidad del viento, temperatura del fluido a la entrada y de ambiente, durante un periodo de tiempo en el que la temperatura de salida del fluido y la energía útil extraída no varían sensiblemente.
La ecuación para calcular el rendimiento del colector en distintas condiciones de
funcionamiento es la siguiente: η = m – b T/I
� m: coeficiente global de pérdidas, dato del colector. � b: factor de eficiencia óptica, dato del colector. Además se incluye un parámetro de
corrección de b "Corb" según el tipo de colector. Por defecto, el programa considera un colector plano con cubierta y destinado a la obtención de ACS, el factor b (0.83) se corrige multiplicando por Corb=0.94.
En el programa java:
clase LocalizacionACS objeto pueblo variables vRendimiento[i]: resultado del rendimiento de los colectores para el mes [i]
vI[i]: resultado de la intensidad de la radiación solar para el mes [i] Corb : dato del factor de corrección del parámetro "b" de los colectores, por defecto 0.94. bcol: dato del factor de eficiencia óptica de los colectores mcol: dato del coeficiente general de pérdidas de los colectores Tuso : dato de la temperatura de uso del ACS vTamb[i]: dato de la temperatura ambiente para el mes [i] vfporcetuso[i]: porcentaje de variación de la temperatura de uso en el mes [i] respecto a su valor inicial.
método public void Calcula_vRendimiento(){ Calcula_vI();//con esto calcula I for(int i=0;i<12;i++){ //vRendimiento[i]=100*Corb*bcol-100*mcol*(Tuso-vTamb[i])/vI[i]; vRendimiento[i]=100*Corb*bcol-100*mcol*(Tuso*vfporcetuso[i]-vTamb[i])/vI[i]; // if(vRendimiento[i]<20){vRendimiento[i]=0;} if(vRendimiento[i]<0){vRendimiento[i]=0;} ConTresDecimales();
vRendimiento[i]=Double.valueOf(formateador.format(vRendimiento[i]));} }
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
103
Estos datos de rendimiento son los que serán utilizados en los cálculos posteriores, para calcular la energía que es aprovechada por el colector solar plano de la que incide sobre él.
Los resultados se pueden consultar el panel "CÁLCULOS" y en el panel "DATOS&
RESULTADOS".
2.2.5.8. Cálculo de la aportación solar por m2.
Llamamos "Aportación solar por m2" a la energía que incide por m2, de superficie de
colector solar plano, y que es transferida al fluido caloportador. Es decir, es la energía, procedente del sol, que el colector aprovecha de la energía total que incide sobre él.
Esta energía incidente se calcula multiplicando la radiación solar que incide por día y metro
cuadrado de superficie por el rendimiento del colector solar plano en cada mes y multiplicando por el numero de días de cada mes.
La ecuación que se aplicará para calcular la energía incidente considerando el rendimiento del
colector solar plano será la siguiente: Aportación = E * η
En el programa java:
clase LocalizacionACS objeto pueblo variables vAportacion[i]: resultado de la energía solar captada por m2 de colector el mes [i]
vE[i]: resultado de la radiación media diaria para el mes [i] vRendimiento [i]: resultado del rendimiento de los colectores para el mes [i]
método public void Calcula_vAportacion(){ Calcula_vRendimiento();//con esto calcula I que calcula E for(int i=0;i<12;i++){ if(vOcupacion[i]>0){vAportacion[i]=vE[i]*vRendimiento[i]/100;}// hemos añadido /100 else{vAportacion[i]=0;} ConTresDecimales();
vAportacion[i]=Double.valueOf(formateador.format(vAportacion[i])); } }
Los resultados, para cada mes, se pueden consultar en el panel "CÁLCULOS".
2.2.5.9. Cálculo de la energía neta disponible (END)
El colector solar plano, las tuberías, el depósito interacumulador, y los demás accesorios de
una instalación solar térmica, durante el funcionamiento mantienen temperaturas superiores a la temperatura ambiente, perdiendo calor por conducción a través de las uniones del sistema a tierra y por convección y radiación al ambiente.
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
104
Las pérdidas por radiación son generalmente pequeñas siendo las pérdidas por convección las más importantes. Las pérdidas de calor son una causa importante de la reducción del rendimiento del sistema de energía solar y obligan a aislar la instalación con el fin de minimizarlas.
En el propio colector solar plano existen pérdidas debido a los distintos fenómenos físicos de
transmisión de calor. Estas pérdidas son las siguientes: � Pérdida de calor frontal por radiación hacia el cielo debido a la absortancia del colector. � Pérdida de calor frontal por convección, en general depende de la velocidad del viento. � Pérdidas de calor posteriores y laterales del colector solar plano, que dependerán del tipo y
espesor del aislamiento estas pérdidas se estiman en un 2 o el 3 % de la energía captada. � Pérdidas por la cara posterior del colector solar plano, dependen del tipo y espesor de
aislamiento que ese utilice. � Pérdidas hacia arriba por la cara expuesta a la radiación dependen de la emitancia del
colector solar plano. En el programa, todas estas perdidas se estiman, por defecto, en un 15 % de la energía captada
por el colector solar plano, por lo que la energía que será utilizada para el calentamiento del agua caliente sanitaria es el 85 % de la captada por el colector solar plano. Así se calculará la energía neta disponible multiplicando la energía incidente considerando el rendimiento del colector solar plano, por el 85 % que será la que se aproveche. Este valor se puede cambiar en los datos de inicio del proyecto. Los cálculos se realizan según la siguiente ecuación:
Energía neta disponible = Aportación * 0,85
En el programa java:
clase LocalizacionACS objeto pueblo variables vENDdia[i]: resultado de la energía neta diaria disponible por m2 para el mes [i]
vAportacion[i]: resultado de la energía solar captada por m2 de colector el mes [i] PerdGlo : dato del factor de pérdidas globales de la energía que llega a los colectores. (por defecto 0.15) vDias[i]: dato del número de días para el mes [i] vENDmes[i]: resultado de la energía neta mensual disponible por m2 para el mes [i] ENDañoM2 : resultado de la energía neta disponible al año por m2.
método public void Calcula_vENDdia(){ Calcula_vAportacion(); for(int i=0;i<12;i++){ vENDdia[i]=vAportacion[i]*(1-PerdGlo);// hemos quitado /100 ya que está en la aportacion } } public void Calcula_vENDmes(){ ConTresDecimales(); Calcula_vENDdia(); for(int i=0;i<12;i++){ vENDmes[i]=vENDdia[i]*v Dias[i]; vENDmes[i]=Double.valueOf(formateador.format(vENDmes[i])); } } public void Calcula_ENDañoM2(){ Calcula_vENDmes(); ENDañoM2=0; for(int i=0;i<12;i++){ ENDañoM2=ENDañoM2+vENDmes[i];} ConTresDecimales();
ENDañoM2=Double.valueOf(formateador.format(ENDañoM2)); }
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
105
De este modo hemos calculado la energía solar por metro cuadrado y día, por mes y por año, de la que se dispone para calentar el agua caliente sanitaria. Los resultados se pueden consultar en el panel "CÁLCULOS" y en el panel "RESULTADOS".
2.2.5.10. Cálculo de la superficie colectora.
Se calculará una superficie colectora "teórica", siguiendo el método de CENSOLAR[1],
dividiendo la necesidad energética anual entre la disponible por metro cuadrado de superficie expuesta a la radiación solar. En el programa java, primero se calcula la demanda de energía anual (DemandaAnual) sumando la demanda de cada mes (vDemanndaMJme[i]), después calcula la energía neta disponible por m2 al año (ENDañoM2) sumando la energía disponible cada mes (vENDmes[i]), dividiendo estos dos valores obtiene la superficie SCteorica. Con el dato de la superficie de un colector (Acol), que toma de las datos de inicio, calcula el número de colectores necesarios (Ncteorico) para cubrir dicha superficie. Estos valores servirán al usuario del programa para decidir el número de captadores con los que contará la instalación que esté calculando. El valor introducido por el usuario (NCrecomendado) por la superficie de un colector (Acol) nos dará el valor de la superficie colectora total (SCresulatante) de la instalación calculada. El programa compara el dato de la superficie introducido con el consumo de ACS litros/día calculado y nos indica si cumple con la condición de diseño 60<=C/A<=100. Esta comprobación también se realizará cada vez que el usuario modifique el valor del consumo (C) y o de la superficie (A).
En el programa java:
clase LocalizacionACS objeto pueblo variables SCteorica : resultado de la superficie, de colectores, en m2 calculada.
NCteorico : resultado del número de colectores necesarios para la "SCteorica" calculada. DemandaAnual : resultado de la demanda energética para todo el año. ENDañoM2 : resultado de la energía neta disponible por m2 y año. Acol : dato en m2 del área de un colector. NCrecomendado : dato del número de colectores a instalar según el proyectista. Scresultante : resultado de la superficie total de colectores según el "NCrecomendado" y "Acol" ConsumoAnualACSm3 : resultado del consumo anual de ACS en m3. NumDiasAnual : resultado del número total de días del año. PruebaSC : resultado del cociente de consumo diario de ACS en m3 por m2 de colectores instalados.
método public void Calcula_DemandaAnual(){ Calcula_vDemandaMJmes(); DemandaAnual=0; for(int i=0;i<12;i++){ DemandaAnual=DemandaAnual+vDemandaMJmes[i]; }ConTresDecimales();
DemandaAnual=Double.valueOf(formateador.format(DemandaAnual)); }
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
106
public void Calcula_SCteorica(){ Calcula_DemandaAnual(); Calcula_ENDañoM2();
SCteorica=DemandaAnual/ENDañoM2; ConTresDecimales();
SCteorica=Double.valueOf(formateador.format(SCteorica)); }
public void Calcula_NCteorico(){ Calcula_SCteorica(); NCteorico=SCteorica/Acol; ConTresDecimales(); NCteorico=Double.valueOf(formateador.format(NCteorico)); } public void Calcula_SCresultante(){ //introducimos por teclado el Ncrecomendado (nº de colectores que asignamos al proyecto) SCresultante=NCrecomendado*Acol; ConTresDecimales(); SCresultante=Double.valueOf(formateador.format(SCresultante)); } public void Calcula_PruebaSC(){ Calcula_ConsumoanualACSm3(); Calcula_NumDiasAnual(); Calcula_SCresultante(); PruebaSC=1000*ConsumoanualACSm3/(NumDiasAnual*SCresultante); ConTresDecimales(); PruebaSC=Double.valueOf(formateador.format(PruebaSC)); } public double getPruebaSC(){ Calcula_PruebaSC(); return PruebaSC; } public String getComprobacionSC(){ Calcula_PruebaSC(); String CSC; if(PruebaSC<60){CSC="No cumple";} else{if(PruebaSC>100){CSC="No cumple";}else{CSC="Cumple";}}
return CSC; } Estas operaciones se realizan en el panel "CÁLCULOS".
2.2.5.11. Cálculo de la energía total obtenida por el sistema de captación de energía solar térmica (ENTotalmes)
En el apartado anterior hemos calculado la energía neta disponible por metro cuadrado de
colector para cada mes del año, en este apartado se calculará la energía total disponible y que se puede obtener por el sistema de energía solar térmica, para ello multiplicaremos la energía neta disponible por la superficie del colector solar plano en metros cuadrados.
Los cálculos de la energía total disponible se especifican a continuación según la siguiente
ecuación: Et = É * S
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
107
En el programa java:
clase LocalizacionACS objeto pueblo variables vENTotalmes[i]: resultado de la energía neta total disponible, en función de la
superficie de colectores instalados, para el mes [i]. vENDmes[i]: resultado de la energía neta disponible por m2 de colector el mes [i]. Scresultante : resultado de la superficie de colectores instalada.
método public void Calcula_vENTotalmes(){ Calcula_vENDmes(); Calcula_SCresultante(); for(int i=0;i<12;i++){ vENTotalmes[i]=vENDmes[i]*SCresultante; ConTresDecimales();
vENTotalmes[i]=Double.valueOf(formateador.format(vENTotalmes[i])); } }
2.2.5.12. Cálculo de la aportación de energía de la instalación solar térmica a la producción de agua caliente sanitaria (Sustitución).
Para la producción de agua caliente sanitaria es necesario aportar energía, para elevar la
temperatura del agua, en el sistema objeto del proyecto, esta energía se aportará mediante un sistema de energía solar térmica. Este sistema, en días nublados y cubiertos no podrá proporcionar toda la energía necesaria, para el calentamiento de toda el agua caliente sanitaria que se consume en un día, aportando la energía que falta el sistema de aportación de energía auxiliar.
El sistema de energía solar térmica aportará una gran parte de las necesidades energéticas. Así
en este apartado se calculará el porcentaje de aportación de energía solar en el sistema de agua caliente sanitaria objeto del proyecto.
La aportación se calculará dividiendo la energía total obtenida "vENTotalmes" entre las
necesidades energéticas mensuales "vDemandaMJmes". En el programa java:
clase LocalizacionACS objeto pueblo variables vSustitucion[i]: resultado del cociente de la demanda energética y la energía solar
disponible para el mes [i]. vDemandaMJmes[i] : resultado de la demanda energética para el mes [i]. vENTotalmes[i]: resultado de la energía solar disponible para el mes [i].
método public void Calcula_vSustitucion(){ Calcula_vDemandaMJmes(); Calcula_vENTotalmes(); for(int i=0;i<12;i++){ if(vOcupacion[i]==0){vS ustitucion[i]=0;} else{double sust=vENTotalmes[i]/vDemandaMJmes[i]; vSustitucion[i]=sust;} ConTresDecimales();
vSustitucion[i]=Double.valueOf(formateador.format(vSustitucion[i])); } }
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
108
Los resultados pueden consultarse en la columna "Sustitución" del panel "RESULTADOS" y en la gráfica del panel "GRÁFICAS".
Durante los meses de verano suele producirse un superávit de energía térmica, es decir se
produce mas energía térmica de la que se consume, por lo que se podría utilizar este exceso de agua caliente sanitaria para otros usos que no sean los habituales.
2.2.5.13. Cálculo del déficit de energía aportada por la instalación solar. El déficit de energía aportada por la instalación de energía solar, es la diferencia entre la
energía necesaria en cada mes y la energía que aporta dicha instalación para el calentamiento del agua caliente sanitaria. Es decir es la diferencia entre las necesidades energéticas mensuales ( vDemandaMJmes ) y la energía solar total disponible ( vENTotalmes ).
Este déficit nos indica cuando la instalación de energía solar suministra toda la energía
necesaria, y cuando es necesario que entre en funcionamiento el sistema auxiliar de aportación de energía, para suministrar el agua caliente sanitaria en las condiciones de consumo.
En el programa java:
clase LocalizacionACS objeto pueblo variables vDeficit[i]: resultado de la diferencia entre la demanda de energía y la energía solar
para cada mes [i] vDemandaMJmes[i]: resultado de la demanda energética para el mes [i]. vENTotalmes[i]: resultado de la energía solar disponible para el mes [i]. DeficitEnergeticoAnual : resultado de la suma de demanda energética no cubierta por energía solar durante todo el año.
método public void Calcula_vDeficit(){ Calcula_vDemandaMJmes(); Calcula_vENTotalmes(); for(int i=0;i<12;i++){ vDeficit[i]=vDemandaMJmes[i]-vENTotalmes[i]; ConTresDecimales(); vDeficit[i]=Double.valueOf(formateador.format(vDeficit[i])); } } public void Calcula_DeficitEnergeticoAnual(){ double defi=0; Calcula_vDeficit(); for(int i=0;i<12;i++){ if(vDeficit[i]<0){}else{defi=defi+vDeficit[i];} } ConTresDecimales();
deficitEnergeticoAnual=Double.valueOf(formateador.format(defi)); }
Los resultados pueden consultarse en la columna "Déficit" del panel "RESULTADOS". Los valores positivos aparecen en color rojo y los negativos en color azul. Los datos negativos
significan que existe superávit de energía disponible para el calentamiento del agua caliente
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
109
sanitaria y por lo tanto están cubiertas todas las necesidades energéticas mediante la instalación de energía solar térmica para la obtención de ACS. Para calcular el déficit total anual, los valores negativos equivalen a un valor del 0%. Solo se indican en la pantalla para poder observar cuanto y cuando la energía solar disponible sobrepasa a la demandada.
2.2.5.14. Cálculo de la aportación solar anual.
Nos da una idea del porcentaje de la demanda anual de energía que es sustituida por energía
solar. Como se indicó anteriormente, en los meses en que el valor de calculado vDeficit[i] resulte negativo se considera igual a 0.
En el programa java:
clase LocalizacionACS objeto pueblo variables VCobertura[i]: resultado del % de la demanda energética mensual cubierta por
energía solar para el mes [i] vDeficit[i]: resultado del déficit energético para el mes [i] aportacionAnual : resultado de % de la demanda energética anual cubierta por energía solar al cabo de un año.
método public void Calcula_vCobertura(){ Calcula_vDeficit(); for(int i=0;i<12;i++){ vCobertura[i]=100*(1-vDeficit[i]/vDemandaMJmes[i]); ConTresDecimales(); vCobertura[i]=Double.valueOf(formateador.format(vCobertura[i])); } } public void Calcula_aportacionAnual(){ Calcula_DemandaAnual(); Calcula_DeficitEnergeticoAnual(); aportacionAnual=100*(DemandaAnual-deficitEnergeticoAnual)/DemandaAnual; ConTresDecimales();
aportacionAnual=Double.valueOf(formateador.format(aportacionAnual)); }
2.2.5.15. Cálculos de costes de la energía y ahorro
En la ventana "Datos generales" introducimos el coste en €/kwh y en función de éste, el
programa calcula el coste de la energía necesaria para toda la demanda, el coste de la energía para el déficit y el ahorro que supone la diferencia de los dos valores anteriores. Es una manera de evaluar la posible amortización de la instalación solar para ACS.
En el programa java:
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
110
clase LocalizacionACS objeto pueblo variables Preciokwh : dato de coste del kwh
vDemandaMJmes[i]: demanda energía en MJ para el mes [i] DemandaAnual : demanda energía anual en MJ vCEmes[i]: coste de la energía eléctrica para la demanda energética para el mes [i]. CosteEanual : coste de la energía eléctrica para la demanda anual. vCosteAuxmes[i]: coste de la energía eléctrica para la demanda no cubierta por energía solar para el mes [i] CAuxAnual : coste de la energía eléctrica para la demanda no cubierta por energía solar durante un año. vAhorromes[i]: coste de la energía eléctrica cubierta por energía solar el mes [i]. AhorroAnual : coste de la energía eléctrica cubierta por energía solar.
método public void Calcula_vCosteEmes(){ Calcula_vDemandaMJmes(); for(int i=0;i<12;i++){ vCEmes[i]=Preciokwh/3.6*vDemandaMJmes[i]; ConTresDecimales(); vCEmes[i]=Double.valueOf(formateador.format(vCEmes[i])); } } public void Calcula_CosteEanual(){ Calcula_DemandaAnual(); CEanual=Preciokwh/3.6*DemandaAnual; ConTresDecimales(); CEanual=Double.valueOf(formateador.format(CEanual)); } public void Calcula_vCosteAuxmes(){ Calcula_vDeficit(); for(int i=0;i<12;i++){ if(vDeficit[i]>0){vCAuxmes[i]=Preciokwh/3.6*vDeficit[i];} else{vCAuxmes[i]=0;} ConTresDecimales(); vCAuxmes[i]=Double.valueOf(formateador.format(vCAuxmes[i])); } } public void Calcula_CosteAuxAnual(){ Calcula_vCosteAuxmes(); CAuxAnual=0; for(int i=0;i<12;i++){ CAuxAnual=CAuxAnual+vCAuxmes[i];} ConTresDecimales(); CAuxAnual=Double.valueOf(formateador.format(CAuxAnual)); } public void Calcula_vAhorromes(){ Calcula_vCosteEmes(); Calcula_vCosteAuxmes(); for(int i=0;i<12;i++){ vAhorromes[i]=vCEmes[i]-vCAuxmes[i]; ConTresDecimales(); vAhorromes[i]=Double.valueOf(formateador.format(vAhorromes[i])); } } public void Calcula_AhorroAnual(){ Calcula_vAhorromes(); AhorroAnual=0; for(int i=0;i<12;i++){ AhorroAnual=AhorroAnual+vAhorromes[i]; } ConTresDecimales();
AhorroAnual=Double.valueOf(formateador.format(AhorroAnual)); } Los resultados pueden consultarse en el panel "RESULTADOS"
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
111
2.2.6. Método F-CHART
2.2.6.1. Cálculo de aportación energética en instalaciones de ACS mediante el método "f-chart"
El "f-chart" ó método de las curvas-f, es un método que permite estimar la aportación energética de un sistema solar para producción de ACS ó ACS y calefacción en períodos de tiempo relativamente largos. Ha sido desarrollado desde 1974 por los profesores W.A. Beckman, S. A. Klein, y J.A. Duffie en el Laboratorio de Energía Solar de la Universidad de Madison en Wisconsin. En las instalaciones solares, los parámetros que influyen en el rendimiento del captador son muy variables, y suponer unas condiciones medias de funcionamiento supone asumir un riesgo elevado. A raíz de la simulación de numerosas instalaciones, a través de TRNSYS, y el posterior estudio de resultados se concluyó que, a pesar de que efectivamente las condiciones y por tanto el rendimiento de los captadores era variable, el aporte energético de la instalación en períodos largos de tiempo (por ejemplo un mes), seguía una determinada correlación dependiente de dos parámetros adimensionales. Dicha correlación se expresa de forma gráfica en la figura 2:
Figura 2. Curvas-f
Para estimar la aportación energética de la instalación solar mensualmente, basta con determinar cada uno de los dos parámetros adimensionales y aplicar la correlación de las curvas-f. De forma numérica f se puede calcular mediante siguiente ecuación:
f=1,029·D1-0,065·D2-0,245·D1
2+0,0018·D2
2+0,0215·D1
3
El parámetro D2 representa la relación entre las pérdidas de energía del captador y la carga total de calentamiento durante un mes.
El parámetro D1 expresa la relación entre la energía absorbida en la superficie captadora y la carga total de calentamiento durante un mes.
Así pues, conocida la radiación solar sobre la superficie de captación y el tipo y número de captadores instalados, se puede calcular la aportación energética mensual para una determinada demanda mediante el empleo del método de las curvas f.
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
112
2.2.7. Cálculo de instalaciones mediante el programa java
Para el método F- Chart se calcula de la siguiente manera: � Estimación de la carga calorífica. � Determinación de la energía absorbida y perdida en el colector. � Cálculo de la ganancia total. � Cálculo de pérdidas totales. � Determinación de cobertura solar mensual. � Determinación de cobertura solar anual
2.2.7.1. Estimación de la carga calorífica (Qa)
Se define la carga calorífica (Qa) como la cantidad de calor mensual que se necesita para
calentar agua. Qa=Ce·C·N·(ta-tr)
� Qa : Carga calorífica mensual para calentar el agua (J/mes) � Ce : Calor específico del líquido calo-conductor en el proceso de intercambio de calor. En el
caso de agua su valor es de 4187 (J /kg°C). � C : Consumo diario de agua (litros/ día). � N : Número de días del mes. � ta : Temperatura del agua caliente de acumulación (°C). � tr : Temperatura del agua de red (°C).
En el programa java:
clase LocalizacionACS objeto pueblo variables vfcarga[i]: resultado de la carga calorífica para el mes [i]
Ce : dato del calor específico del fluido caloportador, por defecto el agua. N : dato del número de usuarios. C : dato del consumo diario de ACS en litros/día·usuario vDias[i]: dato del número de días del mes [i] tac : dato de la temperatura del agua caliente vTred[i] : dato temperatura del agua de red el mes [i] en provincia seleccionada. vfporcetuso[i] : % variación temperatura de uso respecto a valor inicial en el mes [i]. vfporceocupacion[i]: % variación de ocupación respecto a su valor inicial el mes [i]. vfporcelitros[i]: % variación consumo diario de ACS respecto valor inicial el mes [i].
método public void Calcula_vfcarga(){ for(int i=0;i<12;i++){ vfcarga[i]=(Ce*N*C*vDias[i]*(tac-vTred[i]))/Mat h.pow(10,6);//MJ/mes vfcarga[i]=(Ce*N*C*vDias[i]*(tac*vfporcetuso[i] -vTred[i]))/Math.pow(10,6);// vfcarga[i]=vfcarga[i]*vfporceocupacion[i];//para los calculo variando la ocupacion en fchart vfcarga[i]=vfcarga[i]*vfporcelitros[i];//para l os calculo variando los litros en fchart ConTresDecimales();
vfcarga[i]=Double.valueOf(formateador.format(vfcarga[i])); } }
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
113
2.2.7.2. Determinación de energía absorbida por el colector y pérdida del mismo (Ea, Ep). La energía que absorbe el colector (Ea), la cual es trasformada en calor se calcula a través de la
ecuación: Ea=Sc·F’r·(τα)·R1·N
Teniendo en cuenta que: � Sc : Superficie del captador (m2) � F’r·(τα) : Producto de la transmitancia por la absorbancia del colector y el factor de
transporte, equivalente a 1. En este factor ya interviene tanto la eficiencia óptica del captador, como las constantes por modificación del ángulo de incidencia, además del factor captador- intercambiador.
F’r·(τα) =F
R(τα)
n· (τα)/(τα)
n ·(F’
R/F
R)
• F
R(τα)
n Factor de eficiencia óptica del captador. Es la ordenada en el origen de la curva
característica del captador. En el programa corresponde a la variable "FEO".
• (τα)/(τα)n Modificador del ángulo de incidencia. "MAI", valor por defecto 0.96. En general
se puede tomar como constante: 0,96 (superficie transparente sencilla) o 0,94 (superficie transparente doble).
• F’r / Fr Factor de corrección del conjunto captador-intercambiador. "FCCI", por defecto
toma como valor 0.95.
� R1 : Radiación diaria media mensual incidente en la superficie de captación del colector solar (kJ/m2).
� N : Número de días del mes.
En el programa java:
clase LocalizacionACS objeto pueblo variables vEabsorbida[i]: resultado de la energía absorbida para el mes [i].
FEO : dato del factor de eficiencia óptica del captador MAI : dato del factor de modificación del ángulo de incidencia FCCI : dato del factor de corrección del conjunto captador-intercambiador. Fadim : resultado del factor adimensional fSc : dato de la superficie en m2 de captación. vE[i]: resultado de la radiación incidente por m2 de superficie inclinada, el mes [i]. Incluye factor de corrección por suciedad en la cubierta de los colectores (- 3%) y por incidencia de rayos no perpenticulares (- 3%) de valor experimental 0.94. vDias[i]: dato del número de días del mes [i].
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
114
método public void Calcula_Fadim(){ Fadim=FEO*MAI*FCCI; }
public void Calcula_vEabsorbidaf(){ Calcula_vE(); Calcula_Fadim(); for(int i=0;i<12;i++){ vEabsorbida[i]=fSc*Fadim*vE[i]*vDias[i];// MJ/mes ConTresDecimales();
vEabsorbida[i]=Double.valueOf(formateador.format(vEabsorbida[i])); } } La energía que se pierde en el colector (Ep), se determina por medio de la siguiente ecuación:
Ep=Sc·F’r· UL·(100 – ta)·∆t· k1·k2
En donde: � Sc: Superficie útil del captador (m2). � F’r· UL : Factor de eficiencia del intercambiador de calor del colector solar por el coeficiente
global de pérdidas del captador. Este factor viene asociado intrínsecamente a un factor de disipación de calor. (%).
F’r· UL= Fr· UL·( F’r / Fr)
• Fr· UL = Pendiente de la curva característica del captador (coeficiente global de
o pérdidas del captador) "CGP".
• F’r / Fr Factor de corrección del conjunto captador-intercambiador. "FCCI", por defecto 0.95.
� ta : Temperatura mensual media del ambiente. (°C). � ∆t : Período de tiempo, considerando que funciona las 24h/día. (s) � k1 : Factor de corrección debido al almacenamiento.
K1 = [kg acumulación /(75 Sc)]-0,25
37,5 < (kg acumulación) / (m2 captador) < 300
� k2 : Factor de corrección para el agua caliente, en donde se relaciona la temperatura mínima de ésta con el agua de la red usada y también la temperatura media mensual del ambiente.
K2 = 11,6 + 1,18 tac + 3,86 tr – 2,32 ta / (100 – ta)
• tac = Temperatura mínima del ACS, por defecto 45º. • tr = Temperatura del agua de red • ta = Temperatura media mensual del ambiente
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
115
En el programa java:
clase LocalizacionACS objeto pueblo variables vEperdida[i] : resultado de la energía perdida para el mes [i]
CGP : dato del coeficiente global de pérdidas del colector. FCCI : dato del factor de corrección del conjunto captador-intercambiador. FprUL : resultado de F’r· UL= Fr· UL·( F’r / Fr) vDt[i] : resultado del número de segundos del mes [i]. K1 : resultado del factor de corrección k1 para almacenamientos (acumulación) distintos de 75 litros/m2 KgA : datos de los kilogramos (volumen) de acumulación. fSc : resultado de la superficie de captación en m2 vK2[i] : resultado del factor de corrección k2 para el mes [i]. 0.95 : dato del FCCI Tmin : dato temperatura mínima del ACS, por defecto igual a temperatura de uso. vTamb[i] : dato de temperatura ambiente para el mes [i] en provincia seleccionada.
método public void Calcula_FprUL(){ FprUL=CGP*FCCI; ConTresDecimales(); FprUL=Double.valueOf(formateador.format(FprUL)); } public void Calcula_vDt(){ for(int i=0;i<12;i++){ vDt[i]=vDias[i]*24*3600; ConTresDecimales(); vDt[i]=Double.valueOf(formateador.format(vDt[i])); } } public void Calcula_K1(){ double ka1=(KgA/(75*fSc)); K1=Math.pow(ka1,-0.25); ConTresDecimales(); K1=Double.valueOf(formateador.format(K1)); } public void Calcula_vK2(){ for(int i=0;i<12;i++){ vK2[i]=(11.6+1.18*Tmin*vfporcetuso[i]+3.86*vTred[i]-2.32*vTamb[i])/(100-vTamb[i]); ConTresDecimales();
vK2[i]=Double.valueOf(formateador.format(vK2[i])); } }
public void Calcula_vEperdidaf(){ Calcula_vDt(); Calcula_FprUL(); Calcula_K1(); Calcula_vK2(); for(int i=0;i<12;i++){ vEperdida[i]=fSc*FprUL*(100-vTamb[i])*vDt[i]*K1*vK2[i]/1000000;//Mj/mes ConTresDecimales();
vEperdida[i]=Double.valueOf(formateador.format(vEperdida[i])); } }
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
116
2.2.7.3. Cálculo de la ganancia total (D1) A la ganancia del colector (D1) se la conoce como la energía solar útil proporcionada. Esta
ganancia relaciona la energía absorbida por la placa del colector usado y el parámetro Qa durante un mes, como se muestra en la ecuación :
D1=Ea/Qa
En el programa java:
clase LocalizacionACS objeto pueblo variables vD1[i] : resultado de la ganancia D1 para el mes [i]
vEabsorbida[i] : resultado de la energía absorbida para el mes [i]. vfcarga[i] : resultado de la carga calorífica para el mes [i].
método public void Calcula_D1(){ Calcula_vfcarga(); Calcula_vEabsorbidaf(); for(int i=0;i<12;i++){ vD1[i]=vEabsorbida[i]/vfcarga[i]; ConTresDecimales();
vD1[i]=Double.valueOf(formateador.format(vD1[i]));}}
2.2.7.4. Cálculo de pérdidas totales (D2)
Las pérdidas totales en el colector (D2) debido a la reflexión de la luz solar, relacionan las
pérdidas de energía en el captador a determinada temperatura, con la carga calorífica de calentamiento (Qa) durante un mes según la siguiente ecuación :
D2=Ep/Qa
En el programa java:
clase LocalizacionACS objeto pueblo variables vD2[i] : resultado de las pérdidas D2 para el mes [i].
vEperdida[i] : resultado de la energía perdida para el mes [i]. vfcarga[i] : resultado de la carga calorífica para el mes [i].
método public void Calcula_D2(){ Calcula_vfcarga(); Calcula_vEperdidaf(); for(int i=0;i<12;i++){ vD2[i]=vEperdida[i]/vfcarga[i]; ConTresDecimales();
vD2[i]=Double.valueOf(formateador.format(vD2[i]));}}
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
117
2.2.7.5. Determinación de cobertura solar mensual
La energía útil captada en un mes determinado (Qu) se estima mediante la ecuación:
Qu = f·Qa A la fracción de carga calorífica mensual (Qa), que se transforma en energía solar, se la conoce
como parámetro f. El cálculo de este parámetro se realiza con ayuda de la ecuación
f=1,029·D1-0,065·D2-0,245·D1
2+0,0018·D2
2+0,0215·D1
3
En el programa java:
clase LocalizacionACS objeto pueblo variables vf[i] : resultado del factor f para el mes [i].
vEutilc[i] : resultado de la energía útil captada para el mes [i]. vfcarga[i] : resultado de la carga calorífica para el mes [i]. vD1[i] : resultado de la ganancia D1 para el mes [i]. vD2[i] : resultado de las pérdidas D2 para el mes [i].
método public void Calcula_fchart(){ Calcula_D1(); Calcula_D2(); for(int i=0;i<12;i++){ vf[i]=1.029*vD1[i]-0.065*vD2[i]-
0.245*Math.pow(vD1[i],2)+0.0018*Math.pow(vD2[i],2)+0.0215*Math.pow(vD1[i],3); //if(vf[i]>1){vf[i]=1;} vf[i]=vf[i]*100; ConTresDecimales(); vf[i]=Double.valueOf(formateador.format(vf[i]));}} public void Calcula_vEutilcaptada(){ Calcula_vfcarga();Calcula_fchart(); for(int i=0;i<12;i++){ vEutilc[i]=vfcarga[i]*vf[i]/100; ConTresDecimales();
vEutilc[i]=Double.valueOf(formateador.format(vEutilc[i]));}} 2.2.7.6.- Determinación de cobertura solar anual (CSA)
La relación entre la sumatoria de las coberturas solares mensuales (ΣQu) y la sumatoria de la
demanda de cargas caloríficas (ΣQa), determina la cobertura solar anual del colector, como se indica en la ecuación :
CSA=(ΣQu)/ (ΣQa)
En el programa java:
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
118
clase LocalizacionACS objeto pueblo variables CSA : resultado de la cobertura solar anual.
sumaQu : resultado de la suma de la energía útil captada todos los meses del año. sumaQa : resultado de la suma de las cargas caloríficas de todos los meses del año.
método public void Calcula_CoberturaSA(){ Calcula_vfcarga();Calcula_vEutilcaptada(); double sumaQu=0;double sumaQa=0; for(int i=0;i<12;i++){ sumaQu=sumaQu+vEutilc[i]; sumaQa=sumaQa+vfcarga[i];} CSA=sumaQu/sumaQa; ConTresDecimales(); CSA=Double.valueOf(formateador.format(CSA));} public void Comprueba_K1_fchart(){ pruebak1=KgA/fSc;
ConTresDecimales();pruebak1=Double.valueOf(formateador.format(pruebak1)); } 2.2.7.7. Cálculo del volumen de acumulación ( V )
La dimensiones del depósito interacumulador deberán ser proporcionales al consumo
cubriendo la demanda de agua caliente sanitaria de cómo mínimo un día. En España la proporción de acumulación es de 50 – 100 litros por metro cuadrado de superficie colectora. El programa, por defecto, calcula un volumen de 70 litros por m2. Este valor se puede cambiar. El resultado se tomará como una orientación del valor que el usuario del programa tiene que introducir como dato del proyecto. El programa compara el dato del volumen introducido con el calculado y nos indica si cumple con la condición de diseño 0.8<=V/M<=1.2. Esta comprobación también se realizará cada vez que el usuario modifique el valor del volumen.
En el programa java:
clase LocalizacionACS objeto pueblo variables VolAcuTeorico: resultado del volumen de acumulación, por defecto 70 litros por m2
de colector. VolAcuDiseño : dato del volumen de acumulación introducido por el proyectista. PruebaVolAcu : resultado del cociente del VolAcuTeorico entre el VolAcuDiseño
método public void Calcula_VolAcuTeorico(){ // VolAcuM2=70; Calcula_SCresultante(); VolAcuTeorico=SCresultante*VolAcuM2; ConTresDecimales();VolAcuTeorico=Double.valueOf(formateador.format(VolAcuTeorico)); } public void Calcula_PruebaVolAcu(){ Calcula_VolAcuTeorico(); PruebaVolAcu=VolAcuTeorico/VolAcuDiseño; ConTresDecimales(); PruebaVolAcu=Double.valueOf(formateador.format(PruebaVolAcu)); } public String getComprobacionVolAcu(){ Calcula_PruebaVolAcu(); String CVA; if(PruebaVolAcu<0.8){CVA="No cumple";}
else{if(PruebaVolAcu>1.2){CVA="No cumple";}else{CVA="Cumple";}} return CVA; }
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
119
El sistema interacumulador se utiliza para acumular agua caliente sanitaria en las horas de máxima radiación solar y esta agua será utilizada en los momentos de demanda. La producción de agua caliente sanitaria no suele coincidir con los momentos de consumo, de ahí la necesidad de acumularla.
Los resultados se pueden consultar en el panel "ACUMULADOR" y subpanelresultados2_10.