MCal AJava

APLICACIÓN JAVA
CAPÍTULO 2. APLICACIÓN JAVA
El objetivo de este proyecto es el diseño de una aplicación java que pueda servir como
herramienta para la estimación del número de colectores solares planos para producción de ACS.
Siguiendo el método de cálculo de CENSOLAR [1], calcula el número de colectores teórico para
cubrir la demanda energética anual en función de la radiación solar anual por m2, calculada para
una inclinación dada y en la provincia seleccionada. Con este resultado, el usuario decide el
número de colectores que quiere instalar y, en función de la superficie resultante, el programa
calcula la aportación solar anual y el déficit energético anual. Por otro lado, para los mismos
datos de consumo de ACS, el programa aplica el método F-chart y calcula la cobertura solar
anual con el mismo número de colectores decidido tras los resultados del método anterior.
El programa permite cambiar el valor de las variables que intervienen en los dos métodos y ver
de forma gráfica como influyen en el resultado. Hay variables que solo se emplean en uno de los
dos métodos, por eso, no se trata de comparar el resultado de los dos métodos de cálculo sino de
tener dos referencias a la hora de estimar la aportación solar de una instalación para la
producción de ACS, mediante colector solar plano, para unas condiciones de consumo y
localización dadas.
Para este proyecto hemos creado una aplicación JavaSE desarrollada con los programas
NetBeans IDE 7.2.1, iReport-5.1.0 para los informes de resultados, y conexión con base de datos
Access para almacenar resultados y realizar los informes. Para las gráficas de los informes utiliza
librerías de JFreeChart .
El presente capítulo se compone de las siguientes partes:
2.1. Memoria descriptiva

2.1.1. Programación
2.1.2. Diagramas de flujo
2.1.3. Acceso a la base de datos desde java
2.1.4. Informes
2.2. Memoria de cálculos
En "Memoria de cálculos" se exponen los cálculos principales que se realizan en el programa,

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

los informes que puede generar el programa y que podemos sacar por impresora. En el
documento Apéndice II "Códigos", se muestra todo el código java programado para cada una de
las clases creadas para este proyecto.
3
APLICACIÓN JAVA
4
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Programación
2.1. Memoria descriptiva
2.1.1. Programación
Para el desarrollo del proyecto se ha utilizado el entorno de desarrollo integrado (IDE) de

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

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

Orientado a objetos. La filosofía de programación orientada a objetos facilita la creación y
mantenimiento de programas.
Independiente de la arquitectura y portable. Al compilar un programa en Java, el código
resultante es un tipo de código binario conocido como Java Bytecode. Este código es
interpretado por diferentes computadoras de igual manera. Como el código compilado de
Java es interpretado, un programa compilado de Java puede ser utilizado por cualquier
computadora que tenga implementado el intérprete de Java.
Robusto. Java simplifica la gestión de la memoria.
Multitarea. Java puede ejecutar diferentes líneas de código al mismo tiempo.
Dinámico. En java no es necesario cargar completamente el programa en memoria, sino
que las clases compiladas pueden ser cargadas bajo demanda en tiempo de ejecución.
Para desarrollar aplicaciones Java es necesario un "Java Development Kit" o JDK. Existen
múltiples JDKs, desarrollados por compañías diferentes, o desarrollados como proyectos de
software libre. En nuestro caso hemos empleado el que distribuye de modo gratuito Sun
Microsystems, que se puede descargar desde http://java.sun.com. La implementación de Java de
Sun suele ser la más actualizada y, es software libre. No obstante se podría emplear cualquier
otro JDK ya que la portabilidad del lenguaje garantiza que todos funcionarán del mismo modo.
El JDK viene a ser el kit de desarrollo de Java, un conjunto de herramientas , utilidades,
documentación y ejemplos para desarrollar aplicaciones Java.
El entorno JDK no es el más adecuado para el desarrollo de aplicaciones Java, debido a que
funciona única y exclusivamente mediante comandos de consola. Hoy en día la programación se
suele ayudar de entornos visuales, como Netbeans, que facilitan enormemente la tarea. Netbeans
es un excelente entorno de desarrollo, completamente gratuito y se distribuyen bajo licencia
libre. Puede descargarse desde http://netbeans.org . Netbeans es un entorno de desarrollo
integrado (IDE) que permite editar programas en java, compilarlos, ejecutarlos, depurarlos,
5
construir rápidamente el interfaz gráfico de una aplicación eligiendo los componentes de una
paleta, etc. El IDE de NetBeans es gratuito, y de codigo abierto para desarrolladores de software.
Para este proyecto hemos utilizado:
NetBeans IDE 7.2.1

Java Development Kit Version Version 6 Update 20 from Sun Microsystems.
A continuación se explica de forma breve las características de Java que han sido más
utilizadas en la realización de la aplicación.
2.1.1.1. POO programación orientada a objetos
Un Objeto es un elemento que tiene una serie de características llamadas “propiedades”. Por
otro lado, al objeto se le pueden dar órdenes que cumplirá de inmediato. A dichas órdenes se les
denomina “métodos”.
Los métodos se pueden dividir básicamente en tres tipos:
Para cambiar las propiedades del objeto (Métodos set)

Para pedir información al objeto (Métodos get)
Para dar órdenes al objeto.
Todo objeto pertenece a una CLASE.
La CLASE nos permite declarar objetos y construirlos:
Declaración: CLASE nombreobjeto;

LocalizacionACS pueblo;
Construcción: nombreobjeto = new CLASE();

ejemplo: pueblo = new LocalizacionACS();
Declaración y Construcción en una misma línea:

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

objeto que se construye, aunque luego, estas características pueden ser cambiadas por el
programador.
Se pueden añadir a un proyecto Java clases programadas por uno mismo.
Al hacer esto, en el mismo proyecto podemos crear objetos de dichas clases y usarlos para
hacer el programa.
6
En general, un proyecto java está constituido por un grupo de clases, algunas de las cuales
serán de creación propia. En el programa usaremos objetos derivados de dichas clases.
2.1.1.2. Herencia
La Herencia consiste en crear una clase que obtenga todas las características de otra. Esta clase
a su vez tendrá también características propias.
La clase inicial se denomina clase Base y la clase nueva creada a partir de la clase base se
llama clase Derivada:
CLASE BASE
Herencia
CLASE DERIVADA
Se puede hacer que una clase de creación propia derive o herede de otra ya existente añadiendo
en la línea de creación de la clase: “extends NombreClaseBase”
public class Cuadro extends javax.swing.JFrame
La clase creada “cuadro” obtendrá características de la clase “Jframe” de la que hereda.

Aparte, esta clase tendrá métodos propios añadidos por el programador.
2.1.1.3. Bibliotecas y reutilización de código
En NetBeans podemos abrir varios proyectos y copiar los ficheros de clases de uno a otro. Si
un proyecto tiene muchas clases, interesa agruparlas en carpetas.
figura 1. ficheros de clases en la carpeta “paquete”
7
figura 2. ficheros de clases[3], en la carpeta “gráficos” que serán utilizadas

en la clase HistogramaACS, la cual está en “paquete”. Con la orden import
llamamos a los ficheros de clases que estén en otras carpetas.
Es interesante reunir las clases que más usemos en un solo proyecto de tipo biblioteca, para
poder acceder a ellas fácilmente. Una biblioteca se puede compactar en un solo fichero de tipo
.JAR . Al asociar un fichero de biblioteca .JAR a un proyecto, hacemos que en dicho proyecto se
puedan usar las clases contenidas en dicha biblioteca.
figura 3. ficheros de bibliotecas .jar empleadas en este proyecto.
Todas estas ideas hacen efectiva la reutilización de código, es decir, el aprovechar lo ya

programado, para no tener que volverlo a programar.
2.1.1.4. El bloque de control de errores, try{}catch(){}
La estructura try{} encierra entre las llaves el código que puede producir una excepción (un
error grave) que debe ser manejado por el bloque catch(Exception ex){}, en este caso solo
capturamos la excepción que puede surgir.
Ejemplo :
8
private void comboInclinacion_DDSActionPerformed(java.awt.event.ActionEvent evt) {

try { Cambia_Inclinacion("inicio");}
catch (Exception e) {JOptionPane.showMessageDialog(null, "Seleccione una inclinación"); }}
2.1.1.5. Variables globales
Las variables globales, también llamadas propiedades de la clase, son variables que pueden ser
usadas desde cualquier evento del programa. Estas variables mantienen su valor hasta que otro
evento lo modifique.
Las variables globales se declaran justo después de la línea public class.
La inicialización de estas variables se realiza en el constructor. Por ejemplo, creamos la

