A parallel Teaching–Learning-Based Optimization procedure for automatic heliostat aiming

Abstract

The flux distribution generated by the heliostat field of solar central receiver system (SCRS) over the receiver needs to be carefully controlled. It is necessary to avoid dangerous radiation peaks and temperature distributions to maximize the efficiency and keep the system in a safe state. These tasks imply both selecting the subset of heliostats to be activated and assigning each one to a certain aiming point at the receiver. The heliostat field is usually under human control and supervision, what is a potential limiting factor. Thus, there is an active research line to define automatic aiming procedures. In fact, a general and autonomous methodology is being developed by the authors of this work. However, the mathematical modeling leads to face a complex large-scale optimization problem. In this work, applying Teaching–Learning-Based Optimization (TLBO), a population-based large-scale optimizer, is considered. It is intended to serve to perform large explorations of the search-space to finally deploy further local optimizers over the most promising results. Considering the computational cost of the objective function, a parallel version of TLBO has been developed. It significantly accelerates the procedure, and the possibility of being included in a more complex process remains viable. Additionally, the parallel version of TLBO is also linked as a generic open-source library.

Appendix: Parallel TLBO library

1.1 A.1 Overview

In this work, a parallel C version of the TLBO algorithm has been developed for continuous and unconstrained minimization problems. It has been designed to be a general-purpose library that could be used for any other problems. It can be compiled as either a sequential or a parallel code depending on what is needed. Available parallel modes are: thread-based (OpenMP), process-based (MPI) and hybrid (MPI processes and OpenMP threads). In this appendix, a general overview of its structure and usage is given. The link to the source code is: http://gitlab.hpca.ual.es/ncc911/ParallelTLBO

1.2 A.2 Structure

The source code of the software is divided into different files. Their names and code (i.e., functions, sections and variables) are quite descriptive and there should not be any problem in understanding their purpose and usage. Next, they are listed and summarized in alphabetical order (files with ‘*’ will be commented on later):

• ConfigLoader.c/h: It defines and implements the functions for loading the input information from a file, i.e., the population size, the number of cycles and the seed for random generation.

• Launcher.c*: It contains the entry point of the tool, i.e., the ‘main’ function. Configuration loading, memory allocation, optimization (including work distribution for MPI versions) and result display are launched from this file.

• LearnerStage.c/h: It defines and implements the learner phase of TLBO.

• LookForTheBest.c/h: It defines and implements the process of looking for the best individual, by analyzing the vector of aptitudes, and returning its index to become a ‘teacher’.

• MakeFile*: It defines the compilation of the different versions, i.e., the sequential and the parallel ones, for a certain objective function.

• MemoryHandler.c/h: It defines and implements the allocation of the required memory by the TLBO algorithm, i.e., the population matrix (and its mirror) as well as the pairing and random vectors which are generated in a centralized way. It also includes the function for individual copying and display.

• PopulationInitializer.c/h: It defines and implements the initialization of the population, i.e., the random generation of the individuals required at the start of the search.

• RemoveDuplicates.c/h*: It defines and implements the elimination of duplicate individuals.

• SampleConfig: It contains an example of configuration file for the library and the ‘ConfigLoader’ module. Required fields are: the population size, the number of cycles and the random seed (for repeatability). Labels of the field are checked, so only numbers should be modified.

• TeacherStage.c/h: It defines and implements the Teacher Phase of TLBO.

• Timers.c/h: It defines and implements the ‘wall clock’ time instant measurement for computing the real execution time. It is used for non-MPI versions.

• TLBOCore.c/h: It defines and implements the main execution loop of TLBO. Thus, it contains the calls to the auxiliary modules, i.e., the initialization of the population, the generation of random vectors and the calls to the Teacher, Learner and Removing steps.

• ObjectiveFunctions/Sphere.h/c*: It is a sample objective function that has been included to test TLBO. It is a two-dimensional and not computationally expensive function. Parallelization is not really intended for that kind of problems, but it shows the requirements for defining additional objective functions. In addition, it is important to note that these files are in a specific sub-directory called ‘ObjectiveFunctions’. Saving other objective functions there is not required but recommendable to keep the code clean.

1.3 A.3 Usage

Adapting the current TLBO library to be used for different problems only requires minimal modifications in the previously highlighted files with ‘*’. To use for any other problem, let it be called ‘Func’, these simple tasks must be done:

• Create an objective function: It is necessary to define and implement the objective function of the studied problem. Two files, ‘Func.h’ and ‘Func.c’ should be created in ‘/ObjectiveFunctions’. ‘Func.h’ should contain at least two functions (depending on your problem, you may need to include some internal steps, i.e., file reading). One of them is expected to be the objective function, which needs to receive a pointer to double (double*) corresponding to the individual or ‘student’, and returns a single double corresponding to its aptitude. The second one is expected to be able to write the number of variables, i.e., the dimensions of your problem as well as to allocate and fill a vector with the bounds of the search-space. Thus, it receives as parameters, a pointer to integer and another one to double. It should contain in $\{0\}$ the lower bound and in $\{1\}$ the upper bound for the first dimension. This ordering scheme needs to be scaled to the full length of your problem (i.e., 2 doubles are required for every dimension). This memory will be automatically cleaned after the execution by the ‘Launcher’ module. In ‘Func.c’, the described functions should be implemented.

• Link the function to ‘Launcher.c’: It is necessary to change the last ‘include’ in that file to point to ‘Func.h’. Then, a pointer to the new function needs to be saved: ‘double (*objFunc)(double*) = Func’ in the initial zone of the ‘main’ function.

• Adapt the ‘Makefile’: The source file of the new function should be included, for instance, ‘OBJFUNC=ObjectiveFunctions/Func.c’ (it is in the first line of the file).

After these steps, TLBO could be compiled, in the desired version, and used for any other problem. In the module ‘Launcher’, some extra changes may be needed. For instance, it might be necessary to write back the final solution to a file, or the new objective function might require some preliminary and/or final steps (maybe memory cleaning for specific constants...). In addition, the ‘RemoveDuplicates’ module could be modified to alter the comparing sensibility for real values and/or to adapt the definition of ‘equality’ between two candidate solutions for special problems. Changing other files should be done for updating and/or altering the current TLBO implementation.

1.4 A.4 License

This software has been developed by N.C. Cruz, J.L. Redondo, J.D. Álvarez, M. Berenguel and P.M. Ortigosa, at the University of Almeria, Spain. It is distributed ‘as is’, with the best intentions, but without any kind of warranty and/or responsibility of the authors. It can be freely used, modified and distributed by anyone interested at but it is compulsory to reference the original version included herein.