-
Notifications
You must be signed in to change notification settings - Fork 0
/
optimisation.hh
294 lines (270 loc) · 12.2 KB
/
optimisation.hh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
//=========================================================================
// COPYRIGHT (c) 2001-2003 by Trinity College Dublin, Dublin 2, IRELAND
// All rights reserved
//=========================================================================
// Author: Eamonn M. Kenny
// Principal Researcher: Dr. Peter J. Cullen
// First Modification: June 13th 2002
// Last Modification: Dated below "Added dd/mm/yy"
// Previous Projects: none
// Current Project: IP2000 STIWRO
// Software Tool Version: 1.0
//=========================================================================
#ifndef OPTIMISATION_HH
#define OPTIMISATION_HH
#include <iostream>
#include "storage.hh"
#include "list.hh"
#include "capacity.hh"
#include "path-loss.hh"
#include "parameters.hh"
#include "vector.hh"
#include "matrix.hh"
#include "linear-program.hh"
#include "maths-utilities.hh"
class COptimisation
//==========================================================================
// = FUNCTION
// optimisation.hh
//
// = AUTHOR
// Eamonn M. Kenny
//
// = DESCRIPTION
// Implementation of convex and non-linear Optimisation for multiple
// transmitters in a building
//
// = VERSION
// 1.0
//
// = COPYRIGHT
// COPYRIGHT (c) 2001-2003 by Trinity College Dublin, Dublin 2, IRELAND
// All rights reserved
//==========================================================================
{
public:
COptimisation()
{
// default constructor
};
double objective( boolean& isCapacityExceeded,
int& l, double t,
int numberOfSectors,
const CVector<double>& vcentres,
const CVector<double>& oldcentres,
CBaseTransceiver& btsObject,
const CBuilding& buildingObject,
const CCapacity& capacityGrid,
double* targetSIR,
const SystemParameters& parameterObject,
const boolean& writeBestServer,
complex ***fieldStrength );
double objective( boolean& isCapacityExceeded,
int& l, double t,
int numberOfSectors,
const CVector<double>& vcentres,
const CVector<double>& oldcentres,
const CVector<double>& minimisedPower,
CBaseTransceiver& btsObject,
const CBuilding& buildingObject,
const CCapacity& capacityGrid,
double* targetSIR,
const SystemParameters& parameterObject,
const boolean& writeBestServer,
complex ***fieldStrength );
//
// generate the objective function for the non-linear optimisation
// or given that we know the minimised power calculate the objective
// function to see if the same number of SIR values are still obtained
//
void useObjectiveToCreateConvexConstraintMatrix(
CMatrix<double>& A, CVector<double>& b,
CVector<double>& p0, boolean& isCapacityExceeded,
int& l, double t,
int numberOfSectors,
const CVector<double>& vcentres,
CBaseTransceiver& btsObject,
const CBuilding& buildingObject,
const CCapacity& capacityGrid,
double* targetSIR,
const SystemParameters& parameterObject,
const boolean& writeBestServer );
//
// generate the constraint matrix for the convex optimisation
//
CVector<double> gradient( double j,
double t,
int numberOfSectors,
CVector<double>& vcentres,
CBaseTransceiver& btsObject,
const CBuilding& buildingObject,
const CCapacity& capacityGrid,
double* targetSIR,
const SystemParameters& parameterObject,
complex ***fieldStrength );
boolean annealing( double j,
double t,
int numberOfSectors,
CVector<double>& vcentres,
CBaseTransceiver& btsObject,
const CBuilding& buildingObject,
const CCapacity& capacityGrid,
double* targetSIR,
const SystemParameters& parameterObject,
complex ***fieldStrength );
//
// calculate the positions of the base stations which meet the
// Signal to interference ratio (SIR) everywhere (if possible).
// the base station locations are stored as a vector of doubles
// bs1 = (v[1],v[2],v[3]) bs2 = (v[4],v[5],v[6]), etc...
//
void bestServers( List<CPoint3d>& centres,
CBaseTransceiver& btsObject,
const CBuilding& buildingObject,
const CCapacity& capacityGrid );
//
// Generate the best servers for the current sent of transmitters
//
double objectiveFunction(
boolean& isCapacityExceeded,
int& l, double t,
double *maximumPower, complex **gain,
int NumberOfServers, int numberOfSectors,
List<CPoint3d>& centres,
List<CPoint3d>& oldcentres,
const CBuilding& buildingObject,
CBaseTransceiver& btsObject,
const SystemParameters& parameterObject,
const CCapacity& capacityGrid,
double* targetSIR,
const mediaType& media,
const boolean& writeBestServer,
complex ***fieldStrength );
void formConvexOptimisationMatrix(
CMatrix<double>& A, CVector<double>& b,
boolean& isCapacityExceeded,
int& l, double t,
double *maximumPower, complex **gain,
int NumberOfServers, int numberOfSectors,
List<CPoint3d>& centres,
const CBuilding& buildingObject,
CBaseTransceiver& btsObject,
const SystemParameters& parameterObject,
const CCapacity& capacityGrid,
double* targetSIR,
const mediaType& media,
const boolean& writeBestServer );
//
// define the objectiveFunction that needs to be minimised
// or define the matrix for the convex optimisation constraints.
//
CVector<double> convertCentresToVector( List<CPoint3d>& centres );
List<CPoint3d>& vectorToCentres( const CVector<double>& vectorcentres );
//
// change the list of centres into a vector of variables for the
// optimisation routine (or vice versa).
//
CVector<double> steepestDescentSUMT(
List<CPoint3d>& centres,
List<CBoundingBox>& cells,
CBaseTransceiver& btsObject,
int numberOfSectors,
const CBuilding& buildingObject,
const CCapacity& capacityGrid,
const SystemParameters& parameterObject,
double stoppingPercentage );
//
// define a non-linear steepest descent SUMT method which will not
// allow a point to cross the boundary of it's valid area
//
boolean testFeasibility( CVector<double>& x, int cellIndex,
CBoundingBox& area, CPoint3d& pt );
//
// test the feasibility of a point by seeing if it is still in it's cell
// of influence (area).
//
void meanAbsSum( List<CRayPath>& allRayPaths, int numberOfSectors,
double sectorAngle, complex* Rsectors );
void meanAbsSum( List<CRayPath>& allRayPaths, int numberOfSectors,
double sectorAngle, complex* gain,
complex* Rsectors );
void absSum( List<CRayPath>& allRayPaths, int numberOfSectors,
double sectorAngle, complex* Rsectors );
void absSum( List<CRayPath>& allRayPaths, int numberOfSectors,
double sectorAngle, complex* gain,
complex* Rsectors );
void sumAbs( List<CRayPath>& allRayPaths, int numberOfSectors,
double sectorAngle, complex* Rsectors );
void sumAbs( List<CRayPath>& allRayPaths, int numberOfSectors,
double sectorAngle, complex* gain,
complex* Rsectors );
//
// multiple each ray-path by a random phase component and sum all
// components. Then do this a number of times, and then get the mean.
//
double gaussianQuadrature4( double* E, int N, double r,
double a, double stepSize );
//
// gaussian quadrature rule of order 4 to evaluate the integral at a
// discrete set of points E[0]..E[N-1] with variable r and starting at a
// and finishing at a+stepSize
//
double trapezoidal( double* E, int N, double r,
double a, double stepSize );
//
// newton-cotes quadrature rule of order 2. This is adaptive in that
// it keeps subdividing the interval [a,b] until an appropriate error
// bound is reached, also it integrates from [0,+inf] and stops when
// the integral is converged to some tolerance
//
double WnFunction( double* E, int N, double r, double a, double stepSize );
//
// probability density function for random walk
//
void randomWalkMean( List<CRayPath>& allRayPaths, int numberOfSectors,
double sectorAngle, complex* gains,
complex* Rsectors );
void randomWalkMean( List<CRayPath>& allRayPaths, int numberOfSectors,
double sectorAngle, complex* Rsectors );
//
// calculate a probabilty density function of a random walk. This takes
// the incoming ray-path values at a point and adds a random phase to
// them which is then averaged to give the mean amplitude which can then
// be used as a better measure of the field strength (note there is an
// ungained and gained version of this routine)
//
void sort( complex* totalField, int* orderedIndices, int numberOfServers );
//
// the servers total field indices are reordered in descending terms
// this is very useful for the best server calculation
//
double SIR( complex* totalField, int numberOfServers, int bestServer,
double sensitivity, double& pathLoss, double& totalInter );
//
// find the SIR for the current set of servers using the bestserver
// index specified
//
void setTargetSIR( const CCapacity& capacityGrid,
const SystemParameters& parameterObject,
double* targetSIR);
//
// define the target SIR at all user capacity points, this must be done
// to see up code since it would otherwise be calculated from a file
// many times
//
double besselJ0( double x );
//
// bessel function j0(x) including far field term for x > 3
//
boolean offloadServer( int **bestServerMatrix,
const CCapacity& capacityGrid, double sensitivity,
double *totalCapacity,
int *currentBestServer, complex **totalField,
double *targetSIR, double serverCapacity,
int numberOfServers, int numberOfCapacityPoints,
int bestServer );
//
// offload the server if it exceeds it's capacity requirements
//
};
#endif