CAPÍTULO 2. APLICACIÓN JAVA - meteo.ieec.uned.esmeteo.ieec.uned.es/ · La ventana de diseño de NetBeans nos permite crear cada componente, colocarlo en la ventana y asignarle los

APLICACIÓN JAVA

3

CAPÍTULO 2. APLICACIÓN JAVA

El objetivo de este proyecto es el diseño de una aplicación java que pueda servir como herramienta para la estimación del número de colectores solares planos para producción de ACS. Siguiendo el método de cálculo de CENSOLAR [1], calcula el número de colectores teórico para cubrir la demanda energética anual en función de la radiación solar anual por m2, calculada para una inclinación dada y en la provincia seleccionada. Con este resultado, el usuario decide el número de colectores que quiere instalar y, en función de la superficie resultante, el programa calcula la aportación solar anual y el déficit energético anual. Por otro lado, para los mismos datos de consumo de ACS, el programa aplica el método F-chart y calcula la cobertura solar anual con el mismo número de colectores decidido tras los resultados del método anterior.

El programa permite cambiar el valor de las variables que intervienen en los dos métodos y ver

de forma gráfica como influyen en el resultado. Hay variables que solo se emplean en uno de los dos métodos, por eso, no se trata de comparar el resultado de los dos métodos de cálculo sino de tener dos referencias a la hora de estimar la aportación solar de una instalación para la producción de ACS, mediante colector solar plano, para unas condiciones de consumo y localización dadas.

Para este proyecto hemos creado una aplicación JavaSE desarrollada con los programas

NetBeans IDE 7.2.1, iReport-5.1.0 para los informes de resultados, y conexión con base de datos Access para almacenar resultados y realizar los informes. Para las gráficas de los informes utiliza librerías de JFreeChart .

El presente capítulo se compone de las siguientes partes:

2.1. Memoria descriptiva 2.1.1. Programación 2.1.2. Diagramas de flujo 2.1.3. Acceso a la base de datos desde java 2.1.4. Informes

2.2. Memoria de cálculos

En "Memoria de cálculos" se exponen los cálculos principales que se realizan en el programa, las variables que intervienen en cada operación y el código java para cada uno. En "Memoria descriptiva" se trata de mostrar de forma breve y gráfica las partes que componen la aplicación Java. En "Diagramas de flujo" se muestra de forma esquemática la relación entre las distintas partes de la aplicación. En el apartado "Programación" se describen todos los componentes de la aplicación indicando el tipo de objeto y su evento correspondiente. En Acceso a la base de datos se describe como se accede a la base de datos desde la aplicación java. En "Informes" se presentan los informes que se pueden generar con esta aplicación.

Dentro de este proyecto, en el documento Apéndice I. "Ejemplos", se presenta un ejemplo con

los informes que puede generar el programa y que podemos sacar por impresora. En el documento Apéndice II "Códigos", se muestra todo el código java programado para cada una de las clases creadas para este proyecto.

APLICACIÓN JAVA

4

APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación

5

2.1. Memoria descriptiva 2.1.1. Programación

Para el desarrollo del proyecto se ha utilizado el entorno de desarrollo integrado (IDE) de

NetBeans. El IDE NetBeans es una herramienta pensada para escribir, compilar, depurar y ejecutar programas. Está escrito en Java aunque puede servir para cualquier otro lenguaje de programación. Soporta el desarrollo de todos los tipos de aplicación Java y, además, es un producto libre y gratuito sin restricciones de uso.

El lenguaje de programación Java creado por Sun Microsystems a mediados de la década de

los 90, es una plataforma de desarrollo de aplicaciones. La plataforma se divide en tres grandes bloques. Uno de ellos, Java SE (anteriormente conocido como J2SE) es lo más parecido a un lenguaje de programación estándar. Proporciona una sintaxis para un lenguaje de programación, un entorno de ejecución para las aplicaciones creadas en dicho lenguaje y un extenso conjunto de librerías en las cuales se pueden apoyar dichas aplicaciones.Presentaremos brevemente cuáles son las principales características del lenguaje de programación Java.

� Sencillo. Elimina la complejidad de otros leguajes. � Orientado a objetos. La filosofía de programación orientada a objetos facilita la creación y

mantenimiento de programas. � Independiente de la arquitectura y portable. Al compilar un programa en Java, el código

resultante es un tipo de código binario conocido como Java Bytecode. Este código es interpretado por diferentes computadoras de igual manera. Como el código compilado de Java es interpretado, un programa compilado de Java puede ser utilizado por cualquier computadora que tenga implementado el intérprete de Java.

� Robusto. Java simplifica la gestión de la memoria. � Multitarea. Java puede ejecutar diferentes líneas de código al mismo tiempo. � Dinámico. En java no es necesario cargar completamente el programa en memoria, sino

que las clases compiladas pueden ser cargadas bajo demanda en tiempo de ejecución. Para desarrollar aplicaciones Java es necesario un "Java Development Kit" o JDK. Existen

múltiples JDKs, desarrollados por compañías diferentes, o desarrollados como proyectos de software libre. En nuestro caso hemos empleado el que distribuye de modo gratuito Sun Microsystems, que se puede descargar desde http://java.sun.com. La implementación de Java de Sun suele ser la más actualizada y, es software libre. No obstante se podría emplear cualquier otro JDK ya que la portabilidad del lenguaje garantiza que todos funcionarán del mismo modo. El JDK viene a ser el kit de desarrollo de Java, un conjunto de herramientas , utilidades, documentación y ejemplos para desarrollar aplicaciones Java.

El entorno JDK no es el más adecuado para el desarrollo de aplicaciones Java, debido a que

funciona única y exclusivamente mediante comandos de consola. Hoy en día la programación se suele ayudar de entornos visuales, como Netbeans, que facilitan enormemente la tarea. Netbeans es un excelente entorno de desarrollo, completamente gratuito y se distribuyen bajo licencia libre. Puede descargarse desde http://netbeans.org . Netbeans es un entorno de desarrollo integrado (IDE) que permite editar programas en java, compilarlos, ejecutarlos, depurarlos,


6

construir rápidamente el interfaz gráfico de una aplicación eligiendo los componentes de una paleta, etc. El IDE de NetBeans es gratuito, y de codigo abierto para desarrolladores de software.

Para este proyecto hemos utilizado: � NetBeans IDE 7.2.1 � Java Development Kit Version Version 6 Update 20 from Sun Microsystems. A continuación se explica de forma breve las características de Java que han sido más

utilizadas en la realización de la aplicación.

2.1.1.1. POO programación orientada a objetos

Un Objeto es un elemento que tiene una serie de características llamadas “propiedades”. Por

otro lado, al objeto se le pueden dar órdenes que cumplirá de inmediato. A dichas órdenes se les denomina “métodos”.

Los métodos se pueden dividir básicamente en tres tipos: � Para cambiar las propiedades del objeto (Métodos set) � Para pedir información al objeto (Métodos get) � Para dar órdenes al objeto. Todo objeto pertenece a una CLASE. La CLASE nos permite declarar objetos y construirlos:

Declaración: CLASE nombreobjeto; LocalizacionACS pueblo;

Construcción: nombreobjeto = new CLASE();

ejemplo: pueblo = new LocalizacionACS();

Declaración y Construcción en una misma línea: CLASE nombreobjeto = new CLASE();

LocalizacionACS pueblo = new LocalizacionACS(); En la construcción de un objeto se asignan unas propiedades (características) por defecto al

objeto que se construye, aunque luego, estas características pueden ser cambiadas por el programador.

Se pueden añadir a un proyecto Java clases programadas por uno mismo. Al hacer esto, en el mismo proyecto podemos crear objetos de dichas clases y usarlos para

hacer el programa.


7

En general, un proyecto java está constituido por un grupo de clases, algunas de las cuales serán de creación propia. En el programa usaremos objetos derivados de dichas clases. 2.1.1.2. Herencia

La Herencia consiste en crear una clase que obtenga todas las características de otra. Esta clase a su vez tendrá también características propias.

La clase inicial se denomina clase Base y la clase nueva creada a partir de la clase base se

llama clase Derivada: Se puede hacer que una clase de creación propia derive o herede de otra ya existente añadiendo

en la línea de creación de la clase: “extends NombreClaseBase”

public class Cuadro extends javax.swing.JFrame La clase creada “cuadro” obtendrá características de la clase “Jframe” de la que hereda. Aparte, esta clase tendrá métodos propios añadidos por el programador.

2.1.1.3. Bibliotecas y reutilización de código

En NetBeans podemos abrir varios proyectos y copiar los ficheros de clases de uno a otro. Si un proyecto tiene muchas clases, interesa agruparlas en carpetas.

figura 1. ficheros de clases en la carpeta “paquete”

CLASE BASE

CLASE DERIVADA

Herencia


8

figura 2. ficheros de clases[3], en la carpeta “gráficos” que serán utilizadas en la clase HistogramaACS, la cual está en “paquete”. Con la orden import llamamos a los ficheros de clases que estén en otras carpetas.

Es interesante reunir las clases que más usemos en un solo proyecto de tipo biblioteca, para

poder acceder a ellas fácilmente. Una biblioteca se puede compactar en un solo fichero de tipo .JAR . Al asociar un fichero de biblioteca .JAR a un proyecto, hacemos que en dicho proyecto se puedan usar las clases contenidas en dicha biblioteca.

figura 3. ficheros de bibliotecas .jar empleadas en este proyecto.

Todas estas ideas hacen efectiva la reutilización de código, es decir, el aprovechar lo ya programado, para no tener que volverlo a programar.

2.1.1.4. El bloque de control de errores, try{}catch(){}

La estructura try{} encierra entre las llaves el código que puede producir una excepción (un error grave) que debe ser manejado por el bloque catch(Exception ex){}, en este caso solo capturamos la excepción que puede surgir.

Ejemplo :


9

private void comboInclinacion_DDSActionPerformed(java.awt.event.ActionEvent evt) { try { Cambia_Inclinacion("inicio");} catch (Exception e) {JOptionPane.showMessageDialog(null, "Seleccione una inclinación"); }}

2.1.1.5. Variables globales

Las variables globales, también llamadas propiedades de la clase, son variables que pueden ser usadas desde cualquier evento del programa. Estas variables mantienen su valor hasta que otro evento lo modifique.

Las variables globales se declaran justo después de la línea public class. La inicialización de estas variables se realiza en el constructor. Por ejemplo, creamos la

variable “pueblo” objeto de la clase “LocalizaciónACS” como variable global en la clase “Cuadro”.

public class Cuadro extends javax.swing.JFrame { LocalizacionACS pueblo; String Nombre_Ciudad; ... public Cuadro() { initComponents(); ... pueblo = new LocalizacionACS();

...}}

2.1.1.6. Variables locales Son las variables utilizadas para un procedimiento concreto cuyos valores solo sirven dentro de dicho procedimiento. Se declaran e inician detro del evento donde intervienen. Ejemplo:

private void btnSeleccionaTodosActionPerformed(java.awt.event.ActionEvent evt) { int i; for (i = 0; i < 12; i++) { if (chMeses[i].isSelected()) { } else { chMeses[i].setSelected(true); } }}

2.1.1.7. Centralizar código

En java se pueden programar procedimientos que luego puedan ser llamados desde distintos evento. Por ejemplo, para presentar los resultados con tres decimales programamos el siguiente método:


10