variable “pueblo” objeto de la clase “LocalizaciónACS” como variable global en la clase
“Cuadro”.
public class Cuadro extends javax.swing.JFrame {

LocalizacionACS pueblo;
String Nombre_Ciudad;
...
public Cuadro() {
initComponents();
...
pueblo = new LocalizacionACS();
...}}
2.1.1.6. Variables locales
Son las variables utilizadas para un procedimiento concreto cuyos valores solo sirven dentro de
dicho procedimiento. Se declaran e inician detro del evento donde intervienen.
Ejemplo:
private void btnSeleccionaTodosActionPerformed(java.awt.event.ActionEvent evt) {

int i;
for (i = 0; i < 12; i++) { if (chMeses[i].isSelected()) {
} else { chMeses[i].setSelected(true); } }}
2.1.1.7. Centralizar código
En java se pueden programar procedimientos que luego puedan ser llamados desde distintos
evento. Por ejemplo, para presentar los resultados con tres decimales programamos el siguiente
método:
9
public void ConTresDecimales() {

DecimalFormatSymbols simbolo = new DecimalFormatSymbols();
simbolo.setDecimalSeparator('.');
formateador = new DecimalFormat("#####.###", simbolo);
//variable formateador declarada como global }
Se puede llamar a un mismo procedimiento desde distintos eventos, evitando así la repetición
de código. Por ejemplo
double feo = Double.parseDouble(txtf_comprueba_bcol.getText()) + incremento;

ConTresDecimales();
feo = Double.valueOf(formateador.format(feo));
el resultado “feo” tendrá tres decimales sin tener que repetir todo el código anterior.
2.1.1.8. Eventos desde código.
La ventana de diseño de NetBeans nos permite crear cada componente, colocarlo en la ventana
y asignarle los eventos que necesitemos para programar en ellos las acciones que se tengan que
realizar. Sin embargo, si el diseño se ha realizado directamente desde código, será necesario
crear también desde código los distintos eventos a usar y asociarlos al componente
correspondiente.
Para programar eventos hay que tener en cuenta que un evento pertenece a un objeto “Oyente”
(Listener) o a un objeto “Adaptador” (Adapter)
El objeto oyente/adaptador hay que asociarlo al elemento sobre el que sucede el evento.
Los eventos usados son del tipo "Eventos de Acción":
ActionPerformed:Activar un componente (pulsación de botón, enter en un cuadro de texto)
Para programar desde código un evento es necesario conocer lo siguiente:
El nombre del evento / eventos del mismo grupo.

El oyente/adaptador al que pertenece el evento / eventos.
El método para asignar el oyente/adaptador al componente sobre el que actúa el evento.
El tipo de datos de objeto recibido como parámetro por el evento.
Conociendo estos datos, la programación siempre se hace igual:
Componente.MetodoParaAñadirOyente(new NombreOyenteAdaptador() {
public void nombreEvento1(TipoDatoParametro evt) {
LlamadaAProcedimientoEvento1(evt);}
public void nombreEvento2(TipoDatoParametro evt) {
LlamadaAProcedimientoEvento2(evt);}
});
10
Ejemplo:
v_txt_ocupacionn[i].addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
pasar_focoDmesActionPerformed(evt); } });
2.1.1.9. Aplicación Java
Para este proyecto hemos creado una Java SE aplication.
Para el diseño de la aplicación, Java proporciona dos paquetes gráficos: AWT y Swing. La
diferencia fundamental entre AWT y Swing es que Swing proporciona gran cantidad de controles
y componentes para el desarrollo de interfaces gráficas que enriquecen la interfaz del programa.
Es por ello que, en este proyecto se ha utilizado el paquete gráfico Swing. Swing proporciona,
también, muchas clases prefabricadas para facilitar el diseño gráfico. A continuación se explica
de forma breve las características que han sido más utilizadas en la realización de la interfaz :
JFrame: es el componente básico para implementar una interfaz visual con la librería Swing.
Se ha utlilizado para crear la clase “Cuadro” la cual hereda de la clase JFrame.
JTabbedPane: es un componente que permite al usuario cambiar entre un grupo de

componentes haciendo click sobre la pestaña correspondiente. Se ha utilizado para
seleccionar los paneles.
JTextField: es un elemento que permite la entrada de texto por parte del usuario. Se ha
utilizado para introducir los parámetros .
JPanel: es un objeto de los llamados "contenedores". Es así porque sirve para agrupar y
organizar otros elementos de la interfaz. De esta forma, actúa como una caja donde se van
metiendo elementos de la interfaz para poder manejarlos como una agrupación. Es una clase
fundamental que se ha utilizado para dar un diseño atractivo e intuitivo.
JLabel: es una etiqueta de texto. En este proyecto se ha utilizado para informar al usuario a
qué variable corresponden cada uno de los JTextFields y también para mostrar resultados y
gráficos.
JButton: se trata de un elemento que actúa como un pulsador al que se le pueden asignar
acciones una vez pulsado. Se ha utilizado para numerosos controles en la aplicación.
JComboBox: es un componente que permite seleccionar entre una serie de valores

previamente definidos. Se ha utilizado, por ejemplo, para seleccionar la inclinación entre los
distintos valores disponibles en el programa.
JRadioButton: es un elemento que puede ser seleccionado o no. Se ha utilizado en opciones

de cálculos y para seleccionar datos por defecto.
11
JCheckBox: es un elemento que puede ser seleccionado o no. Actúa como un botón de estado
en el que la información que recogemos es, si está seleccionado, cierta, y en caso contrario,
falsa. Se ha utilizado en opciones de cálculos .
JDialog: Los Cuadros de Diálogo son ventanas simplificadas que muestran distintas opciones
al usuario. Los objetos JDialog son los que permiten la creación y uso de cuadros de diálogo
en un proyecto java. Existen dos tipos de cuadros de diálogo: los modales y no modales. Los
cuadros de diálogo modales no permiten que se active otra ventana hasta que el cuadro de
diálogo no se haya cerrado. Los cuadros de diálogo no modales permiten trabajar con otra
ventana a pesar de que el propio cuadro de diálogo no haya sido cerrado.
JRadioButton JComboBox JDialog
JLabel
JTextField
JPanel
JButton
JCheckBox
figura 4. elementos más usados en la aplicación
2.1.1.10. Instalación de la aplicación Java
Una vez que se ha finalizado el programa, en Netbeans, debemos prepararlo para la instalación
en cualquier otro ordenador. Para ello, es necesario tener en cuenta todos aquellos ficheros
externos cuyos contenidos intervienen en la aplicación: base de datos, imágenes, informes, etc...
Procedemos de la siguiente manera:
12
En Netbeans, ejecutamos la orden Limpiar y construir proyecto principal. Esta orden

compila el programa y crea una carpeta llamada dist dentro de la carpeta del proyecto, la cual
será la carpeta “distribuible”.
Dentro de la carpeta dist se crea un fichero con extensión .jar. Este fichero se puede decir que
es el “ejecutable” del programa. El fichero .jar contiene todas las clases que hemos
programado en el proyecto. En nuestro caso se ha generado el fichero
Simulacion_ACS_1_1.jar
Los programas java pueden ejecutarse en cualquier entorno, pero para que un ejecutable .jar
pueda ser ejecutado en un determinado sistema, debe estar instalado en él la máquina virtual
de java.
Además del fichero ejecutable (.jar) con el nombre del proyecto, se crea también una carpeta
lib. Esta carpeta contiene las librerías adicionales que se hayan incluido en el proyecto.
figura 5. librerías adicionales incluidas en el proyecto.
Bases de datos. Es necesario copiar el archivo base de datos en la carpeta dist. En nuestro
caso hemos creado la carpeta “Base” para la base de datos, entonces copiamos la carpeta
“Base” en la carpeta distribuible.
Imágenes (para la presentación, los iconos de los botones de las barras de herramientas, etc.)
, también tenemos que introducir los ficheros de estas imágenes dentro de la carpeta
distribuible.
Informes. Es necesario que los ficheros de estos estén dentro de la carpeta del distribuible.
Los ficheros de informes necesarios para el funcionamiento del programa son los ficheros
compilados .jasper. Estos ficheros están dentro de una carpeta llamada “informesireport” ,
así que copiamos la carpeta con los informes dentro de la carpeta del distribuible.
Imágenes de informes. Como los informes del programa usan imágenes, la situación de estas
en la carpeta distribuible depende de la forma en que haya configurado dichas imágenes en el
iReport. Para este proyecto las imágenes se guardan en la capeta “Gráficas” que también
copiamos en la carpeta dist.
Una vez incluidos todos estos elementos ya tenemos la carpeta distribuible completada.
Para la instalación de la aplicación en otro ordenador, solo hay que copiar en una misma
carpeta todos los elementos que intervienen, es decir:
Archivo ejecutable "Simulacion_ACS_1_1.jar"

carpeta "lib"
13
capeta "Base"
carpeta "Graficas"
carpeta "informesireport"
El ordenador de destino tiene que tener instalada la máquina virtual de java, propia del sistema
operativo que utilice, para que el proyecto pueda ejecutarse.
2.1.1.11. Componente de la aplicación.
A continuación presentamos cada uno de los componentes de la clase principal "Cuadro.java"

