Download CAPÍTULO 2. APLICACIÓN JAVA El objetivo de este proyecto es el
Document related concepts
no text concepts found
Transcript
APLICACIÓN JAVA 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. 3 APLICACIÓN JAVA 4 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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, 5 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. 6 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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: CLASE BASE Herencia 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” 7 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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 : 8 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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: 9 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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);} }); 10 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. 11 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. JRadioButton JDialog JComboBox JLabel JTextField JPanel JButton JCheckBox 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: 12 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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" 13 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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 14 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnNuevoproyectoActionPerformed(java.awt.event.ActionEvent evt) { evento: 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);} 15 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void comboDDNPlocActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void txtDDNPnuevalocKeyReleased(java.awt.event.KeyEvent evt) { evento: 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. private void btnDDNPCancelalocActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnDDNP_CalculaTodoActionPerformed(java.awt.event.ActionEvent evt) { evento: Boton_Gordo();} 16 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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]. private void btnDDNPAceptalocActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void Rbtn_datosDefectoActionPerformed(java.awt.event.ActionEvent evt) { evento: 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);} 17 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación C1.1.3.2. "Volver" componente: btnVolver_Datosdelsitio [JButton] descripción: Anula los datos, cierra la ventana y abre el dialogodatos_nuevoproyecto. private void btnVolver_DatosdelsitioActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btn_CancelarDatosdelsitioActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btn_ContinuarDatosdelsitioActionPerformed(java.awt.event.ActionEvent evt) { evento: Continuar_Datosdelsitio();} C1.1.4. dialogo_datosmensuales [JDialog]. "Datos mensuales" figura 10. dialogo_datosmensuales 18 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void RbtnDatosmensualesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnVolverDatosMensualesActionPerformed(java.awt.event.ActionEvent evt) { evento: // 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. private void btnCancelarDatosMensualesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnContinuardatosmensualesActionPerformed(java.awt.event.ActionEvent evt) { evento: Continuar_Datosmensuales();} 19 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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 private void btnSeleccionaTodosActionPerformed(java.awt.event.ActionEvent evt) { evento: int i; for (i = 0; i < 12; i++) { if (chMeses[i].isSelected()) {} else {chMeses[i].setSelected(true);} 20 }} APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación C1.2.1.2. "Cancelar" componente: btnCancelaSeleccion [JButton] descripción: Anula la selección de todos los meses private void btnCancelaSeleccionMesesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnCalcula_porcuadrosActionPerformed(java.awt.event.ActionEvent evt) { evento: 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 21 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void combocalculosmesActionPerformed(java.awt.event.ActionEvent evt) { evento: Introduce_datos_calculosporcombomes(); } C1.2.2.2. "Consultar" componente: btncalculosConsultar [JButton] descripción: Calcula el mes seleccionado y muestra los resultados. (figura 13) private void btncalculosConsultarActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btncalculosModificarDatosActionPerformed(java.awt.event.ActionEvent evt) { evento: Reiniciar_subpanelesResultados(); dialogo_datosdelsitio.setSize(500, 400); dialogo_datosdelsitio.setLocation(300, 300); dialogo_datosdelsitio.setVisible(true); } 22 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnresultadosNCteoricoActionPerformed(java.awt.event.ActionEvent evt) { evento: 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) private void btnresultadosSCActionPerformed(java.awt.event.ActionEvent evt) { evento: Calcula_Superficieresultante(); } 23 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnresultadosCostesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btndatosyresultados_ConsultarActionPerformed(java.awt.event.ActionEvent evt) { evento: Ver_Datos_y_Resultados(); } 24 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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”. private void btnacuCalculaVolumenActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnacuCompruebavolumenActionPerformed(java.awt.event.ActionEvent evt) { evento: Calcula_PruebaAcu(); //ventana resultados VerResultados();} 25 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnf_Mas_VolAcuActionPerformed(java.awt.event.ActionEvent evt) { evento: 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(); } 26 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btn_datos_fQaActionPerformed(java.awt.event.ActionEvent evt) { evento: dialogo_fQa.setSize(400, 400); dialogo_fQa.setVisible(true); Vacia_Cargas_fchart(); } 27 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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”. private void Rbtn_fQa_valorespordefectoActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnfQa_AceptarActionPerformed(java.awt.event.ActionEvent evt) { evento: 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) private void btn_calcular_fQaActionPerformed(java.awt.event.ActionEvent evt) { evento: 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 28 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btn_datos_fEaActionPerformed(java.awt.event.ActionEvent evt) { evento: 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”. private void Rbtn_fEa_valorespordefectoActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnfEa_AceptarActionPerformed(java.awt.event.ActionEvent evt) { evento: AceptaDatos_Ea_fchart(); dialogo_fEa.dispose();} 29 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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). private void btn_Calcula_fEaActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btn_datos_fEpActionPerformed(java.awt.event.ActionEvent evt) { evento: dialogo_fEp.setSize(400, 400); dialogo_fEp.setVisible(true); Vacia_Eperdida_fchart();} 30 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación C1.7.3.2. "Valores por defecto" componente: descripción: evento: Rbtn_fEp_valorespordefecto [JRadioButton] 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”. 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. private void btnfEp_AceptarActionPerformed(java.awt.event.ActionEvent evt) { evento: 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). private void btn_Calcula_fEpActionPerformed(java.awt.event.ActionEvent evt) { evento: 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 31 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btn_Calcula_fchartActionPerformed(java.awt.event.ActionEvent evt) { evento: 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 32 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnf_ComprobarK1ActionPerformed(java.awt.event.ActionEvent evt) { evento: Comrobar_K1_fchart(); Almacena_simulacion_sinverlo();} 33 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnf_Mas_kgActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnf_Mas_panelesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnf_Mas_bcolActionPerformed(java.awt.event.ActionEvent evt) { evento: 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();} 34 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnf_Mas_mcolActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnf_Mas_factorIntercambiadorActionPerformed(java.awt.event.ActionEvent evt) { evento: 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 35 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnf_Graficar_fchartActionPerformed(java.awt.event.ActionEvent evt) { evento: 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). private void btnf_todos_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnf_Masocupacion_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnf_Masliitrosdia_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: Cambia_LitrosDia_Mm(5);//incrementa en 5 Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados Almacena_simulacion_sinverlo(); } 36 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnf_Mastuso_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnf_MasInclinacion_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnf_Cancelar_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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) private void btnVerresultados_fchartActionPerformed(java.awt.event.ActionEvent evt) { evento: VerResultados_enJTable(1); VervariacionesFchartAnual_enJTable(1); } 37 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnGuadar_fchartActionPerformed(java.awt.event.ActionEvent evt) { evento: Guardar_Resultados_finales(); GuardarResultadosACS(1); GuardarVariacionAnual(1); } 38 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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). 39 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnDA_Mas_colectoresActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnInicio_Graf2ActionPerformed(java.awt.event.ActionEvent evt) { evento: Cancela_cambios_DA(); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados Almacena_simulacion_sinverlo(); } 40 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación C1.9.3.2. "todos" componente: btnDA_todos_Mm [JButton] descripción: Selecciona todos los meses marcando todas las casillas de selección (figura34). private void btnDA_todos_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnDA_Masocupacion_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnDA_Masliitrosdia_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnDA_Mastuso_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: Cambia_Tuso_Mm(5);//incrementa en 5 Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados Almacena_simulacion_sinverlo(); } 41 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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 private void btnDA_MasInclinacion_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnDA_Cancelar_MmActionPerformed(java.awt.event.ActionEvent evt) { evento: 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) private void btnVerResultados_G2ActionPerformed(java.awt.event.ActionEvent evt) { evento: VerResultados_enJTable(1); VervariacionesFchartAnual_enJTable(1); 42 } APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnGuardar_graf2ActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. 43 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnGuardarResultadosActionPerformed(java.awt.event.ActionEvent evt) { evento: //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. private void btnBorra_GuardarResustadosActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnVergraf_RenAporSusActionPerformed(java.awt.event.ActionEvent evt) { evento: dialogo_graf_RenAporSus_JFC.setSize(950,650); dialogo_graf_RenAporSus_JFC.setResizable(true); dialogo_graf_RenAporSus_JFC.setVisible(true); Dibuja_RenAporSus_JFC(); } 44 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnVergraf_DAActionPerformed(java.awt.event.ActionEvent evt) { evento: 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 45 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnVergrar_fchartActionPerformed(java.awt.event.ActionEvent evt) { evento: 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 private void btnGuardarGraficas_enArchivoActionPerformed(java.awt.event.ActionEvent evt) { evento: //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]. private void btn_Ver_dialogo_graf_panelesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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) private void btn_verTablavariacionesActionPerformed(java.awt.event.ActionEvent evt) { evento: GuardarVariacionAnual(1); } 46 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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) private void btnVergraf_variacionesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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 47 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btn_VergrafInfo_generalActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btn_verTablamensualActionPerformed(java.awt.event.ActionEvent evt) { evento: 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 48 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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). private void btnRen_Inicio_JFCActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnRen_Mas_bcolActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnRen_Mas_mcolActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnRen_Mas_TempActionPerformed(java.awt.event.ActionEvent evt) { evento: Cambia_Tuso_Mm(5); dibuja_lineasderendimiento(); } 49 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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 private void btnImprime_graficaRendimientoActionPerformed(java.awt.event.ActionEvent evt) { evento: Imprimegrafica_VariacionesRendimiento(); } figura 43. opción imprimir la gráfica del rendimiento de los paneles para distintos valores de b,m y T. 50 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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) { } } 51 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. 52 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación • • • "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). 53 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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) 54 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btn_dibuja_panelesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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); } } 55 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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] 56 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnEliminar_RegistroBDActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btn_Elimina_todo_tablaResultadosActionPerformed(java.awt.event.ActionEvent evento: 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º ”. private void btneliminaVariasFilas1ActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. 57 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnInforme_BDResultadosActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnInformeGeneralActionPerformed(java.awt.event.ActionEvent evt) { evento: //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); 58 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnInformegraficoActionPerformed(java.awt.event.ActionEvent evt) { evento: 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);}} 59 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnInformeProvincia_BDResultadosActionPerformed(java.awt.event.ActionEvent evento: 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. private void btnInformeppanelesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnCerrar_ResultadosActionPerformed(java.awt.event.ActionEvent evt) { evento: BD_Resultados.dispose(); } 60 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btn_EliminaRegistro_variacionesActionPerformed(java.awt.event.ActionEvent evt) evento: { 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. private void btn_Eliminatodo_tablaVariacionActionPerformed(java.awt.event.ActionEvent evt) { evento: EliminaFilaVariaciones_todas(); } 61 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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º ”. private void btneliminaVariasFilasActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnInforme_variacionesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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();} } 62 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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) private void btnVertablamensual_BDVAActionPerformed(java.awt.event.ActionEvent evt) { evento: GuardarTablamensual(); VerTablamensual_enJTable(1);} C3.14.7. "Cerrar" componente: btnCerrar_Variaciones descripción: Cierra esta ventana private void btnCerrar_VariacionesActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. private void btnEliminagrupoTablamensualActionPerformed(java.awt.event.ActionEvent evt) { evento: EliminaFilasTablamensual(); } 63 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación 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. private void btnInformemensualActionPerformed(java.awt.event.ActionEvent evt) { evento: Informe_mensual(); } C3.15.4. "Cerrar" componente: btnCerrarTablamensual [JButton] descripción: Cierra esta ventana. private void btnCerrarTablamensualActionPerformed(java.awt.event.ActionEvent evt) { evento: 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. cerrar figura 52. Salir y cerrar la conexión con la base de datos. 64 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo 2.1.2. Diagramas de flujo INICIO Nuevo proyecto Diálogo nuevo proyecto Cancelar provincia Nº colectores Aceptar Calcula todo Volumen acumulador Diálogo datos generales Volver Datos del sitio Continuar 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 : € por defecto Cancelar Diálogo datos mensuales Volver Ocupación %mes Temperatura de red Radiacción H Factor k (inclinación) Horas sol Temperatura ambiente Datos mensuales Continuar Cancelar CÁLCULOS 65 por defecto APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo ...Calcula todo CÁLCULOS Datos del sitio Seleccionar meses Modificar datos Seleccionar todos Rendimiento Cancelar Calcular Inicio mes b, m inclinación Temperatura Consultar + 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 - + - + - Imprimir RESULTADOS Demanda MJ/mes Energía neta disponible MJ/m2 Calcular Demanda anual: MJ Energía/año·m2 : MJ Superficie colectora teórica: m2 Número de colectores teórico: Nº de colectores a instalar Superficie colectora resultante (A) Calcular superficie resultante Resultados 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: € F-Chart DATOS& RESULTADOS GRÁFICAS Rendimiento mes Aportación solar relativa Sustitución mes Gráficas demanda-aportación ACUMULADOR Acumulación por m2 Demanda MJ/mes Energía neta total MJ/mes V Modificar datos Consultar M Datos y Resultados mes: Ocupación %mes Temperatura de red H corregida Factor k (inclinación) Energía neta incidente Horas sol Intensidad incidente Temperatura ambiente Rendimiento colector Consumo ACS m3 Calcular Volumen proyectado Comprobar volumen 0.8 < V/M <1.2 66 + - APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo Gráficas demanda-aportación variaciones Nº de colectores Inicio Cancelar todos Selaccionar mes + - Guardar resultado actual 60< C/A <100 Ocupación Litros/día·ud Temperatura Inclinación + - + - + - + - no Localización Provincia Temp ACS Consumo ACS Demanda MJ Superf m2 Paneles b m Base de datos FCCI* de resultados MAI* inclinación acumulación MJ/m2 año Aportación año CSA Guardar Ver resultadosV/M M/A C/A ¿guardar? sí Tabla resultadosACS Resultados anteriores Tabla variacionesFchartAnual* Diálogo BD_Resultados eliminar Cerrar Eliminar todo Eliminar Informe por provincias provincia Temperatura ACS Consumo m3/año Demanda MJ/año Eliminar filas entre Informe general 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 Informes Informe gráfico 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 67 Informe por paneles panel Imagen JPanel Diálogo BD_variacion_anual APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo Diálogo BD_variacion_anual eliminar Cerrar Eliminar todo Eliminar Informes Eliminar filas entre variable 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 Resultados mensuales tabla_mensual Informes Diálogo BD_tablamensual 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 eliminar Eliminar grupo Informe mensual Consumo ACS Acumulador superficie b m FCCI MAI 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 68 Cerrar APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo 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 F-Chart Cargas caloríficas Energía absorbida Energía perdida ...Calcula todo por defecto específico Datos Calor Nº usuarios: Litros/día·ud Diálogo fQa Temp ACS Temp red b FCCI MAI Temp ACS Nº colectores aceptar Calcula Qa m kg acumulad(M) Temp mínima del ACS Datos Diálogo fEa aceptar Superficie resultante (A) Radiación incidente/m2 Energía solar absorbida Consumo de ACS litros/día Carga calorífica mensual (Qa) D1 D2 Factor F’rUL Factor k1 Factor k2 Dt (segundos) Energía perdida mensual Calcula Ea Calcular f Datos Diálogo fEp aceptar Calcula Ep f Qu CSA Tabla variacionesFchartAnual no sí ¿guardar? Tabla resultadosACS 69 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo Localización Provincia Temp ACS Consumo ACS Demanda MJ Superf m2 (A) Paneles b m Gráficas f-chart variaciones Nº de colectores Base de datos de resultados kg de acumulación b m FCCI Guardar + - FCCI* MAI* inclinación acumulación (M) MJ/m2 año Aportación año CSA V/M M/A C/A + - + - + - Ver resultados + Guardar resultado actual Resultados anteriores Inicio Comprobar 37.5< M/A<300 Selaccionar mes Cancelar todos Ocupación Litros/día·ud Temperatura Inclinación + - + - + - + Tabla variacionesFchartAnual* no ¿guardar? sí Tabla resultadosACS Diálogo BD_Resultados 70 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo 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 Diálogo Carpeta BD_VariacionAnual “gráficas” Ver gráficas informe general dialogo_graf_ RenAporSus_JFC DemApor_JFC fchart_JFC paneles_JFC variaciones_JFC InformeGeneral_JFC Diálogo BD_tablamensual 71 paneles variable Dibuja panel Dibuja gráfica Datos Resultados Datos y resultados Acumulador Cálculo f-chart Variaciones f-chart Demanda-Aportación Consumo m3/año Consumo litros/dia Temperatura ACS Superficie m2 Inclinación Acumulador litros b m FCCI MAI APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo 72 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos 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. 73 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos 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 { ... 74 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos //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);} } 75 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos 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) 76 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos 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){...} 77 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos 78 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes 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 79 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes 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. 80 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes 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 public void Informa_poe_paneles(String rutainforme){...} 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"); } figura 53.- Informe por paneles 81 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes 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 public void Informe_mensual(){...} evento private void btnInformemensualActionPerformed(java.awt.event.ActionEvent evt) { Informe_mensual(); } figura 54.- Informe mensual 82 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes 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 Origen de datos Archivo .jasper evento btnInformegrafico [JButton] (figuras 48 y 49) Tabla resultadosACS Informe grafico.jasper private void btnInformegraficoActionPerformed(java.awt.event.ActionEvent evt) {...} figura 55.- Informe gráfico 83 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes 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 public void Info_Variable(String var,String titulo){...} evento 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. 84 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes 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 private void btnInformeGeneralActionPerformed(java.awt.event.ActionEvent evt) {...} evento 85 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes figura 57.- página 1 de INFORME GENERAL figura 58.- INFORME GENERAL gráfica demanda y MJm2anual 86 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes figura 59.- INFORME GENERAL gráfica aportación y CSA 87 APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes 88 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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. 89 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 90 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 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 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 91 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS Método 2 basado en F-Chart DATOS 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 RESULTADOS 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. 92 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 : 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 €/kwh Ocupación %mes Temperatura de red Radiación H Factor k (inclinación) Horas sol Temperatura ambiente Calor específico Modificación ángulo de incidencia Factor captador-intercambiador Acumulación por m2 Temperatura mínima del ACS 45 0 1.05 0.15 32 40 2.01 0.83 y 4.8 0.94 45 0.12 100 Según provincia Según provincia Según provincia Según provincia Según provincia 4184 J/kgºC 0.96 0.95 70 litros 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. 93 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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. 94 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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: 95 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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. 96 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 demandaaportación"). 97 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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] public void Calcula_vConsumo(){ método: 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 demandaaportación" y "F-chart". En el programa java: clase objeto variables LocalizacionACS pueblo 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]; 98 } } APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables método LocalizacionACS pueblo 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] 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". 99 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables método LocalizacionACS pueblo 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. 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: 100 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS clase objeto variables método LocalizacionACS pueblo 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 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 objeto variables método LocalizacionACS pueblo 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 public void Calcula_vI(){ Calcula_vE(); for(int i=0;i<12;i++){ vI[i]=277.778*vE[i]/vHorasSolUtil[i]; ConTresDecimales(); vI[i]=Double.valueOf(formateador.format(vI[i])); } } 101 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables método LocalizacionACS pueblo 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. 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]));} } 102 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables método LocalizacionACS pueblo 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] 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. 103 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables método LocalizacionACS pueblo 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. 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]*vDias[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)); } 104 } } APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables método LocalizacionACS pueblo 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. 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)); } 105 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 106 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS En el programa java: clase objeto variables método LocalizacionACS pueblo 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. 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 objeto variables método LocalizacionACS pueblo 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]. public void Calcula_vSustitucion(){ Calcula_vDemandaMJmes(); Calcula_vENTotalmes(); for(int i=0;i<12;i++){ if(vOcupacion[i]==0){vSustitucion[i]=0;} else{double sust=vENTotalmes[i]/vDemandaMJmes[i]; vSustitucion[i]=sust;} ConTresDecimales(); vSustitucion[i]=Double.valueOf(formateador.format(vSustitucion[i])); 107 } } APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables método LocalizacionACS pueblo 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. 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 108 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables método LocalizacionACS pueblo 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. 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: 109 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS clase objeto variables método LocalizacionACS pueblo 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. 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_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_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_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" 110 } } APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 curvasf. De forma numérica f se puede calcular mediante siguiente ecuación: 2 2 3 f=1,029·D1-0,065·D2-0,245·D1 +0,0018·D2 +0,0215·D1 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. 111 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables LocalizacionACS pueblo 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]))/Math.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 los calculo variando los litros en fchart ConTresDecimales(); vfcarga[i]=Double.valueOf(formateador.format(vfcarga[i])); } } 112 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 captadorintercambiador. F’r·(τα) =F (τα) · (τα)/(τα) ·(F’ /F ) R • n n R R F (τα) Factor de eficiencia óptica del captador. Es la ordenada en el origen de la curva R n característica del captador. En el programa corresponde a la variable "FEO". • (τα)/(τα) Modificador del ángulo de incidencia. "MAI", valor por defecto 0.96. En general n 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 objeto variables LocalizacionACS pueblo 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]. 113 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS public void Calcula_Fadim(){ método 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 114 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS En el programa java: clase objeto variables LocalizacionACS pueblo 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. public void Calcula_FprUL(){ método 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])); } } 115 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 objeto variables método LocalizacionACS pueblo 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]. 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 objeto variables método LocalizacionACS pueblo 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]. 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]));}} 116 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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 2 2 3 f=1,029·D1-0,065·D2-0,245·D1 +0,0018·D2 +0,0215·D1 En el programa java: clase objeto variables LocalizacionACS pueblo 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: 117 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS clase objeto variables método LocalizacionACS pueblo 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. 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 objeto variables método LocalizacionACS pueblo 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 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; } 118 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 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. 119 APLICACIÓN JAVA. MEMORIA DE CÁLCULOS 120