public void ConTresDecimales() { DecimalFormatSymbols simbolo = new DecimalFormatSymbols(); simbolo.setDecimalSeparator('.'); formateador = new DecimalFormat("#####.###", simbolo); //variable formateador declarada como global }

Se puede llamar a un mismo procedimiento desde distintos eventos, evitando así la repetición

de código. Por ejemplo double feo = Double.parseDouble(txtf_comprueba_bcol.getText()) + incremento; ConTresDecimales(); feo = Double.valueOf(formateador.format(feo));

el resultado “feo” tendrá tres decimales sin tener que repetir todo el código anterior.

2.1.1.8. Eventos desde código. La ventana de diseño de NetBeans nos permite crear cada componente, colocarlo en la ventana

y asignarle los eventos que necesitemos para programar en ellos las acciones que se tengan que realizar. Sin embargo, si el diseño se ha realizado directamente desde código, será necesario crear también desde código los distintos eventos a usar y asociarlos al componente correspondiente.

Para programar eventos hay que tener en cuenta que un evento pertenece a un objeto “Oyente”

(Listener) o a un objeto “Adaptador” (Adapter)

El objeto oyente/adaptador hay que asociarlo al elemento sobre el que sucede el evento. Los eventos usados son del tipo "Eventos de Acción": � ActionPerformed:Activar un componente (pulsación de botón, enter en un cuadro de texto)

Para programar desde código un evento es necesario conocer lo siguiente: � El nombre del evento / eventos del mismo grupo. � El oyente/adaptador al que pertenece el evento / eventos. � El método para asignar el oyente/adaptador al componente sobre el que actúa el evento. � El tipo de datos de objeto recibido como parámetro por el evento. Conociendo estos datos, la programación siempre se hace igual: Componente.MetodoParaAñadirOyente(new NombreOyenteAdaptador() { public void nombreEvento1(TipoDatoParametro evt) { LlamadaAProcedimientoEvento1(evt);} public void nombreEvento2(TipoDatoParametro evt) { LlamadaAProcedimientoEvento2(evt);} });


11

Ejemplo:

v_txt_ocupacionn[i].addActionListener(new ActionListener() { public void actionPerformed(ActionEvent evt) {

pasar_focoDmesActionPerformed(evt); } }); 2.1.1.9. Aplicación Java

Para este proyecto hemos creado una Java SE aplication. Para el diseño de la aplicación, Java proporciona dos paquetes gráficos: AWT y Swing. La

diferencia fundamental entre AWT y Swing es que Swing proporciona gran cantidad de controles y componentes para el desarrollo de interfaces gráficas que enriquecen la interfaz del programa. Es por ello que, en este proyecto se ha utilizado el paquete gráfico Swing. Swing proporciona, también, muchas clases prefabricadas para facilitar el diseño gráfico. A continuación se explica de forma breve las características que han sido más utilizadas en la realización de la interfaz :

� JFrame: es el componente básico para implementar una interfaz visual con la librería Swing.

Se ha utlilizado para crear la clase “Cuadro” la cual hereda de la clase JFrame. � JTabbedPane: es un componente que permite al usuario cambiar entre un grupo de

componentes haciendo click sobre la pestaña correspondiente. Se ha utilizado para seleccionar los paneles.

� JTextField: es un elemento que permite la entrada de texto por parte del usuario. Se ha

utilizado para introducir los parámetros . � JPanel: es un objeto de los llamados "contenedores". Es así porque sirve para agrupar y

organizar otros elementos de la interfaz. De esta forma, actúa como una caja donde se van metiendo elementos de la interfaz para poder manejarlos como una agrupación. Es una clase fundamental que se ha utilizado para dar un diseño atractivo e intuitivo.

� JLabel: es una etiqueta de texto. En este proyecto se ha utilizado para informar al usuario a

qué variable corresponden cada uno de los JTextFields y también para mostrar resultados y gráficos.

� JButton: se trata de un elemento que actúa como un pulsador al que se le pueden asignar

acciones una vez pulsado. Se ha utilizado para numerosos controles en la aplicación. � JComboBox: es un componente que permite seleccionar entre una serie de valores

previamente definidos. Se ha utilizado, por ejemplo, para seleccionar la inclinación entre los distintos valores disponibles en el programa.

� JRadioButton: es un elemento que puede ser seleccionado o no. Se ha utilizado en opciones

de cálculos y para seleccionar datos por defecto.


12

� JCheckBox: es un elemento que puede ser seleccionado o no. Actúa como un botón de estado en el que la información que recogemos es, si está seleccionado, cierta, y en caso contrario, falsa. Se ha utilizado en opciones de cálculos .

� JDialog: Los Cuadros de Diálogo son ventanas simplificadas que muestran distintas opciones

al usuario. Los objetos JDialog son los que permiten la creación y uso de cuadros de diálogo en un proyecto java. Existen dos tipos de cuadros de diálogo: los modales y no modales. Los cuadros de diálogo modales no permiten que se active otra ventana hasta que el cuadro de diálogo no se haya cerrado. Los cuadros de diálogo no modales permiten trabajar con otra ventana a pesar de que el propio cuadro de diálogo no haya sido cerrado.

figura 4. elementos más usados en la aplicación

2.1.1.10. Instalación de la aplicación Java

Una vez que se ha finalizado el programa, en Netbeans, debemos prepararlo para la instalación en cualquier otro ordenador. Para ello, es necesario tener en cuenta todos aquellos ficheros externos cuyos contenidos intervienen en la aplicación: base de datos, imágenes, informes, etc... Procedemos de la siguiente manera:

JRadioButton JComboBox

JLabel

JTextField

JButton

JPanel

JDialog

JCheckBox


13

� En Netbeans, ejecutamos la orden Limpiar y construir proyecto principal. Esta orden compila el programa y crea una carpeta llamada dist dentro de la carpeta del proyecto, la cual será la carpeta “distribuible”.

� Dentro de la carpeta dist se crea un fichero con extensión .jar. Este fichero se puede decir que

es el “ejecutable” del programa. El fichero .jar contiene todas las clases que hemos programado en el proyecto. En nuestro caso se ha generado el fichero Simulacion_ACS_1_1.jar

� Los programas java pueden ejecutarse en cualquier entorno, pero para que un ejecutable .jar

pueda ser ejecutado en un determinado sistema, debe estar instalado en él la máquina virtual de java.

� Además del fichero ejecutable (.jar) con el nombre del proyecto, se crea también una carpeta

lib. Esta carpeta contiene las librerías adicionales que se hayan incluido en el proyecto.

figura 5. librerías adicionales incluidas en el proyecto.

� Bases de datos. Es necesario copiar el archivo base de datos en la carpeta dist. En nuestro caso hemos creado la carpeta “Base” para la base de datos, entonces copiamos la carpeta “Base” en la carpeta distribuible. � Imágenes (para la presentación, los iconos de los botones de las barras de herramientas, etc.)

, también tenemos que introducir los ficheros de estas imágenes dentro de la carpeta distribuible.

� Informes. Es necesario que los ficheros de estos estén dentro de la carpeta del distribuible.

Los ficheros de informes necesarios para el funcionamiento del programa son los ficheros compilados .jasper. Estos ficheros están dentro de una carpeta llamada “informesireport” , así que copiamos la carpeta con los informes dentro de la carpeta del distribuible.

� Imágenes de informes. Como los informes del programa usan imágenes, la situación de estas

en la carpeta distribuible depende de la forma en que haya configurado dichas imágenes en el iReport. Para este proyecto las imágenes se guardan en la capeta “Gráficas” que también copiamos en la carpeta dist.

� Una vez incluidos todos estos elementos ya tenemos la carpeta distribuible completada.

Para la instalación de la aplicación en otro ordenador, solo hay que copiar en una misma carpeta todos los elementos que intervienen, es decir:

� Archivo ejecutable "Simulacion_ACS_1_1.jar" � carpeta "lib"


14

� capeta "Base" � carpeta "Graficas" � carpeta "informesireport"

El ordenador de destino tiene que tener instalada la máquina virtual de java, propia del sistema operativo que utilice, para que el proyecto pueda ejecutarse.

2.1.1.11. Componente de la aplicación.

A continuación presentamos cada uno de los componentes de la clase principal "Cuadro.java" de la aplicación Java desarrollada para este proyecto.

figura 6. Componentes de la aplicación. Ventana de diseño NetBeans


15

Componente JFrame Form Cuadro:

Componente 1. Paneles [JTabbedPane] Componente 1.1. panel_datos [JPanel] . "INICIO"

figura 7. panel_datos, aplicación Java

C1.1.1. “Nuevo proyecto” componente: btnNuevoproyecto [JButton] descripción: Botón de inicio de los cálculos.

Abre el cuadro de dialogos “dialogodatos_nuevoproyecto” para introducir los datos de un proyecto nuevo y borra los del anterior si lo hubiera.

evento: private void btnNuevoproyectoActionPerformed(java.awt.event.ActionEvent evt) { Cancelar_Todo(); dialogodatos_nuevoproyecto.setSize(400, 400); dialogodatos_nuevoproyecto.setLocation(300, 300); dialogodatos_nuevoproyecto.setTitle("Localización"); comboDDNPloc.setSelectedIndex(0); etiDDNPloc.setText("");

dialogodatos_nuevoproyecto.setVisible(true);}


16

C1.1.2. dialogodatos_nuevoproyecto [JDialog]

figura 8. cuadro de diálogo “dialogodatos_nuevoproyecto”

C1.1.2.1. “Provincia”

componente: comboDDNPloc [JComboBox] descripción: Combo para seleccionar el nombre de la provincia donde se localiza el proyecto.

Escribe el nombre de la provincia seleccionada en la etiqueta etiDDNPloc. Todos los datos estarán referidos a la capital de dicha provincia.

evento: private void comboDDNPlocActionPerformed(java.awt.event.ActionEvent evt) { String loc = comboDDNPloc.getSelectedItem().toString();

etiDDNPloc.setText(loc);} C1.1.2.2. "Nueva localización" componente: txtDDNPloc [JTextField] descripción: Campo de texto donde podemos escribir un nombre que aparecerá en la etiqueta

etiDDNP_nombreciudad y que se almacenará como nombre de la localización del proyecto.

evento: private void txtDDNPnuevalocKeyReleased(java.awt.event.KeyEvent evt) { String loc = txtDDNPnuevaloc.getText(); etiDDNP_nombreciudad.setText(loc);}

C1.1.2.3. "Cancelar"

componente: btnDDNPCancelaloc [JButton] descripción: Botón que cierra el cuadro de diálogo y cancela el inicio del nuevo proyecto. evento: private void btnDDNPCancelalocActionPerformed(java.awt.event.ActionEvent evt) {

Cancela_Nuevo(); dialogodatos_nuevoproyecto.dispose(); }

C1.1.2.4. "Calcula todo" componente: btnDDNP_CalculaTodo [JButton] descripción: Realiza todos los cálculos del programa para la provincia seleccionada con los

datos iniciales de un ejemplo tomados como valores por defecto. evento: private void btnDDNP_CalculaTodoActionPerformed(java.awt.event.ActionEvent evt) {

Boton_Gordo();}


17

C1.1.2.5. "Aceptar"

componente: btnDDNPAceptaloc [JButton] descripción: Acepta el nombre de la provincia y abre el cuadro de diálogo dialogo_datosdelsitio

[JDialog]. evento: private void btnDDNPAceptalocActionPerformed(java.awt.event.ActionEvent evt) {

Acepta_Nuevo("continuar"); }

C1.1.3. dialogo_datosdelsitio [JDialog]. "Datos generales"

figura 9. dialogo_datosdelsitio [JDialog]

C1.1.3.1. "Valores por defecto"

componente: Rbtn_datosDefecto [JRadioButton] descripción: Rellena los campos de texto con los datos de un ejemplo tomado por defecto. Cada

campo de texto se puede rellenar con los valores que queramos. En la figura 9 podemos ver los datos por defecto.

evento: private void Rbtn_datosDefectoActionPerformed(java.awt.event.ActionEvent evt) { double[] DG = new double[12]; if (Rbtn_datosDefecto.isSelected()) { // DG[0]=45; DG[1] = 0; DG[2] = 1.05; DG[3] = 0.15; DG[4] = 32; DG[5] = 40; DG[6] = 2.01; DG[7] = 0.83; DG[8] = 4.8; DG[9] = 45; DG[10] = 0.94; DG[11] = 0.12; } else { Cancela_Datos_Generales(0);}

Introduce_Datos_Generales(DG);}


18

C1.1.3.2. "Volver"

componente: btnVolver_Datosdelsitio [JButton] descripción: Anula los datos, cierra la ventana y abre el dialogodatos_nuevoproyecto. evento: private void btnVolver_DatosdelsitioActionPerformed(java.awt.event.ActionEvent evt) {

Cancela_Datos_Generales(0); if (Rbtn_datosDefecto.isSelected()) {Rbtn_datosDefecto.setSelected(false);} dialogo_datosdelsitio.dispose();

dialogodatos_nuevoproyecto.setVisible(true);}


componente: btnCancelar_Datosdelsitio [JButton] descripción: Anula los datos para poder introducirlos de nuevo. evento: private void btn_CancelarDatosdelsitioActionPerformed(java.awt.event.ActionEvent evt) {

Cancela_Datos_Generales(0); if (Rbtn_datosDefecto.isSelected()) {Rbtn_datosDefecto.setSelected(false); }}

C1.1.3.4. "Continuar"

componente: btnContinuar_Datosdelsitio [JButton] descripción: Cierra el dialogo_datosdelsitio, rellena los campos de texto del panel_datos con

los valores introducidos y abre el cuadro de diálogo dialogo_datosmensuales. evento: private void btn_ContinuarDatosdelsitioActionPerformed(java.awt.event.ActionEvent evt) {

Continuar_Datosdelsitio();}

C1.1.4. dialogo_datosmensuales [JDialog]. "Datos mensuales"

figura 10. dialogo_datosmensuales


19


componente: RbtnDatosmensuales [JRadioButton] descripción: Rellena los campos de texto según la provincia seleccionada y la inclinación

(fuente Censolar[2]). Cada campo de texto se puede rellenar con los valores que queramos. En la figura 10 podemos ver los datos por defecto para Badajoz.

evento: private void RbtnDatosmensualesActionPerformed(java.awt.event.ActionEvent evt) { if (RbtnDatosmensuales.isSelected()) { Introduce_Datos_Mensuales_pordefecto();}

else { Cancela_Datos_Mensuales();} }

C1.1.4.2. "Volver"

componente: btnVolverDatosMensuales [JButton] descripción: Anula los datos, cierra la ventana y abre el dialogodatos_datosdelsitio. evento: private void btnVolverDatosMensualesActionPerformed(java.awt.event.ActionEvent evt) {

// Cancela_Datos_Generales(); if (RbtnDatosmensuales.isSelected()) {RbtnDatosmensuales.setSelected(false); } dialogo_datosmensuales.dispose(); // Cancela_Datos_Generales(1);Cancela_Datos_Mensuales();

dialogo_datosdelsitio.setVisible(true); }


componente: btnCancelarDatosMensuales [JButton] descripción: Anula los datos para poder introducirlos de nuevo. evento: private void btnCancelarDatosMensualesActionPerformed(java.awt.event.ActionEvent evt) {

Cancela_Datos_Mensuales(); if (RbtnDatosmensuales.isSelected()) {

RbtnDatosmensuales.setSelected(false); }

C1.1.4.4. "Continuar"

componente: btnContinuarDatosMensuales [JButton] descripción: Cierra el dialogo_datosmensuales y pasa al panel panel_calculos. evento: private void btnContinuardatosmensualesActionPerformed(java.awt.event.ActionEvent evt) {

Continuar_Datosmensuales();}


20

Componente 1.2. panel_calculos [JPanel] . "CÁLCULOS"

figura 11. panel_calculos [JPanel]

C1.2.1. subpanelCVM [JPanel]

figura 6. subpanelCVM [JPanel]

C1.2.1.1. "Seleccionar todos"

componente: btnSeleccionaTodos [JButton] descripción: Selecciona para los cáculos todos los meses del año evento: private void btnSeleccionaTodosActionPerformed(java.awt.event.ActionEvent evt) {

int i; for (i = 0; i < 12; i++) { if (chMeses[i].isSelected()) {}

else {chMeses[i].setSelected(true);} }}


21


componente: btnCancelaSeleccion [JButton] descripción: Anula la selección de todos los meses evento: private void btnCancelaSeleccionMesesActionPerformed(java.awt.event.ActionEvent evt) {

int i; for (i = 0; i < 12; i++) {

if (chMeses[i].isSelected()) { chMeses[i].setSelected(false); } else { } }} C1.2.1.3. "Calcular"

componente: btnCalcula_porcuadros [JButton] descripción: Calcula la energía necesaria en MJ (neMJ) para calentar el agua y la energía neta

disponible por m2 (ENDmes) en cada mes seleccionado. Los resultados los muestra en el panel "panel_resultados". Figura 12.

evento: private void btnCalcula_porcuadrosActionPerformed(java.awt.event.ActionEvent evt) { if (pueblo.Nombre.equals("")) { JOptionPane.showMessageDialog(null, "Debe introducir los datos necesarios"); }// Nuevo_Proyecto(); if (pueblo.Tuso == 0) { JOptionPane.showMessageDialog(null, "Debe introducir los datos necesarios"); }//Nuevo_Datos_DelSitio(); if (pueblo.vH[1] == 0) { JOptionPane.showMessageDialog(null, "Debe introducir los datos necesarios"); }// Nuevo_Datos_Mensuales(); Aceptar_DatosdeEntrada(); Calculo_mensual_porcuadro(); Vaciar_resultados_porcuadro(); Vaciar_subpaneldatosyresultados(); Paneles.setSelectedComponent(panel_resultados);

}

figura 12. resultados del botón btnCalcula_porcuadros


22

C1.2.2. subpanelcalculo1 [JPanel]

figura 13. subpanelcalculo1

C1.2.2.1. "mes"

componente: combocalculosmes [JComboBox] descripción: Selecciona el mes en el que queramos consultar los resultados. evento: private void combocalculosmesActionPerformed(java.awt.event.ActionEvent evt) {

Introduce_datos_calculosporcombomes(); }

C1.2.2.2. "Consultar"

componente: btncalculosConsultar [JButton] descripción: Calcula el mes seleccionado y muestra los resultados. (figura 13) evento: private void btncalculosConsultarActionPerformed(java.awt.event.ActionEvent evt) {

Consulta_calculosporcombomes(); }

C1.2.2.3. "Modificar datos"

componente: btncalculosModificarDatos [JButton] descripción: Abre el dialogo_datosdelsitio para modificar los datos que queramos antes de

continuar. evento: private void btncalculosModificarDatosActionPerformed(java.awt.event.ActionEvent evt) {

Reiniciar_subpanelesResultados(); dialogo_datosdelsitio.setSize(500, 400); dialogo_datosdelsitio.setLocation(300, 300); dialogo_datosdelsitio.setVisible(true);

}


23

Componente 1.3. panel_resultados [JPanel] . "RESULTADOS"

figura 14. panel_resultados

C1.3.1. "Calcular"

componente: btnresultadosNCteorico [JButton] descripción: Calcula y muestra los resultados de la demanda de energía anual, la energía anual

por m2, la superficie teórica necesaria (método Censolar[1]) y el número de colectores necesarios para dicha supeficie según los datos que pusimos al inicio.

evento: private void btnresultadosNCteoricoActionPerformed(java.awt.event.ActionEvent evt) { Calculo_resultadosNC_porcuadro();}

C1.3.2. "Calcular Superficie resultante"

componente: btnresultadosSC [JButton] descripción: Calcula la superficie resultante según el número de colectores que queramos

asignar al proyecto. Es dato de diseño necesario para continuar con los cálculos. En el campo de texto superior escribimos el valor elegido y la superficie resultante se mostrará en la etiqueta inferior (figura 9)

evento: private void btnresultadosSCActionPerformed(java.awt.event.ActionEvent evt) { Calcula_Superficieresultante(); }


24

C1.3.3. "Resultados"

componente: btnresultadosCostes [JButton] descripción: Calcula y muestra los resultados de la energía neta total en cada mes según la

superficie resultante (ENTotalmes), el cociente de la energía neta y la demanda de cada mes (Sustitución), la demanda no cubierta por energía solar (Déficit), el coste de la energía eléctrica para toda la demanda (Coste kwh), el coste del déficit (Coste Aux), la diferencia entre el coste total y el auxiliar (Ahorro) y la cobertura solar (método Censolar) para cada mes. Además calcula los valores anuales de Aportación solar %, déficit energético, coste eléctrico de la demanda, coste eléctrico del déficit y ahorro.

evento: private void btnresultadosCostesActionPerformed(java.awt.event.ActionEvent evt) { Calcula_panelresultados();}

Componente 1.4. panel_datosyresultados [JPanel]. "DATOS&RESULTADOS"

figura 15. panel_datosyresultados

C1.4.1. "Consultar"

componente: btndatosyresultados_Consultar [JButton] descripción: Muestra los valores mensuales de ocupación (%usuarios), temperatura del agua de

red, H, k, E, horas de sol, I, temperatura ambiente, rendimiento de los colectores y consumo de ACS.

evento: private void btndatosyresultados_ConsultarActionPerformed(java.awt.event.ActionEvent evt) { Ver_Datos_y_Resultados(); }


25

Componente 1.5. panel_acumulador [JPanel] . "ACUMULADOR"

figura 16. panel_acumulador

C1.5.1. "Calcular"

componente: btnacuCalculaVolumen [JButton] descripción: Calcula el volumen en litros del acumulador en función de la superficie de

colectores, por defecto considera 70 l/m2 aunque este valor lo podemos cambiar en el campo de texto “Acumulación por m2”.

evento: private void btnacuCalculaVolumenActionPerformed(java.awt.event.ActionEvent evt) { Calcula_VolumenAcu(); }

C1.5.2. "Comprobar Volumen"

componente: btnacuCompruebavolumen [JButton] descripción: Conprueba el volumen que pongamos como dato del proyecto según el criterio

0.8<=V/M<=1.2 donde V/M es el cociente entre el volumen teórico y el volumen proyectado.

evento: private void btnacuCompruebavolumenActionPerformed(java.awt.event.ActionEvent evt) { Calcula_PruebaAcu(); //ventana resultados

VerResultados();}


26

C1.5.3. "Volumen proyectado +"

componente: btnf_Mas_VolAcu [JButton] descripción: Aumenta 100 litros el volumen del acumulador y recalcula todos las operaciones

donde interviene. El botón (-) hace lo mismo pero disminuyendo 100 litros. evento: private void btnf_Mas_VolAcuActionPerformed(java.awt.event.ActionEvent evt) {

Cambia_VolumenAcumulacion(100); Cambia_KgAcumulacion_fchart(100);//Aumenta 100Kg Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1());

CambiayGrafica_fchart();}

Componente 1.6. panel_histogramas [JPanel] . "GRÁFICAS"

figura 17. panel_histogramas Muestra los valores mensuales de: � Rendimiento de los colectores. � Aportación solar relativa. Compara la aportación solar de cada mes respecto al mes de

mayor aportación. � Sustitución. Porcentage de energía solar respecto a la energía total necesaria cada mes. Cada vez que se entra el el panel se redibujan las gráficas. Evento:

private void panel_histogramasMouseReleased(java.awt.event.MouseEvent evt) { Dibuja_Histogramas_RendiAporSustitucion(); }


27

Componente 1.7. panel_FCHART [JPanel]. "F-Chart"

figura 18. panel_FCHART

C1.7.1. panel_fQa [JPanel] “Cargas caloríficas”

figura 19. panel_fQa y dialogo_fQa

C1.7.1.1. "Datos"

componente: btn_datos_fQa [JButton] descripción: Abre el cuadro de diálogo dialogo_fQa (figura 19) para introdudir los valores de

calor específico (del agua por defecto), el número de usuarios, el consumo de agua diario y la temperatura de uso del ACS. Cada vez que le damos anula los datos anteriores.

evento: private void btn_datos_fQaActionPerformed(java.awt.event.ActionEvent evt) { dialogo_fQa.setSize(400, 400); dialogo_fQa.setVisible(true);

Vacia_Cargas_fchart(); }


28


componente: Rbtn_fQa_valorespordefecto [JRadioButton] descripción: Introduce los valores de calor específico del agua y los valores iniciales que

pusimos de número de usuarios, consumo diario por usuario y temperatura del ACS. Estos valores se pueden modificar en los campos de texto donde aparecen a través del teclado. Si estamos conforme con los valores continuamos presionando “Aceptar”.

evento: private void Rbtn_fQa_valorespordefectoActionPerformed(java.awt.event.ActionEvent evt) { Valoresdefecto_Carga_fchart();}

C1.7.1.3. "Aceptar"

componente: btn_fQa_ Aceptar [JButton] descripción: Acepta los datos para calcular las cargas térmicas (Qa) de cada mes y cierra el

dialogo_fQa. evento: private void btnfQa_AceptarActionPerformed(java.awt.event.ActionEvent evt) {

AceptaDatos_Qa_fchart(); dialogo_fQa.dispose();}

C1.7.1.4. "Calcular Qa"

componente: btn_calcular_fQa [JButton] descripción: Calcula la carga térmica (Qa) en cada mes y muestra en la tabla de abajo los

resultados. Además muestra los valores de la temperatura del agua de red con los que se ha calculado Qa cada mes. (Figura 20)

evento: private void btn_calcular_fQaActionPerformed(java.awt.event.ActionEvent evt) { if (etifQa_Ce.getText().isEmpty()) { dialogo_fQa.setSize(400, 400); dialogo_fQa.setVisible(true);

} else { Calcula_Cargas_fchart(); } }

figura 20. temperatura del agua de red (tr) y cargas térmicas(Qa) para el método f-chart


29

C1.7.2. panel_fEa [JPanel]. "Energía absorbida"

figura 21. panel_fEa y dialogo_fEa C1.7.2.1 "Datos"

componente: btn_datos_fEa [JButton] descripción: Abre el cuadro de diálogo dialogo_fEa (figura 21) para introdudir los valores de

factor de eficiencia óptica, el factor de modificación del ángulo de incidencia, el factor captador-intercambiador, el número de paneles y la superficie de un panel. Cada vez que le damos anula los datos anteriores.

evento: private void btn_datos_fEaActionPerformed(java.awt.event.ActionEvent evt) { dialogo_fEa.setSize(400, 400); dialogo_fEa.setVisible(true);

Vacia_Eabsorbida_fchart();} C1.7.2.2. "Valores por defecto" componente: Rbtn_fEa_valorespordefecto [JRadioButton] descripción: Introduce los valores que pusimos al inicio de los cáculo. Estos valores se pueden

modificar en los campos de texto donde aparecen a través del teclado. Si estamos conforme con los valores continuamos presionando “Aceptar”.

evento: private void Rbtn_fEa_valorespordefectoActionPerformed(java.awt.event.ActionEvent evt) { ValoresDefecto_Eabsorbida_fchart();}

C1.7.2.3. "Aceptar"

componente: btn_fEa_ Aceptar [JButton] descripción: Acepta los datos para calcular la energía absorbida (Ea) de cada mes y cierra el

dialogo_fEa. evento: private void btnfEa_AceptarActionPerformed(java.awt.event.ActionEvent evt) {

AceptaDatos_Ea_fchart(); dialogo_fEa.dispose();}


30

C1.7.2.4. "Calcular Ea"

componente: btn_calcular_fEa [JButton] descripción: Calcula la radiación incidente (Ri) y la energía absorbida por los colectores (Ea)

en cada mes y muestra en la tabla de abajo los resultados (figura 22). evento: private void btn_Calcula_fEaActionPerformed(java.awt.event.ActionEvent evt) {

if (etifEa_FEO.getText().isEmpty()) { dialogo_fEa.setSize(400, 400); dialogo_fEa.setVisible(true);

} else { Calcula_Eabsorbida_fchart(); } }

figura 22. Energía absorbida, método f-chart

C1.7.3. panel_fEp [JPanel] . "Energía perdida"

figura 23. panel_fEp y dialogo_fEp

C1.7.3.1. "Datos"

componente: btn_datos_fEp [JButton] descripción: Abre el cuadro de diálogo dialogo_fEp (figura 23) para introdudir los valores del

coeficiente global de pérdidas (factor m de los colectores), kg de acumulación (volumen de agua en litros del acumulador) y la temperatura mínima del ACS. Cada vez que le damos anula los datos anteriores.

evento: private void btn_datos_fEpActionPerformed(java.awt.event.ActionEvent evt) { dialogo_fEp.setSize(400, 400); dialogo_fEp.setVisible(true);

Vacia_Eperdida_fchart();}


31


componente: Rbtn_fEp_valorespordefecto [JRadioButton] descripción: Introduce los valores que pusimos al inicio de los cáculos. Estos valores se

pueden modificar en los campos de texto donde aparecen a través del teclado. Si estamos conforme con los valores continuamos presionando “Aceptar”.

evento: private void Rbtn_fEp_valorespordefectoActionPerformed(java.awt.event.ActionEvent evt) { ValoresDefecto_Eperdida_fchart();}

C1.7.3.3. "Aceptar"

componente: btn_fEa_ Aceptar [JButton] descripción: Acepta los datos y calcula el factor k1 para calcular la energía perdida (Ea) de

cada mes y cierra el dialogo_fEa. evento: private void btnfEp_AceptarActionPerformed(java.awt.event.ActionEvent evt) {

AceptaDatos_Ea_fchart(); dialogo_fEp.dispose();}

C1.7.3.4. "Calcular Ep"

componente: btn_calcular_fEp [JButton] descripción: Calcula el intervalo de tiempo en segundos (Dts), el factor k2 y la energía perdida

(Ep) en cada mes y muestra en la tabla de abajo los resultados (figura 24). evento: private void btn_Calcula_fEpActionPerformed(java.awt.event.ActionEvent evt) {

if (etifEp_CGP.getText().isEmpty()) { dialogo_fEp.setSize(400, 400); dialogo_fEp.setVisible(true);

} else { Calcula_Eperdida_fchart(); }}

figura 24. Cálculo de la energía perdida, método f-chart


32

C1.7.4. "Calcular f"

componente: btn_Calcula_fchart [JButton] descripción: Calcula los valores D1 y D2 para calcular el factor f de cada mes según la

expresión f=1.029·D1-0.065·D2-0.2453D1^2+0.0018·D2^2+0.0215·D1^3. Además calcula la energía útil (Qu) y la cobertura solar anual (CSA). Los resultados los muestra en la tabla de abajo (figura 25). Cada vez que calcula nos da la opción de guardar los resultados en una tabla que luego podremos consultar y que describiremos más adelante.

evento: private void btn_Calcula_fchartActionPerformed(java.awt.event.ActionEvent evt) { try{Calcula_fchart(); VerResultados(); Almacena_simulacion_sinverlo(); }catch(Exception e){}

}

figura 25. Cálculo f-chart

Componente 1.8. panel_graficas-fchart [JPanel]. “Graficas f-chart”

figura 26. panel_graficas_fchart


33

C1.8.1. panel_graf [JPanel]

figura 27. panel_graf y panel_valores_grafica_fchart A la izquierda, en el panel_graf dibuja una curva azul que une los valores del factor f de cada

mes y una línea roja que representa el valor de la cobertura solar anual (CSA) caluladas con el método f-chart. A la derecha, en el panel_valores_grafica_fchart se muestran los valores calculados de f y CSA. Tanto las curvas como los valores se actualizan cada vez que varían los datos del proyecto.

C1.8.2. panel_comprobacion_fk1 [JPanel]

figura 28.- panel_comprobacion_fk1

C1.8.2.1. "Comprobar"

componente: btn_Comprobark1 [JButton] descripción: Comprueba si el valor calculado k1 cumple con la condición de diseño 37.5< kg

acumulación / m2 captadores <300 y muestra el resultados indicando si cumple o no. Esta comprobación se realiza cada vez que cambiemos los valores de kg y número de paneles con los botones “+,-“. También no da la opción de guardar los resultados.

evento: private void btnf_ComprobarK1ActionPerformed(java.awt.event.ActionEvent evt) { Comrobar_K1_fchart();

Almacena_simulacion_sinverlo();}


34

C1.8.2.2. "kg acumulación +"

componente: btnf_Mas_kg [JButton] descripción: Aumenta en 100 kg los kg de acumulación y con el nuevo valor recalcula k1, los

factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btn_menos_kg disminuye 100 kg y realiza los mismos eventos.

evento: private void btnf_Mas_kgActionPerformed(java.awt.event.ActionEvent evt) { Cambia_KgAcumulacion_fchart(100);//Aumenta 100Kg Cambia_VolumenAcumulacion(100); Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart(); VerResultados();

Almacena_simulacion_sinverlo(); }

C1.8.2.3. "Número de paneles +"

componente: btnf_Mas_paneles [JButton] descripción: Aumenta en 1 el número de captadores y con el nuevo valor recalcula k1, los

factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. Además recalcula todos los valores obtenidos anteriormente en los que interviene el número de paneles. El botón btnf_menos_paneles disminuye 1 y realiza los mismos eventos.

evento: private void btnf_Mas_panelesActionPerformed(java.awt.event.ActionEvent evt) { Cambia_NumeroPaneles_fchart(1);//incrementa el numero de paneles en 1 Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart(); Cambia_NumeroColectores(1);


C1.8.2.4. "b +"

componente: btnf_Mas_bcol [JButton] descripción: Incrementa 0.01 el valor del factor de eficiencia óptica (parámetro b de los

paneles) y con el nuevo valor recalcula el rendimiento de los paneles, el k1, los factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menos_bcol disminuye 0.01 y realiza los mismos eventos.

evento: private void btnf_Mas_bcolActionPerformed(java.awt.event.ActionEvent evt) { Cambia_FEObcol_fchart(0.01); Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart(); //nuevo Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados



35

C1.8.2.5. "m +"

componente: btnf_Mas_mcol [JButton] descripción: Incrementa 0.1 el valor del coeficiente global de pérdidas (parámetro m de los

paneles) y con el nuevo valor recalcula el rendimiento de los paneles, el k1, los factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menos_mcol disminuye 0.1 y realiza los mismos eventos.

evento: private void btnf_Mas_mcolActionPerformed(java.awt.event.ActionEvent evt) { Cambia_CGPmcol_fchart(0.1); Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart(); Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados

Almacena_simulacion_sinverlo();} C1.8.2.6. "factor intercambiador +"

componente: btnf_Mas_factorIntercambiador [JButton] descripción: Incrementa 0.01 el valor del factor del intercambiador y con el nuevo valor

recalcula el k1, los factores f, la CSA y actualiza las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menos_factorIntercambiador disminuye 0.01 y realiza los mismos eventos.

evento: private void btnf_Mas_factorIntercambiadorActionPerformed(java.awt.event.ActionEvent evt) { Cambia_FCCI_fchart(0.01); Comrobar_K1_fchart(); etif_compruebaK1.setText("" + pueblo.getK1()); CambiayGrafica_fchart();

Almacena_simulacion_sinverlo();} C1.8.3. panelf_MasMenos [JPanel]

figura 29. panelf_MasMenos


36

C1.8.3.1. "Iniciar"

componente: btnf_Graficar_fchart [JButton] descripción: Con los datos iniciales del proyecto rellena los campos de texto con los valores de

ocupación, consumo diario, temperatura del ACS e inclinación de los paneles. Actualiza los resultados y las gráficas.

evento: private void btnf_Graficar_fchartActionPerformed(java.awt.event.ActionEvent evt) { Cancela_cambios_fchart(); Cancela_cambios_fchart(); Ver_Datos_y_Resultados();//actualiza casillas ocu y consu del panel datos y resultados


C1.8.3.2. "todos"

componente: btnf_todos_Mn [JButton] descripción: Selecciona todos los meses marcando todas las casillas de selección (figura29). evento: private void btnf_todos_MmActionPerformed(java.awt.event.ActionEvent evt) {

Selecciona_mesesTodos_Mm();}

C1.8.3.3. "Ocupación +"

componente: btnf_Masocupacion [JButton] descripción: Aumenta un 5% la ocupación (número de usuarios) de los meses marcados en las

casillas de selección y con los nuevos valores actualiza los resultados y las gráficas. El valor máximo es 100. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menosocupacion disminuye un 5% y realiza los mismos eventos.

evento: private void btnf_Masocupacion_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Ocupacion_Mm(5);//incrementa un 5% Ver_Datos_y_Resultados();//actualiza casillas ocu y consu del panel datos y resultados


C1.8.3.4. "Litros /día usuario +"

componente: btnf_Maslitrosdia [JButton] descripción: Aumenta 5 litros el consumo diario de ACS por usuario de los meses marcados en

las casillas de selección y con los nuevos valores actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menoslitrosdia disminuye 5 litros y realiza los mismos eventos.

evento: private void btnf_Masliitrosdia_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_LitrosDia_Mm(5);//incrementa en 5 Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados



37

C1.8.3.5. "Tuso +"

componente: btnf_Mastuso [JButton] descripción: Aumenta 5ºC la temperatura del ACS de los meses marcados en las casillas de

selección y con los nuevos valores actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menostuso disminuye 5ºC y realiza los mismos eventos.

evento: private void btnf_Mastuso_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Tuso_Mm(5);//incrementa en 5 Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados


C1.8.3.6. "Inclinación +"

componente: btnf_MasInclinacion [JButton] descripción: Aumenta un 5º la inclinación de los paneles de los meses marcados en las casillas

de selección y con los nuevos valores actualiza los resultados y las gráficas. El valor máximo es 65º y el mínimo 35º. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnf_menosocupacion disminuye 5º y realiza los mismos eventos.

evento: private void btnf_MasInclinacion_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Inclinacion_Mm(5); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados

Almacena_simulacion_sinverlo(); } C1.8.3.7. "Cancelar"

componente: btnf_Cancelar_Mn descripción: Cancela todos los cambios repecto a los datos iniciales de ocupación, consumo

diario, temperatura de uso e inclinación. Elimina las marcas de todos los meses. Rellena los campos con los datos iniciales del proyecto y actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla.

evento: private void btnf_Cancelar_MmActionPerformed(java.awt.event.ActionEvent evt) { Cancela_Cambios_Mn(); // Cancela_cambios_fchart(); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados


C1.8.4. "Ver resultados"

componente: btnVerresultados_fchart [JButton] descripción: Abre la ventana BD_Resultados [JDialog] (figura 30) evento: private void btnVerresultados_fchartActionPerformed(java.awt.event.ActionEvent evt) {

VerResultados_enJTable(1); VervariacionesFchartAnual_enJTable(1); }


38

figura 30. ventana BD_Resultados En esta ventana podemos ver los resultados que hemos guardado y realizar informes y

guardarlos en archivo o imprimirlos.

C1.8.5. "Guardar"

componente: btnGuardar_fchart descripción: Guarda los resultados con los datos que tengamos en ese momento y abre la

ventana BD_Resultados [JDialog] (figura 25) que describiremos más adelante. evento: private void btnGuadar_fchartActionPerformed(java.awt.event.ActionEvent evt) {

Guardar_Resultados_finales(); GuardarResultadosACS(1);

GuardarVariacionAnual(1); }


39

Componente 1.9. panel_GRAF2 [JPanel] . “Gráficas demanda-aportación”

figura 31. panel_GRAF2 Evento:

private void panel_GRAF2MouseReleased(java.awt.event.MouseEvent evt) { GraficayDibuja_DemandaAporatacion_Masmenos(); }

C1.9.1. panhistoDemandaAportacion [JPanel]

figura 32. gráficas demanda-aportación Compara la demanda de energía para calentar el agua cada mes calculado (barras de de color

amarillo) con la aportación solar de los paneles disponibles cada mes (barras de color rojo).


40

C1.9.2. panel_comprobacion_DAlitrosm2 [JPanel]. “Superficie colectora calculada”

figura 33. panel_comprobacion_DAlitrosm2

C1.9.2.1. "Nº de colectores +"

componente: btnDA_Mas_colectores [JButton] descripción: Aumenta en 1 el número de captadores y con el nuevo valor recalcula y actualiza

las gráficas. Comprueba la condición de diseno 60<=C/A<=100 , cociente entre el consumo diario por usuario y la superficie de captadores. Finalmente nos da la opción de guardar los resultados en una tabla. Además recalcula todos los valores obtenidos anteriormente en los que interviene el número de paneles. El botón btnDA_menos_colectores disminuye 1 y realiza los mismos eventos.

evento: private void btnDA_Mas_colectoresActionPerformed(java.awt.event.ActionEvent evt) { Cambia_NumeroColectores(1); GraficayDibuja_DemandaAporatacion_Masmenos(); Cambia_NumeroPaneles_fchart(1);//ventana resultados Calculo_resultadosNC_porcuadro(); Cambia_NumeroColectores(0);

VerResultados(); Almacena_simulacion_sinverlo();}

C1.9.3. panelDA_MasMenos [JPanel]

figura 34.- panelDA_MasMenos

C1.9.3.1. "INICIO" componente: btnInicio_Graf2 [JButton] descripción: Con los datos iniciales del proyecto rellena los campos de texto con los valores de

ocupación, consumo diario, temperatura del ACS e inclinación de los paneles. Actualiza los resultados y las gráficas.

evento: private void btnInicio_Graf2ActionPerformed(java.awt.event.ActionEvent evt) { Cancela_cambios_DA(); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados



41

C1.9.3.2. "todos"

componente: btnDA_todos_Mm [JButton] descripción: Selecciona todos los meses marcando todas las casillas de selección (figura34). evento: private void btnDA_todos_MmActionPerformed(java.awt.event.ActionEvent evt) {

Selecciona_mesesTodos_Mm(); }

C1.9.3.3 "Ocupación +"

componente: btnDA_Masocupacion_Mm [JButton] descripción: Aumenta un 5% la ocupación (número de usuarios) de los meses marcados en las

casillas de selección y con los nuevos valores actualiza los resultados y las gráficas. El valor máximo es 100. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnDA_menosocupacion_Mm disminuye un 5% y realiza los mismos eventos.

evento: private void btnDA_Masocupacion_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Ocupacion_Mm(5);//incrementa un 5% Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados


C1.9.3.4. "Litros/día usuario +"

componente: btnDA_Maslitrosdia_Mm [JButton] descripción: Aumenta 5 litros el consumo diario de ACS por usuario de los meses marcados en

las casillas de selección y con los nuevos valores actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnDA_menoslitrosdia_Mm disminuye 5 litros y realiza los mismos eventos.

evento: private void btnDA_Masliitrosdia_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_LitrosDia_Mm(5);// incrementa 5 litros Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados


C1.9.3.5. "Tuso +"

componente: btnDA_Mastuso_Mm [JButton] descripción: Aumenta 5ºC la temperatura del ACS de los meses marcados en las casillas de

selección y con los nuevos valores actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnDA_menostuso_Mm disminuye 5ºC y realiza los mismos eventos.

evento: private void btnDA_Mastuso_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Tuso_Mm(5);//incrementa en 5 Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados



42

C1.9.3.6. "Inclinación +"

componente: btnDA_MasInclinacion_Mm [JButton] descripción: Aumenta un 5º la inclinación de los paneles de los meses marcados en las casillas

de selección y con los nuevos valores actualiza los resultados y las gráficas. El valor máximo es 65º y el mínimo 35º. Finalmente nos da la opción de guardar los resultados en una tabla. El botón btnDA_menosocupacion_Mm disminuye 5º y realiza los mismos eventos

evento: private void btnDA_MasInclinacion_MmActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Inclinacion_Mm(5); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados



componente: btnDA_Cancelar_Mm descripción: Cancela todos los cambios repecto a los datos iniciales de ocupación, consumo

diario, temperatura de uso e inclinación. Elimina las marcas de todos los meses. Rellena los campos con los datos iniciales del proyecto y actualiza los resultados y las gráficas. Finalmente nos da la opción de guardar los resultados en una tabla.

evento: private void btnDA_Cancelar_MmActionPerformed(java.awt.event.ActionEvent evt) { Cancela_Cambios_Mn(); // Cancela_cambios_DA(); Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados Ver_Datos_y_Resultados();//actualiza ocupación y consumo del panel datos y resultados


C1.9.4. "ver resultados"

componente: btnVerResultados_G2 [JButton] descripción: Abre la ventana BD_Resultados [JDialog] (figura 35) evento: private void btnVerResultados_G2ActionPerformed(java.awt.event.ActionEvent evt) {

VerResultados_enJTable(1); VervariacionesFchartAnual_enJTable(1); }


43

figura 35. ventana BD_Resultados En esta ventana podemos ver los resultados que hemos guardado y realizar informes y

guardarlos en archivo o imprimirlos.

C1.9.5. "Guardar"

componente: btnGuardar_graf2 descripción: Guarda los resultados con los datos que tengamos en ese momento y abre la

ventana BD_Resultados [JDialog] (figura 35) que describiremos más adelante. evento: private void btnGuardar_graf2ActionPerformed(java.awt.event.ActionEvent evt) {

Guardar_Resultados_finales(); GuardarResultadosACS(1);


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.


44

C1.10.1. "Guardar"

componente: btnGuardarResultados [JButton] descripción: Guarda los datos y resultados en el panel_proyecto (figura 30) y en las tablas de la

base de datos a la que está conectado el programa. evento: private void btnGuardarResultadosActionPerformed(java.awt.event.ActionEvent evt) {

//para todos los botones guardar Guardar_Resultados_finales();//en el panel proyectos guardados GuardarResultadosACS(1);//En BD y en la JTable

GuardarVariacionAnual(1); } C1.10.2. "Borrar anterior"

componente: btnBorra_GuardarResultados [JButton] descripción: Elimina el contenido de la última fila que esté almacenada en el panel_proyectos. evento: private void btnBorra_GuardarResustadosActionPerformed(java.awt.event.ActionEvent evt) {

JLabel[][] dATOSgr = {DatosGR_1, DatosGR_2, DatosGR_3, DatosGR_4, DatosGR_5, DatosGR_6,DatosGR_7, DatosGR_8, DatosGR_9, DatosGR_10, DatosGR_11, DatosGR_12, DatosGR_13};

int numfilas = dATOSgr.length; int numcolumnas = dATOSgr[0].length; for (int j = 0; j < numfilas - 1; j++) { if (dATOSgr[j + 1][0].getText().isEmpty()) {

for (int i = 0; i < numcolumnas; i++) { dATOSgr[j][i].setText(""); dATOSgr[j][i].setBackground(Color.GRAY); } } } for (int i = 0; i < numcolumnas; i++) { dATOSgr[12][i].setText(""); dATOSgr[12][i].setBackground(Color.GRAY);

} }

Componente 1.11. panel_JFreechart [JPanel]. "Gráficas JFree"

Con el uso de librerías de JFreechart se dibujan la gráficas que se emplearán como imagen en

los informes iReport.

C1.11.1."Ver gráficas RenApoSus"

componente: btnVergraf_RenAporSus [JButton] descripción: Dibuja las gráficas de rendimiento, aportación relativa y sustitución y las muestra

en la ventana Dialogo_graf_RenaporSus_JFC [JDialog] (figura 36). Estas gráficas pueden guardarse como archivos de imagen y son utilizadas en los informes.

evento: private void btnVergraf_RenAporSusActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_RenAporSus_JFC.setSize(950,650); dialogo_graf_RenAporSus_JFC.setResizable(true); dialogo_graf_RenAporSus_JFC.setVisible(true);

Dibuja_RenAporSus_JFC(); }


45

figura 36. gráficas de rendimiento, aportación solar relativa y sustitución con JFreechart

C1.11.2. "Ver gráficas DA"

componente: btnVergraf_DA [JButton] descripción: Dibuja las gráficas de demanda de energía y aportación solar y las muestra en la

ventana Dialogo_graf_DemApor_JFC [JDialog] (figura 37). Estas gráficas pueden guardarse como archivos de imagen y son utilizadas en los informes.

evento: private void btnVergraf_DAActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_DemApor_JFC.setSize(700,650); dialogo_graf_DemApor_JFC.setResizable(true); dialogo_graf_DemApor_JFC.setVisible(true);

Dibuja_DemandaAportacion_JFC(); }

figura 37. gráfica Demanda-Aportación con JFreechart


46

C1.11.3. "Ver gráfica f-chart"

componente: btnVergraf_fchart [JButton] descripción: Dibuja las gráficas de f-chart y cobertura solar anual y las muestra en la ventana

Dialogo_graf_fchar_JFC [JDialog] (figura 38). Estas gráficas pueden guardarse como archivos de imagen y son utilizadas en los informes.

evento: private void btnVergrar_fchartActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_fchar_JFC.setSize(700,650); dialogo_graf_fchar_JFC.setResizable(true); dialogo_graf_fchar_JFC.setVisible(true);

Dibuja_fChart_JFC(); }

figura 38. gráficas fchart con JFreechart

C1.11.3. "Guardar gráficas en archivo"

componente: btnGuardarGraficas_enArchivo [JButton] descripción: dibuja y guarda las graficas para el informe evento: private void btnGuardarGraficas_enArchivoActionPerformed(java.awt.event.ActionEvent evt) {

//dibuja y guarda las graficas para el informe Dibuja_y_Guarda_enArchivo(); }

C1.11.4. "Ver paneles en imagen"

componente: btn_Ver_dialogo_graf_paneles [JButton] descripción: abre la ventana dialogo_graf_paneles [JDialog]. evento: private void btn_Ver_dialogo_graf_panelesActionPerformed(java.awt.event.ActionEvent evt) {

dialogo_graf_paneles.setSize(1100,850); dialogo_graf_paneles.setResizable(true);

dialogo_graf_paneles.setVisible(true); }

C1.11.5. "Ver tabla variaciones"

componente: btn_verTablavariaciones [JButton] descripción: Abre la ventana BD_Variacion_anual [JDialog]. (figura 39) evento: private void btn_verTablavariacionesActionPerformed(java.awt.event.ActionEvent evt) {



47

figura 39. tabla para los informes de variaciones

C1.11.6. "ver gráficas variaciones"

componente: btnVergraf_variaciones [JButton] descripción: Abre la ventana dialogo_graf_variaciones_JFC [JDialog] en la que podemos

dibujar la variaciones de la aportación solar anual (método Censolar [1]) y la CSA (método F-chart) en función de la variable que seleccionemos. Los datos los obtiene de los que se han ido guardando en la tabla variaciones. (figura 40)

evento: private void btnVergraf_variacionesActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_variaciones_JFC.setSize(700,650); dialogo_graf_variaciones_JFC.setResizable(true);

dialogo_graf_variaciones_JFC.setVisible(true); }

figura 40. dialogo_graf_variaciones_JFC


48

C1.11.7. "ver gráfica informe general"

componente: btn_Vergrafinfo_general [JButton] descripción: Abre la ventana dialogo_graf_InformeGeneral [JDialog] en la que muestra los

valores anuales de demanda, MJ/m2, aportación solar (método Censolar) y CSA para cada provincia para los mismos datos de entrada. Guarda como archivo de imagen y realiza y guarda el informe general.

evento: private void btn_VergrafInfo_generalActionPerformed(java.awt.event.ActionEvent evt) { dialogo_graf_InformeGeneral.setSize(1200,850); dialogo_graf_InformeGeneral.setResizable(true); dialogo_graf_InformeGeneral.setVisible(true);

DibujayGuarda_InformeGeneral_JFC(); }

C1.11.8. "Ver tabla mensual"

componente: btn_verTablamensual [JButton] descripción: Abre la ventana BD_tablamensual [JDialog] y guarda los datos y resultados

mensuales que se emplearán en el informe mensual. evento: private void btn_verTablamensualActionPerformed(java.awt.event.ActionEvent evt) {

GuardarTablamensual(); VerTablamensual_enJTable(1); }

Componente 1.12. panel_rendimiento [JPanel]. “Rendimiento”

Muestra la gráfica del rendimiento de los colectores cada mes y permite ver como varía en

función del factor de eficiencia óptica (b), el coeficiente general de pérdidas (m) y la temperatura del ACS.

figura 41. panel_Rendimiento_JFC


49

C1.12.1. "Inicio"

componente: btnRen_Inicio_JFC [JButton] descripción: Dibuja la gráfica de los valores mensuales del rendimiento de los paneles y

muestra los valores de b,m y T (figura 41). evento: private void btnRen_Inicio_JFCActionPerformed(java.awt.event.ActionEvent evt) {

etiRen_b.setText(""+pueblo.bcol); etiRen_m.setText(""+pueblo.mcol); etiRen_Temp.setText(txtf_tuso_Mm[0].getText()); Grafica_JFC grafica=new Grafica_JFC(); grafica.Dibuja_Linea_JFree(pueblo.vRendimiento,panRenJFC_graficas,

etiRenJFC_graficas,"rendimiento","mes","rendimiento"); for(int i=0;i<b.length;i++){for(int j=0; j<12;j++){b[i][j]=0;}};//cero[j];}}; }

C1.12.2. "b +"

componente: btnRen_Mas_bcol [JButton] descripción: Aumenta 0.05 el valor de b y dibuja la gráfica con el nuevo valor. Nos da la

opción de guardar los datos en una tabla. Además aparece en la gráfica una leyenda con el color de la línea y los valores (b,m,T) empleados (figura 42). El botón btnRen_menos_bcol disminuye b 0.05 y realiza los mismos eventos.

evento: private void btnRen_Mas_bcolActionPerformed(java.awt.event.ActionEvent evt) { Cambia_FEObcol_fchart(0.05);

dibuja_lineasderendimiento(); } C1.12.3. "m +"

componente: btnRen_Mas_mcol [JButton] descripción: Aumenta 0.5 el valor de m y dibuja la gráfica con el nuevo valor. Nos da la

opción de guardar los datos en una tabla. Además aparece en la gráfica una leyenda con el color de la línea y los valores (b,m,T) empleados (figura 42). El botón btnRen_menos_mcol disminuye m 0.5 y realiza los mismos eventos.

evento: private void btnRen_Mas_mcolActionPerformed(java.awt.event.ActionEvent evt) { Cambia_CGPmcol_fchart(0.5);

dibuja_lineasderendimiento(); }

C1.12.4. "T +"

componente: btnRen_Mas_Temp [JButton] descripción: Aumenta 5ºC el valor de T y dibuja la gráfica con el nuevo valor. Nos da la

opción de guardar los datos en una tabla. Además aparece en la gráfica una leyenda con el color de la línea y los valores (b,m,T) empleados. El botón btnRen_menos_mcol disminuye T 5ºC y realiza los mismos eventos.

evento: private void btnRen_Mas_TempActionPerformed(java.awt.event.ActionEvent evt) { Cambia_Tuso_Mm(5);

dibuja_lineasderendimiento(); }


50

figura 42. variaciones del rendimiento de los colectores

C1.12.5. "Imprimir"

componente: btnImprime_graficaRendimiento descripción: Permite sacar por impresora la gráfica que tengamos el el panel_rendimiento_JFC evento: private void btnImprime_graficaRendimientoActionPerformed(java.awt.event.ActionEvent evt) {

Imprimegrafica_VariacionesRendimiento(); }

figura 43. opción imprimir la gráfica del rendimiento de los paneles para distintos valores de b,m y T.


51

Componente 2. subpanelesresultados_2 [JPanel] A la derecha de la pantalla irá apareciendo un resumen de los valores de los principales datos y

resultados conforme intervienen en los cálculos. Cada vez que se modifica un dato aprarece su valor y los resultados actualizados. De esta forma vemos como influye la variación del valor de una variable en los resultados finales independientemente de la pestaña [JPanel] en que estemos operando.

figura 44. subpanelresultados_2 método: public void VerResultados() { try { //subpanelresultados2_8 etiresultadosDA3.setText("" + pueblo.getDemandaAnual()); etiresultadosENanual3.setText("" + pueblo.getENDañoM2()); etiresultadosSCteorica3.setText("" + pueblo.getSCteorica()); etiresultadosNCteorico3.setText("" + pueblo.getNCteorico()); etiresultadosCAm5.setText("" + pueblo.getConsumoanualACSm3()); //subpanelresultados2_9 etiresultadosAportacionAnual2.setText("" + pueblo.getaportacionAnual()); etiresultadosDeficitAnual2.setText("" + pueblo.getdeficitEnergeticoAnual()); etiresultadosCEanual2.setText("" + pueblo.getCosteEanual()); etiresultadosCAuxanual2.setText("" + pueblo.getCosteAuxAnual()); etiresultadosAhorroanual2.setText("" + pueblo.getAhorroAnual()); etiresultadosCSA2.setText("" + pueblo.getCoberturaSA()); //subpanelresultados2_10 etiresultadosSCresultante2.setText("" + pueblo.getSCresultante()); etiresultadosVolumen2.setText("" + pueblo.VolAcuDiseño); etiresultadosbcol2.setText("" + pueblo.getbcol()); etiresultadosmcol2.setText("" + pueblo.getmcol()); etiresultadosFCCI2.setText("" + pueblo.getFCCI()); Prueba_Resultados(); } catch (Exception ex) { } }


52

Componente 2.1. subpanelresultados2_8 [JPanel] � "Demanda anual": energía necesaria para calentar el agua. � "Energía anual/m2": energía solar disponible por m2 � "Superficie teórica m2": superficie (m2) necesaria para la demanda calculada según el

método de Censolar [1]. � "Nº colectores teóricos": número de colectores según los datos del proyecto para la superficie

teórica. � "Consumo ACS m3 año": consumo anual según los datos del proyecto (ocupación, usuarios

y litros/día)

figura 45.- subpanelresultados2_8

Componente 2.2. subpanelresultados2_9 [JPanel] � "Aportación solar %": Aportación solar anual calculada por el método de Censolar [1]. � "Déficit energético": Parte de la demanda no cubierta por energía solar. � "Coste Energía anual": coste en € de la energía eléctrica, para cubrir la toda la demanda

anual, según el precio del kwh que pongamos como dato al inicio del proyecto. � "Coste Auxiliar anual": coste en € de la energía eléctrica para demanda no cubierta por

energía solar. � "Ahorro anual": diferencia entre los dos costes anteriores. � "CSA f-chart": Cobertura Solar Anual calculada por el método de F-Chart.

figura 46. subpanelesresultados2_9

Componente 2.3. subpanelresultados2_10 [JPanel] � "Superficie resultante m2": superficie calculada con el número de paneles que asignemos al

proyecto. Este valor es el que se emplea en los cáculos. � "Volumen acumulador": volumen en litros del acumulador que asignemos al proyecto. Este

valor es el que se emplea en los cálculos. � "b": factor de eficiencia óptica de los colectores. � "m": coeficiente de pérdidas de los colectores. � "FCCI": factor del intercambiador. � Condiciones de diseño. Cada botón(?) [JButton] nos muestra cada condición.


53

• "V/M": volumen del acumulador respecto al volumen recomendado (por defecto 70 l/m2 de panel.)

• "C/A": litros diarios respecto a la superficie total (m2) de paneles. • "M/A": volumen del acumulador del proyecto respecto a la superficie total (m2) de

paneles.

figura 47. subpanelesresultados2_10

Componentes 3. Other Components

figura 48. Elementos del grupo Other Components del Form cuadro

C3.1. dialogodatos_nuevoproyecto [JDialog] Se abre con el botón “Nuevo proyecto” de panel “Inicio” (figura 7). A partir de aquí podemos

seguir presionando “Aceptar” o “Calcula todo” (figura 8). “Aceptar” cierra esta ventana y abre dialogo_datosdelsitio [JDialog] (figura 9). “Calcular todo” realiza todos los cálculos de una sola vez y con los datos por defecto de la

provincia seleccionada y los valores que nos pide del número de colectores y volumen del acumulador (figura 49).

figura 49. Datos necesarios para “Calcular todo"

C3.2. dialogo_datosdelsitio [JDialog] Se abre con el botón “Aceptar” de la ventana dialogodatos_nuevoproyecto (figura 8). Después

de introducir los datos seguimos con el botón “Continuar” (figura 9) que cerrará esta ventana y abrirá el dialogo_datosmensuales [JDialog] (figura 10).


54

C3.3. dialogo_datosmensuales [JDialog] Se abre después de aceptar los datos de la ventana dialogo_datosdelsitio[JDialog]. Después de introducir los datos seguimos con el botón “Continuar” (figura 10) que cerrará esta

ventana y nos lleva al panel_calculos [JPanel] (figura 11).

C3.4. dialogo_fQa [JDialog] Se abre con el botón “Datos” del panel_fQa [JPanel] (figura 19)

C3.5. dialogo_fEa [JDialog]

Se abre con el botón “Datos” del panel_fEa [JPanel] (figura 21)

C3.6. dialogo_fEp [JDialog] Se abre con el botón “Datos” del panel_fEp [JPanel] (figura 23)

C3.7. dialogo_graf_RenAportSus_JFC [JDialog] Se abre con el botón “Ver gráficas RenAporSus” del panel_JFreeChart [JPanel] (figura 36)

C3.8. dialogo_graf_DemApor_JFC [JDialog] Se abre con el botón “Ver gráficas DA” del panel_JFreeChart [JPanel] (figura 37)

C3.9. dialogo_graf_fchart_JFC [JDialog] Se abre con el botón “Ver gráfica f-chart” del panel_JFreeChart [JPanel] (figura 38)


55

C3.10. dialogo_graf_paneles [JDialog] Se abre con el botón “Ver paneles en imagen” del panel_JFreeChart [JPanel] (figura 38)

figura 46. imagen del panel Datos y Resultados dibujado en dialogo_graf_paneles C3.10.1. "Dibuja panel"

componente: btn_dibuja_paneles [JButton] descripción: El botón “Dibuja panel” captura como imagen el panel que señalemos en el

“combo” y la pinta en el panel de arriba. Además guarda la imagen como archivo .jpg en la carpeta “Graficas” del programa. Este archivo se emplea como imagen para los informes iReport.

evento: private void btn_dibuja_panelesActionPerformed(java.awt.event.ActionEvent evt) { Imagen_panel dibujo=new Imagen_panel();

String nom=cbo_dibuja_paneles.getSelectedItem().toString(); JPanel panel=new JPanel(); String nA="";//nombre que le daremos al archivo imagen en la carpeta Graficas try{ if(nom=="paneles"){JOptionPane.showMessageDialog(null,"Selecione un panel");} else{if(nom.equals("Datos")){nA="panel_datos";panel=panel_datos;} if(nom.equals("Resultados")){nA="panel_resultados";panel=panel_resultados;} if(nom.equals("Datos y Resultados")){Ver_Datos_y_Resultados(); nA="panel_datosyresultados";panel=panel_datosyresultados;} if(nom.equals("Acumulador")){nA="panel_acumulador";panel=panel_acumulador;} if(nom.equals("Calculo FChart")){nA="panel_FCHART";panel=panel_FCHART;}

if(nom.equals("Variaciones FChart")){nA="panel_grafica_fchart";panel=panel_grafica_fchart;} if(nom.equals("Demanda Aportacion")){nA="panel_GRAF2";panel=panel_GRAF2;} dibujo.Archiva_Imagem_jpg(nA,panel); dibujo.Pinta_arcivo_enJLabel(nA, eti_graf_paneles);}

}catch(Exception e){JOptionPane.showMessageDialog(null,"algo no va bien, puede que: "+e); } }


56

figura 47. archivos de imagen guardados en la carpeta “Graficas” del programa.

C3.11. dialogo_graf_variaciones_JFC [JDialog]

Se abre con el botón “ver gráficas variaciones” del panel_JFreeChart [JPanel] (figura 39)

C3.12. dialogo_graf_InformeGeneral [JDialog]

Se abre con el botón “ver gráfica informe general “ del panel_JFreeChart [JPanel] (figuras 39) Muestra la imagen que aparecerá en el “informe general”.

C3.13. BD_Resultados [JDialog]

Se abre con los botones “Guardar” y “Ver resultados” y con el botón “Resultados” del panel “INICIO”.

figura 48. BD_Resultados [JDialog]


57

C13.1. tablaResultadosACS [JTable]

Muestra los datos y resultados que se guardan en la tabla de la base de datos del programa. Estos valores se pueden consultar en los informes que genera el programa.

C3.13.2. "Eliminar"

componente: btnEliminar_RegistroBD [JButton] descripción: Elimina los datos de la fila seleccionada de la tabla. Una vez eliminado no se

puede recuperar. evento: private void btnEliminar_RegistroBDActionPerformed(java.awt.event.ActionEvent evt) {

EliminaFila(); }

C3.13.3. "Eliminar todo"

componente: btn_Elimina_todo_tablaResultados [JButton] descripción: Elimina todos los registros de la tabla. Una vez eliminados no se recuperan. evento: private void btn_Elimina_todo_tablaResultadosActionPerformed(java.awt.event.ActionEvent

evt) { EliminaFilaResultados_todas(); }

C3.13.4. "Elimina filas entre"

componente: btneliminaVariasFilas1 [JButton] descripción: Elimina las filas con varlor id comprendido entre los valores que pongamos en los

campos de texto “fila nº ”. evento: private void btneliminaVariasFilas1ActionPerformed(java.awt.event.ActionEvent evt) {

EliminaFilaResultados_selecionadas(); }

C3.13.5. panel_Informes_BD_Resultados [JPanel]

figura 49. panel_Informes_BD_Resultados Cada botón de este panel abre una ventana donde podemos ver el tipo de informe generado con

los datos de tabla Resultados almacenados en la base de datos del programa y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora. A continuación veremos los eventos que se ejecutan con cada botón.


58

C3.13.5.1. "Informe"

componente: btnInforme_BDResultados [JButton] descripción: Abre una ventana donde podemos ver el informe generado con todos los

resultados,ordenados por provincia, que se han ido guardando en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.

evento: private void btnInforme_BDResultadosActionPerformed(java.awt.event.ActionEvent evt) { try{ String rutainforme="Informesireport\\Informeagosto13.jasper"; //fichero jasper generado con ireport dentro del proyecto netbean JasperPrint informe=JasperFillManager.fillReport(rutainforme,null,conexion); JasperViewer ventanavisor=new JasperViewer(informe,false); ventanavisor.setTitle("INFORME DE PRUEBA"); ventanavisor.setVisible(true);} catch(Exception e){JOptionPane.showMessageDialog(null,"Error al mostrar informe"+e);

} } C3.13.5.2. "Informe general"

componente: btnInformeGeneral [JButton] descripción: Abre una ventana donde podemos ver el "informe general" con los resultados para

todas las provincias, almacenados en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.

evento: private void btnInformeGeneralActionPerformed(java.awt.event.ActionEvent evt) { //informe para 10paneles 1500 litros y 45º de inclinacion y 45ºC dialogo_graf_InformeGeneral.setSize(1200,850); dialogo_graf_InformeGeneral.setResizable(true); dialogo_graf_InformeGeneral.setVisible(true); DibujayGuarda_InformeGeneral_JFC(); dialogo_graf_InformeGeneral.dispose(); try{ String rutainforme="Informesireport\\Informegeneral.jasper";//fichero jasper generado

con ireport dentro del proyecto netbean JasperPrint informe=JasperFillManager.fillReport(rutainforme,null,conexion); JasperViewer ventanavisor=new JasperViewer(informe,false); ventanavisor.setTitle("INFORME GENERAL");

ventanavisor.setVisible(true);} catch(Exception e){JOptionPane.showMessageDialog(null,"Error al mostrar informe"+e); } //para las gráficas try{ String rutainforme1="Informesireport\\info_graf_general_demanda.jasper"; String rutainforme2="Informesireport\\info_graf_general_MJm2anual.jasper"; String rutainforme3="Informesireport\\info_graf_general_aportacion.jasper"; String rutainforme4="Informesireport\\info_graf_general_CSA.jasper"; //fichero jasper generado con ireport dentro del proyecto netbean JasperPrint informe1=JasperFillManager.fillReport(rutainforme1,null,conexion); JasperPrint informe2=JasperFillManager.fillReport(rutainforme2,null,conexion); JasperPrint informe3=JasperFillManager.fillReport(rutainforme3,null,conexion);


59

JasperPrint informe4=JasperFillManager.fillReport(rutainforme4,null,conexion); JasperViewer ventanavisor1=new JasperViewer(informe1,false); JasperViewer ventanavisor2=new JasperViewer(informe2,false); JasperViewer ventanavisor3=new JasperViewer(informe3,false); JasperViewer ventanavisor4=new JasperViewer(informe4,false); ventanavisor1.setTitle("INFORME GENERAL gráfica demanda"); ventanavisor1.setVisible(true); ventanavisor2.setTitle("INFORME GENERAL gráfica MJm2anual"); ventanavisor2.setVisible(true); ventanavisor3.setTitle("INFORME GENERAL gráfica aportación"); ventanavisor3.setVisible(true); ventanavisor4.setTitle("INFORME GENERAL gráfica CSA"); ventanavisor4.setVisible(true);} catch(Exception e){JOptionPane.showMessageDialog(null,"Error al mostrar informe"+e); }

}

C3.13.5.3. "Informe gráfico"

componente: btnInformegrafico [JButton] descripción: Genera un archivo que muestran las graficas de rendimiento,

aportación,sustitución, Demanda-Aportación y fchart. El contenido del informe se muestra en una ventana desde la cual podemos imprimirlo.

evento: private void btnInformegraficoActionPerformed(java.awt.event.ActionEvent evt) { try{//Guarda en la tabla los datos del proyecto //En la JTable GuardarResultadosACS(1); //dibuja las graficas y las archiva Dibuja_y_Guarda_enArchivo(); //se coloca en el ultimo registro y captura el número de proyecto String consulta="select * from resultadosACS order by Numero"; ResultSet r=sentencia.executeQuery(consulta); r.last();

int np=Integer.parseInt(r.getString("Numero"));//es un dato numérico String rutainforme="Informesireport\\Informe grafico.jasper";//numeproye es el nombre que le

dimos al parametro en ireport Map parametros=new HashMap(); parametros.put("numeproye",np); JasperPrint informe=JasperFillManager.fillReport(rutainforme,parametros,conexion); JasperViewer ventanavisor=new JasperViewer(informe,false); ventanavisor.setTitle("INFORME GRAFICO Instalación solar térmica para ACS en

"+r.getString("provincia")); ventanavisor.setVisible(true);

}catch(Exception e){JOptionPane.showMessageDialog(null,"Error en el informe"+" "+ e);}}


60

C3.13.5.4. "Informe por provincias"

componente: btnInformeProvincia [JButton] descripción: Abre una ventana donde podemos ver el informe generado con los datos de tabla

mensual, almacenados en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.

evento: private void btnInformeProvincia_BDResultadosActionPerformed(java.awt.event.ActionEvent evt) {

try{ String rutainforme="Informesireport\\InformeACS_con_parametros.jasper"; //Localizacion es el nombre que le dimos al parametro en ireport Map parametros=new HashMap(); String prov=cboInformeProvincia_BDResultados.getSelectedItem().toString(); if(prov=="provincia"){JOptionPane.showMessageDialog(null,"Seleccione una provincia"); }else{ parametros.put("Localizacion",prov); JasperPrint informe=JasperFillManager.fillReport(rutainforme,parametros,conexion); JasperViewer ventanavisor=new JasperViewer(informe,false); ventanavisor.setTitle("INFORME DE PROVINCIA"); ventanavisor.setVisible(true);} }catch(Exception e){JOptionPane.showMessageDialog(null,"Error en el informe"+" "+ e); }

} C3.13.5.5. "Informe por paneles"

componente: btnInformeppaneles [JButton] descripción: Abre una ventana donde podemos ver el informe generado con los JPanel

seleccionados . En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.

evento: private void btnInformeppanelesActionPerformed(java.awt.event.ActionEvent evt) { Informa_por_paneles("Informesireport\\Informepp_entradaycalculos.jasper"); Informa_por_paneles("Informesireport\\Informepp_datosyresultados.jasper"); Informa_por_paneles("Informesireport\\Informepp_CalculoFchart.jasper");

}

C3.13.6. "Cerrar"

componente: btnCerrar_Resultados [JButton] descripción: Cierra esta ventana. evento: private void btnCerrar_ResultadosActionPerformed(java.awt.event.ActionEvent evt) {

BD_Resultados.dispose(); }


61

C3.14. BD_Variacion_anual [JDialog]

Se abre con los botones “Guardar” y “Ver resultados” y con el botón “Resultados” del panel “INICIO” después de cerrar la ventana BD_Resultados.

figura 50. BD_Variaciones_anual

C3.14.1. tablaVariacion_anual [JTable]

Muestra los datos y resultados que se guardan en la tabla de la base de datos del programa. Estos valores se pueden consultar en los informes que genera el programa.

C3.14.2. "Eliminar fila"

componente: btnEliminarRegistro_variaciones [JButton] descripción: Elimina los datos de la fila seleccionada de la tabla. Una vez eliminado no se

puede recuperar. evento: private void btn_EliminaRegistro_variacionesActionPerformed(java.awt.event.ActionEvent evt)

{ EliminaFilaVariaciones(); }

C3.14.3. "Eliminar todo"

componente: btn_Eliminatodo_tablaVariacion [JButton] descripción: Elimina todos los registros de la tabla. Una vez eliminados no se recuperan. evento: private void btn_Eliminatodo_tablaVariacionActionPerformed(java.awt.event.ActionEvent evt) {

EliminaFilaVariaciones_todas(); }


62

C3.14.4. "Elimina filas entre"

componente: btneliminaVariasFilas [JButton] descripción: Elimina las filas con varlor id comprendido entre los valores que pongamos en los

campos de texto “fila nº ”. evento: private void btneliminaVariasFilasActionPerformed(java.awt.event.ActionEvent evt) {

EliminaFilaVariaciones_selecionadas(); }

C3.14.5. "Informes"

componente: btnInforme_variaciones descripción: Abre una ventana donde podemos ver el informe generado con los datos de tabla

Variaciones, almacenados en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora. En el comboInfo_Variaciones [JComboBox] se marca la variable que define el informe.

evento: private void btnInforme_variacionesActionPerformed(java.awt.event.ActionEvent evt) { int info=comboInfo_Variacion.getSelectedIndex(); if(info==0){JOptionPane.showMessageDialog(null,"Seleccione una variable");} else{ dialogo_graf_variaciones_JFC.setSize(950,650); dialogo_graf_variaciones_JFC.setResizable(true); dialogo_graf_variaciones_JFC.setVisible(true); if(info==1){DibujayGuarda_Grafica_Variaciones("consumo"); Info_Variable("consumo","INFORME VARIACIONES CON EL CONSUMO DE ACS");} if(info==2){DibujayGuarda_Grafica_Variaciones("tempACS"); Info_Variable("tempACS","INFORME VARIACIONES CON LA TEMPERATURA DEL

ACS");} if(info==3){DibujayGuarda_Grafica_Variaciones("inclinacion"); Info_Variable("inclinacion","INFORME VARIACIONES CON LA INCLINACIÓN DE

LOS PANELES");} if(info==4){DibujayGuarda_Grafica_Variaciones("acumulacion"); Info_Variable("acumulacion","INFORME VARIACIONES CON EL VOLUMEN DEL

ACUMULADOR");} if(info==5){DibujayGuarda_Grafica_Variaciones("superficie"); Info_Variable("superficie","INFORME VARIACIONES CON LA SUPERFICIE DE

CAPTADORES");} if(info==6){DibujayGuarda_Grafica_Variaciones("b"); Info_Variable("b","INFORME VARIACIONES CON EL FACTOR DE EFICIENCIA

ÓPTICA (b)");} if(info==7){DibujayGuarda_Grafica_Variaciones("m"); Info_Variable("m","INFORME VARIACIONES CON EL m DE LOS COLECTORES");} if(info==8){DibujayGuarda_Grafica_Variaciones("FCCI"); Info_Variable("FCCI","INFORME VARIACIONES CON EL FCCI factor

intercambiador");} if(info==9){DibujayGuarda_Grafica_Variaciones("MAI"); Info_Variable("MAI","INFORME MAI ángulo de incidencia");}

dialogo_graf_variaciones_JFC.dispose();} }


63

C3.14.6. "Resultados mensuales"

componente: btnVertablamensual_BDVA descripción: Guarda los datos y resultados mensuales en la tablamensual y abre la ventana

BD_tablamensual [JDialog] (figura 51) evento: private void btnVertablamensual_BDVAActionPerformed(java.awt.event.ActionEvent evt) {

GuardarTablamensual(); VerTablamensual_enJTable(1);}

C3.14.7. "Cerrar"

componente: btnCerrar_Variaciones descripción: Cierra esta ventana evento: private void btnCerrar_VariacionesActionPerformed(java.awt.event.ActionEvent evt) {

BD_Variacion_anual.dispose(); }

C3.15. BD_tablamensual [JDialog]

Se abre con el botón “Resultados mensuales” de la ventana BD_Variacion_anual [JDialog] y con el botón “Ver tabla mensual” del panel “Graficas JFree”.

figura 51. BD_tablamensual

C3.15.1. tablamensual [JTable] Muestra los datos y resultados mensuales que se guardan en la tabla de la base de datos del

programa. Estos valores se pueden consultar en los informes que genera el programa.

C3.15.2. "Eliminar grupo"

componente: btnEliminagrupoTablamensual [JButton] descripción: Elimina los datos de las filas con igual número “Id” al de la provincia seleccionada

seleccionada de la tabla. Una vez eliminado no se puede recuperar. evento: private void btnEliminagrupoTablamensualActionPerformed(java.awt.event.ActionEvent evt) {

EliminaFilasTablamensual(); }


64

C3.15.3. "Informe mensual"

componente: btnInformemensual [JButton] descripción: Abre una ventana donde podemos ver el informe generado con los datos de tabla

mensual, almacenados en la base de datos del programa, y el archivo .jasper correspondiente (de la carpeta informesireport del programa). En esta ventana podemos guardar el informe como archivo y sacarlo por impresora.

evento: private void btnInformemensualActionPerformed(java.awt.event.ActionEvent evt) { Informe_mensual(); }

C3.15.4. "Cerrar"

componente: btnCerrarTablamensual [JButton] descripción: Cierra esta ventana. evento: private void btnCerrarTablamensualActionPerformed(java.awt.event.ActionEvent evt) {

BD_tablamensual.dispose(); } Cerrar el programa

Al cerrar el programa se cierra tambien la conexión con la base de datos. Los datos y resultados guardados durante la sesión quedarán almacenados en las tablas de la base de datos y podrán consultarse y emplearse en los informes en otras sesiones posteriores.

figura 52. Salir y cerrar la conexión con la base de datos.

cerrar

APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo

65

2.1.2. Diagramas de flujo

Aceptar Calcula todo

Diálogo datos generales

Volver

Datos del sitio

Cancelar Continuar

Diálogo datos mensuales

Volver

Datos mensuales

Cancelar Continuar

CÁLCULOS

Nuevo proyecto

Diálogo nuevo proyecto

Cancelar provincia

INICIO

Inclinación : Desviación N-S (β): Corrección de H: Pérdidas globales: Nº de usuarios: Litros/día·usuario: Área de colector: Parámetros b y m : Corrección de b: Temperatura de uso: Precio del kw·h : €

Ocupación %mes Temperatura de red Radiacción H Factor k (inclinación) Horas sol Temperatura ambiente

Nº colectores

Volumen acumulador

por defecto

por defecto


66

CÁLCULOS

Seleccionar meses

Seleccionar todos

Calcular Cancelar

mes

Consultar

Modificar datos

Datos del sitio

RESULTADOS

Calcular

Nº de colectores a instalar

Resultados

Calcular superficie resultante

DATOS& RESULTADOS

ACUMULADOR GRÁFICAS Gráficas

demanda-aportación

Consultar Modificar datos

Calcular

Volumen proyectado

Comprobar volumen

+ -

Acumulación por m2

F-Chart

Rendimiento

Inicio

b, m

+ -

inclinación

+ -

Temperatura

+ -

Imprimir

Resultados mensuales: Consumo ACS m3 Salto térmico Demanda termias Demanda MJ H corregida Energía neta incidente Intensidad incidente Energía neta disponible MJ/m2 Rendimiento colector Aportación solar por m2

Demanda MJ/mes Energía neta disponible MJ/m2

Demanda anual: MJ Energía/año·m2 : MJ Superficie colectora teórica: m2 Número de colectores teórico:

Superficie colectora resultante (A)

Resultados mensuales: Demanda MJ Energía neta disponible MJ/m2 Sustitución % Déficit de energía Coste eléctrico de la demanda Coste eléctrico del déficit Ahorro

Resultados anuales: Demanda anual: MJ Energía/año·m2 : MJ Aportación solar: % Déficit energético: MJ Ahorro anual : € Coste energía auxiliar: €

Datos y Resultados mes: Ocupación %mes Temperatura de red H corregida Factor k (inclinación) Energía neta incidente

Rendimiento mes Aportación solar relativa Sustitución mes

Demanda MJ/mes Energía neta total MJ/mes

0.8 < V/M <1.2

V

M

...Calcula todo

Horas sol Intensidad incidente Temperatura ambiente Rendimiento colector Consumo ACS m3


67

Diálogo BD_variacion_anual

Informe por provincias

Informe gráfico

Informe por paneles

Informe general

Temperatura ACS Consumo m3/año Demanda MJ/año

Temperatura ACS Consumo m3/año b,m, inclinación superficie total acumulador

DATOS: Provincia (todas) Demanda MJ MJ/m2 año Aportación CSA

Imagen JPanel

Provincia Temperatura ACS Consumo m3/año Demanda MJ superficie total b,m, inclinación acumulador MJ/m2 año Aportación CSA Gráficas de : Rendimiento Ap.solar realtiva Sustitución Demanda-Aport CSA f-chart

Gráficas demanda-aportación

variaciones Base de datos de resultados

Nº de colectores

+ -

Inicio

Selaccionar mes Cancelar todos

Ocupación

+ -

Litros/día·ud

+ -

Temperatura

+ -

Inclinación

+ -

Ver resultados

Resultados anteriores

Guardar

Guardar resultado actual

Diálogo BD_Resultados

¿guardar? no sí Tabla variacionesFchartAnual* Tabla resultadosACS

eliminar

Eliminar Eliminar todo Informes

Cerrar

Eliminar filas entre

Localización Provincia Temp ACS Consumo ACS Demanda MJ Superf m2 Paneles b m FCCI* MAI* inclinación acumulación MJ/m2 año Aportación año CSA V/M M/A C/A

60< C/A <100

provincia panel


68

Diálogo BD_variacion_anual

eliminar

Eliminar

Eliminar todo

Informes

Cerrar

Eliminar filas entre variable

Informes

Resultados mensuales

tabla_mensual

Diálogo BD_tablamensual

eliminar

Eliminar grupo Cerrar Informe mensual

provincia mes ocupación Consumo ACS Temp red Temp ambiente Temp ACS inclinación horas sol rendimiento Demanda MJ Aportación MJ Sustitución Qa Ea Ep f

Consumo ACS Temp ACS Acumulador superficie inclinación b m FCCI MAI

provincia Demanda MJ MJ/m2 año Aportación CSA V/M M/A C/A

provincia mes ocupación Consumo ACS Temp red Temp ambiente Temp ACS inclinación horas sol rendimiento Demanda MJ Aportación MJ Sustitución Qa Ea Ep f-chart

Consumo ACS Acumulador superficie b m FCCI MAI Demanda MJ MJ/m2 año Aportación CSA V/M M/A C/A


69

F-Chart

Cargas caloríficas

Energía absorbida

Energía perdida

Datos Datos Datos

Diálogo fQa

aceptar

Diálogo fEa

aceptar

Diálogo fEp

aceptar

Calcula Qa Calcula Ea Calcula Ep

Calcular f

¿guardar? no sí Tabla variacionesFchartAnual

Tabla resultadosACS

Calor específico Nº usuarios: Litros/día·ud Temp ACS Temp red

bFCCI MAI

Temp ACSNº colectores

m kg acumulad(M) Temp mínima del ACS

Consumo de ACS litros/día Carga calorífica mensual (Qa)

Superficie resultante (A) Radiación incidente/m2 Energía solar absorbida

Factor F’rUL Factor k1 Factor k2 Dt (segundos) Energía perdida mensual

D1 D2

f Qu

CSA

f = 1.029*D1-0.065*D2-0.245*D12 + 0.0018* D22+0.0215* D13

Qa = Ce*C*N*(tac-tred) Ea = Sc*F’r*(τα)*Ri*N Ep = Sc*F’r*UL*(100-ta)*Dt*k1*k2 D1= Ea/Qa D2 = Ep/Qa Qu = f*Qa

por defecto

...Calcula todo


70

Gráficas f-chart

variaciones Base de datos de resultados

Nº de colectores

+ -

Inicio

Selaccionar mes Cancelar todos

Ocupación

+ -

Litros/día·ud

+ -

Temperatura

+ -

Inclinación

+ -

Ver resultados

Resultados anteriores

Diálogo BD_Resultados

Guardar

Guardar resultado actual

¿guardar? no sí

Tabla variacionesFchartAnual*

Tabla resultadosACS

kg de acumulación

+ -

b

+ - + - + -

m

FCCI

Comprobar

37.5< M/A<300

FCCI* MAI* inclinación acumulación (M) MJ/m2 año Aportación año CSA V/M M/A C/A

Localización Provincia Temp ACS Consumo ACS Demanda MJ Superf m2 (A) Paneles b m


71

Gráficas JFree

Guardar gráficas en archivo Ver gráficas RenAporSus Ver paneles en imagen

Ver tabla variaciones Ver gráficas DA Ver gráficas variaciones

Ver tabla mensual Ver gráfica f-chart Ver gráficas informe general

Diálogo BD_VariacionAnual

Diálogo BD_tablamensual

Carpeta “gráficas”

dialogo_graf_

RenAporSus_JFC DemApor_JFC fchart_JFC paneles_JFC variaciones_JFC InformeGeneral_JFC

paneles variable

Dibuja panel Dibuja gráfica

Consumo m3/año Consumo litros/dia Temperatura ACS Superficie m2 Inclinación Acumulador litros b m FCCI MAI

Datos Resultados Datos y resultados Acumulador Cálculo f-chart Variaciones f-chart Demanda-Aportación


72

APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos

73

2.1.3. Acceso a Base de Datos desde nuestra aplicación Java. Para que nuestro programa Java pueda usar la base de datos ha sido necesario realizar los

siguientes pasos:

paso1. Colocar el fichero de base de datos en una subcarpeta de la carpeta del proyecto java. Para nuestra aplicación hemos creado el fichero “baseResultadosACS.mdb” dode se

almacenará toda la información que necesitemos gestionar para crear los “informes”. Es decir, hemos creado un fichero de base de datos. Este fichero se incluirá dentro del programa java en la carpeta “Base”. Nuestro programa java accederá a este fichero continuamente para añadir nuevos datos, eliminar datos, o extraer datos según lo ordene el usuario del programa.

paso2. Crear los objetos conexión (Connection) y sentencia (Statement) Primero definimos estos objetos como globales en la clase “Cuadro”, para así poderlos usar

desde cualquier lado. Además será necesario indicar el import para las clases Connection y Statement. Estos import son respectivamente: java.sql.Connection y java.sql.Statement

paso3. Método: controlador, conexión y sentencia. Una vez definidos los objetos conexión y sentencia, para que nuestro programa pueda acceder

a la base de datos “baseResultadosACS” creamos el método “PrepararBaseDatos” al que llamaremos desde el constructor.

paso3.1. Cargar el controlador del tipo de base de datos a usar El controlador define el tipo de base de datos que se va a usar (base de datos de Access, o de

MySQL, o de cualquier otro gestor de base de datos) En nuestro caso, tendremos que indicar el controlador para base de datos de Access.

String controlador = "sun.jdbc.odbc.JdbcOdbcDriver";

paso3.2. Crear el objeto conexión indicando el fichero de la base de datos.

Para crear la conexión es necesario añadir (import) la clase DriverManager. El objeto “conexion” es el que efectúa la conexión real con la base de datos. Para construir este

objeto hacen falta tres datos: � El nombre del usuario que manipulará la base de datos. En el caso de Access no necesitamos

indicar ningún nombre de usuario.


74

� El password del usuario que manipulará la base de datos. En el caso de Access tampoco necesitaremos ningún password.

� La DSN de la base de datos. DSN significa “nombre del origen de datos” y es una cadena de

texto que contiene información sobre el fichero de base de datos que queremos usar. En el código, la creación de la DSN será:

String DSN = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ="+ "Base\\resultadosACS.mdb ";

Con estos datos creamos el objeto "conexion" con la instrucción :

conexion=DriverManager.getConnection(DSN,user,password);

paso3.3. Crear el objeto sentencia a partir del objeto conexión

El objeto “sentencia” será el que nos permita ejecutar órdenes SQL sobre la base de datos. Es

decir, el objeto que nos permite actuar y manipular la base de datos. El objeto sentencia se crea a partir del objeto conexión creado en el paso anterior, usando la

siguiente instrucción:

sentencia=conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

Se usará el objeto “sentencia” para ejecutar consultas SQL en la base de datos. Dichas

consultas se almacenan en objetos del tipo “ResultSet” los cuales permiten seleccionar el registro de una tabla de la base de datos y extraer el datos de un campo en concreto.

paso4. Finalmente debemos programar el evento “windowClosing” de la ventana principal de forma que se cierre la conexión al salir del programa.

Esta preparación se debe realizar en el momento en que se ejecuta el programa, por lo cual

hemos introducido este código en el constructor. A continuación mostramos la parte del código, de nuestra aplicación java, donde aparecen los elementos descritos para acceder a la base de datos que se utiliza en dicha aplicación.

* * @author Eduardo */ ... import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.Statement; ... public class Cuadro extends javax.swing.JFrame { ...


75

//varibles globales para acceso a Base de datos access Connection conexion; Statement sentencia; DefaultTableModel mt,mtv,mtmes; ... public Cuadro() { initComponents(); PrepararBaseDatos();// llamada al método PrepararTablaResultados(); PrepararTablaVariacion_anual(); PrepararTabla_mensual(); ...}}... //Método para acceso a base de datos //1.-creamos carpeta Base con el archivo Access baseResultadosACS.mdb //2.-Variables globales para la conexión y sentencia //3.-Cargar controlador, crear objetos conexión y sentencia "PrepararBaseDatos()","Cerrar_la_conexion()" //4.-JTable "tablaResultadosACS" donde visualizar los datos,"PrepararTablaResultados()" //5.-Método para guardar los resultados "GuardarResultadosACS()" public void PrepararBaseDatos(){ try {//1.-Cargar el controlador de Access=sun.jdbc.odbcOdbcDriver, segun el tipo de basedeDatos //en MySQL se usa la cadena: com.mysql.jdbc.Driver String controlador = "sun.jdbc.odbc.JdbcOdbcDriver"; Class.forName(controlador).newInstance();//para activar el controlador } catch (Exception e) { JOptionPane.showMessageDialog(null, "Error en la carga del controlador --"+e); } //2.-Creamos el objeto conexion conection try { //String DNS="jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ="+"carpeta en este

proyecto\\nombreArchivo.MDB"; String DNS = "jdbc:odbc:Driver={Microsoft Access Driver(*.mdb)}; DBQ="+"Base\\baseResultadosACS.mdb"; String user = ""; String password = ""; conexion = DriverManager.getConnection(DNS,user,password); } catch (Exception e) { JOptionPane.showMessageDialog(null, "Error en la conexión "+e); } //3.-Creamos el objeto sentencia try{ sentencia=(Statement) conexion.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY );} catch(Exception e){JOptionPane.showMessageDialog(null,"Error en la sentencia "+e); Cerrar_la_conexion();} } void Cerrar_la_conexion(){//cuando cerremos la ventana try{conexion.close();} catch(Exception e){JOptionPane.showMessageDialog(null,"No se pudo cerrar la conexión "+e);} }


76

2.1.3.2. Métodos para guardar datos y resultados en nuestra base de datos

public void GuardarResultadosACS(int loveo){... } public void GuardarVariacionAnual(int loveo){...} public void Almacena_simulacion_sinverlo(){...} public void guardar_variacionesycomprobaciones(){...} public void GuardarTablamensual(){...} public void PonerFila_enBlanco(){...} public void PonerFilaVariaciones_enBlanco(){...}

2.1.3.3. Métodos para borrar datos de una tabla de nuestra base de datos public void EliminaFila(){...} public void EliminaFilaVariaciones(){...} public void EliminaFilasTablamensual(){...} public void EliminaFilaVariaciones_todas(){...} public void EliminaFilaResultados_todas(){...} public void EliminaFilaVariaciones_selecionadas(){...} public void EliminaFilaResultados_selecionadas(){...} public void Eliminar_fila_enBlanco(String tabla){...}

2.1.3.4. Representación de tablas de la base de datos en un JTable El objeto JTable nos permite introducir tablas en nuestras aplicaciones.En estos objetos

podemos mostrar el contenido de una tabla de la base de datos o del resultado de una consulta. Para extraer datos de la base de datos realizamos una consulta SQL de tipo SELECT cuyo

resultado se almacena en un objeto ResultSet. Un ResultSet básicamente es una tabla almacenada en memoria (y por tanto no visible). Podemos trasladar el contenido de un ResultSet a un JTable para que el usuario lo pueda visualizar dentro de nuestra aplicación java.

Agregamos, como variables globales al proyecto, los objetos “modelo de tabla”

(DefaultTableModel), para cada una de las tres tablas que utilizamos, llamados mt, mtv y mtmes. También añadiremos en el constructor una llamada los métodos PrepararTablaResultados(),PrepararTablaVariacion_anual(),PrepararTabla_mensual() y programamos dichos métodos.

public void PrepararTablaResultados(){... } public void PrepararTablaVariacion_anual(){... } public void PrepararTabla_mensual(){... }

El proceso básicamente el siguiente: Base de Datos � ResultSet � Vector � Modelo de Tabla � JTable � De la base de datos extraemos datos a un ResultSet. (Esto se hace ejecutando una consulta

SQL de tipo SELECT a través del objeto sentencia)

� Del ResultSet extraemos los datos a un modelo de tabla. (Esto se hace recorriendo el ResultSet y almacenando cada registro en un vector)


77

� Almacenamiento del vector en el modelo de tabla. (Cada vector extraido del ResultSet se inserta como fila en el modelo de tabla)

� Se asigna el modelo de tabla al objeto JTable. (Al hacer esto el objeto JTable muestra el contenido del modelo)

Los métodos creados son:

public void VerResultados_enJTable(int loveo){... } public void VervariacionesFchartAnual_enJTable(int loveo){...} public void VerTablamensual_enJTable(int loveo){...}


78

APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes

79

2.1.4. Informes

Una vez creado el programa, surgió la necesidad de imprimir documentos tales como listados

de datos y resultados, gráficos, etc. Estos documentos se rellenan con datos tomados directamente desde la base de datos de nuestro programa. A estos documentos los llamaremos “ informes” . Para crear estos documentos necesitamos usar un programa de creación de informes. En nuestro caso, hemos usado un programa gratuito llamado Ireport que hemos descargado de la página http://www.jasperforge.org/sf/projects/ireport. Este programa permite definir la estructura general del informe (sin tener en cuenta los datos).

Es necesario indicar la conexión a la base de datos y la consulta SQL para extraer los datos que

aparecerán en el informe. Una vez creado el informe, este se enlaza con nuestra aplicación, de forma que cuando el

usuario pulse la opción de imprimir, el informe se rellene con los datos de la base de datos y luego sea enviado a la impresora.

2.1.4.1. Conexión con Informes desde Java Cuando creamos un informe con iReport, se genera un fichero del tipo .jasper. Los ficheros

.jasper son informes compilados, de forma que puedan ser usados en aplicaciones java. Para que nuestro programa sea capaz de presentar informes, hemos creado una carpeta llamada

“informesireport” dentro de la carpeta de nuestro programa. Y dentro de dicha carpeta hemos copiado los ficheros .jasper de los informes que queremos utilizar.

En nuestra aplicación, el informe aparece en una ventana (el visor de informes, objeto

JasperViewer) que tiene una pequeña barra de herramientas. En esta barra podrá imprimir el informe o cambiar su zoom, entre otras opciones.

Los ficheros que contienen las librerías necesarias para el programa iReport son los siguientes:

commons-collections-2.1, commons-logging-1.0.2 y jasperreports-2.0.1. Gracias a la inclusión de estos ficheros, nuestro proyecto ya dispone de las librerías de clases que contienen a las clases que necesitamos ( JasperPrint, JasperFillManager, JasperViewer). Una vez agregadas estas librerías, el proceso para imprimir un informe es el siguiente:

� Crear un objeto del tipo JasperPrint (el informe) � Crear un objeto visor (JasperViewer) que permita visualizar el informe o bien imprimir

directamente el informe con un objeto JasperPrintManager. Cuando un informe tiene una instrucción SQL fija, siempre mostrará los mismos datos. En

otros casos parte de la instrucción SQL del informe puede variar, de forma que extrae distinta información según el dato que varía. Estos datos variantes se denominan parámetros. El parámetro debe ser sustituido por un valor que es proporcionado desde la aplicación java, y es entonces cuando la instrucción SQL se completa y se ejecuta. En la aplicación java es necesario


80

crear un objeto de tipo Map que contenga los distintos parámetros con los valores de cada uno para luego enviar este objeto al informe que se quiere mostrar.

2.1.4.2. Informes en nuestro programa.

Informe 1. Informe por paneles Informe 2. Informe mensual Informe 3. Informe gráfico Informe 4. Informe por variables Informe 5. Informe general

Para los informes se emplean los datos alamacenados en las tablas del archivo

“baseResultadosACS.mdb” de la carpeta “Base” del programa y los archivos .jasper de la carpeta “informesireport” del programa. Dichas tablas son:

� resultadosACS � variacionesFchartAnual � tabla_mensual

A continuación describiremos brevemente los principales informes que se pueden generar con el programa.


81

Informe 1. “Informe por paneles“

Permite imprimir y guardar como archivo pdf todos los paneles [Jpanel] principales del programa con los datos y resultados del proyecto en curso.

Botón btnInformeppaneles [JButton] (figuras 48 y 49) Origen de datos Tabla resultadosACS Archivo .jasper Informepp_entradaycalculos.jasper

Informepp_datosyresultados.jasper Informepp_CalculoFchart.jasper

evento public void Informa_poe_paneles(String rutainforme){...} private void btnInformeppanelesActionPerformed(java.awt.event.ActionEvent evt) { Informa_por_paneles("Informesireport\\Informepp_entradaycalculos.jasper"); Informa_por_paneles("Informesireport\\Informepp_datosyresultados.jasper");

Informa_por_paneles("Informesireport\\Informepp_CalculoFchart.jasper"); }

figura 53.- Informe por paneles


82

Informe 2. “Informe mensual“

Permite imprimir y guardar como archivo pdf los datos y resultados mensuales del proyecto en curso.

Botón btnInformemensual [JButton] (figura51) Origen de datos Tabla variacionesFchartAnual

Tabla tabla_mensual Archivo .jasper Subinforme_mensual2.jasper

Informe_mensual2.jasper evento public void Informe_mensual(){...}

private void btnInformemensualActionPerformed(java.awt.event.ActionEvent evt) {

Informe_mensual(); }

figura 54.- Informe mensual


83

Informe 3. “Informe gráfico“ Permite imprimir y guardar como archivo pdf las graficas de rendimiento, sustitución,

aportación solar relativa, demanda-aportación y F-Chart, del proyecto en curso, en una página.

Botón btnInformegrafico [JButton] (figuras 48 y 49) Origen de datos Tabla resultadosACS Archivo .jasper Informe grafico.jasper evento private void btnInformegraficoActionPerformed(java.awt.event.ActionEvent evt) {...}

figura 55.- Informe gráfico


84

Informe 4. “Informes“ (variable) Permite imprimir y guardar como archivo pdf los datos y resultados anuales del proyecto en

curso para distintos valores de una de las siguientes variables: Ocupación (consumo), Temperatura ACS, Inclinación, Acumulación, Superficie, b, m, FCCI,

MAI. Para cada variable se genera un informe en el que, manteniendo fijas las demás, se muestra en forma de gráficas como varían los resultados anuales de Aportación y CSA. Además se muestra en forma de de tabla los resultados de demanda, MJm2 y condiciones de diseño para cada valor de la variable en estudiada.

Botón BtnInforme_variaciones [JButton] (figura50) Origen de datos Tabla variacionesFchartAnual Archivo .jasper Info_Variable_”variable”.jasper, hay un archivo .jasper para cada variable evento public void Info_Variable(String var,String titulo){...}

public void DibujayGuarda_Grafica_Variaciones(String varX){...} private void btnInforme_variacionesActionPerformed(java.awt.event.ActionEvent evt) { int info=comboInfo_Variacion.getSelectedIndex(); if(info==0){JOptionPane.showMessageDialog(null,"Seleccione una variable");} else{ dialogo_graf_variaciones_JFC.setSize(950,650); dialogo_graf_variaciones_JFC.setResizable(true); dialogo_graf_variaciones_JFC.setVisible(true); if(info==1){DibujayGuarda_Grafica_Variaciones("consumo"); Info_Variable("consumo","INFORME VARIACIONES CON EL CONSUMO DE

ACS");} ... dialogo_graf_variaciones_JFC.dispose();}

}

figura 56.- Informe variaciones con el consumo de ACS.


85

Informe 5. “Informe general“ Genera los siguientes informes: 5.1. INFORME GENERAL Permite imprimir y guardar como archivo pdf los datos y resultados anuales de todos los

proyecto guardados el la tabla resultados ACS. El objeto de este informe es ver como varián los resultados anuales según la localización del proyecto.

5.2. INFORME GENERAL gráfica demanda Permite imprimir y guardar como archivo pdf la gráfica de los valores de la demanda anual de

energía para cada provincia de España fijando los demás datos. 5.3. INFORME GENERAL gráfica MJm2 anual Permite imprimir y guardar como archivo pdf la gráfica de los valores de MJm2 anual en cada

provincia de España fijando los demás datos. 5.4. INFORME GENERAL gráfica aportacion Permite imprimir y guardar como archivo pdf la gráfica de los valores de la aportación solar

anual de energía para cada provincia de España fijando los demás datos. 5.5. INFORME GENERAL gráfica CSA Permite imprimir y guardar como archivo pdf la gráfica de los valores de la CSA para cada

provincia de España fijando los demás datos.

Botón btnInformeGeneral [JButton] (figuras 48 y 49) Origen de datos Tabla resultadosACS Archivo .jasper Informegeneral.jasper

info_graf_general_demanda.jasper info_graf_general_MJm2anual.jasper info_graf_general_aportacion.jasper info_graf_general_CSA.jasper

evento private void btnInformeGeneralActionPerformed(java.awt.event.ActionEvent evt) {...}


86

figura 57.- página 1 de INFORME GENERAL

figura 58.- INFORME GENERAL gráfica demanda y MJm2anual


87

figura 59.- INFORME GENERAL gráfica aportación y CSA


88

APLICACIÓN JAVA. MEMORIA DE CÁLCULOS

89

2.2. Memoria de cálculos Siguiendo el método de cálculo de CENSOLAR [1], calcula el número de colectores teórico

para cubrir la demanda energética anual en función de la radiación solar anual por m2, calculada para una inclinación dada y en la provincia seleccionada. Con este resultado el usuario decide el número de colectores que quiere instalar y, en función de la superficie resultante, el programa calcula la aportación solar anual y el déficit energético anual. Por otro lado, para los mismos datos de consumo de ACS, el programa aplica el método F-chart y calcula la cobertura solar anual con el mismo número de colectores decidido tras los resultados del método anterior.

El programa permite cambiar el valor de las variables que intervienen en los dos métodos y ver

de forma gráfica como influyen en el resultado. Como hay variables que se emplean en uno y en el otro no, no se trata de comparar el resultado de los dos métodos de cálculo sino de tener dos referencias a la hora de estimar la aportación solar de una instalación para la producción de ACS, mediante colector solar plano, para unas condiciones de consumo y localización dadas.


90

El presente apartado se compone de las siguientes partes: 2.2.1. Datos y resultados 2.2.2. Datos por defecto 2.2.3. Cálculo de las cargas de consumo de ACS 2.2.4. Dimensionado de la superficie de colectores

2.2.4.1. Justificación de cálculos 2.2.5. Código java para los cálculos

2.2.5.1. Consumo mensual de ACS 2.2.5.2. Salto térmico 2.2.5.3. Necesidades energéticas mensuales 2.2.5.4. Radiación media sobre superficie horizontal 2.2.5.5. Radiación media sobre superficie inclinada 2.2.5.6. Intensidad media útil de radiación solar 2.2.5.7. Rendimiento del colector solar plano 2.2.5.8. Aportación solar por m2 2.2.5.9. Energía neta disponible 2.2.5.10. Superficie colectora 2.2.5.11. Energía total obtenida 2.2.5.12. Aportación de energía solar 2.2.5.13. Déficit de energía 2.2.5.14. Aportación solar anual

2.2.6. Método F-chart 2.2.7. Código java para los cálculos (F-chart)

2.2.7.1. Estimación de la carga calorífica 2.2.7.2. Estimación de la energía absorbida y perdida 2.2.7.3. Cálculo del parámetro de ganancia D1 2.2.7.4. Cálculo del parámetro de pérdidas D2 2.2.7.5. Cobertura solar mensual f 2.2.7.6. Cobertura solar anual CSA 2.2.7.7. Volumen de acumulación


91

2.2.1. Datos y resultados Partiendo de los datos de la columna de izquierda el programa calcula los de la derecha. Método 1: basado en CENSOLAR [1]

DATOS RESULTADOS Inclinación : Desviación N-S (β): 0 Corrección de H: Pérdidas globales: Nº de usuarios: Litros/día·usuario: Área de colector: Parámetros b y m del colector: Corrección de b: Temperatura de uso: Precio del kw·h : € Ocupación %mes Datos mensuales

Temperatura de red Radiación H Factor k (inclinación) Horas sol Temperatura ambiente

Nº colectores a instalar

Resultados mensuales: Consumo ACS m3 Salto térmico Demanda termias Demanda MJ H corregida Energía neta incidente Intensidad incidente Energía neta disponible MJ/m2 Energía neta total MJ/mes Rendimiento de un colector Aportación solar por m2 Sustitución % Déficit de energía Coste eléctrico de la demanda Coste eléctrico del déficit Ahorro

Resultados anuales: Demanda anual: MJ Energía/año·m2 : MJ Aportación solar: % Déficit energético: MJ Ahorro anual : € Coste energía auxiliar: €

Superficie colectora teórica: m2 Número de colectores teórico: Superficie colectora resultante (A) Condición de diseño: 60<C/A<100

VARIACIONES (*) Ocupación Litros/día·usuario Temperatura de uso Inclinación Número de colectores


92

Método 2 basado en F-Chart

DATOS RESULTADOS Inclinación : Desviación N-S (β): 0 Corrección de H: Pérdidas globales: Nº de usuarios: Litros/día·usuario: Área de colector: Parámetros b y m del colector: Corrección de b: Temperatura de uso: Ocupación %mes Datos mensuales

Temperatura de red Radiación H Factor k (inclinación) Horas sol Temperatura ambiente

Nº colectores a instalar Calor específico Modificación del ángulo de incidencia Factor captador-intercambiador Acumulación por m2 Volumen de acumulación (M) Temperatura mínima del ACS

Consumo de ACS litros/día Carga calorífica mensual Superficie resultante (A) Energía solar absorbida mensual Factor F’rUL Factor k1 corrección por acumulación Factor k2 corrección por Energía perdida mensual Variable D1 para f Variable D2 para f Fracción solar mensual f Energía solar útil mensual Fracción solar anual CSA volumen de acumulación teórico (V) Condiciones de diseño

0.8<=V/M<=1.2 37.5<=M/A<=300

VARIACIONES(*) Ocupación Litros/día·usuario Temperatura de uso Inclinación Número de colectores Kg de acumulación b m Factor captador-intercambiador Modificación ángulo de incidencia (**)

(**) no tiene botones "+-" (*) Denominamos "variaciones" a las variables para las cuales el programa dispone de

"botones +-" con los que podemos ver las variaciones de los resultados en función del incremento de estás variables. Cada vez que pulsamos "+" o "-" aumenta o disminuye, en una cantidad fijada, el valor de la variable correspondiente y se recalculan todas las operaciones y se dibujan las gráficas con los nuevos valores y resultados. Las variaciones afectan a los dos métodos y variarán los resultados según influyan o no.


93

Además de estas variaciones, podemos cambiar cualquier otro dato introduciendo su valor, mediante teclado, en el campo de texto correspondiente.

2.2.2. Datos por defecto. El programa tiene la opción de introducir los siguientes valores por defecto: Inclinación : 45 Desviación N-S (β): 0 0 Corrección de H: 1.05 Pérdidas globales: 0.15 Nº de usuarios: 32 Litros/día·usuario: 40 Área de colector: 2.01 Parámetros b y m del colector: 0.83 y 4.8 Corrección de b: 0.94 Temperatura de uso: 45 Precio €/kwh 0.12 Ocupación %mes 100 Temperatura de red Según provincia Radiación H Según provincia Factor k (inclinación) Según provincia Horas sol Según provincia Temperatura ambiente Según provincia Calor específico 4184 J/kgºC Modificación ángulo de incidencia 0.96 Factor captador-intercambiador 0.95 Acumulación por m2 70 litros Temperatura mínima del ACS 45 Valores mensuales por defecto. En función de la provincia y la inclinación seleccionadas el programa introduce los valores

para cada mes de: � Temperatura de red � Radiación H � Factor k (inclinación) � Horas sol � Temperatura ambiente

(fuente CENSOLAR [2]) Con cada opción de "Valores por defecto" el programa introduce los valores por defecto

correspondientes al evento que se esté ejecutando en ese momento.


94

El programa incorpora un botón llamado "Calcula todo" con el cual, una vez seleccionada la provincia, nos pide que indiquemos el número de colectores y el volumen del acumulador. Con estos dos datos y tomando todos los "valores por defecto" anteriores realiza todas las operaciones a la vez. Esta opción se diseñó para ofrecer una forma rápida de comparar los resultados en función de la provincia seleccionada manteniendo todos los demás datos iguales.

A continuación describiremos cómo se realizan los cálculos necesarios en el programa.

2.2.3. Cálculo de la carga de consumo Una vez seleccionada la localización del proyecto, el programa nos pedirá los siguientes datos: � Inclinación: Ángulo que formarán los colectores respecto a la superficie horizontal. Por

defecto, toma el valor de 45º pero tenemos la opción de tomar los valores 35,40,45,50,55 y 60. (ventana datos generales)

� Desviación N-S: por defecto 0º, todos los datos en el programa están referidos a este valor.

� Corrección de H: factor que modifica el valor de la radiación media diaria sobre superficie horizontal (H), por defecto el programa toma un valor de 1.05, (valor para niveles de contaminación atmosférica muy bajos).

� Pérdidas globales: por defecto toma un valor de 0.15 como valor recomendado (CENSOLAR[1]), cuando no se dispone de datos para estimar las pérdidas de calor, que dependen del aislamiento y del tipo de consumo.

� Nº de usuarios: Número máximo de usuarios, en un mes, para los que se calcula la instalación.

� Litros/día·usuario: Consumo diario estimado para cada usuario. Por defecto, 40 litros.

� Área del colector: superficie útil en m2 del colector que el proyectista decida instalar. Por defecto toma 2.01 m2.

� Parámetro b: factor de eficiencia óptica de los colectores, por defecto b=0.83.

� Parámetro m: Coeficiente de pérdidas de los colectores, por defecto m=4.8.

� Temperatura de uso: temperatura de uso del ACS, por defecto 45ºC.

� Precio del kwh: por defecto, energía eléctrica, 0.12€/kwh. Todos estos datos se introducen en la ventana "Datos generales", podemos seleccionar los

valores por defecto o introducir el valor que queramos por teclado.


95

figura 1. ventana Datos generales Pulsando "Continuar" el programa asigna estos datos al proyecto y partir de aquí podemos

calcular las necesidades energéticas para cada mes, para lo cual necesitamos conocer los siguientes datos mensuales:

� Ocupación: es el porcentaje del número máximo de usuarios que cada mes utilizará la

instalación. Por defecto tiene un valor del 100% todos los meses, podemos cambiarlo en la ventana "Datos mensuales" y con los botones +- en los paneles "Gráficas f-chart" y "Gráficas demanda-aportación".

� Consumo mensual (m3): es el consumo total de ACS cada mes, en m3.

� Temperatura media del agua red: Por defecto el programa toma los valores de la capital de la provincia seleccionada en el proyecto (fuente CENSOLAR[1]), podemos consultarlos en el panel "DATOS&RESULTADOS".

� Salto térmico: Diferencia entre la temperatura de uso y la temperatura de red.

� Demanda energética : energía necesaria para calentar el agua desde la temperatura de red hasta la de consumo. El valor calculado aparece en la columna neMJ del el panel "CÁLCULOS".

2.2.4. Dimensionado de la superficie de colectores

Se calculará una superficie colectora "teórica", siguiendo el método de CENSOLAR[1],

dividiendo la necesidad energética anual entre la disponible por metro cuadrado de superficie expuesta a la radiación solar.

En el programa java, primero se calcula la demanda de energía anual (DemandaAnual)

sumando la demanda de cada mes (vDemanndaMJme[i]), después calcula la energía neta disponible por m2 al año (ENDañoM2) sumando la energía disponible cada mes (vENDmes[i]) , dividiendo estos dos valores obtiene la superficie SCteorica. Con el dato de la superficie de un colector (Acol), que toma de las datos de inicio, calcula el número de colectores necesarios (Ncteorico) para cubrir dicha superficie. Para todo esto necesitamos conocer los siguiente datos:


96

Justificación de cálculos: � Necesidad energética diaria en MJ.

� H = Energía incidente en un m2 horizontal (MJ), su valor mensual aparecerá en la ventana

"Datos mensuales" para la provincia seleccionada.(fuente CENSOLAR[2])

� Valor de H corregido: por defecto, multiplica H por el factor 1.05 (valor para zona de sierra de atmósfera limpia), su valor resultante puede consultarse en el panel "DATOS&RESULTADOS".

� Coeficiente de corrección k para una latitud de la provincia seleccionada y la inclinación

tomada como dato, su valor para cada mes aparece en la ventana "Datos mensuales". (fuente CENSOLAR[2])

� Energía neta incidente (MJ/m2): E=0.94kH. Considera que un 6% de la energía incidente no

se aprovecha debido a los momentos en que la intensidad es menor del valor umbral 200 W/m2 (CENSOLAR[1])

� Nº de horas de sol útiles, sus valores dependen de la provincia seleccionada y puede

consultarse en el panel "DATOS&RESULTADOS" . (fuente CENSOLAR[2])

� Intensidad media útil I, en W/m2, se obtiene dividiendo E (previamente pasada a julios) por las horas de sol útiles (pasada a segundos). "DATOS&RESULTADOS"

� Temperatura ambiente durante las horas de sol: sus valores dependen de la provincia

seleccionada y puede consultarse en el panel "DATOS&RESULTADOS" . (fuente CENSOLAR[2])

� Rendimiento de los colectores. Por defecto, considera un colector con cubierta y destinado a

la obtención de ACS, el factor b se corrige multiplicándolo por 0.94. Su valor resultante puede consultarse en el panel "DATOS&RESULTADOS".

� Aportación solar por m2: Se obtiene multiplicando la energía neta incidente (E) por el

rendimiento de los colectores. Su valor mensual se puede consultar en el panel "CÁLCULOS".

� Energía neta disponible al día por m2: corregimos la Aportación con el factor 0.85 a fin de considerar las pérdidas producidas en el acumulador (15%).

� Energía neta disponible al mes por m2: multiplica por el número de días de cada mes. Su valor puede consultarse en el panel "CÁCULOS" y en la columna ENDmes del panel "RESULTADOS".

� Superficie colectora necesaria. Para ello dividimos la demanda energética total entre la energía neta disponible por m2.


97

Una vez decidido el número de colectores a instalar, el programa continúa realizando los siguientes cálculos. � Energía solar disponible: Se obtiene multiplicando la superficie proyectada por la energía

neta por m2 � Sustitución: representa la fracción de consumo energético que es satisfecha por la energía

solar. � Déficit energético: Representa la energía auxiliar que hay que aportar los meses en que la

energía solar no basta por sí sola para cubrir el 100% de las necesidades.

� Coste de la energía eléctrica ( € por kwh) para cubrir el 100% de la demanda.

� Coste de la energía eléctrica para cubrir el déficit.

� Ahorro en el coste de energía eléctrica.

2.2.5. Código java para los cálculos

A continuación veremos como se realizan todos estos cálculos en el programa java.

2.2.5.1. Cálculo del consumo mensual de agua

Multiplica los litros/día·usuarios (LitrosDia) por el número de usuarios (NunUsu), por el

número de días del mes correspondiente (vDias[i]) y por el porcentaje de ocupación del mes calculado vOcupacion[i].

El programa nos da la opción de recalcular el consumo cambiando la ocupación y los litros

diarios y así observar como varían los demás resultados en función de estas variables. Para esto, en el método se incluyen los vectores vDAporceocupacion[i] y vDAporcelitros[i]. Son vectores de 12 componente que representan, para cada mes, la fracción entre el valor inicial y el nuevo valor. Inicialmente todos tienen valor 1. Así, cuando cambiamos, con los botones +-, el valor de estas variables el programa calcula el porcentaje de variación y lo aplica al cálculo, en función de donde intervenga dicha variable (en este caso en el consumo). De esta manera podemos recuperar el resultado inicial haciendo que estos vectores tomen el valor 1 en todos sus componentes (Botón "Cancelar" en los paneles "Gráficas f-chart" y "Gráficas demanda-aportación").


98

En el programa java:

clase: LocalizacionACS objeto: pueblo variables: VConsumo[i] : resultado del consumo de ACS en el mes [i]

LitrosDia : dato del consumo de ACS por día y usuario NumUsu : dato del número de usuarios vDias[i] : dato del número de días del mes [i] vOcupación: dato del % de usuarios en el mes [i] vDAporceocupacion[i]: porcentaje de la nueva ocupación respecto a la ocupación inicial en el mes [i] vDAporcelitros[i]: porcentaje del nuevo litros/día·usuario respecto a su valor inicial en el mes [i]

método: public void Calcula_vConsumo(){ for(int i=0;i<12;i++){ vConsumo[i]=(LitrosDia*NumUsu*vDias[i]*vOcupacion[i])/100000; vConsumo[i]=vConsumo[i]*vDAporceocupacion[i];//para calculo variando ocupacion en DA vConsumo[i]=vConsumo[i]*vDAporcelitros[i];//para los calculo variando los litros en DA ConTresDecimales();

vConsumo[i]=Double.valueOf(formateador.format(vConsumo[i])); } } Los valores calculados podemos consultarlos en el panel "DATOS&RESULTADOS"

2.2.5.2. Cálculo del salto térmico ( ∆T )

El salto térmico es la diferencia de temperatura entre, la temperatura de la red de distribución

de agua y la temperatura de uso o consumo del agua caliente sanitaria, producida en la instalación. Por defecto, los datos incluidos en el programa están referidos a la capital de la provincia seleccionada en cada proyecto pero también tenemos la opción de introducir los valores que queramos en la tabla de la ventana "datos mensuales".

De este salto térmico depende, la cantidad de energía que será necesario aportar mediante el

sistema de agua caliente sanitaria por energía solar, y el rendimiento de la instalación. El valor de la temperatura de uso, por defecto de 45 ºC, podemos modificarlo en la ventana de

"datos de entrada" y con los botones "Masmenos" de los paneles[JPanel] "Grafica demanda-aportación" y "F-chart".


clase LocalizacionACS objeto pueblo variables vSalto[i] : resultado del salto térmico en el mes [i]

Tuso : dato de la temperatura de uso del ACS VTred [i]: dato temperatura del agua red, para provincia seleccionada, en el mes [i]

método public void Calcula_vSalto(){ for(int i=0;i<12;i++){ vSalto[i]=Tuso-vTred[i]; } }


99

Los valores resultantes podemos consultarlos en el panel "CALCULOS" con el botón "consultar".

2.2.5.3. Cálculo de las necesidades energéticas mensuales (neMJ) Estos cálculos se realizarán calculando la energía necesaria para calentar, los litros de agua

calculados en el consumo, desde la temperatura de red de distribución hasta la temperatura de consumo durante todos los días de cada mes. Los cálculos se realizan según la siguiente ecuación:

Q = m * Cp * ( ∆T )* N° días En donde:

� m es la cantidad de agua a calentar cada día. � Cp es el calor especifico del agua 4.184 KJ / litro � ∆T es el incremento de temperatura que del agua ºC � Q es la necesidad energética mensual MJ / mes � N° días es el número de días de cada mes.

El programa nos da la opción de recalcular la demanda energética cambiando la ocupación, litros diarios y la temperatura de uso y así observar como varían los demás resultados en función de estas variables. Para esto, en el método se incluyen los vectores vDAporceocupacion[i] y vDAporcelitros[i], descritos anteriormente y el vector vDAporcetuso[i] para las variaciones de la temperatura de uso respecto al valor inicial del proyecto en que se esté calculando.


clase LocalizacionACS objeto pueblo variables vDemandaMJmes[i] : resultado de la demanda energética en el mes [i]

vConsumo[i] : consumo mensual de ACS en el mes [i], descrito anteriormente vSalto[i]: salto térmico en el mes [i], descrito anteriormente vDAportetuso [i]: porcentaje de variación de la temperatura de uso respecto a su valor inicial en el mes [i]

método public void Calcula_vDemandaMJmes(){ for(int i=0;i<12;i++){ vConsumo[i]=(LitrosDia*NumUsu*vDias[i]*vOcupacion[i])/100000; vSalto[i]=Tuso-vTred[i]; vConsumo[i]=vConsumo[i]*vDAporceocupacion[i];//para los calculo variando la ocupac en DA vConsumo[i]=vConsumo[i]*vDAporcelitros[i];//para los calculo variando los litros en DA vSalto[i]=Tuso*vDAporcetuso[i]-vTred[i];//para los calculo variando la Tuso en DA vDemandaMJmes[i]=vConsumo[i]*vSalto[i]*4.184;//MJ/mes ConTresDecimales();

vDemandaMJmes[i]=Double.valueOf(formateador.format(vDemandaMJmes[i])); } }

Los resultados se pueden consultar en el panel "CÁLCULOS" y en la columna "neMJ" del panel "RESULTADOS".


100

2.2.5.4. Cálculo de la radiación media diaria sobre superficie horizontal para cada mes ( H ) El programa contiene los datos de radiación solar de las tablas de CENSOLAR[2]. Las

unidades de partida son MJ / m2 por día medio de cada mes. Una vez seleccionada la provincia, los valores de radiación aparecen, por defecto, en la ventana "Datos mensuales". Para los cálculos, este valor se corrige multiplicándolo por el factor "CorH" según condiciones ambientales de la localización del proyecto (1.05 para atmósferas muy limpias y 0.95 para atmósferas contaminadas). Estos valores se pueden consultar en el panel "DATOS&RESULTADOS".


clase LocalizacionACS objeto pueblo variables vHcor[i]: resultado de la radiación media diaria, corregida, sobre superficie

horizontal, en la provincia seleccionada, para el mes [i] vH[i]: dato de la radiación media diaria sobre superficie horizontal, en la provincia seleccionada, para el mes [i] CorH : dato del factor de corrección de H, por defecto 1.05.

método public void Calcula_vHcor(){ for(int i=0;i<12;i++){ vHcor[i]=vH[i]*CorH; ConTresDecimales(); vHcor[i]=Double.valueOf(formateador.format(vHcor[i]));

} }

2.2.5.5. Cálculo de la radiación media diaria sobre superficie inclinada para cada mes Según la inclinación de los colectores, se calcula la radiación media incidente, por m2 de

superficie colectora, multiplicando el valor de la radiación sobre superficie horizontal (vHcor[i]) por el factor "k" (vCork[i]) que depende la inclinación, del mes y de la localización (latitud) del proyecto. El programa contiene los valores de "k" para cada provincia y para las inclinaciones de 35,40,45,50,55 y 60º. En función del valor de inclinación con el que estemos operando los valores de k, para cada mes, aparecen en la ventana "Datos mensuales" y pueden consultarse en el panel "DATOS&RESULTADOS".

Por tratarse de un sistema de aprovechamiento térmico de la energía solar, se considerarán

unas pérdidas del 6% debido a los momentos en que, debido a la poca altura del sol, la intensidad de irradiación es menor del valor umbral de 200 w/m2. Por eso, además se corrige el resultado multiplicando por el factor 0.94 . De esta forma tendremos el valor efectivo de la energía aprovechable por los colectores.



101

clase LocalizacionACS objeto pueblo variables vE[i]: resultado de la radiación aprovechable que incide un día medio sobre cada m2

de superficie inclinada de colectores en el mes [i] vHcor [i]: resultado de la irradiación horizontal media para el mes [i] en la provincia seleccionada. vCork [i]: dato del factor de corrección "k" para el mes [i], para la inclinación y la provincia seleccionada. 0.94 : dato del factor resultante de estimar un 6% de pérdida de la energía incidente debido a los momentos en que la altura del sol es pequeña resultando que la intensidad es menor del valor umbral de 200 w/m2

método public void Calcula_vE(){ Calcula_vHcor(); for(int i=0;i<12;i++){ vE[i]=0.94*vCork[i]*vHcor[i]; ConTresDecimales();

vE[i]=Double.valueOf(formateador.format(vE[i])); } } Los resultados pueden consultarse en el panel "DATOS&RESULTADOS"

2.2.5.6. Cálculo de la intensidad media útil de radiación solar (vI) La intensidad media útil de la radiación solar, es la es la intensidad con que incide la radiación

de forma instantánea en un día medio de cada mes. Esta intensidad se mide en W / m2, por ello se transformaran las unidades de radiación diaria media de cada mes en unidades de radiación instantánea, dividiendo la radiación diaria media entre el número de horas medias de cada mes, obteniendo la intensidad media útil para cada mes según la siguiente ecuación:

I = H*106 / n° horas * 3600 =(MJ * 106 J/ MJ ) / m2 día * n° horas *3600 s / h =W / m 2

El programa asigna un número de horas sol útil, a cada mes, para cada provincia. Estos valores

son los que emplea para calcular la Intensidad y pueden ser consultados en el panel "DATOS&RESULTADOS". Los resultados obtenidos son de gran importancia ya que serán utilizados para calcular el rendimiento del colector solar plano de la instalación.


clase LocalizacionACS objeto pueblo variables vI[i]: resultado de la intensidad media útil de radiación solar para el mes [i]

vE[i]: 277.778 : resultado del factor de conversión de MJ/m2·día a W/m2 vHorasSolUtil[i]: dato del número de horas sol el mes [i], en provincia seleccionada

método public void Calcula_vI(){ Calcula_vE(); for(int i=0;i<12;i++){ vI[i]=277.778*vE[i]/vHora sSolUtil[i]; ConTresDecimales();

vI[i]=Double.valueOf(formateador.format(vI[i])); } }


102

Los resultados se pueden consultar el panel "CÁLCULOS" y en el panel "DATOS&RESULTADOS".

2.2.5.7. Cálculo del rendimiento del colector solar plano.

Los colectores solares planos se ensayan generalmente siguiendo un procedimiento que

consiste en hacerlos funcionar en un banco de pruebas bajo unas condiciones estables de radiación solar, velocidad del viento, temperatura del fluido a la entrada y de ambiente, durante un periodo de tiempo en el que la temperatura de salida del fluido y la energía útil extraída no varían sensiblemente.

La ecuación para calcular el rendimiento del colector en distintas condiciones de

funcionamiento es la siguiente: η = m – b T/I

� m: coeficiente global de pérdidas, dato del colector. � b: factor de eficiencia óptica, dato del colector. Además se incluye un parámetro de

corrección de b "Corb" según el tipo de colector. Por defecto, el programa considera un colector plano con cubierta y destinado a la obtención de ACS, el factor b (0.83) se corrige multiplicando por Corb=0.94.


clase LocalizacionACS objeto pueblo variables vRendimiento[i]: resultado del rendimiento de los colectores para el mes [i]

vI[i]: resultado de la intensidad de la radiación solar para el mes [i] Corb : dato del factor de corrección del parámetro "b" de los colectores, por defecto 0.94. bcol: dato del factor de eficiencia óptica de los colectores mcol: dato del coeficiente general de pérdidas de los colectores Tuso : dato de la temperatura de uso del ACS vTamb[i]: dato de la temperatura ambiente para el mes [i] vfporcetuso[i]: porcentaje de variación de la temperatura de uso en el mes [i] respecto a su valor inicial.

método public void Calcula_vRendimiento(){ Calcula_vI();//con esto calcula I for(int i=0;i<12;i++){ //vRendimiento[i]=100*Corb*bcol-100*mcol*(Tuso-vTamb[i])/vI[i]; vRendimiento[i]=100*Corb*bcol-100*mcol*(Tuso*vfporcetuso[i]-vTamb[i])/vI[i]; // if(vRendimiento[i]<20){vRendimiento[i]=0;} if(vRendimiento[i]<0){vRendimiento[i]=0;} ConTresDecimales();

vRendimiento[i]=Double.valueOf(formateador.format(vRendimiento[i]));} }


103

Estos datos de rendimiento son los que serán utilizados en los cálculos posteriores, para calcular la energía que es aprovechada por el colector solar plano de la que incide sobre él.

Los resultados se pueden consultar el panel "CÁLCULOS" y en el panel "DATOS&

RESULTADOS".

2.2.5.8. Cálculo de la aportación solar por m2.

Llamamos "Aportación solar por m2" a la energía que incide por m2, de superficie de

colector solar plano, y que es transferida al fluido caloportador. Es decir, es la energía, procedente del sol, que el colector aprovecha de la energía total que incide sobre él.

Esta energía incidente se calcula multiplicando la radiación solar que incide por día y metro

cuadrado de superficie por el rendimiento del colector solar plano en cada mes y multiplicando por el numero de días de cada mes.

La ecuación que se aplicará para calcular la energía incidente considerando el rendimiento del

colector solar plano será la siguiente: Aportación = E * η


clase LocalizacionACS objeto pueblo variables vAportacion[i]: resultado de la energía solar captada por m2 de colector el mes [i]

vE[i]: resultado de la radiación media diaria para el mes [i] vRendimiento [i]: resultado del rendimiento de los colectores para el mes [i]

método public void Calcula_vAportacion(){ Calcula_vRendimiento();//con esto calcula I que calcula E for(int i=0;i<12;i++){ if(vOcupacion[i]>0){vAportacion[i]=vE[i]*vRendimiento[i]/100;}// hemos añadido /100 else{vAportacion[i]=0;} ConTresDecimales();

vAportacion[i]=Double.valueOf(formateador.format(vAportacion[i])); } }

Los resultados, para cada mes, se pueden consultar en el panel "CÁLCULOS".

2.2.5.9. Cálculo de la energía neta disponible (END)

El colector solar plano, las tuberías, el depósito interacumulador, y los demás accesorios de

una instalación solar térmica, durante el funcionamiento mantienen temperaturas superiores a la temperatura ambiente, perdiendo calor por conducción a través de las uniones del sistema a tierra y por convección y radiación al ambiente.


104

Las pérdidas por radiación son generalmente pequeñas siendo las pérdidas por convección las más importantes. Las pérdidas de calor son una causa importante de la reducción del rendimiento del sistema de energía solar y obligan a aislar la instalación con el fin de minimizarlas.

En el propio colector solar plano existen pérdidas debido a los distintos fenómenos físicos de

transmisión de calor. Estas pérdidas son las siguientes: � Pérdida de calor frontal por radiación hacia el cielo debido a la absortancia del colector. � Pérdida de calor frontal por convección, en general depende de la velocidad del viento. � Pérdidas de calor posteriores y laterales del colector solar plano, que dependerán del tipo y

espesor del aislamiento estas pérdidas se estiman en un 2 o el 3 % de la energía captada. � Pérdidas por la cara posterior del colector solar plano, dependen del tipo y espesor de

aislamiento que ese utilice. � Pérdidas hacia arriba por la cara expuesta a la radiación dependen de la emitancia del

colector solar plano. En el programa, todas estas perdidas se estiman, por defecto, en un 15 % de la energía captada

por el colector solar plano, por lo que la energía que será utilizada para el calentamiento del agua caliente sanitaria es el 85 % de la captada por el colector solar plano. Así se calculará la energía neta disponible multiplicando la energía incidente considerando el rendimiento del colector solar plano, por el 85 % que será la que se aproveche. Este valor se puede cambiar en los datos de inicio del proyecto. Los cálculos se realizan según la siguiente ecuación:

Energía neta disponible = Aportación * 0,85


clase LocalizacionACS objeto pueblo variables vENDdia[i]: resultado de la energía neta diaria disponible por m2 para el mes [i]

vAportacion[i]: resultado de la energía solar captada por m2 de colector el mes [i] PerdGlo : dato del factor de pérdidas globales de la energía que llega a los colectores. (por defecto 0.15) vDias[i]: dato del número de días para el mes [i] vENDmes[i]: resultado de la energía neta mensual disponible por m2 para el mes [i] ENDañoM2 : resultado de la energía neta disponible al año por m2.

método public void Calcula_vENDdia(){ Calcula_vAportacion(); for(int i=0;i<12;i++){ vENDdia[i]=vAportacion[i]*(1-PerdGlo);// hemos quitado /100 ya que está en la aportacion } } public void Calcula_vENDmes(){ ConTresDecimales(); Calcula_vENDdia(); for(int i=0;i<12;i++){ vENDmes[i]=vENDdia[i]*v Dias[i]; vENDmes[i]=Double.valueOf(formateador.format(vENDmes[i])); } } public void Calcula_ENDañoM2(){ Calcula_vENDmes(); ENDañoM2=0; for(int i=0;i<12;i++){ ENDañoM2=ENDañoM2+vENDmes[i];} ConTresDecimales();

ENDañoM2=Double.valueOf(formateador.format(ENDañoM2)); }


105

De este modo hemos calculado la energía solar por metro cuadrado y día, por mes y por año, de la que se dispone para calentar el agua caliente sanitaria. Los resultados se pueden consultar en el panel "CÁLCULOS" y en el panel "RESULTADOS".

2.2.5.10. Cálculo de la superficie colectora.

Se calculará una superficie colectora "teórica", siguiendo el método de CENSOLAR[1],

dividiendo la necesidad energética anual entre la disponible por metro cuadrado de superficie expuesta a la radiación solar. En el programa java, primero se calcula la demanda de energía anual (DemandaAnual) sumando la demanda de cada mes (vDemanndaMJme[i]), después calcula la energía neta disponible por m2 al año (ENDañoM2) sumando la energía disponible cada mes (vENDmes[i]), dividiendo estos dos valores obtiene la superficie SCteorica. Con el dato de la superficie de un colector (Acol), que toma de las datos de inicio, calcula el número de colectores necesarios (Ncteorico) para cubrir dicha superficie. Estos valores servirán al usuario del programa para decidir el número de captadores con los que contará la instalación que esté calculando. El valor introducido por el usuario (NCrecomendado) por la superficie de un colector (Acol) nos dará el valor de la superficie colectora total (SCresulatante) de la instalación calculada. El programa compara el dato de la superficie introducido con el consumo de ACS litros/día calculado y nos indica si cumple con la condición de diseño 60<=C/A<=100. Esta comprobación también se realizará cada vez que el usuario modifique el valor del consumo (C) y o de la superficie (A).


clase LocalizacionACS objeto pueblo variables SCteorica : resultado de la superficie, de colectores, en m2 calculada.

NCteorico : resultado del número de colectores necesarios para la "SCteorica" calculada. DemandaAnual : resultado de la demanda energética para todo el año. ENDañoM2 : resultado de la energía neta disponible por m2 y año. Acol : dato en m2 del área de un colector. NCrecomendado : dato del número de colectores a instalar según el proyectista. Scresultante : resultado de la superficie total de colectores según el "NCrecomendado" y "Acol" ConsumoAnualACSm3 : resultado del consumo anual de ACS en m3. NumDiasAnual : resultado del número total de días del año. PruebaSC : resultado del cociente de consumo diario de ACS en m3 por m2 de colectores instalados.

método public void Calcula_DemandaAnual(){ Calcula_vDemandaMJmes(); DemandaAnual=0; for(int i=0;i<12;i++){ DemandaAnual=DemandaAnual+vDemandaMJmes[i]; }ConTresDecimales();

DemandaAnual=Double.valueOf(formateador.format(DemandaAnual)); }


106

public void Calcula_SCteorica(){ Calcula_DemandaAnual(); Calcula_ENDañoM2();

SCteorica=DemandaAnual/ENDañoM2; ConTresDecimales();

SCteorica=Double.valueOf(formateador.format(SCteorica)); }

public void Calcula_NCteorico(){ Calcula_SCteorica(); NCteorico=SCteorica/Acol; ConTresDecimales(); NCteorico=Double.valueOf(formateador.format(NCteorico)); } public void Calcula_SCresultante(){ //introducimos por teclado el Ncrecomendado (nº de colectores que asignamos al proyecto) SCresultante=NCrecomendado*Acol; ConTresDecimales(); SCresultante=Double.valueOf(formateador.format(SCresultante)); } public void Calcula_PruebaSC(){ Calcula_ConsumoanualACSm3(); Calcula_NumDiasAnual(); Calcula_SCresultante(); PruebaSC=1000*ConsumoanualACSm3/(NumDiasAnual*SCresultante); ConTresDecimales(); PruebaSC=Double.valueOf(formateador.format(PruebaSC)); } public double getPruebaSC(){ Calcula_PruebaSC(); return PruebaSC; } public String getComprobacionSC(){ Calcula_PruebaSC(); String CSC; if(PruebaSC<60){CSC="No cumple";} else{if(PruebaSC>100){CSC="No cumple";}else{CSC="Cumple";}}

return CSC; } Estas operaciones se realizan en el panel "CÁLCULOS".

2.2.5.11. Cálculo de la energía total obtenida por el sistema de captación de energía solar térmica (ENTotalmes)

En el apartado anterior hemos calculado la energía neta disponible por metro cuadrado de

colector para cada mes del año, en este apartado se calculará la energía total disponible y que se puede obtener por el sistema de energía solar térmica, para ello multiplicaremos la energía neta disponible por la superficie del colector solar plano en metros cuadrados.

Los cálculos de la energía total disponible se especifican a continuación según la siguiente

ecuación: Et = É * S


107


clase LocalizacionACS objeto pueblo variables vENTotalmes[i]: resultado de la energía neta total disponible, en función de la

superficie de colectores instalados, para el mes [i]. vENDmes[i]: resultado de la energía neta disponible por m2 de colector el mes [i]. Scresultante : resultado de la superficie de colectores instalada.

método public void Calcula_vENTotalmes(){ Calcula_vENDmes(); Calcula_SCresultante(); for(int i=0;i<12;i++){ vENTotalmes[i]=vENDmes[i]*SCresultante; ConTresDecimales();

vENTotalmes[i]=Double.valueOf(formateador.format(vENTotalmes[i])); } }

2.2.5.12. Cálculo de la aportación de energía de la instalación solar térmica a la producción de agua caliente sanitaria (Sustitución).

Para la producción de agua caliente sanitaria es necesario aportar energía, para elevar la

temperatura del agua, en el sistema objeto del proyecto, esta energía se aportará mediante un sistema de energía solar térmica. Este sistema, en días nublados y cubiertos no podrá proporcionar toda la energía necesaria, para el calentamiento de toda el agua caliente sanitaria que se consume en un día, aportando la energía que falta el sistema de aportación de energía auxiliar.

El sistema de energía solar térmica aportará una gran parte de las necesidades energéticas. Así

en este apartado se calculará el porcentaje de aportación de energía solar en el sistema de agua caliente sanitaria objeto del proyecto.

La aportación se calculará dividiendo la energía total obtenida "vENTotalmes" entre las

necesidades energéticas mensuales "vDemandaMJmes". En el programa java:

clase LocalizacionACS objeto pueblo variables vSustitucion[i]: resultado del cociente de la demanda energética y la energía solar

disponible para el mes [i]. vDemandaMJmes[i] : resultado de la demanda energética para el mes [i]. vENTotalmes[i]: resultado de la energía solar disponible para el mes [i].

método public void Calcula_vSustitucion(){ Calcula_vDemandaMJmes(); Calcula_vENTotalmes(); for(int i=0;i<12;i++){ if(vOcupacion[i]==0){vS ustitucion[i]=0;} else{double sust=vENTotalmes[i]/vDemandaMJmes[i]; vSustitucion[i]=sust;} ConTresDecimales();

vSustitucion[i]=Double.valueOf(formateador.format(vSustitucion[i])); } }


108

Los resultados pueden consultarse en la columna "Sustitución" del panel "RESULTADOS" y en la gráfica del panel "GRÁFICAS".

Durante los meses de verano suele producirse un superávit de energía térmica, es decir se

produce mas energía térmica de la que se consume, por lo que se podría utilizar este exceso de agua caliente sanitaria para otros usos que no sean los habituales.

2.2.5.13. Cálculo del déficit de energía aportada por la instalación solar. El déficit de energía aportada por la instalación de energía solar, es la diferencia entre la

energía necesaria en cada mes y la energía que aporta dicha instalación para el calentamiento del agua caliente sanitaria. Es decir es la diferencia entre las necesidades energéticas mensuales ( vDemandaMJmes ) y la energía solar total disponible ( vENTotalmes ).

Este déficit nos indica cuando la instalación de energía solar suministra toda la energía

necesaria, y cuando es necesario que entre en funcionamiento el sistema auxiliar de aportación de energía, para suministrar el agua caliente sanitaria en las condiciones de consumo.


clase LocalizacionACS objeto pueblo variables vDeficit[i]: resultado de la diferencia entre la demanda de energía y la energía solar

para cada mes [i] vDemandaMJmes[i]: resultado de la demanda energética para el mes [i]. vENTotalmes[i]: resultado de la energía solar disponible para el mes [i]. DeficitEnergeticoAnual : resultado de la suma de demanda energética no cubierta por energía solar durante todo el año.

método public void Calcula_vDeficit(){ Calcula_vDemandaMJmes(); Calcula_vENTotalmes(); for(int i=0;i<12;i++){ vDeficit[i]=vDemandaMJmes[i]-vENTotalmes[i]; ConTresDecimales(); vDeficit[i]=Double.valueOf(formateador.format(vDeficit[i])); } } public void Calcula_DeficitEnergeticoAnual(){ double defi=0; Calcula_vDeficit(); for(int i=0;i<12;i++){ if(vDeficit[i]<0){}else{defi=defi+vDeficit[i];} } ConTresDecimales();

deficitEnergeticoAnual=Double.valueOf(formateador.format(defi)); }

Los resultados pueden consultarse en la columna "Déficit" del panel "RESULTADOS". Los valores positivos aparecen en color rojo y los negativos en color azul. Los datos negativos

significan que existe superávit de energía disponible para el calentamiento del agua caliente


109

sanitaria y por lo tanto están cubiertas todas las necesidades energéticas mediante la instalación de energía solar térmica para la obtención de ACS. Para calcular el déficit total anual, los valores negativos equivalen a un valor del 0%. Solo se indican en la pantalla para poder observar cuanto y cuando la energía solar disponible sobrepasa a la demandada.

2.2.5.14. Cálculo de la aportación solar anual.

Nos da una idea del porcentaje de la demanda anual de energía que es sustituida por energía

solar. Como se indicó anteriormente, en los meses en que el valor de calculado vDeficit[i] resulte negativo se considera igual a 0.


clase LocalizacionACS objeto pueblo variables VCobertura[i]: resultado del % de la demanda energética mensual cubierta por

energía solar para el mes [i] vDeficit[i]: resultado del déficit energético para el mes [i] aportacionAnual : resultado de % de la demanda energética anual cubierta por energía solar al cabo de un año.

método public void Calcula_vCobertura(){ Calcula_vDeficit(); for(int i=0;i<12;i++){ vCobertura[i]=100*(1-vDeficit[i]/vDemandaMJmes[i]); ConTresDecimales(); vCobertura[i]=Double.valueOf(formateador.format(vCobertura[i])); } } public void Calcula_aportacionAnual(){ Calcula_DemandaAnual(); Calcula_DeficitEnergeticoAnual(); aportacionAnual=100*(DemandaAnual-deficitEnergeticoAnual)/DemandaAnual; ConTresDecimales();

aportacionAnual=Double.valueOf(formateador.format(aportacionAnual)); }

2.2.5.15. Cálculos de costes de la energía y ahorro

En la ventana "Datos generales" introducimos el coste en €/kwh y en función de éste, el

programa calcula el coste de la energía necesaria para toda la demanda, el coste de la energía para el déficit y el ahorro que supone la diferencia de los dos valores anteriores. Es una manera de evaluar la posible amortización de la instalación solar para ACS.



110

clase LocalizacionACS objeto pueblo variables Preciokwh : dato de coste del kwh

vDemandaMJmes[i]: demanda energía en MJ para el mes [i] DemandaAnual : demanda energía anual en MJ vCEmes[i]: coste de la energía eléctrica para la demanda energética para el mes [i]. CosteEanual : coste de la energía eléctrica para la demanda anual. vCosteAuxmes[i]: coste de la energía eléctrica para la demanda no cubierta por energía solar para el mes [i] CAuxAnual : coste de la energía eléctrica para la demanda no cubierta por energía solar durante un año. vAhorromes[i]: coste de la energía eléctrica cubierta por energía solar el mes [i]. AhorroAnual : coste de la energía eléctrica cubierta por energía solar.

método public void Calcula_vCosteEmes(){ Calcula_vDemandaMJmes(); for(int i=0;i<12;i++){ vCEmes[i]=Preciokwh/3.6*vDemandaMJmes[i]; ConTresDecimales(); vCEmes[i]=Double.valueOf(formateador.format(vCEmes[i])); } } public void Calcula_CosteEanual(){ Calcula_DemandaAnual(); CEanual=Preciokwh/3.6*DemandaAnual; ConTresDecimales(); CEanual=Double.valueOf(formateador.format(CEanual)); } public void Calcula_vCosteAuxmes(){ Calcula_vDeficit(); for(int i=0;i<12;i++){ if(vDeficit[i]>0){vCAuxmes[i]=Preciokwh/3.6*vDeficit[i];} else{vCAuxmes[i]=0;} ConTresDecimales(); vCAuxmes[i]=Double.valueOf(formateador.format(vCAuxmes[i])); } } public void Calcula_CosteAuxAnual(){ Calcula_vCosteAuxmes(); CAuxAnual=0; for(int i=0;i<12;i++){ CAuxAnual=CAuxAnual+vCAuxmes[i];} ConTresDecimales(); CAuxAnual=Double.valueOf(formateador.format(CAuxAnual)); } public void Calcula_vAhorromes(){ Calcula_vCosteEmes(); Calcula_vCosteAuxmes(); for(int i=0;i<12;i++){ vAhorromes[i]=vCEmes[i]-vCAuxmes[i]; ConTresDecimales(); vAhorromes[i]=Double.valueOf(formateador.format(vAhorromes[i])); } } public void Calcula_AhorroAnual(){ Calcula_vAhorromes(); AhorroAnual=0; for(int i=0;i<12;i++){ AhorroAnual=AhorroAnual+vAhorromes[i]; } ConTresDecimales();

AhorroAnual=Double.valueOf(formateador.format(AhorroAnual)); } Los resultados pueden consultarse en el panel "RESULTADOS"


111

2.2.6. Método F-CHART

2.2.6.1. Cálculo de aportación energética en instalaciones de ACS mediante el método "f-chart"

El "f-chart" ó método de las curvas-f, es un método que permite estimar la aportación energética de un sistema solar para producción de ACS ó ACS y calefacción en períodos de tiempo relativamente largos. Ha sido desarrollado desde 1974 por los profesores W.A. Beckman, S. A. Klein, y J.A. Duffie en el Laboratorio de Energía Solar de la Universidad de Madison en Wisconsin. En las instalaciones solares, los parámetros que influyen en el rendimiento del captador son muy variables, y suponer unas condiciones medias de funcionamiento supone asumir un riesgo elevado. A raíz de la simulación de numerosas instalaciones, a través de TRNSYS, y el posterior estudio de resultados se concluyó que, a pesar de que efectivamente las condiciones y por tanto el rendimiento de los captadores era variable, el aporte energético de la instalación en períodos largos de tiempo (por ejemplo un mes), seguía una determinada correlación dependiente de dos parámetros adimensionales. Dicha correlación se expresa de forma gráfica en la figura 2:

Figura 2. Curvas-f

Para estimar la aportación energética de la instalación solar mensualmente, basta con determinar cada uno de los dos parámetros adimensionales y aplicar la correlación de las curvas-f. De forma numérica f se puede calcular mediante siguiente ecuación:

f=1,029·D1-0,065·D2-0,245·D1

2+0,0018·D2

2+0,0215·D1

3

El parámetro D2 representa la relación entre las pérdidas de energía del captador y la carga total de calentamiento durante un mes.

El parámetro D1 expresa la relación entre la energía absorbida en la superficie captadora y la carga total de calentamiento durante un mes.

Así pues, conocida la radiación solar sobre la superficie de captación y el tipo y número de captadores instalados, se puede calcular la aportación energética mensual para una determinada demanda mediante el empleo del método de las curvas f.


112

2.2.7. Cálculo de instalaciones mediante el programa java

Para el método F- Chart se calcula de la siguiente manera: � Estimación de la carga calorífica. � Determinación de la energía absorbida y perdida en el colector. � Cálculo de la ganancia total. � Cálculo de pérdidas totales. � Determinación de cobertura solar mensual. � Determinación de cobertura solar anual

2.2.7.1. Estimación de la carga calorífica (Qa)

Se define la carga calorífica (Qa) como la cantidad de calor mensual que se necesita para

calentar agua. Qa=Ce·C·N·(ta-tr)

� Qa : Carga calorífica mensual para calentar el agua (J/mes) � Ce : Calor específico del líquido calo-conductor en el proceso de intercambio de calor. En el

caso de agua su valor es de 4187 (J /kg°C). � C : Consumo diario de agua (litros/ día). � N : Número de días del mes. � ta : Temperatura del agua caliente de acumulación (°C). � tr : Temperatura del agua de red (°C).


clase LocalizacionACS objeto pueblo variables vfcarga[i]: resultado de la carga calorífica para el mes [i]

Ce : dato del calor específico del fluido caloportador, por defecto el agua. N : dato del número de usuarios. C : dato del consumo diario de ACS en litros/día·usuario vDias[i]: dato del número de días del mes [i] tac : dato de la temperatura del agua caliente vTred[i] : dato temperatura del agua de red el mes [i] en provincia seleccionada. vfporcetuso[i] : % variación temperatura de uso respecto a valor inicial en el mes [i]. vfporceocupacion[i]: % variación de ocupación respecto a su valor inicial el mes [i]. vfporcelitros[i]: % variación consumo diario de ACS respecto valor inicial el mes [i].

método public void Calcula_vfcarga(){ for(int i=0;i<12;i++){ vfcarga[i]=(Ce*N*C*vDias[i]*(tac-vTred[i]))/Mat h.pow(10,6);//MJ/mes vfcarga[i]=(Ce*N*C*vDias[i]*(tac*vfporcetuso[i] -vTred[i]))/Math.pow(10,6);// vfcarga[i]=vfcarga[i]*vfporceocupacion[i];//para los calculo variando la ocupacion en fchart vfcarga[i]=vfcarga[i]*vfporcelitros[i];//para l os calculo variando los litros en fchart ConTresDecimales();

vfcarga[i]=Double.valueOf(formateador.format(vfcarga[i])); } }


113

2.2.7.2. Determinación de energía absorbida por el colector y pérdida del mismo (Ea, Ep). La energía que absorbe el colector (Ea), la cual es trasformada en calor se calcula a través de la

ecuación: Ea=Sc·F’r·(τα)·R1·N

Teniendo en cuenta que: � Sc : Superficie del captador (m2) � F’r·(τα) : Producto de la transmitancia por la absorbancia del colector y el factor de

transporte, equivalente a 1. En este factor ya interviene tanto la eficiencia óptica del captador, como las constantes por modificación del ángulo de incidencia, además del factor captador- intercambiador.

F’r·(τα) =F

R(τα)

n· (τα)/(τα)

n ·(F’

R/F

R)

• F

R(τα)

n Factor de eficiencia óptica del captador. Es la ordenada en el origen de la curva

característica del captador. En el programa corresponde a la variable "FEO".

• (τα)/(τα)n Modificador del ángulo de incidencia. "MAI", valor por defecto 0.96. En general

se puede tomar como constante: 0,96 (superficie transparente sencilla) o 0,94 (superficie transparente doble).

• F’r / Fr Factor de corrección del conjunto captador-intercambiador. "FCCI", por defecto

toma como valor 0.95.

� R1 : Radiación diaria media mensual incidente en la superficie de captación del colector solar (kJ/m2).

� N : Número de días del mes.


clase LocalizacionACS objeto pueblo variables vEabsorbida[i]: resultado de la energía absorbida para el mes [i].

FEO : dato del factor de eficiencia óptica del captador MAI : dato del factor de modificación del ángulo de incidencia FCCI : dato del factor de corrección del conjunto captador-intercambiador. Fadim : resultado del factor adimensional fSc : dato de la superficie en m2 de captación. vE[i]: resultado de la radiación incidente por m2 de superficie inclinada, el mes [i]. Incluye factor de corrección por suciedad en la cubierta de los colectores (- 3%) y por incidencia de rayos no perpenticulares (- 3%) de valor experimental 0.94. vDias[i]: dato del número de días del mes [i].


114

método public void Calcula_Fadim(){ Fadim=FEO*MAI*FCCI; }

public void Calcula_vEabsorbidaf(){ Calcula_vE(); Calcula_Fadim(); for(int i=0;i<12;i++){ vEabsorbida[i]=fSc*Fadim*vE[i]*vDias[i];// MJ/mes ConTresDecimales();

vEabsorbida[i]=Double.valueOf(formateador.format(vEabsorbida[i])); } } La energía que se pierde en el colector (Ep), se determina por medio de la siguiente ecuación:

Ep=Sc·F’r· UL·(100 – ta)·∆t· k1·k2

En donde: � Sc: Superficie útil del captador (m2). � F’r· UL : Factor de eficiencia del intercambiador de calor del colector solar por el coeficiente

global de pérdidas del captador. Este factor viene asociado intrínsecamente a un factor de disipación de calor. (%).

F’r· UL= Fr· UL·( F’r / Fr)

• Fr· UL = Pendiente de la curva característica del captador (coeficiente global de

o pérdidas del captador) "CGP".

• F’r / Fr Factor de corrección del conjunto captador-intercambiador. "FCCI", por defecto 0.95.

� ta : Temperatura mensual media del ambiente. (°C). � ∆t : Período de tiempo, considerando que funciona las 24h/día. (s) � k1 : Factor de corrección debido al almacenamiento.

K1 = [kg acumulación /(75 Sc)]-0,25

37,5 < (kg acumulación) / (m2 captador) < 300

� k2 : Factor de corrección para el agua caliente, en donde se relaciona la temperatura mínima de ésta con el agua de la red usada y también la temperatura media mensual del ambiente.

K2 = 11,6 + 1,18 tac + 3,86 tr – 2,32 ta / (100 – ta)

• tac = Temperatura mínima del ACS, por defecto 45º. • tr = Temperatura del agua de red • ta = Temperatura media mensual del ambiente


115


clase LocalizacionACS objeto pueblo variables vEperdida[i] : resultado de la energía perdida para el mes [i]

CGP : dato del coeficiente global de pérdidas del colector. FCCI : dato del factor de corrección del conjunto captador-intercambiador. FprUL : resultado de F’r· UL= Fr· UL·( F’r / Fr) vDt[i] : resultado del número de segundos del mes [i]. K1 : resultado del factor de corrección k1 para almacenamientos (acumulación) distintos de 75 litros/m2 KgA : datos de los kilogramos (volumen) de acumulación. fSc : resultado de la superficie de captación en m2 vK2[i] : resultado del factor de corrección k2 para el mes [i]. 0.95 : dato del FCCI Tmin : dato temperatura mínima del ACS, por defecto igual a temperatura de uso. vTamb[i] : dato de temperatura ambiente para el mes [i] en provincia seleccionada.

método public void Calcula_FprUL(){ FprUL=CGP*FCCI; ConTresDecimales(); FprUL=Double.valueOf(formateador.format(FprUL)); } public void Calcula_vDt(){ for(int i=0;i<12;i++){ vDt[i]=vDias[i]*24*3600; ConTresDecimales(); vDt[i]=Double.valueOf(formateador.format(vDt[i])); } } public void Calcula_K1(){ double ka1=(KgA/(75*fSc)); K1=Math.pow(ka1,-0.25); ConTresDecimales(); K1=Double.valueOf(formateador.format(K1)); } public void Calcula_vK2(){ for(int i=0;i<12;i++){ vK2[i]=(11.6+1.18*Tmin*vfporcetuso[i]+3.86*vTred[i]-2.32*vTamb[i])/(100-vTamb[i]); ConTresDecimales();

vK2[i]=Double.valueOf(formateador.format(vK2[i])); } }

public void Calcula_vEperdidaf(){ Calcula_vDt(); Calcula_FprUL(); Calcula_K1(); Calcula_vK2(); for(int i=0;i<12;i++){ vEperdida[i]=fSc*FprUL*(100-vTamb[i])*vDt[i]*K1*vK2[i]/1000000;//Mj/mes ConTresDecimales();

vEperdida[i]=Double.valueOf(formateador.format(vEperdida[i])); } }


116

2.2.7.3. Cálculo de la ganancia total (D1) A la ganancia del colector (D1) se la conoce como la energía solar útil proporcionada. Esta

ganancia relaciona la energía absorbida por la placa del colector usado y el parámetro Qa durante un mes, como se muestra en la ecuación :

D1=Ea/Qa


clase LocalizacionACS objeto pueblo variables vD1[i] : resultado de la ganancia D1 para el mes [i]

vEabsorbida[i] : resultado de la energía absorbida para el mes [i]. vfcarga[i] : resultado de la carga calorífica para el mes [i].

método public void Calcula_D1(){ Calcula_vfcarga(); Calcula_vEabsorbidaf(); for(int i=0;i<12;i++){ vD1[i]=vEabsorbida[i]/vfcarga[i]; ConTresDecimales();

vD1[i]=Double.valueOf(formateador.format(vD1[i]));}}

2.2.7.4. Cálculo de pérdidas totales (D2)

Las pérdidas totales en el colector (D2) debido a la reflexión de la luz solar, relacionan las

pérdidas de energía en el captador a determinada temperatura, con la carga calorífica de calentamiento (Qa) durante un mes según la siguiente ecuación :

D2=Ep/Qa


clase LocalizacionACS objeto pueblo variables vD2[i] : resultado de las pérdidas D2 para el mes [i].

vEperdida[i] : resultado de la energía perdida para el mes [i]. vfcarga[i] : resultado de la carga calorífica para el mes [i].

método public void Calcula_D2(){ Calcula_vfcarga(); Calcula_vEperdidaf(); for(int i=0;i<12;i++){ vD2[i]=vEperdida[i]/vfcarga[i]; ConTresDecimales();

vD2[i]=Double.valueOf(formateador.format(vD2[i]));}}


117

2.2.7.5. Determinación de cobertura solar mensual

La energía útil captada en un mes determinado (Qu) se estima mediante la ecuación:

Qu = f·Qa A la fracción de carga calorífica mensual (Qa), que se transforma en energía solar, se la conoce

como parámetro f. El cálculo de este parámetro se realiza con ayuda de la ecuación

f=1,029·D1-0,065·D2-0,245·D1

2+0,0018·D2

2+0,0215·D1

3


clase LocalizacionACS objeto pueblo variables vf[i] : resultado del factor f para el mes [i].

vEutilc[i] : resultado de la energía útil captada para el mes [i]. vfcarga[i] : resultado de la carga calorífica para el mes [i]. vD1[i] : resultado de la ganancia D1 para el mes [i]. vD2[i] : resultado de las pérdidas D2 para el mes [i].

método public void Calcula_fchart(){ Calcula_D1(); Calcula_D2(); for(int i=0;i<12;i++){ vf[i]=1.029*vD1[i]-0.065*vD2[i]-

0.245*Math.pow(vD1[i],2)+0.0018*Math.pow(vD2[i],2)+0.0215*Math.pow(vD1[i],3); //if(vf[i]>1){vf[i]=1;} vf[i]=vf[i]*100; ConTresDecimales(); vf[i]=Double.valueOf(formateador.format(vf[i]));}} public void Calcula_vEutilcaptada(){ Calcula_vfcarga();Calcula_fchart(); for(int i=0;i<12;i++){ vEutilc[i]=vfcarga[i]*vf[i]/100; ConTresDecimales();

vEutilc[i]=Double.valueOf(formateador.format(vEutilc[i]));}} 2.2.7.6.- Determinación de cobertura solar anual (CSA)

La relación entre la sumatoria de las coberturas solares mensuales (ΣQu) y la sumatoria de la

demanda de cargas caloríficas (ΣQa), determina la cobertura solar anual del colector, como se indica en la ecuación :

CSA=(ΣQu)/ (ΣQa)



118

clase LocalizacionACS objeto pueblo variables CSA : resultado de la cobertura solar anual.

sumaQu : resultado de la suma de la energía útil captada todos los meses del año. sumaQa : resultado de la suma de las cargas caloríficas de todos los meses del año.

método public void Calcula_CoberturaSA(){ Calcula_vfcarga();Calcula_vEutilcaptada(); double sumaQu=0;double sumaQa=0; for(int i=0;i<12;i++){ sumaQu=sumaQu+vEutilc[i]; sumaQa=sumaQa+vfcarga[i];} CSA=sumaQu/sumaQa; ConTresDecimales(); CSA=Double.valueOf(formateador.format(CSA));} public void Comprueba_K1_fchart(){ pruebak1=KgA/fSc;

ConTresDecimales();pruebak1=Double.valueOf(formateador.format(pruebak1)); } 2.2.7.7. Cálculo del volumen de acumulación ( V )

La dimensiones del depósito interacumulador deberán ser proporcionales al consumo

cubriendo la demanda de agua caliente sanitaria de cómo mínimo un día. En España la proporción de acumulación es de 50 – 100 litros por metro cuadrado de superficie colectora. El programa, por defecto, calcula un volumen de 70 litros por m2. Este valor se puede cambiar. El resultado se tomará como una orientación del valor que el usuario del programa tiene que introducir como dato del proyecto. El programa compara el dato del volumen introducido con el calculado y nos indica si cumple con la condición de diseño 0.8<=V/M<=1.2. Esta comprobación también se realizará cada vez que el usuario modifique el valor del volumen.


clase LocalizacionACS objeto pueblo variables VolAcuTeorico: resultado del volumen de acumulación, por defecto 70 litros por m2

de colector. VolAcuDiseño : dato del volumen de acumulación introducido por el proyectista. PruebaVolAcu : resultado del cociente del VolAcuTeorico entre el VolAcuDiseño

método public void Calcula_VolAcuTeorico(){ // VolAcuM2=70; Calcula_SCresultante(); VolAcuTeorico=SCresultante*VolAcuM2; ConTresDecimales();VolAcuTeorico=Double.valueOf(formateador.format(VolAcuTeorico)); } public void Calcula_PruebaVolAcu(){ Calcula_VolAcuTeorico(); PruebaVolAcu=VolAcuTeorico/VolAcuDiseño; ConTresDecimales(); PruebaVolAcu=Double.valueOf(formateador.format(PruebaVolAcu)); } public String getComprobacionVolAcu(){ Calcula_PruebaVolAcu(); String CVA; if(PruebaVolAcu<0.8){CVA="No cumple";}

else{if(PruebaVolAcu>1.2){CVA="No cumple";}else{CVA="Cumple";}} return CVA; }


119

El sistema interacumulador se utiliza para acumular agua caliente sanitaria en las horas de máxima radiación solar y esta agua será utilizada en los momentos de demanda. La producción de agua caliente sanitaria no suele coincidir con los momentos de consumo, de ahí la necesidad de acumularla.

Los resultados se pueden consultar en el panel "ACUMULADOR" y subpanelresultados2_10.


120

Documents

CAPÍTULO 2. APLICACIÓN JAVA - meteo.ieec.uned.esmeteo.ieec.uned.es/ · La ventana de diseño de NetBeans nos permite crear cada componente, colocarlo en la ventana y asignarle los