de la aplicación Java desarrollada para este proyecto.
figura 6. Componentes de la aplicación. Ventana de diseño NetBeans
14
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);}
15
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();}
16
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);}
17
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
18
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();}
19
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);} }}
20
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) {
}//Nuevo_Datos_DelSitio();
if (pueblo.vH[1] == 0) {
}// Nuevo_Datos_Mensuales();
Aceptar_DatosdeEntrada();
Calculo_mensual_porcuadro();
Vaciar_resultados_porcuadro();
Vaciar_subpaneldatosyresultados();
Paneles.setSelectedComponent(panel_resultados);
}
figura 12. resultados del botón btnCalcula_porcuadros
21
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);
}
22
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(); }
23
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(); }
24
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();}
25
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();
}
26
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(); }
27
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
28
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.
evento: private void btn_datos_fEaActionPerformed(java.awt.event.ActionEvent evt) {
dialogo_fEa.setSize(400, 400);
dialogo_fEa.setVisible(true);
Vacia_Eabsorbida_fchart();}
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.
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();}
29
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.
evento: private void btn_datos_fEpActionPerformed(java.awt.event.ActionEvent evt) {
dialogo_fEp.setSize(400, 400);
dialogo_fEp.setVisible(true);
Vacia_Eperdida_fchart();}
30
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.
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
31
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
32
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) {
Almacena_simulacion_sinverlo();}
33
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);
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
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
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
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);
//nuevo
Ver_Datos_y_Resultados();//actualiza rendimiento del panel datos y resultados
34
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
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);
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();
C1.8.3. panelf_MasMenos [JPanel]
figura 29. panelf_MasMenos
35
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.
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
36
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.
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
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º.
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);
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.
evento: private void btnf_Cancelar_MmActionPerformed(java.awt.event.ActionEvent evt) {
Cancela_Cambios_Mn(); // Cancela_cambios_fchart();
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); }
37
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); }
38
Componente 1.9. panel_GRAF2 [JPanel] . “Gráficas demanda-aportación”
figura 31. panel_GRAF2
Evento:
private void panel_GRAF2MouseReleased(java.awt.event.MouseEvent evt) {
GraficayDibuja_DemandaAporatacion_Masmenos(); }
C1.9.1. panhistoDemandaAportacion [JPanel]
figura 32. gráficas demanda-aportación
Compara la demanda de energía para calentar el agua cada mes calculado (barras de de color
amarillo) con la aportación solar de los paneles disponibles cada mes (barras de color rojo).
39
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.
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) {
GraficayDibuja_DemandaAporatacion_Masmenos();
Cambia_NumeroPaneles_fchart(1);//ventana resultados
Calculo_resultadosNC_porcuadro();
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();
40
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.
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%
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.
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
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.
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
41
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º.
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);
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.
evento: private void btnDA_Cancelar_MmActionPerformed(java.awt.event.ActionEvent evt) {
Cancela_Cambios_Mn(); // Cancela_cambios_DA();
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); }
42
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();
Componente 1.10. panel_proyectos [JPanel]. “Proyectos guardados”
figura 36. panel_proyectos
Muestra datos y resultados de los proyectos calculados durante una sesión. Al comenzar una
nueva sesión no habrá ningún dato en este panel.
43
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
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(); }
44
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
45
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) {
46
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
47
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
48
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
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);
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
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);
49
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.
50
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());
etiresultadosAportacionAnual2.setText("" + pueblo.getaportacionAnual());
etiresultadosDeficitAnual2.setText("" + pueblo.getdeficitEnergeticoAnual());
etiresultadosCEanual2.setText("" + pueblo.getCosteEanual());
etiresultadosCAuxanual2.setText("" + pueblo.getCosteAuxAnual());
etiresultadosAhorroanual2.setText("" + pueblo.getAhorroAnual());
etiresultadosCSA2.setText("" + pueblo.getCoberturaSA());
etiresultadosSCresultante2.setText("" + pueblo.getSCresultante());
etiresultadosVolumen2.setText("" + pueblo.VolAcuDiseño);
etiresultadosbcol2.setText("" + pueblo.getbcol());
etiresultadosmcol2.setText("" + pueblo.getmcol());
etiresultadosFCCI2.setText("" + pueblo.getFCCI());
Prueba_Resultados();
} catch (Exception ex) { } }
51
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
"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
"Superficie resultante m2": superficie calculada con el número de paneles que asignemos al
proyecto. Este valor es el que se emplea en los cáculos.
"Volumen acumulador": volumen en litros del acumulador que asignemos al proyecto. Este
valor es el que se emplea en los cálculos.
"b": factor de eficiencia óptica de los colectores.
"m": coeficiente de pérdidas de los colectores.
"FCCI": factor del intercambiador.
Condiciones de diseño. Cada botón(?) [JButton] nos muestra cada condición.
52
• "V/M": volumen del acumulador respecto al volumen recomendado (por defecto 70 l/m2
de panel.)
• "C/A": litros diarios respecto a la superficie total (m2) de paneles.
• "M/A": volumen del acumulador del proyecto respecto a la superficie total (m2) de
paneles.
figura 47. subpanelesresultados2_10
Componentes 3. Other Components
figura 48. Elementos del grupo Other Components del Form cuadro
C3.1. dialogodatos_nuevoproyecto [JDialog]
Se abre con el botón “Nuevo proyecto” de panel “Inicio” (figura 7). A partir de aquí podemos
seguir presionando “Aceptar” o “Calcula todo” (figura 8).
“Aceptar” cierra esta ventana y abre dialogo_datosdelsitio [JDialog] (figura 9).
“Calcular todo” realiza todos los cálculos de una sola vez y con los datos por defecto de la
provincia seleccionada y los valores que nos pide del número de colectores y volumen del
acumulador (figura 49).
figura 49. Datos necesarios para “Calcular todo"
C3.2. dialogo_datosdelsitio [JDialog]
Se abre con el botón “Aceptar” de la ventana dialogodatos_nuevoproyecto (figura 8). Después

de introducir los datos seguimos con el botón “Continuar” (figura 9) que cerrará esta ventana y
abrirá el dialogo_datosmensuales [JDialog] (figura 10).
53
C3.3. dialogo_datosmensuales [JDialog]
Se abre después de aceptar los datos de la ventana dialogo_datosdelsitio[JDialog].
Después de introducir los datos seguimos con el botón “Continuar” (figura 10) que cerrará esta
ventana y nos lleva al panel_calculos [JPanel] (figura 11).
C3.4. dialogo_fQa [JDialog]
Se abre con el botón “Datos” del panel_fQa [JPanel] (figura 19)
C3.5. dialogo_fEa [JDialog]
Se abre con el botón “Datos” del panel_fEa [JPanel] (figura 21)
C3.6. dialogo_fEp [JDialog]
Se abre con el botón “Datos” del panel_fEp [JPanel] (figura 23)
C3.7. dialogo_graf_RenAportSus_JFC [JDialog]
Se abre con el botón “Ver gráficas RenAporSus” del panel_JFreeChart [JPanel] (figura 36)
C3.8. dialogo_graf_DemApor_JFC [JDialog]
Se abre con el botón “Ver gráficas DA” del panel_JFreeChart [JPanel] (figura 37)
C3.9. dialogo_graf_fchart_JFC [JDialog]
Se abre con el botón “Ver gráfica f-chart” del panel_JFreeChart [JPanel] (figura 38)
54
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); } }
55
figura 47. archivos de imagen guardados en la carpeta “Graficas” del programa.
C3.11. dialogo_graf_variaciones_JFC [JDialog]
Se abre con el botón “ver gráficas variaciones” del panel_JFreeChart [JPanel] (figura 39)
C3.12. dialogo_graf_InformeGeneral [JDialog]
Se abre con el botón “ver gráfica informe general “ del panel_JFreeChart [JPanel] (figuras 39)
Muestra la imagen que aparecerá en el “informe general”.
C3.13. BD_Resultados [JDialog]
Se abre con los botones “Guardar” y “Ver resultados” y con el botón “Resultados” del panel
“INICIO”.
figura 48. BD_Resultados [JDialog]
56
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.
57
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);
ventanavisor.setTitle("INFORME GENERAL");
}
//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);
58
JasperViewer ventanavisor1=new JasperViewer(informe1,false);
ventanavisor1.setTitle("INFORME GENERAL gráfica demanda");
ventanavisor1.setVisible(true);
ventanavisor2.setTitle("INFORME GENERAL gráfica MJm2anual");
ventanavisor3.setTitle("INFORME GENERAL gráfica aportación");
ventanavisor4.setTitle("INFORME GENERAL gráfica CSA");
ventanavisor4.setVisible(true);}
}
}
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
//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);
ventanavisor.setTitle("INFORME GRAFICO Instalación solar térmica para ACS en
"+r.getString("provincia"));
ventanavisor.setVisible(true);
}catch(Exception e){JOptionPane.showMessageDialog(null,"Error en el informe"+" "+ e);}}
59
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);
ventanavisor.setTitle("INFORME DE PROVINCIA");
}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(); }
60
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(); }
61
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
Variaciones, almacenados en la base de datos del programa, y el archivo .jasper
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.setVisible(true);
if(info==1){DibujayGuarda_Grafica_Variaciones("consumo");
Info_Variable("consumo","INFORME VARIACIONES CON EL CONSUMO DE ACS");}
if(info==2){DibujayGuarda_Grafica_Variaciones("tempACS");
Info_Variable("tempACS","INFORME VARIACIONES CON LA TEMPERATURA DEL
ACS");}
if(info==3){DibujayGuarda_Grafica_Variaciones("inclinacion");
Info_Variable("inclinacion","INFORME VARIACIONES CON LA INCLINACIÓN DE
LOS PANELES");}
if(info==4){DibujayGuarda_Grafica_Variaciones("acumulacion");
Info_Variable("acumulacion","INFORME VARIACIONES CON EL VOLUMEN DEL
ACUMULADOR");}
if(info==5){DibujayGuarda_Grafica_Variaciones("superficie");
Info_Variable("superficie","INFORME VARIACIONES CON LA SUPERFICIE DE
CAPTADORES");}
if(info==6){DibujayGuarda_Grafica_Variaciones("b");
Info_Variable("b","INFORME VARIACIONES CON EL FACTOR DE EFICIENCIA
ÓPTICA (b)");}
if(info==7){DibujayGuarda_Grafica_Variaciones("m");
Info_Variable("m","INFORME VARIACIONES CON EL m DE LOS COLECTORES");}
if(info==8){DibujayGuarda_Grafica_Variaciones("FCCI");
Info_Variable("FCCI","INFORME VARIACIONES CON EL FCCI factor
intercambiador");}
if(info==9){DibujayGuarda_Grafica_Variaciones("MAI");
Info_Variable("MAI","INFORME MAI ángulo de incidencia");}
dialogo_graf_variaciones_JFC.dispose();} }
62
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(); }
63
C3.15.3. "Informe mensual"
componente: btnInformemensual [JButton]

mensual, almacenados en la base de datos del programa, y el archivo .jasper
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.
cerrar
figura 52. Salir y cerrar la conexión con la base de datos.
64
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Diagramas de flujo
2.1.2. Diagramas de flujo

INICIO
Nuevo proyecto
Diálogo nuevo proyecto
Cancelar provincia
Nº colectores
Aceptar Calcula todo
Volumen acumulador
Diálogo datos generales Inclinación :

Desviación N-S (β):
Corrección de H:
Volver Pérdidas globales:
por defecto
Nº de usuarios:
Datos del Litros/día·usuario:
Área de colector:
sitio Parámetros b y m :
Corrección de b:
Temperatura de uso:
Precio del kw·h : €
Continuar Cancelar
Diálogo datos mensuales
Volver
Datos Ocupación %mes
por defecto
Temperatura de red
mensuales Radiacción H
Factor k (inclinación)
Horas sol
Temperatura ambiente
Continuar Cancelar
CÁLCULOS
65
...Calcula
Datos del
CÁLCULOS todo
sitio
Seleccionar meses
Modificar
datos Seleccionar todos
Rendimiento
Cancelar Calcular
Inicio
mes
b, m inclinación Temperatura
Consultar
+ - + - + -
Resultados mensuales:
Consumo ACS m3
Salto térmico Imprimir
Demanda termias
Demanda MJ
H corregida Demanda MJ/mes
Energía neta incidente RESULTADOS Energía neta disponible MJ/m2
Intensidad incidente
Energía neta disponible MJ/m2
Rendimiento colector Demanda anual: MJ
Aportación solar por m2 Energía/año·m2 : MJ
Calcular Superficie colectora teórica: m2
Número de colectores teórico:
Nº de colectores a instalar
Resultados mensuales: Resultados anuales:
Superficie Demanda MJ Demanda anual: MJ
colectora Calcular superficie resultante Energía neta disponible MJ/m2 Energía/año·m2 : MJ
resultante (A) Sustitución % Aportación solar: %
Déficit de energía Déficit energético: MJ
Coste eléctrico de la demanda Ahorro anual : €
Resultados Coste eléctrico del déficit Coste energía auxiliar: €
Ahorro
F-Chart
DATOS& Gráficas ACUMULADOR
RESULTADOS GRÁFICAS demanda-aportación
Rendimiento mes Acumulación por m2
Aportación solar relativa Demanda MJ/mes
Sustitución mes Energía neta total MJ/mes
V Calcular
Modificar Consultar
datos Volumen
M + -
proyectado
Datos y Resultados mes: Horas sol
Ocupación %mes Intensidad incidente
Temperatura de red Temperatura ambiente Comprobar
H corregida Rendimiento colector
Factor k (inclinación) Consumo ACS m3
volumen
Energía neta incidente 0.8 < V/M <1.2
66
Gráficas
demanda-aportación Localización
Provincia
Temp ACS
Consumo ACS
Demanda MJ
Superf m2
Paneles
b
variaciones Base de datos m
FCCI*
de resultados MAI*
inclinación
acumulación
Nº de Inicio MJ/m2 año
colectores Aportación año
Guardar Ver CSA
Selaccionar mes
Cancelar resultadosV/M
M/A
+ - todos C/A
60< C/A <100 Guardar resultado Resultados
actual anteriores
Ocupación Litros/día·ud Temperatura Inclinación
+ - + - + - + -
no ¿guardar? sí Tabla resultadosACS Tabla variacionesFchartAnual*
Diálogo BD_Resultados
eliminar
Cerrar
Eliminar todo Eliminar Eliminar Informes

filas entre
Informe por Informe Informe Informe

provincias general gráfico por paneles
Temperatura ACS Provincia
provincia Consumo m3/año Temperatura ACS panel
b,m, inclinación Consumo m3/año Diálogo
superficie total Demanda MJ
Temperatura ACS acumulador superficie total Imagen BD_variacion_anual
Consumo m3/año b,m, inclinación JPanel
Demanda MJ/año DATOS: acumulador
Provincia (todas) MJ/m2 año
Demanda MJ Aportación
MJ/m2 año CSA
Aportación Gráficas de :
CSA Rendimiento
Ap.solar realtiva
Sustitución
Demanda-Aport
CSA f-chart
67
Diálogo
BD_variacion_anual
eliminar
Cerrar
Eliminar todo
provincia
mes
Eliminar Informes Resultados ocupación
mensuales Consumo ACS
Eliminar Temp red
filas entre variable Temp ambiente
Temp ACS
tabla_mensual inclinación
Consumo ACS provincia horas sol
Temp ACS Demanda MJ Informes
rendimiento
Acumulador MJ/m2 año Demanda MJ
superficie Aportación Aportación MJ
inclinación CSA Diálogo Sustitución
b V/M BD_tablamensual Qa
m M/A Ea
FCCI C/A Ep
MAI f
eliminar
Eliminar grupo Informe mensual Cerrar

Consumo ACS provincia
Acumulador mes
superficie ocupación
b Consumo ACS
m Temp red
FCCI Temp ambiente
MAI Temp ACS
Demanda MJ inclinación
MJ/m2 año horas sol
Aportación rendimiento
CSA Demanda MJ
V/M Aportación MJ
M/A Sustitución
C/A Qa
Ea
Ep
f-chart
68
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
F-Chart Ep = Sc*F’r*UL*(100-ta)*Dt*k1*k2
D1= Ea/Qa D2 = Ep/Qa
Qu = f*Qa
...Calcula
Cargas Energía Energía todo
caloríficas absorbida perdida
por defecto
Datos Calor específico

Nº usuarios: FCCI
b Datos m
kg acumulad(M)
Datos
Litros/día·ud MAI Temp mínima
Diálogo fQa Temp ACS Temp ACS Diálogo fEa del ACS Diálogo fEp
Temp red Nº colectores
aceptar aceptar Factor F’rUL aceptar

Factor k1
Superficie resultante (A) Factor k2
Radiación incidente/m2 Dt (segundos)
Calcula Qa Energía solar absorbida Calcula Ea Energía perdida mensual Calcula Ep
Consumo de ACS litros/día

Carga calorífica mensual (Qa) D1 f
D2 Qu
Calcular f CSA
Tabla variacionesFchartAnual
no ¿guardar? sí
Tabla resultadosACS
69
Localización FCCI*
Provincia MAI*
Temp ACS inclinación
Consumo ACS acumulación (M)
Demanda MJ MJ/m2 año
Superf m2 (A) Aportación año
Paneles CSA
b V/M
m M/A
Gráficas f-chart C/A
variaciones Base de datos

de resultados
Nº de kg de b m FCCI
colectores acumulación
Guardar Ver
resultados
+ - + - + - + - + -
Guardar resultado Resultados
actual anteriores
Comprobar Inicio
37.5< M/A<300 Cancelar
Selaccionar mes
todos
Ocupación Litros/día·ud Temperatura Inclinación
+ - + - + - + -
Tabla variacionesFchartAnual*
no ¿guardar? sí
Tabla resultadosACS
Diálogo BD_Resultados
70
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 Carpeta dialogo_graf_

BD_VariacionAnual “gráficas”
RenAporSus_JFC DemApor_JFC fchart_JFC paneles_JFC variaciones_JFC InformeGeneral_JFC
Diálogo
BD_tablamensual
paneles variable
Dibuja panel Dibuja gráfica
Datos Consumo m3/año

Resultados Consumo litros/dia
Datos y resultados Temperatura ACS
Acumulador Superficie m2
Cálculo f-chart Inclinación
Variaciones f-chart Acumulador litros
Demanda-Aportación b
m
FCCI
MAI
71
72
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Acceso a base de datos
2.1.3. Acceso a Base de Datos desde nuestra aplicación Java.
Para que nuestro programa Java pueda usar la base de datos ha sido necesario realizar los
siguientes pasos:
paso1. Colocar el fichero de base de datos en una subcarpeta de la carpeta del proyecto java.
Para nuestra aplicación hemos creado el fichero “baseResultadosACS.mdb” dode se

almacenará toda la información que necesitemos gestionar para crear los “informes”. Es decir,
hemos creado un fichero de base de datos. Este fichero se incluirá dentro del programa java en la
carpeta “Base”. Nuestro programa java accederá a este fichero continuamente para añadir nuevos
datos, eliminar datos, o extraer datos según lo ordene el usuario del programa.
paso2. Crear los objetos conexión (Connection) y sentencia (Statement)
Primero definimos estos objetos como globales en la clase “Cuadro”, para así poderlos usar
desde cualquier lado. Además será necesario indicar el import para las clases Connection y
Statement. Estos import son respectivamente: java.sql.Connection y java.sql.Statement
paso3. Método: controlador, conexión y sentencia.
Una vez definidos los objetos conexión y sentencia, para que nuestro programa pueda acceder
a la base de datos “baseResultadosACS” creamos el método “PrepararBaseDatos” al que
llamaremos desde el constructor.
paso3.1. Cargar el controlador del tipo de base de datos a usar
El controlador define el tipo de base de datos que se va a usar (base de datos de Access, o de
MySQL, o de cualquier otro gestor de base de datos)
En nuestro caso, tendremos que indicar el controlador para base de datos de Access.
String controlador = "sun.jdbc.odbc.JdbcOdbcDriver";
paso3.2. Crear el objeto conexión indicando el fichero de la base de datos.
Para crear la conexión es necesario añadir (import) la clase DriverManager.
El objeto “conexion” es el que efectúa la conexión real con la base de datos. Para construir este
objeto hacen falta tres datos:
El nombre del usuario que manipulará la base de datos. En el caso de Access no necesitamos
indicar ningún nombre de usuario.
73
El password del usuario que manipulará la base de datos. En el caso de Access tampoco
necesitaremos ningún password.
La DSN de la base de datos. DSN significa “nombre del origen de datos” y es una cadena de
texto que contiene información sobre el fichero de base de datos que queremos usar. En el
código, la creación de la DSN será:
String DSN = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ="+ "Base\\resultadosACS.mdb ";
Con estos datos creamos el objeto "conexion" con la instrucción :
conexion=DriverManager.getConnection(DSN,user,password);
paso3.3. Crear el objeto sentencia a partir del objeto conexión
El objeto “sentencia” será el que nos permita ejecutar órdenes SQL sobre la base de datos. Es
decir, el objeto que nos permite actuar y manipular la base de datos.
El objeto sentencia se crea a partir del objeto conexión creado en el paso anterior, usando la
siguiente instrucción:
sentencia=conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
Se usará el objeto “sentencia” para ejecutar consultas SQL en la base de datos. Dichas
consultas se almacenan en objetos del tipo “ResultSet” los cuales permiten seleccionar el registro
de una tabla de la base de datos y extraer el datos de un campo en concreto.
paso4. Finalmente debemos programar el evento “windowClosing” de la ventana principal de

forma que se cierre la conexión al salir del programa.
Esta preparación se debe realizar en el momento en que se ejecuta el programa, por lo cual
hemos introducido este código en el constructor. A continuación mostramos la parte del código,
de nuestra aplicación java, donde aparecen los elementos descritos para acceder a la base de
datos que se utiliza en dicha aplicación.
*
* @author Eduardo
*/
...
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
...
public class Cuadro extends javax.swing.JFrame {
...
74
//varibles globales para acceso a Base de datos access

Connection conexion;
Statement sentencia;
DefaultTableModel mt,mtv,mtmes;
...
public Cuadro() {
initComponents();
PrepararBaseDatos();// llamada al método
PrepararTablaResultados();
PrepararTablaVariacion_anual();
PrepararTabla_mensual();
...}}...
//Método para acceso a base de datos
//1.-creamos carpeta Base con el archivo Access baseResultadosACS.mdb
//2.-Variables globales para la conexión y sentencia
//3.-Cargar controlador, crear objetos conexión y sentencia "PrepararBaseDatos()","Cerrar_la_conexion()"
//4.-JTable "tablaResultadosACS" donde visualizar los datos,"PrepararTablaResultados()"
//5.-Método para guardar los resultados "GuardarResultadosACS()"
public void PrepararBaseDatos(){

try {//1.-Cargar el controlador de Access=sun.jdbc.odbcOdbcDriver, segun el tipo de basedeDatos
//en MySQL se usa la cadena: com.mysql.jdbc.Driver
String controlador = "sun.jdbc.odbc.JdbcOdbcDriver";
Class.forName(controlador).newInstance();//para activar el controlador
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error en la carga del controlador --"+e);
}
//2.-Creamos el objeto conexion conection
try {
//String DNS="jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ="+"carpeta en este
proyecto\\nombreArchivo.MDB";
String DNS = "jdbc:odbc:Driver={Microsoft Access Driver(*.mdb)};
DBQ="+"Base\\baseResultadosACS.mdb";
String user = "";

String password = "";
conexion = DriverManager.getConnection(DNS,user,password);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error en la conexión "+e);
}
//3.-Creamos el objeto sentencia
try{
sentencia=(Statement) conexion.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY
);}
catch(Exception e){JOptionPane.showMessageDialog(null,"Error en la sentencia "+e);
Cerrar_la_conexion();}
}
void Cerrar_la_conexion(){//cuando cerremos la ventana

try{conexion.close();}
catch(Exception e){JOptionPane.showMessageDialog(null,"No se pudo cerrar la conexión "+e);}
}
75
2.1.3.2. Métodos para guardar datos y resultados en nuestra base de datos
public void GuardarResultadosACS(int loveo){... }

public void GuardarVariacionAnual(int loveo){...}
public void Almacena_simulacion_sinverlo(){...}
public void guardar_variacionesycomprobaciones(){...}
public void GuardarTablamensual(){...}
public void PonerFila_enBlanco(){...}
public void PonerFilaVariaciones_enBlanco(){...}
2.1.3.3. Métodos para borrar datos de una tabla de nuestra base de datos
public void EliminaFila(){...}

public void EliminaFilaVariaciones(){...}
public void EliminaFilasTablamensual(){...}
public void EliminaFilaVariaciones_todas(){...}
public void EliminaFilaResultados_todas(){...}
public void EliminaFilaVariaciones_selecionadas(){...}
public void EliminaFilaResultados_selecionadas(){...}
public void Eliminar_fila_enBlanco(String tabla){...}
2.1.3.4. Representación de tablas de la base de datos en un JTable
El objeto JTable nos permite introducir tablas en nuestras aplicaciones.En estos objetos
podemos mostrar el contenido de una tabla de la base de datos o del resultado de una consulta.
Para extraer datos de la base de datos realizamos una consulta SQL de tipo SELECT cuyo
resultado se almacena en un objeto ResultSet. Un ResultSet básicamente es una tabla
almacenada en memoria (y por tanto no visible). Podemos trasladar el contenido de un ResultSet
a un JTable para que el usuario lo pueda visualizar dentro de nuestra aplicación java.
Agregamos, como variables globales al proyecto, los objetos “modelo de tabla”

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

public void PrepararTablaVariacion_anual(){... }
public void PrepararTabla_mensual(){... }
El proceso básicamente el siguiente:
Base de Datos ResultSet Vector Modelo de Tabla JTable
De la base de datos extraemos datos a un ResultSet. (Esto se hace ejecutando una consulta
SQL de tipo SELECT a través del objeto sentencia)
Del ResultSet extraemos los datos a un modelo de tabla. (Esto se hace recorriendo el
ResultSet y almacenando cada registro en un vector)
76
Almacenamiento del vector en el modelo de tabla. (Cada vector extraido del ResultSet se
inserta como fila en el modelo de tabla)
Se asigna el modelo de tabla al objeto JTable. (Al hacer esto el objeto JTable muestra el
contenido del modelo)
Los métodos creados son:
public void VerResultados_enJTable(int loveo){... }

public void VervariacionesFchartAnual_enJTable(int loveo){...}
public void VerTablamensual_enJTable(int loveo){...}
77
78
APLICACIÓN JAVA. MEMORIA DESCRIPTIVA. Informes
2.1.4. Informes
Una vez creado el programa, surgió la necesidad de imprimir documentos tales como listados
de datos y resultados, gráficos, etc. Estos documentos se rellenan con datos tomados
directamente desde la base de datos de nuestro programa. A estos documentos los llamaremos
“informes”. Para crear estos documentos necesitamos usar un programa de creación de
informes. En nuestro caso, hemos usado un programa gratuito llamado Ireport que hemos
descargado de la página http://www.jasperforge.org/sf/projects/ireport. Este programa permite
definir la estructura general del informe (sin tener en cuenta los datos).
Es necesario indicar la conexión a la base de datos y la consulta SQL para extraer los datos que
aparecerán en el informe.
Una vez creado el informe, este se enlaza con nuestra aplicación, de forma que cuando el
usuario pulse la opción de imprimir, el informe se rellene con los datos de la base de datos y
luego sea enviado a la impresora.
2.1.4.1. Conexión con Informes desde Java
Cuando creamos un informe con iReport, se genera un fichero del tipo .jasper. Los ficheros
.jasper son informes compilados, de forma que puedan ser usados en aplicaciones java.
Para que nuestro programa sea capaz de presentar informes, hemos creado una carpeta llamada
“informesireport” dentro de la carpeta de nuestro programa. Y dentro de dicha carpeta hemos
copiado los ficheros .jasper de los informes que queremos utilizar.
En nuestra aplicación, el informe aparece en una ventana (el visor de informes, objeto
JasperViewer) que tiene una pequeña barra de herramientas. En esta barra podrá imprimir el
informe o cambiar su zoom, entre otras opciones.
Los ficheros que contienen las librerías necesarias para el programa iReport son los siguientes:
commons-collections-2.1, commons-logging-1.0.2 y jasperreports-2.0.1. Gracias a la inclusión
de estos ficheros, nuestro proyecto ya dispone de las librerías de clases que contienen a las clases
que necesitamos ( JasperPrint, JasperFillManager, JasperViewer). Una vez agregadas estas
librerías, el proceso para imprimir un informe es el siguiente:
Crear un objeto del tipo JasperPrint (el informe)
Crear un objeto visor (JasperViewer) que permita visualizar el informe o bien imprimir
directamente el informe con un objeto JasperPrintManager.
Cuando un informe tiene una instrucción SQL fija, siempre mostrará los mismos datos. En
otros casos parte de la instrucción SQL del informe puede variar, de forma que extrae distinta
información según el dato que varía. Estos datos variantes se denominan parámetros. El
parámetro debe ser sustituido por un valor que es proporcionado desde la aplicación java, y es
entonces cuando la instrucción SQL se completa y se ejecuta. En la aplicación java es necesario
79
crear un objeto de tipo Map que contenga los distintos parámetros con los valores de cada uno
para luego enviar este objeto al informe que se quiere mostrar.
2.1.4.2. Informes en nuestro programa.
Informe 1. Informe por paneles

Informe 2. Informe mensual
Informe 3. Informe gráfico
Informe 4. Informe por variables
Informe 5. Informe general
Para los informes se emplean los datos alamacenados en las tablas del archivo
“baseResultadosACS.mdb” de la carpeta “Base” del programa y los archivos .jasper de la carpeta
“informesireport” del programa. Dichas tablas son:
resultadosACS
variacionesFchartAnual
tabla_mensual
A continuación describiremos brevemente los principales informes que se pueden generar con
el programa.
80
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
81
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
82
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)

Archivo .jasper Informe grafico.jasper
evento private void btnInformegraficoActionPerformed(java.awt.event.ActionEvent evt) {...}
figura 55.- Informe gráfico
83
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.setVisible(true);
if(info==1){DibujayGuarda_Grafica_Variaciones("consumo");
Info_Variable("consumo","INFORME VARIACIONES CON EL CONSUMO DE
ACS");}
...
dialogo_graf_variaciones_JFC.dispose();}
}
figura 56.- Informe variaciones con el consumo de ACS.
84
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)

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) {...}
85
figura 57.- página 1 de INFORME GENERAL
figura 58.- INFORME GENERAL gráfica demanda y MJm2anual
86
figura 59.- INFORME GENERAL gráfica aportación y CSA
87
88
APLICACIÓN JAVA. MEMORIA DE CÁLCULOS
2.2. Memoria de cálculos
Siguiendo el método de cálculo de CENSOLAR [1], calcula el número de colectores teórico

para cubrir la demanda energética anual en función de la radiación solar anual por m2, calculada
para una inclinación dada y en la provincia seleccionada. Con este resultado el usuario decide el
número de colectores que quiere instalar y, en función de la superficie resultante, el programa
calcula la aportación solar anual y el déficit energético anual. Por otro lado, para los mismos
datos de consumo de ACS, el programa aplica el método F-chart y calcula la cobertura solar
anual con el mismo número de colectores decidido tras los resultados del método anterior.
El programa permite cambiar el valor de las variables que intervienen en los dos métodos y ver
de forma gráfica como influyen en el resultado. Como hay variables que se emplean en uno y en
el otro no, no se trata de comparar el resultado de los dos métodos de cálculo sino de tener dos
referencias a la hora de estimar la aportación solar de una instalación para la producción de ACS,
mediante colector solar plano, para unas condiciones de consumo y localización dadas.
89
El presente apartado se compone de las siguientes partes:
2.2.1. Datos y resultados
2.2.2. Datos por defecto
2.2.3. Cálculo de las cargas de consumo de ACS
2.2.4. Dimensionado de la superficie de colectores
2.2.4.1. Justificación de cálculos
2.2.5. Código java para los cálculos
2.2.5.1. Consumo mensual de ACS

2.2.5.2. Salto térmico
2.2.5.3. Necesidades energéticas mensuales
2.2.5.4. Radiación media sobre superficie horizontal
2.2.5.5. Radiación media sobre superficie inclinada
2.2.5.6. Intensidad media útil de radiación solar
2.2.5.7. Rendimiento del colector solar plano
2.2.5.8. Aportación solar por m2
2.2.5.9. Energía neta disponible
2.2.5.10. Superficie colectora
2.2.5.11. Energía total obtenida
2.2.5.12. Aportación de energía solar
2.2.5.13. Déficit de energía
2.2.5.14. Aportación solar anual
2.2.6. Método F-chart
2.2.7. Código java para los cálculos (F-chart)
2.2.7.1. Estimación de la carga calorífica

2.2.7.2. Estimación de la energía absorbida y perdida
2.2.7.3. Cálculo del parámetro de ganancia D1
2.2.7.4. Cálculo del parámetro de pérdidas D2
2.2.7.5. Cobertura solar mensual f
2.2.7.6. Cobertura solar anual CSA
2.2.7.7. Volumen de acumulación
90
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 : Resultados mensuales:
Desviación N-S (β): 0 Consumo ACS m3
Corrección de H: Salto térmico
Pérdidas globales: Demanda termias
Nº de usuarios: Demanda MJ
Litros/día·usuario: H corregida
Área de colector: Energía neta incidente
Parámetros b y m del colector: Intensidad incidente
Corrección de b: Energía neta disponible MJ/m2
Temperatura de uso: Energía neta total MJ/mes
Precio del kw·h : € Rendimiento de un colector
Ocupación %mes Aportación solar por m2
Datos mensuales Sustitución %
Temperatura de red Déficit de energía
Radiación H Coste eléctrico de la demanda
Factor k (inclinación) Coste eléctrico del déficit
Horas sol Ahorro
Temperatura ambiente Resultados anuales:
Nº colectores a instalar Demanda anual: MJ
Energía/año·m2 : MJ
Aportación solar: %
Déficit energético: MJ
Ahorro anual : €
Coste energía auxiliar: €
Superficie colectora teórica: m2
Número de colectores teórico:
Superficie colectora resultante (A)
Condición de diseño: 60<C/A<100

VARIACIONES (*)
Ocupación
Litros/día·usuario
Temperatura de uso
Inclinación
Número de colectores
91
Método 2 basado en F-Chart
DATOS RESULTADOS
Inclinación : Consumo de ACS litros/día
Desviación N-S (β): 0 Carga calorífica mensual
Corrección de H: Superficie resultante (A)
Pérdidas globales: Energía solar absorbida mensual
Nº de usuarios: Factor F’rUL
Litros/día·usuario: Factor k1 corrección por acumulación
Área de colector: Factor k2 corrección por
Parámetros b y m del colector: Energía perdida mensual
Corrección de b: Variable D1 para f
Temperatura de uso: Variable D2 para f
Ocupación %mes Fracción solar mensual f
Datos mensuales Energía solar útil mensual
Temperatura de red Fracción solar anual CSA
Radiación H volumen de acumulación teórico (V)
Horas sol Condiciones de diseño
Temperatura ambiente 0.8<=V/M<=1.2
Nº colectores a instalar 37.5<=M/A<=300
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
VARIACIONES(*)
Ocupación
Litros/día·usuario
Temperatura de uso
Inclinación
Número de colectores
Kg de acumulación
b
m
Factor captador-intercambiador
Modificación ángulo de incidencia (**)
(**) no tiene botones "+-"
(*) Denominamos "variaciones" a las variables para las cuales el programa dispone de
"botones +-" con los que podemos ver las variaciones de los resultados en función del
incremento de estás variables. Cada vez que pulsamos "+" o "-" aumenta o disminuye, en una
cantidad fijada, el valor de la variable correspondiente y se recalculan todas las operaciones y se
dibujan las gráficas con los nuevos valores y resultados. Las variaciones afectan a los dos
métodos y variarán los resultados según influyan o no.
92
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
Horas sol
Temperatura ambiente
(fuente CENSOLAR [2])
Con cada opción de "Valores por defecto" el programa introduce los valores por defecto
correspondientes al evento que se esté ejecutando en ese momento.
93
El programa incorpora un botón llamado "Calcula todo" con el cual, una vez seleccionada la
provincia, nos pide que indiquemos el número de colectores y el volumen del acumulador. Con
estos dos datos y tomando todos los "valores por defecto" anteriores realiza todas las operaciones
a la vez. Esta opción se diseñó para ofrecer una forma rápida de comparar los resultados en
función de la provincia seleccionada manteniendo todos los demás datos iguales.
A continuación describiremos cómo se realizan los cálculos necesarios en el programa.
2.2.3. Cálculo de la carga de consumo
Una vez seleccionada la localización del proyecto, el programa nos pedirá los siguientes datos:
Inclinación: Ángulo que formarán los colectores respecto a la superficie horizontal. Por
defecto, toma el valor de 45º pero tenemos la opción de tomar los valores 35,40,45,50,55 y
60. (ventana datos generales)
Desviación N-S: por defecto 0º, todos los datos en el programa están referidos a este valor.
Corrección de H: factor que modifica el valor de la radiación media diaria sobre superficie
horizontal (H), por defecto el programa toma un valor de 1.05, (valor para niveles de
contaminación atmosférica muy bajos).
Pérdidas globales: por defecto toma un valor de 0.15 como valor recomendado
(CENSOLAR[1]), cuando no se dispone de datos para estimar las pérdidas de calor, que
dependen del aislamiento y del tipo de consumo.
Nº de usuarios: Número máximo de usuarios, en un mes, para los que se calcula la

instalación.
Litros/día·usuario: Consumo diario estimado para cada usuario. Por defecto, 40 litros.
Área del colector: superficie útil en m2 del colector que el proyectista decida instalar. Por
defecto toma 2.01 m2.
Parámetro b: factor de eficiencia óptica de los colectores, por defecto b=0.83.
Parámetro m: Coeficiente de pérdidas de los colectores, por defecto m=4.8.
Temperatura de uso: temperatura de uso del ACS, por defecto 45ºC.
Precio del kwh: por defecto, energía eléctrica, 0.12€/kwh.
Todos estos datos se introducen en la ventana "Datos generales", podemos seleccionar los
valores por defecto o introducir el valor que queramos por teclado.
94
figura 1. ventana Datos generales
Pulsando "Continuar" el programa asigna estos datos al proyecto y partir de aquí podemos
calcular las necesidades energéticas para cada mes, para lo cual necesitamos conocer los
siguientes datos mensuales:
Ocupación: es el porcentaje del número máximo de usuarios que cada mes utilizará la
instalación. Por defecto tiene un valor del 100% todos los meses, podemos cambiarlo en la
ventana "Datos mensuales" y con los botones +- en los paneles "Gráficas f-chart" y "Gráficas
demanda-aportación".
Consumo mensual (m3): es el consumo total de ACS cada mes, en m3.
Temperatura media del agua red: Por defecto el programa toma los valores de la capital de la
provincia seleccionada en el proyecto (fuente CENSOLAR[1]), podemos consultarlos en el
panel "DATOS&RESULTADOS".
Salto térmico: Diferencia entre la temperatura de uso y la temperatura de red.
Demanda energética : energía necesaria para calentar el agua desde la temperatura de red
hasta la de consumo. El valor calculado aparece en la columna neMJ del el panel
"CÁLCULOS".
2.2.4. Dimensionado de la superficie de colectores
Se calculará una superficie colectora "teórica", siguiendo el método de CENSOLAR[1],

dividiendo la necesidad energética anual entre la disponible por metro cuadrado de superficie
expuesta a la radiación solar.
En el programa java, primero se calcula la demanda de energía anual (DemandaAnual)

sumando la demanda de cada mes (vDemanndaMJme[i]), después calcula la energía neta
disponible por m2 al año (ENDañoM2) sumando la energía disponible cada mes (vENDmes[i]) ,
dividiendo estos dos valores obtiene la superficie SCteorica. Con el dato de la superficie de un
colector (Acol), que toma de las datos de inicio, calcula el número de colectores necesarios
(Ncteorico) para cubrir dicha superficie. Para todo esto necesitamos conocer los siguiente datos:
95
Justificación de cálculos:
Necesidad energética diaria en MJ.
H = Energía incidente en un m2 horizontal (MJ), su valor mensual aparecerá en la ventana

"Datos mensuales" para la provincia seleccionada.(fuente CENSOLAR[2])
Valor de H corregido: por defecto, multiplica H por el factor 1.05 (valor para zona de sierra
de atmósfera limpia), su valor resultante puede consultarse en el panel
"DATOS&RESULTADOS".
Coeficiente de corrección k para una latitud de la provincia seleccionada y la inclinación

tomada como dato, su valor para cada mes aparece en la ventana "Datos mensuales". (fuente
CENSOLAR[2])
Energía neta incidente (MJ/m2): E=0.94kH. Considera que un 6% de la energía incidente no

se aprovecha debido a los momentos en que la intensidad es menor del valor umbral 200
W/m2 (CENSOLAR[1])
Nº de horas de sol útiles, sus valores dependen de la provincia seleccionada y puede

consultarse en el panel "DATOS&RESULTADOS" . (fuente CENSOLAR[2])
Intensidad media útil I, en W/m2, se obtiene dividiendo E (previamente pasada a julios) por
las horas de sol útiles (pasada a segundos). "DATOS&RESULTADOS"
Temperatura ambiente durante las horas de sol: sus valores dependen de la provincia
seleccionada y puede consultarse en el panel "DATOS&RESULTADOS" . (fuente
CENSOLAR[2])
Rendimiento de los colectores. Por defecto, considera un colector con cubierta y destinado a
la obtención de ACS, el factor b se corrige multiplicándolo por 0.94. Su valor resultante
puede consultarse en el panel "DATOS&RESULTADOS".
Aportación solar por m2: Se obtiene multiplicando la energía neta incidente (E) por el
rendimiento de los colectores. Su valor mensual se puede consultar en el panel
"CÁLCULOS".
Energía neta disponible al día por m2: corregimos la Aportación con el factor 0.85 a fin de
considerar las pérdidas producidas en el acumulador (15%).
Energía neta disponible al mes por m2: multiplica por el número de días de cada mes. Su
valor puede consultarse en el panel "CÁCULOS" y en la columna ENDmes del panel
"RESULTADOS".
Superficie colectora necesaria. Para ello dividimos la demanda energética total entre la
energía neta disponible por m2.
96
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").
97
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]; } }
98
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.
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(){
vConsumo[i]=(LitrosDia*NumUsu*vDias[i]*vOcupacion[i])/100000;
vSalto[i]=Tuso-vTred[i];
vConsumo[i]=vConsumo[i]*vDAporceocupacion[i];//para los calculo variando la ocupac en DA

vConsumo[i]=vConsumo[i]*vDAporcelitros[i];//para los calculo variando los litros en DA
vSalto[i]=Tuso*vDAporcetuso[i]-vTred[i];//para los calculo variando la Tuso en DA
vDemandaMJmes[i]=vConsumo[i]*vSalto[i]*4.184;//MJ/mes
ConTresDecimales();
vDemandaMJmes[i]=Double.valueOf(formateador.format(vDemandaMJmes[i])); } }
Los resultados se pueden consultar en el panel "CÁLCULOS" y en la columna "neMJ" del

panel "RESULTADOS".
99
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".
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(){
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.
100
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();
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.
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]/vHorasSolUtil[i];
ConTresDecimales();
vI[i]=Double.valueOf(formateador.format(vI[i])); } }
101
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.
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
//vRendimiento[i]=100*Corb*bcol-100*mcol*(Tuso-vTamb[i])/vI[i];
vRendimiento[i]=100*Corb*bcol-100*mcol*(Tuso*vfporcetuso[i]-vTamb[i])/vI[i];
// if(vRendimiento[i]<20){vRendimiento[i]=0;}
if(vRendimiento[i]<0){vRendimiento[i]=0;}
ConTresDecimales();
vRendimiento[i]=Double.valueOf(formateador.format(vRendimiento[i]));} }
102
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 * η
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
if(vOcupacion[i]>0){vAportacion[i]=vE[i]*vRendimiento[i]/100;}// hemos añadido /100
else{vAportacion[i]=0;}
ConTresDecimales();
vAportacion[i]=Double.valueOf(formateador.format(vAportacion[i])); } }
Los resultados, para cada mes, se pueden consultar en el panel "CÁLCULOS".
2.2.5.9. Cálculo de la energía neta disponible (END)
El colector solar plano, las tuberías, el depósito interacumulador, y los demás accesorios de
una instalación solar térmica, durante el funcionamiento mantienen temperaturas superiores a la
temperatura ambiente, perdiendo calor por conducción a través de las uniones del sistema a tierra
y por convección y radiación al ambiente.
103
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
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();
vENDdia[i]=vAportacion[i]*(1-PerdGlo);// hemos quitado /100 ya que está en la aportacion } }
public void Calcula_vENDmes(){

ConTresDecimales(); Calcula_vENDdia();
for(int i=0;i<12;i++){ vENDmes[i]=vENDdia[i]*vDias[i];
vENDmes[i]=Double.valueOf(formateador.format(vENDmes[i])); } }
public void Calcula_ENDañoM2(){

Calcula_vENDmes(); ENDañoM2=0;
for(int i=0;i<12;i++){ ENDañoM2=ENDañoM2+vENDmes[i];}
ConTresDecimales();
ENDañoM2=Double.valueOf(formateador.format(ENDañoM2)); }
104
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).
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;
DemandaAnual=DemandaAnual+vDemandaMJmes[i];
}ConTresDecimales();
DemandaAnual=Double.valueOf(formateador.format(DemandaAnual)); }
105
public void Calcula_SCteorica(){

Calcula_DemandaAnual();
Calcula_ENDañoM2();
SCteorica=DemandaAnual/ENDañoM2;
ConTresDecimales();
SCteorica=Double.valueOf(formateador.format(SCteorica)); }
public void Calcula_NCteorico(){

Calcula_SCteorica();
NCteorico=SCteorica/Acol;
ConTresDecimales();
NCteorico=Double.valueOf(formateador.format(NCteorico)); }
public void Calcula_SCresultante(){

//introducimos por teclado el Ncrecomendado (nº de colectores que asignamos al proyecto)
SCresultante=NCrecomendado*Acol;
ConTresDecimales();
SCresultante=Double.valueOf(formateador.format(SCresultante)); }
public void Calcula_PruebaSC(){

Calcula_ConsumoanualACSm3();
Calcula_NumDiasAnual();
Calcula_SCresultante();
PruebaSC=1000*ConsumoanualACSm3/(NumDiasAnual*SCresultante);
ConTresDecimales();
PruebaSC=Double.valueOf(formateador.format(PruebaSC)); }
public double getPruebaSC(){

Calcula_PruebaSC();
return PruebaSC; }
public String getComprobacionSC(){

Calcula_PruebaSC();
String CSC;
if(PruebaSC<60){CSC="No cumple";}
else{if(PruebaSC>100){CSC="No cumple";}else{CSC="Cumple";}}
return CSC; }
Estas operaciones se realizan en el panel "CÁLCULOS".
2.2.5.11. Cálculo de la energía total obtenida por el sistema de captación de energía solar térmica
(ENTotalmes)
En el apartado anterior hemos calculado la energía neta disponible por metro cuadrado de
colector para cada mes del año, en este apartado se calculará la energía total disponible y que se
puede obtener por el sistema de energía solar térmica, para ello multiplicaremos la energía neta
disponible por la superficie del colector solar plano en metros cuadrados.
Los cálculos de la energía total disponible se especifican a continuación según la siguiente

ecuación:
Et = É * S
106
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".
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){vSustitucion[i]=0;}
else{double sust=vENTotalmes[i]/vDemandaMJmes[i];
vSustitucion[i]=sust;}
ConTresDecimales();
vSustitucion[i]=Double.valueOf(formateador.format(vSustitucion[i])); } }
107
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.
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_vENTotalmes();
vDeficit[i]=vDemandaMJmes[i]-vENTotalmes[i];
ConTresDecimales();
vDeficit[i]=Double.valueOf(formateador.format(vDeficit[i])); } }
public void Calcula_DeficitEnergeticoAnual(){

double defi=0;
Calcula_vDeficit();
if(vDeficit[i]<0){}else{defi=defi+vDeficit[i];}
}
ConTresDecimales();
deficitEnergeticoAnual=Double.valueOf(formateador.format(defi)); }
Los resultados pueden consultarse en la columna "Déficit" del panel "RESULTADOS".
Los valores positivos aparecen en color rojo y los negativos en color azul. Los datos negativos
significan que existe superávit de energía disponible para el calentamiento del agua caliente
108
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.
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();
vCobertura[i]=100*(1-vDeficit[i]/vDemandaMJmes[i]);
ConTresDecimales();
vCobertura[i]=Double.valueOf(formateador.format(vCobertura[i])); } }
public void Calcula_aportacionAnual(){

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.
109
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(){
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(){

CEanual=Preciokwh/3.6*DemandaAnual;
ConTresDecimales();
CEanual=Double.valueOf(formateador.format(CEanual)); }
public void Calcula_vCosteAuxmes(){

Calcula_vDeficit();
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;
CAuxAnual=CAuxAnual+vCAuxmes[i];}
ConTresDecimales();
CAuxAnual=Double.valueOf(formateador.format(CAuxAnual)); }
public void Calcula_vAhorromes(){

Calcula_vCosteEmes(); Calcula_vCosteAuxmes();
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"
110
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:
2 2 3
f=1,029·D1-0,065·D2-0,245·D1 +0,0018·D2 +0,0215·D1
El parámetro D2 representa la relación entre las pérdidas de energía del captador y la carga
total de calentamiento durante un mes.
El parámetro D1 expresa la relación entre la energía absorbida en la superficie captadora y la
carga total de calentamiento durante un mes.
Así pues, conocida la radiación solar sobre la superficie de captación y el tipo y número de
captadores instalados, se puede calcular la aportación energética mensual para una determinada
demanda mediante el empleo del método de las curvas f.
111
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).
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(){
vfcarga[i]=(Ce*N*C*vDias[i]*(tac-vTred[i]))/Math.pow(10,6);//MJ/mes
vfcarga[i]=(Ce*N*C*vDias[i]*(tac*vfporcetuso[i]-vTred[i]))/Math.pow(10,6);//
vfcarga[i]=vfcarga[i]*vfporceocupacion[i];//para los calculo variando la ocupacion en fchart
vfcarga[i]=vfcarga[i]*vfporcelitros[i];//para los calculo variando los litros en fchart
ConTresDecimales();
vfcarga[i]=Double.valueOf(formateador.format(vfcarga[i])); } }
112
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 (τα) · (τα)/(τα) ·(F’ /F )

R n n R R
• F (τα) Factor de eficiencia óptica del captador. Es la ordenada en el origen de la curva

R n
característica del captador. En el programa corresponde a la variable "FEO".
• (τα)/(τα) Modificador del ángulo de incidencia. "MAI", valor por defecto 0.96. En general
n
se puede tomar como constante: 0,96 (superficie transparente sencilla) o 0,94 (superficie
transparente doble).
• F’r/ Fr Factor de corrección del conjunto captador-intercambiador. "FCCI", por defecto

toma como valor 0.95.
R1 : Radiación diaria media mensual incidente en la superficie de captación del

colector solar (kJ/m2).
N : Número de días del mes.
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].
113
método public void Calcula_Fadim(){ Fadim=FEO*MAI*FCCI; }
public void Calcula_vEabsorbidaf(){

Calcula_vE();
Calcula_Fadim();
vEabsorbida[i]=fSc*Fadim*vE[i]*vDias[i];// MJ/mes
ConTresDecimales();
vEabsorbida[i]=Double.valueOf(formateador.format(vEabsorbida[i])); } }
La energía que se pierde en el colector (Ep), se determina por medio de la siguiente ecuación:
Ep=Sc·F’r· UL·(100 – ta)·∆t· k1·k2
En donde:
Sc: Superficie útil del captador (m2).
F’r· UL : Factor de eficiencia del intercambiador de calor del colector solar por el coeficiente
global de pérdidas del captador. Este factor viene asociado intrínsecamente a un factor de
disipación de calor. (%).
F’r· UL= Fr· UL·( F’r / Fr)
• Fr· UL = Pendiente de la curva característica del captador (coeficiente global de

o pérdidas del captador) "CGP".
• F’r / Fr Factor de corrección del conjunto captador-intercambiador. "FCCI", por defecto

0.95.
ta : Temperatura mensual media del ambiente. (°C).
∆t : Período de tiempo, considerando que funciona las 24h/día. (s)
k1 : Factor de corrección debido al almacenamiento.
K1 = [kg acumulación /(75 Sc)]-0,25
37,5 < (kg acumulación) / (m2 captador) < 300
k2 : Factor de corrección para el agua caliente, en donde se relaciona la temperatura mínima

de ésta con el agua de la red usada y también la temperatura media mensual del ambiente.
K2 = 11,6 + 1,18 tac + 3,86 tr – 2,32 ta / (100 – ta)
• tac = Temperatura mínima del ACS, por defecto 45º.

• tr = Temperatura del agua de red
• ta = Temperatura media mensual del ambiente
114
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(){

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(){

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();
vEperdida[i]=fSc*FprUL*(100-vTamb[i])*vDt[i]*K1*vK2[i]/1000000;//Mj/mes
ConTresDecimales();
vEperdida[i]=Double.valueOf(formateador.format(vEperdida[i])); } }
115
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
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();
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
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].
método public void Calcula_D2(){
Calcula_vfcarga();
Calcula_vEperdidaf();
vD2[i]=vEperdida[i]/vfcarga[i];
ConTresDecimales();
vD2[i]=Double.valueOf(formateador.format(vD2[i]));}}
116
2.2.7.5. Determinación de cobertura solar mensual
La energía útil captada en un mes determinado (Qu) se estima mediante la ecuación:
Qu = f·Qa
A la fracción de carga calorífica mensual (Qa), que se transforma en energía solar, se la conoce
como parámetro f. El cálculo de este parámetro se realiza con ayuda de la ecuación
2 2 3
f=1,029·D1-0,065·D2-0,245·D1 +0,0018·D2 +0,0215·D1
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].
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();
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();
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)
117
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;
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.
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; }
118
El sistema interacumulador se utiliza para acumular agua caliente sanitaria en las horas de
máxima radiación solar y esta agua será utilizada en los momentos de demanda. La producción
de agua caliente sanitaria no suele coincidir con los momentos de consumo, de ahí la necesidad
de acumularla.
Los resultados se pueden consultar en el panel "ACUMULADOR" y subpanelresultados2_10.
119
120

MCal AJava

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

MCal AJava

Cargado por

Copyright:

Formatos disponibles

APLICACIÓN JAVA

CAPÍTULO 2. APLICACIÓN JAVA

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

2.1. Memoria descriptiva

En "Memoria de cálculos" se exponen los cálculos principales que se realizan en el programa,

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

2.1. Memoria descriptiva

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

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

Sencillo. Elimina la complejidad de otros leguajes.

Para este proyecto hemos utilizado:

NetBeans IDE 7.2.1

2.1.1.1. POO programación orientada a objetos

Los métodos se pueden dividir básicamente en tres tipos:

Para cambiar las propiedades del objeto (Métodos set)

Todo objeto pertenece a una CLASE.

La CLASE nos permite declarar objetos y construirlos:

Declaración: CLASE nombreobjeto;

Construcción: nombreobjeto = new CLASE();

Declaración y Construcción en una misma línea:

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

Se pueden añadir a un proyecto Java clases programadas por uno mismo.

public class Cuadro extends javax.swing.JFrame

La clase creada “cuadro” obtendrá características de la clase “Jframe” de la que hereda.

2.1.1.3. Bibliotecas y reutilización de código

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

figura 2. ficheros de clases[3], en la carpeta “gráficos” que serán utilizadas

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

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

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

2.1.1.5. Variables globales

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

public class Cuadro extends javax.swing.JFrame {

2.1.1.6. Variables locales

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

2.1.1.7. Centralizar código

public void ConTresDecimales() {

double feo = Double.parseDouble(txtf_comprueba_bcol.getText()) + incremento;

2.1.1.8. Eventos desde código.

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.

Conociendo estos datos, la programación siempre se hace igual:

2.1.1.9. Aplicación Java

Para este proyecto hemos creado una Java SE aplication.

JTabbedPane: es un componente que permite al usuario cambiar entre un grupo de

JComboBox: es un componente que permite seleccionar entre una serie de valores

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

JRadioButton JComboBox JDialog

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

2.1.1.10. Instalación de la aplicación Java

Procedemos de la siguiente manera:

En Netbeans, ejecutamos la orden Limpiar y construir proyecto principal. Esta orden

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

Archivo ejecutable "Simulacion_ACS_1_1.jar"

2.1.1.11. Componente de la aplicación.

A continuación presentamos cada uno de los componentes de la clase principal "Cuadro.java"

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

Componente JFrame Form Cuadro:

Componente 1. Paneles [JTabbedPane]