RTModel 2.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- RTModel/RTModel.py +293 -0
- RTModel/__init__.py +5 -0
- RTModel/bin/Finalizer.exe +0 -0
- RTModel/bin/InitCond.exe +0 -0
- RTModel/bin/LevMar.exe +0 -0
- RTModel/bin/ModelSelector.exe +0 -0
- RTModel/bin/Reader.exe +0 -0
- RTModel/data/ESPL.tbl +0 -0
- RTModel/data/TemplateLibrary.txt +114 -0
- RTModel/include/LevMarFit.h +81 -0
- RTModel/include/VBBinaryLensingLibrary.h +312 -0
- RTModel/include/bumper.h +32 -0
- RTModel/lib/Finalizer.cpp +412 -0
- RTModel/lib/InitCond.cpp +1398 -0
- RTModel/lib/LevMar.cpp +12 -0
- RTModel/lib/LevMarFit.cpp +1277 -0
- RTModel/lib/ModelSelector.cpp +913 -0
- RTModel/lib/Reader.cpp +670 -0
- RTModel/lib/VBBinaryLensingLibrary.cpp +4986 -0
- RTModel/lib/bumper.cpp +168 -0
- RTModel/plotmodel/__init__.py +5 -0
- RTModel/plotmodel/plotmodel.py +452 -0
- RTModel-2.0.dist-info/LICENSE +165 -0
- RTModel-2.0.dist-info/METADATA +61 -0
- RTModel-2.0.dist-info/RECORD +27 -0
- RTModel-2.0.dist-info/WHEEL +5 -0
- RTModel-2.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,913 @@
|
|
|
1
|
+
// ModelSelector.cpp : main project file.
|
|
2
|
+
// This program select the best model and viable alternatives from PreModels of a given class
|
|
3
|
+
|
|
4
|
+
#define _USE_MATH_DEFINES
|
|
5
|
+
#define _CRT_SECURE_NO_WARNINGS
|
|
6
|
+
#include <stdio.h>
|
|
7
|
+
#include <stdlib.h>
|
|
8
|
+
#include <string.h>
|
|
9
|
+
#include <math.h>
|
|
10
|
+
#include <malloc.h>
|
|
11
|
+
#include <filesystem>
|
|
12
|
+
#include <regex>
|
|
13
|
+
#include "bumper.h"
|
|
14
|
+
|
|
15
|
+
using namespace std;
|
|
16
|
+
using namespace std::filesystem;
|
|
17
|
+
|
|
18
|
+
double supfac = 3.0; // factor multiplying the inverse covariance in search for superpositions (models are incompatible if farther than supfac*sigma)
|
|
19
|
+
double chifac = 1.; // number of sigmas in the chi square distribution for accepting alternative models after the best one
|
|
20
|
+
int maxmodels = 10; // maximum number of models returned
|
|
21
|
+
|
|
22
|
+
int main(int argc, char* argv[]) {
|
|
23
|
+
|
|
24
|
+
char eventname[256] = "";
|
|
25
|
+
char filename[256] = "", filnum[256] = "", filnum2[10] = "";
|
|
26
|
+
char modelcode[256];
|
|
27
|
+
char command[256], buffer[256];
|
|
28
|
+
double value;
|
|
29
|
+
double t, y, w, * pr, * sigmapr, * Cov, *Curv, fac, facr, c1, c0, chithr, bestplan = 1.e100, bestbin = 1.e100;
|
|
30
|
+
double renorm;
|
|
31
|
+
int nfil, il, nlc, nmod, np, k;
|
|
32
|
+
int nps=4,dof;
|
|
33
|
+
FILE* f, * g;
|
|
34
|
+
|
|
35
|
+
bumper* bumperlist=0, *scanbumper, *scanbumper2;
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
printf("******************************************\n");
|
|
39
|
+
printf("********** Model selector *********\n");
|
|
40
|
+
printf("******************************************\n\n\n");
|
|
41
|
+
printf("This program finds the best independent models of a given class\n\n");
|
|
42
|
+
|
|
43
|
+
// Directory preliminaries. Reads event name from arguments.
|
|
44
|
+
|
|
45
|
+
auto exedir = current_path();
|
|
46
|
+
|
|
47
|
+
if (argc > 2) {
|
|
48
|
+
strcpy(eventname, argv[1]);
|
|
49
|
+
strcpy(modelcode, argv[2]);
|
|
50
|
+
}
|
|
51
|
+
else {
|
|
52
|
+
printf("\n\nEvent name? ");
|
|
53
|
+
scanf("%s", eventname);
|
|
54
|
+
printf("\n\nModel code? ");
|
|
55
|
+
scanf("%s", modelcode);
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
printf("\n\n- Event: %s\n", eventname);
|
|
59
|
+
|
|
60
|
+
current_path(eventname);
|
|
61
|
+
|
|
62
|
+
if (exists("Models")) {
|
|
63
|
+
current_path("Models");
|
|
64
|
+
auto searchstring = regex(string(modelcode) + ".*");
|
|
65
|
+
for (auto const& itr : directory_iterator(".")) {
|
|
66
|
+
string curfile = (itr).path().filename().string();
|
|
67
|
+
if (regex_match(curfile, searchstring)) {
|
|
68
|
+
printf("\n\nModels already selected");
|
|
69
|
+
return 0;
|
|
70
|
+
}
|
|
71
|
+
itr;
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
current_path(eventname);
|
|
75
|
+
|
|
76
|
+
if (exists("ini")) {
|
|
77
|
+
current_path("ini");
|
|
78
|
+
f = fopen("ModelSelector.ini", "r");
|
|
79
|
+
if (f != 0) {
|
|
80
|
+
printf("\n\n- Reading options in ModelSelector.ini");
|
|
81
|
+
while (!feof(f)) {
|
|
82
|
+
int red = fscanf(f, "%s %s %lf", command, buffer, &value);
|
|
83
|
+
if (red < 1) {
|
|
84
|
+
command[0] = 0;
|
|
85
|
+
//if (red != 0) {
|
|
86
|
+
// printf("\n\n!!! Bad command in Reader.ini");
|
|
87
|
+
// return -1;
|
|
88
|
+
//};
|
|
89
|
+
}
|
|
90
|
+
if (strcmp(command, "maxmodels") == 0) {
|
|
91
|
+
maxmodels = (int) value;
|
|
92
|
+
}
|
|
93
|
+
if (strcmp(command, "sigmasoverlap") == 0) {
|
|
94
|
+
supfac = value;
|
|
95
|
+
}
|
|
96
|
+
if (strcmp(command, "sigmaschisquare") == 0) {
|
|
97
|
+
chifac = value;
|
|
98
|
+
}
|
|
99
|
+
}
|
|
100
|
+
fclose(f);
|
|
101
|
+
}
|
|
102
|
+
else {
|
|
103
|
+
printf("\n\n- Default options:");
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
printf("\nNumber of sigmas used to declare overlap between two models: %lf", supfac);
|
|
107
|
+
printf("\nNumber of sigmas in chi square distribution for model acceptance: %lf", chifac);
|
|
108
|
+
printf("\nMaximum number of models reported: %d", maxmodels);
|
|
109
|
+
supfac *= supfac;
|
|
110
|
+
|
|
111
|
+
switch (modelcode[0]) {
|
|
112
|
+
case 'P':
|
|
113
|
+
nps = 4;
|
|
114
|
+
break;
|
|
115
|
+
case 'B':
|
|
116
|
+
nps = 7;
|
|
117
|
+
if (modelcode[1] == 'O') {
|
|
118
|
+
nps += 3;
|
|
119
|
+
}
|
|
120
|
+
break;
|
|
121
|
+
case 'L':
|
|
122
|
+
nps = 7;
|
|
123
|
+
if (modelcode[1] == 'O') {
|
|
124
|
+
nps += 5;
|
|
125
|
+
}
|
|
126
|
+
break;
|
|
127
|
+
default:
|
|
128
|
+
printf("\n\n - Invalid model code!!!");
|
|
129
|
+
return -1;
|
|
130
|
+
}
|
|
131
|
+
if (modelcode[1] == 'X') {
|
|
132
|
+
nps += 2;
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
supfac *= nps;
|
|
136
|
+
|
|
137
|
+
printf("\n- Model code: %s", modelcode);
|
|
138
|
+
|
|
139
|
+
// Read curve to fit
|
|
140
|
+
|
|
141
|
+
printf("\n\nReading data\n");
|
|
142
|
+
|
|
143
|
+
|
|
144
|
+
current_path(eventname);
|
|
145
|
+
|
|
146
|
+
f = fopen("LCToFit.txt", "r");
|
|
147
|
+
fscanf(f, "%d", &np);
|
|
148
|
+
nfil = 1;
|
|
149
|
+
for (int i = 0; i < np; i++) {
|
|
150
|
+
fscanf(f, "%d %lf %lf %lf %d", &il, &t, &y, &w, &k);
|
|
151
|
+
if ((i != 0) && il!=nfil-1) {
|
|
152
|
+
nfil++;
|
|
153
|
+
}
|
|
154
|
+
}
|
|
155
|
+
fclose(f);
|
|
156
|
+
|
|
157
|
+
pr = (double*)malloc(sizeof(double) * (nps + 2 * nfil));
|
|
158
|
+
sigmapr = (double*)malloc(sizeof(double) * (nps + 2 * nfil));
|
|
159
|
+
Cov = (double*)malloc(sizeof(double) * (nps * nps));
|
|
160
|
+
Curv = (double*)malloc(sizeof(double) * (nps * nps));
|
|
161
|
+
|
|
162
|
+
dof = np - nps; // degrees of freedom
|
|
163
|
+
|
|
164
|
+
// Read models
|
|
165
|
+
|
|
166
|
+
printf("\n\nReading models\n");
|
|
167
|
+
|
|
168
|
+
if (!exists("PreModels")) {
|
|
169
|
+
printf("\n! No models for this class");
|
|
170
|
+
return 0;
|
|
171
|
+
}
|
|
172
|
+
current_path("PreModels");
|
|
173
|
+
nmod = 0;
|
|
174
|
+
|
|
175
|
+
auto searchstring = regex(string(modelcode) + "[0-9]*");
|
|
176
|
+
for (auto const& itr : directory_iterator(".")) {
|
|
177
|
+
if (regex_match((itr).path().filename().string(), searchstring) && (itr).is_directory()) {
|
|
178
|
+
current_path(itr);
|
|
179
|
+
|
|
180
|
+
f = fopen("nlc.dat", "r");
|
|
181
|
+
fscanf(f, "%d %d", &il, &nlc);
|
|
182
|
+
fclose(f);
|
|
183
|
+
|
|
184
|
+
for (int i1 = 0; i1 <= il; i1++) {
|
|
185
|
+
sprintf(filename, "%d.txt", i1);
|
|
186
|
+
// if(_findfirst(filename,&strfile)==-1) continue;
|
|
187
|
+
f = fopen(filename, "r");
|
|
188
|
+
for (int j = 0; j < nps + 2 * nfil; j++) {
|
|
189
|
+
fscanf(f, "%le", &(pr[j]));
|
|
190
|
+
}
|
|
191
|
+
fscanf(f, "%le", &(c0));
|
|
192
|
+
|
|
193
|
+
renorm = sqrt(c0 / dof);
|
|
194
|
+
|
|
195
|
+
for (int j = 0; j < nps + 2 * nfil; j++) {
|
|
196
|
+
fscanf(f, "%le", &(sigmapr[j]));
|
|
197
|
+
if (!(sigmapr[j] >= 0)) c0 = -1;
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
for (int i = 0; i < nps; i++) {
|
|
201
|
+
for (int j = 0; j < nps; j++) {
|
|
202
|
+
fscanf(f, "%le", &(Cov[i + j * nps]));
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
switch (modelcode[0]) {
|
|
207
|
+
case 'P':
|
|
208
|
+
sigmapr[1] = sigmapr[1] / pr[1];
|
|
209
|
+
sigmapr[3] = sigmapr[3] / pr[3];
|
|
210
|
+
pr[1] = log(pr[1]);
|
|
211
|
+
pr[3] = log(pr[3]);
|
|
212
|
+
if (modelcode[1] == 'S') {
|
|
213
|
+
sigmapr[0] = sigmapr[0] / pr[0];
|
|
214
|
+
pr[0] = log(pr[0]);
|
|
215
|
+
}
|
|
216
|
+
break;
|
|
217
|
+
case 'B':
|
|
218
|
+
if (modelcode[1] == 'O') {
|
|
219
|
+
sigmapr[2] = sigmapr[2] / pr[2];
|
|
220
|
+
sigmapr[3] = sigmapr[3] / pr[3];
|
|
221
|
+
sigmapr[9] = sigmapr[9] / pr[9];
|
|
222
|
+
pr[2] = log(pr[2]);
|
|
223
|
+
pr[3] = log(pr[3]);
|
|
224
|
+
pr[9] = log(pr[9]);
|
|
225
|
+
}
|
|
226
|
+
else {
|
|
227
|
+
sigmapr[0] = sigmapr[0] / pr[0];
|
|
228
|
+
sigmapr[1] = sigmapr[1] / pr[1];
|
|
229
|
+
sigmapr[6] = sigmapr[6] / pr[6];
|
|
230
|
+
pr[0] = log(pr[0]);
|
|
231
|
+
pr[1] = log(pr[1]);
|
|
232
|
+
pr[6] = log(pr[6]);
|
|
233
|
+
}
|
|
234
|
+
break;
|
|
235
|
+
case 'L':
|
|
236
|
+
sigmapr[0] = sigmapr[0] / pr[0];
|
|
237
|
+
sigmapr[1] = sigmapr[1] / pr[1];
|
|
238
|
+
sigmapr[4] = sigmapr[4] / pr[4];
|
|
239
|
+
sigmapr[5] = sigmapr[5] / pr[5];
|
|
240
|
+
pr[0] = log(pr[0]);
|
|
241
|
+
pr[1] = log(pr[1]);
|
|
242
|
+
pr[4] = log(pr[4]);
|
|
243
|
+
pr[5] = log(pr[5]);
|
|
244
|
+
//// If q>1, exchange the two masses
|
|
245
|
+
//if (pr[1] > 0) {
|
|
246
|
+
// pr[1] = -pr[1];
|
|
247
|
+
// pr[3] += M_PI;
|
|
248
|
+
//}
|
|
249
|
+
// Put alpha in [0,2\pi]
|
|
250
|
+
pr[3] -= floor(pr[3] / (2 * M_PI)) * 2 * M_PI;
|
|
251
|
+
if (modelcode[1] == 'S') {
|
|
252
|
+
//// If u0<0, use parametrization with u0>0
|
|
253
|
+
//if (pr[2] < 0) {
|
|
254
|
+
// pr[3] = 2 * M_PI - pr[3];
|
|
255
|
+
// pr[2] = -pr[2];
|
|
256
|
+
//}
|
|
257
|
+
}
|
|
258
|
+
break;
|
|
259
|
+
}
|
|
260
|
+
|
|
261
|
+
fclose(f);
|
|
262
|
+
|
|
263
|
+
// printf("\n%s %d",str2file.name,i1);
|
|
264
|
+
// Check for extremely negative blending
|
|
265
|
+
//for (int j = nps; j < nps + 2 * nfil; j += 2) {
|
|
266
|
+
// if (pr[j] < -pr[j + 1] * 0.5 /*|| pr[j + 1]<1.e-4*pr[j]*/) c0 = -1;
|
|
267
|
+
//}
|
|
268
|
+
|
|
269
|
+
if (c0 > 0) {
|
|
270
|
+
if (nmod) {
|
|
271
|
+
if (c0 < bumperlist->Amp) {
|
|
272
|
+
scanbumper = bumperlist;
|
|
273
|
+
bumperlist = new bumper(pr, nps);
|
|
274
|
+
bumperlist->SetCovariance(Cov, dof / c0);
|
|
275
|
+
strcpy(bumperlist->modelcode, (char *) (itr).path().filename().string().c_str());
|
|
276
|
+
bumperlist->il = i1;
|
|
277
|
+
bumperlist->Amp = c0;
|
|
278
|
+
bumperlist->next = scanbumper;
|
|
279
|
+
}
|
|
280
|
+
else {
|
|
281
|
+
scanbumper = bumperlist;
|
|
282
|
+
while ((scanbumper->next) && (scanbumper->next->Amp < c0)) scanbumper = scanbumper->next;
|
|
283
|
+
scanbumper2 = new bumper(pr, nps);
|
|
284
|
+
scanbumper2->SetCovariance(Cov, dof / c0);
|
|
285
|
+
strcpy(scanbumper2->modelcode, (char*)(itr).path().filename().string().c_str());
|
|
286
|
+
scanbumper2->il = i1;
|
|
287
|
+
scanbumper2->Amp = c0;
|
|
288
|
+
scanbumper2->next = scanbumper->next;
|
|
289
|
+
scanbumper->next = scanbumper2;
|
|
290
|
+
}
|
|
291
|
+
}
|
|
292
|
+
else {
|
|
293
|
+
bumperlist = new bumper(pr, nps);
|
|
294
|
+
bumperlist->SetCovariance(Cov, dof / c0);
|
|
295
|
+
strcpy(bumperlist->modelcode, (char*)(itr).path().filename().string().c_str());
|
|
296
|
+
bumperlist->il = i1;
|
|
297
|
+
bumperlist->Amp = c0;
|
|
298
|
+
}
|
|
299
|
+
nmod++;
|
|
300
|
+
}
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
current_path("..");
|
|
304
|
+
}
|
|
305
|
+
}
|
|
306
|
+
if (nmod == 0) {
|
|
307
|
+
printf("\n! No models for this class");
|
|
308
|
+
return 0;
|
|
309
|
+
}
|
|
310
|
+
printf("\nnmod: %d", nmod);
|
|
311
|
+
c1 = (bumperlist) ? bumperlist->Amp : 1.e100;
|
|
312
|
+
printf("\nNumber of initial models = %d\nMinimum chi square = %lf\n", nmod, c1);
|
|
313
|
+
chithr = c1 + c1 / dof * chifac * sqrt(2 * dof);
|
|
314
|
+
printf("\nThreshold for acceptable models = %lf\n", chithr);
|
|
315
|
+
|
|
316
|
+
// Apply reflections and check for redundancy
|
|
317
|
+
|
|
318
|
+
nmod = 0;
|
|
319
|
+
for (scanbumper = bumperlist; scanbumper; scanbumper = scanbumper->next) {
|
|
320
|
+
// Use these parameters as reference parameters for comparison with other models
|
|
321
|
+
for (int i = 0; i < nps; i++) {
|
|
322
|
+
pr[i] = scanbumper->p0[i];
|
|
323
|
+
}
|
|
324
|
+
// Check for overlap with all other models
|
|
325
|
+
for (scanbumper2 = bumperlist; scanbumper2 != scanbumper; scanbumper2 = scanbumper2->next) {
|
|
326
|
+
// Build inverse covariance as the inverse of the sum of covariances
|
|
327
|
+
CombineCovariances(scanbumper, scanbumper2, Cov, Curv, nps);
|
|
328
|
+
|
|
329
|
+
switch (modelcode[0]) {
|
|
330
|
+
// Single lens
|
|
331
|
+
case 'P':
|
|
332
|
+
facr = 0.;
|
|
333
|
+
for (int i = 0; i < nps; i++) {
|
|
334
|
+
for (int j = 0; j < nps; j++) {
|
|
335
|
+
facr += (pr[i] - (scanbumper2->p0)[i]) * (pr[j] - (scanbumper2->p0)[j]) * Curv[i * nps + j];
|
|
336
|
+
}
|
|
337
|
+
}
|
|
338
|
+
fac = facr;
|
|
339
|
+
break;
|
|
340
|
+
// Binary lens
|
|
341
|
+
case 'L':
|
|
342
|
+
// Check with no reflections
|
|
343
|
+
pr[1] = scanbumper->p0[1];
|
|
344
|
+
pr[2] = scanbumper->p0[2];
|
|
345
|
+
pr[3] = scanbumper->p0[3];
|
|
346
|
+
while (pr[3] - scanbumper2->p0[3] > M_PI) pr[3] -= 2*M_PI;
|
|
347
|
+
while (pr[3] - scanbumper2->p0[3] < -M_PI) pr[3] += 2*M_PI;
|
|
348
|
+
facr = 0.;
|
|
349
|
+
for (int i = 0; i < nps; i++) {
|
|
350
|
+
for (int j = 0; j < nps; j++) {
|
|
351
|
+
facr += (pr[i] - (scanbumper2->p0)[i]) * (pr[j] - (scanbumper2->p0)[j]) * Curv[i * nps + j];
|
|
352
|
+
}
|
|
353
|
+
}
|
|
354
|
+
fac = facr;
|
|
355
|
+
if(modelcode[1]=='S') {
|
|
356
|
+
// Repeat with reflection along x1 axis
|
|
357
|
+
pr[3] = 2 * M_PI - scanbumper->p0[3];
|
|
358
|
+
pr[2] = -scanbumper->p0[2];
|
|
359
|
+
while (pr[3] - scanbumper2->p0[3] > M_PI) pr[3] -= 2*M_PI;
|
|
360
|
+
while (pr[3] - scanbumper2->p0[3] < -M_PI) pr[3] += 2*M_PI;
|
|
361
|
+
|
|
362
|
+
scanbumper->signCovariance(2);
|
|
363
|
+
scanbumper->signCovariance(3);
|
|
364
|
+
CombineCovariances(scanbumper, scanbumper2, Cov, Curv, nps);
|
|
365
|
+
|
|
366
|
+
facr = 0.;
|
|
367
|
+
for (int i = 0; i < nps; i++) {
|
|
368
|
+
for (int j = 0; j < nps; j++) {
|
|
369
|
+
facr += (pr[i] - (scanbumper2->p0)[i]) * (pr[j] - (scanbumper2->p0)[j]) * Curv[i * nps + j];
|
|
370
|
+
}
|
|
371
|
+
}
|
|
372
|
+
if (facr < fac) fac = facr;
|
|
373
|
+
scanbumper->signCovariance(2);
|
|
374
|
+
scanbumper->signCovariance(3);
|
|
375
|
+
|
|
376
|
+
// Repeat with reflection between the two masses
|
|
377
|
+
pr[1] = -scanbumper->p0[1];
|
|
378
|
+
pr[3] = M_PI - scanbumper->p0[3];
|
|
379
|
+
pr[2] = -scanbumper->p0[2];
|
|
380
|
+
while (pr[3] - scanbumper2->p0[3] > M_PI) pr[3] -= 2*M_PI;
|
|
381
|
+
while (pr[3] - scanbumper2->p0[3] < -M_PI) pr[3] += 2*M_PI;
|
|
382
|
+
scanbumper->signCovariance(1);
|
|
383
|
+
scanbumper->signCovariance(2);
|
|
384
|
+
scanbumper->signCovariance(3);
|
|
385
|
+
CombineCovariances(scanbumper, scanbumper2, Cov, Curv, nps);
|
|
386
|
+
facr = 0.;
|
|
387
|
+
for (int i = 0; i < nps; i++) {
|
|
388
|
+
for (int j = 0; j < nps; j++) {
|
|
389
|
+
facr += (pr[i] - (scanbumper2->p0)[i]) * (pr[j] - (scanbumper2->p0)[j]) * Curv[i * nps + j];
|
|
390
|
+
}
|
|
391
|
+
}
|
|
392
|
+
if (facr < fac) fac = facr;
|
|
393
|
+
scanbumper->signCovariance(1);
|
|
394
|
+
scanbumper->signCovariance(2);
|
|
395
|
+
scanbumper->signCovariance(3);
|
|
396
|
+
}
|
|
397
|
+
|
|
398
|
+
// Repeat with both reflections
|
|
399
|
+
pr[3] = scanbumper->p0[3] - M_PI;
|
|
400
|
+
pr[2] = scanbumper->p0[2];
|
|
401
|
+
pr[1] = -scanbumper->p0[1];
|
|
402
|
+
while (pr[3] - scanbumper2->p0[3] > M_PI) pr[3] -= 2*M_PI;
|
|
403
|
+
while (pr[3] - scanbumper2->p0[3] < -M_PI) pr[3] += 2*M_PI;
|
|
404
|
+
scanbumper->signCovariance(1);
|
|
405
|
+
CombineCovariances(scanbumper, scanbumper2, Cov, Curv, nps);
|
|
406
|
+
facr = 0.;
|
|
407
|
+
for (int i = 0; i < nps; i++) {
|
|
408
|
+
for (int j = 0; j < nps; j++) {
|
|
409
|
+
facr += (pr[i] - (scanbumper2->p0)[i]) * (pr[j] - (scanbumper2->p0)[j]) * Curv[i * nps + j];
|
|
410
|
+
}
|
|
411
|
+
}
|
|
412
|
+
if (facr < fac) fac = facr;
|
|
413
|
+
scanbumper->signCovariance(1);
|
|
414
|
+
break;
|
|
415
|
+
// Binary source
|
|
416
|
+
case 'B':
|
|
417
|
+
// Check with no reflections
|
|
418
|
+
pr[1] = scanbumper->p0[1];
|
|
419
|
+
pr[2] = scanbumper->p0[2];
|
|
420
|
+
pr[3] = scanbumper->p0[3];
|
|
421
|
+
pr[4] = scanbumper->p0[4];
|
|
422
|
+
pr[5] = scanbumper->p0[5];
|
|
423
|
+
facr = 0.;
|
|
424
|
+
for (int i = 0; i < nps; i++) {
|
|
425
|
+
for (int j = 0; j < nps; j++) {
|
|
426
|
+
facr += (pr[i] - (scanbumper2->p0)[i]) * (pr[j] - (scanbumper2->p0)[j]) * Curv[i * nps + j];
|
|
427
|
+
}
|
|
428
|
+
}
|
|
429
|
+
fac = facr;
|
|
430
|
+
if (modelcode[1] == 'S') {
|
|
431
|
+
// Exchange two sources
|
|
432
|
+
pr[1] = -scanbumper->p0[1];
|
|
433
|
+
pr[2] = scanbumper->p0[3];
|
|
434
|
+
pr[3] = scanbumper->p0[2];
|
|
435
|
+
pr[4] = scanbumper->p0[5];
|
|
436
|
+
pr[5] = scanbumper->p0[4];
|
|
437
|
+
scanbumper->signCovariance(1);
|
|
438
|
+
scanbumper->flipCovariance(2, 3);
|
|
439
|
+
scanbumper->flipCovariance(4, 5);
|
|
440
|
+
CombineCovariances(scanbumper, scanbumper2, Cov, Curv, nps);
|
|
441
|
+
facr = 0.;
|
|
442
|
+
for (int i = 0; i < nps; i++) {
|
|
443
|
+
for (int j = 0; j < nps; j++) {
|
|
444
|
+
facr += (pr[i] - (scanbumper2->p0)[i]) * (pr[j] - (scanbumper2->p0)[j]) * Curv[i * nps + j];
|
|
445
|
+
}
|
|
446
|
+
}
|
|
447
|
+
if (facr < fac) fac = facr;
|
|
448
|
+
scanbumper->signCovariance(1);
|
|
449
|
+
scanbumper->flipCovariance(2, 3);
|
|
450
|
+
scanbumper->flipCovariance(4, 5);
|
|
451
|
+
}
|
|
452
|
+
}
|
|
453
|
+
// If models are closer than threshold, the higher chi square model is set beyond acceptance threshold
|
|
454
|
+
if (fac < supfac) {
|
|
455
|
+
if (scanbumper->Amp < scanbumper2->Amp) {
|
|
456
|
+
scanbumper2->Amp = chithr + 1;
|
|
457
|
+
}
|
|
458
|
+
else {
|
|
459
|
+
scanbumper->Amp = chithr + 1;
|
|
460
|
+
}
|
|
461
|
+
}
|
|
462
|
+
}
|
|
463
|
+
nmod++;
|
|
464
|
+
if (nmod - floor(nmod / 50.) * 50. == 0) printf("\nn: %d", nmod);
|
|
465
|
+
}
|
|
466
|
+
|
|
467
|
+
// Remove models beyond threshold and all duplicates which have been sent beyond threshold
|
|
468
|
+
if (bumperlist) {
|
|
469
|
+
while (bumperlist->Amp>chithr) {
|
|
470
|
+
nmod--;
|
|
471
|
+
scanbumper = bumperlist->next;
|
|
472
|
+
delete bumperlist;
|
|
473
|
+
bumperlist = scanbumper;
|
|
474
|
+
}
|
|
475
|
+
scanbumper = bumperlist;
|
|
476
|
+
fac = bumperlist->Amp;
|
|
477
|
+
while (scanbumper->next) {
|
|
478
|
+
if (scanbumper->next->Amp>chithr) {
|
|
479
|
+
nmod--;
|
|
480
|
+
scanbumper2 = scanbumper->next->next;
|
|
481
|
+
delete scanbumper->next;
|
|
482
|
+
scanbumper->next = scanbumper2;
|
|
483
|
+
}
|
|
484
|
+
else {
|
|
485
|
+
scanbumper = scanbumper->next;
|
|
486
|
+
}
|
|
487
|
+
}
|
|
488
|
+
}
|
|
489
|
+
|
|
490
|
+
printf("\nNumber of independent models with chi square less than \n%.1lf times the minimum = %d\n", chithr, nmod);
|
|
491
|
+
|
|
492
|
+
if (nmod > maxmodels) nmod = maxmodels;
|
|
493
|
+
printf("\nModels to be saved = %d\n", nmod);
|
|
494
|
+
|
|
495
|
+
|
|
496
|
+
// Store best models passing the selection in directory "Models"
|
|
497
|
+
|
|
498
|
+
current_path("..");
|
|
499
|
+
create_directory("Models");
|
|
500
|
+
|
|
501
|
+
scanbumper = bumperlist;
|
|
502
|
+
for (il = 1; il <= nmod; il++) {
|
|
503
|
+
// Copy corresponding file to directory Models
|
|
504
|
+
auto frompath = path("PreModels") / path(scanbumper->modelcode) / path(to_string(scanbumper->il) + ".txt");
|
|
505
|
+
auto topath = path("Models") / path(string(scanbumper->modelcode) + "-" + to_string(scanbumper->il) + ".txt");
|
|
506
|
+
copy_file(frompath, topath,copy_options::overwrite_existing);
|
|
507
|
+
scanbumper = scanbumper->next;
|
|
508
|
+
}
|
|
509
|
+
|
|
510
|
+
|
|
511
|
+
current_path("InitCond");
|
|
512
|
+
|
|
513
|
+
switch(modelcode[0]) {
|
|
514
|
+
case 'L':
|
|
515
|
+
if (modelcode[1] == 'S') {
|
|
516
|
+
// Preparation of initial conditions for parallax
|
|
517
|
+
printf("\n- Preparing initial conditions for parallax");
|
|
518
|
+
strcpy(filename, "PreInitCondLX.txt");
|
|
519
|
+
if (f = fopen("PreInitCondLX.txt", "r")) {
|
|
520
|
+
g = fopen("InitCondLX.txt", "w");
|
|
521
|
+
fscanf(f, "%d", &np);
|
|
522
|
+
fprintf(g, "0 %d\n", np + 2 * nmod);
|
|
523
|
+
printf("\nNumber of initial conditions: %d", np + 2 * nmod);
|
|
524
|
+
for (int i = 0; i < np; i++) {
|
|
525
|
+
for (int j = 0; j < 9; j++) {
|
|
526
|
+
fscanf(f, "%lg", &pr[j]);
|
|
527
|
+
fprintf(g, "%.10le ", pr[j]);
|
|
528
|
+
}
|
|
529
|
+
fprintf(g, "\n");
|
|
530
|
+
}
|
|
531
|
+
fclose(f);
|
|
532
|
+
|
|
533
|
+
scanbumper = bumperlist;
|
|
534
|
+
for (il = 1; il <= nmod; il++) {
|
|
535
|
+
for (int i = 0; i < nps; i++) {
|
|
536
|
+
pr[i] = scanbumper->p0[i];
|
|
537
|
+
}
|
|
538
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le 0.0e-003 0.0e-003\n", exp(pr[0]), exp(pr[1]), pr[2], pr[3], exp(pr[4]), exp(pr[5]), pr[6]);
|
|
539
|
+
pr[2] = -pr[2]; // Reflected solution
|
|
540
|
+
pr[3] = 2 * M_PI - pr[3];
|
|
541
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le 0.0e-003 0.0e-003\n", exp(pr[0]), exp(pr[1]), pr[2], pr[3], exp(pr[4]), exp(pr[5]), pr[6]);
|
|
542
|
+
scanbumper = scanbumper->next;
|
|
543
|
+
}
|
|
544
|
+
fclose(g);
|
|
545
|
+
}
|
|
546
|
+
}
|
|
547
|
+
if (modelcode[1] == 'X') {
|
|
548
|
+
printf("\n- Preparing initial conditions for orbital motion");
|
|
549
|
+
if (f = fopen("PreInitCondLO.txt", "r")) {
|
|
550
|
+
g = fopen("InitCondLO.txt", "w");
|
|
551
|
+
fscanf(f, "%d", &np);
|
|
552
|
+
fprintf(g, "0 %d\n", np + nmod);
|
|
553
|
+
printf("\nNumber of initial conditions: %d", np + nmod);
|
|
554
|
+
for (int i = 0; i < np; i++) {
|
|
555
|
+
for (int j = 0; j < 12; j++) {
|
|
556
|
+
fscanf(f, "%lg", &pr[j]);
|
|
557
|
+
fprintf(g, "%.10le ", pr[j]);
|
|
558
|
+
}
|
|
559
|
+
fprintf(g, "\n");
|
|
560
|
+
}
|
|
561
|
+
fclose(f);
|
|
562
|
+
|
|
563
|
+
scanbumper = bumperlist;
|
|
564
|
+
for (il = 1; il <= nmod; il++) {
|
|
565
|
+
for (int i = 0; i < nps; i++) {
|
|
566
|
+
pr[i] = scanbumper->p0[i];
|
|
567
|
+
}
|
|
568
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le 0.0e-006 0.0e-006 1.0e-006\n", exp(pr[0]), exp(pr[1]), pr[2], pr[3], exp(pr[4]), exp(pr[5]), pr[6], pr[7], pr[8]);
|
|
569
|
+
scanbumper = scanbumper->next;
|
|
570
|
+
}
|
|
571
|
+
fclose(g);
|
|
572
|
+
}
|
|
573
|
+
}
|
|
574
|
+
break;
|
|
575
|
+
case 'P':
|
|
576
|
+
if (modelcode[1] == 'S') {
|
|
577
|
+
// Preparation of initial conditions for parallax
|
|
578
|
+
printf("\n- Preparing initial conditions for parallax");
|
|
579
|
+
if (f = fopen("PreInitCondPX.txt", "r")) {
|
|
580
|
+
g = fopen("InitCondPX.txt", "w");
|
|
581
|
+
fscanf(f, "%d", &np);
|
|
582
|
+
fprintf(g, "0 %d\n", np + 2 * nmod);
|
|
583
|
+
printf("\nNumber of initial conditions: %d", np + 2 * nmod);
|
|
584
|
+
for (int i = 0; i < np; i++) {
|
|
585
|
+
for (int j = 0; j < 6; j++) {
|
|
586
|
+
fscanf(f, "%lg", &pr[j]);
|
|
587
|
+
fprintf(g, "%.10le ", pr[j]);
|
|
588
|
+
}
|
|
589
|
+
fprintf(g, "\n");
|
|
590
|
+
}
|
|
591
|
+
fclose(f);
|
|
592
|
+
|
|
593
|
+
scanbumper = bumperlist;
|
|
594
|
+
for (il = 1; il <= nmod; il++) {
|
|
595
|
+
for (int i = 0; i < nps; i++) {
|
|
596
|
+
pr[i] = scanbumper->p0[i];
|
|
597
|
+
}
|
|
598
|
+
fprintf(g, "%.10le %.10le %.10le %.10le 0.0e-003 0.0e-003\n", exp(pr[0]), exp(pr[1]), pr[2], exp(pr[3]));
|
|
599
|
+
// Reflected solution
|
|
600
|
+
fprintf(g, "%.10le %.10le %.10le %.10le 0.0e-003 0.0e-003\n", -exp(pr[0]), exp(pr[1]), pr[2], exp(pr[3]));
|
|
601
|
+
scanbumper = scanbumper->next;
|
|
602
|
+
}
|
|
603
|
+
fclose(g);
|
|
604
|
+
}
|
|
605
|
+
printf("\n- Adding initial conditions for planets");
|
|
606
|
+
if (f = fopen("PreInitCondLS.txt", "r")) {
|
|
607
|
+
int npeaks=0;
|
|
608
|
+
double* peaks;
|
|
609
|
+
g = fopen("InitCondLS.txt", "w");
|
|
610
|
+
fscanf(f, "%d %d", &npeaks, &np);
|
|
611
|
+
fprintf(g, "%d %d\n",npeaks, np + 4 * nmod);
|
|
612
|
+
peaks = (double*)malloc(sizeof(double) * npeaks);
|
|
613
|
+
|
|
614
|
+
printf("\nNumber of initial conditions: %d", np + 4 * nmod);
|
|
615
|
+
for (int i = 0; i < npeaks; i++) {
|
|
616
|
+
fscanf(f, "%lg", &peaks[i]);
|
|
617
|
+
fprintf(g, "%le", peaks[i]);
|
|
618
|
+
fscanf(f, "%[^\n]s", &buffer);
|
|
619
|
+
fprintf(g, "%s\n", buffer);
|
|
620
|
+
}
|
|
621
|
+
for (int i = 0; i < np; i++) {
|
|
622
|
+
for (int j = 0; j < 7; j++) {
|
|
623
|
+
fscanf(f, "%lg", &pr[j]);
|
|
624
|
+
fprintf(g, "%.10le ", pr[j]);
|
|
625
|
+
}
|
|
626
|
+
fprintf(g, "\n");
|
|
627
|
+
}
|
|
628
|
+
fclose(f);
|
|
629
|
+
|
|
630
|
+
|
|
631
|
+
scanbumper = bumperlist;
|
|
632
|
+
for (il = 1; il <= nmod; il++) {
|
|
633
|
+
for (int i = 0; i < nps; i++) {
|
|
634
|
+
pr[i] = scanbumper->p0[i];
|
|
635
|
+
}
|
|
636
|
+
|
|
637
|
+
double mindpeak = 1.e100;
|
|
638
|
+
int idpeak = 0;
|
|
639
|
+
for (int ipeak = 0; ipeak < npeaks; ipeak++) {
|
|
640
|
+
double ddpeak = fabs(peaks[ipeak] - pr[2]);
|
|
641
|
+
if (ddpeak < mindpeak) {
|
|
642
|
+
idpeak = ipeak;
|
|
643
|
+
mindpeak = ddpeak;
|
|
644
|
+
}
|
|
645
|
+
}
|
|
646
|
+
|
|
647
|
+
double u0 = exp(pr[0]);
|
|
648
|
+
double s0,s;
|
|
649
|
+
for (int ipeak = 0; ipeak < npeaks; ipeak++) {
|
|
650
|
+
if (ipeak == idpeak) continue;
|
|
651
|
+
double q = 0.001;
|
|
652
|
+
double dt = (peaks[ipeak] - pr[2]) / exp(pr[1]);
|
|
653
|
+
double xc = sqrt(u0 * u0 + dt * dt);
|
|
654
|
+
double alpha0 = atan2(u0, -dt), alpha;
|
|
655
|
+
double rho = 0.001; // exp(pr[3] - sqrt(scanbumper->cov[3 * nps + 3]));
|
|
656
|
+
|
|
657
|
+
s0 = 0.5 * (sqrt(4 + xc * xc) + xc);
|
|
658
|
+
while (xc < 4 * sqrt(q) / (s0 * s0)) q *= 0.1;
|
|
659
|
+
s = s0 + 4 * sqrt(q) / (s0 * s0);
|
|
660
|
+
alpha = alpha0;
|
|
661
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", s, q, u0, alpha, rho,exp(pr[1]),pr[2]);
|
|
662
|
+
s = s0 - 4 * sqrt(q) / (s0 * s0);
|
|
663
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2]);
|
|
664
|
+
|
|
665
|
+
s = 0.5 * (sqrt(4 + xc * xc) - xc);
|
|
666
|
+
|
|
667
|
+
while (xc < 2 * sqrt(q) / s) q *= 0.1;
|
|
668
|
+
alpha = alpha0 + M_PI + asin(fabs(2*sqrt(q)/s)/xc);
|
|
669
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2]);
|
|
670
|
+
alpha = alpha0 + M_PI - asin(fabs(2 * sqrt(q) / s) / xc);
|
|
671
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2]);
|
|
672
|
+
}
|
|
673
|
+
scanbumper = scanbumper->next;
|
|
674
|
+
}
|
|
675
|
+
fclose(g);
|
|
676
|
+
free(peaks);
|
|
677
|
+
}
|
|
678
|
+
}
|
|
679
|
+
else {
|
|
680
|
+
printf("\n- Adding initial conditions for planets");
|
|
681
|
+
if (f = fopen("PreInitCondLX.txt", "r")) {
|
|
682
|
+
int npeaks = 0;
|
|
683
|
+
double* peaks;
|
|
684
|
+
g = fopen("InitCondLX-2.txt", "w");
|
|
685
|
+
fscanf(f, "%d %d", &npeaks, &np);
|
|
686
|
+
fprintf(g, "%d %d\n", npeaks, np + 4 * nmod);
|
|
687
|
+
peaks = (double*)malloc(sizeof(double) * npeaks);
|
|
688
|
+
|
|
689
|
+
printf("\nNumber of initial conditions: %d", np + 4 * nmod);
|
|
690
|
+
for (int i = 0; i < npeaks; i++) {
|
|
691
|
+
fscanf(f, "%lg", &peaks[i]);
|
|
692
|
+
fprintf(g, "%le", peaks[i]);
|
|
693
|
+
fscanf(f, "%[^\n]s", &buffer);
|
|
694
|
+
fprintf(g, "%s\n", buffer);
|
|
695
|
+
}
|
|
696
|
+
for (int i = 0; i < np; i++) {
|
|
697
|
+
for (int j = 0; j < 9; j++) {
|
|
698
|
+
fscanf(f, "%lg", &pr[j]);
|
|
699
|
+
fprintf(g, "%.10le ", pr[j]);
|
|
700
|
+
}
|
|
701
|
+
fprintf(g, "\n");
|
|
702
|
+
}
|
|
703
|
+
fclose(f);
|
|
704
|
+
|
|
705
|
+
double mindpeak = 1.e100;
|
|
706
|
+
int idpeak = 0;
|
|
707
|
+
for (int ipeak = 0; ipeak < npeaks; ipeak++) {
|
|
708
|
+
double ddpeak = fabs(peaks[ipeak] - pr[2]);
|
|
709
|
+
if (ddpeak < mindpeak) {
|
|
710
|
+
idpeak = ipeak;
|
|
711
|
+
mindpeak = ddpeak;
|
|
712
|
+
}
|
|
713
|
+
}
|
|
714
|
+
|
|
715
|
+
scanbumper = bumperlist;
|
|
716
|
+
for (il = 1; il <= nmod; il++) {
|
|
717
|
+
for (int i = 0; i < nps; i++) {
|
|
718
|
+
pr[i] = scanbumper->p0[i];
|
|
719
|
+
}
|
|
720
|
+
|
|
721
|
+
double mindpeak = 1.e100;
|
|
722
|
+
int idpeak = 0;
|
|
723
|
+
for (int ipeak = 0; ipeak < npeaks; ipeak++) {
|
|
724
|
+
double ddpeak = fabs(peaks[ipeak] - pr[2]);
|
|
725
|
+
if (ddpeak < mindpeak) {
|
|
726
|
+
idpeak = ipeak;
|
|
727
|
+
mindpeak = ddpeak;
|
|
728
|
+
}
|
|
729
|
+
}
|
|
730
|
+
|
|
731
|
+
double u0 = exp(pr[0]);
|
|
732
|
+
double s0, s;
|
|
733
|
+
for (int ipeak = 0; ipeak < npeaks; ipeak++) {
|
|
734
|
+
if (ipeak == idpeak) continue;
|
|
735
|
+
double q = 0.001;
|
|
736
|
+
double dt = (peaks[ipeak] - pr[2]) / exp(pr[1]);
|
|
737
|
+
double xc = sqrt(u0 * u0 + dt * dt);
|
|
738
|
+
double alpha0 = atan2(u0, -dt), alpha;
|
|
739
|
+
double rho = 0.001; // exp(pr[3] - sqrt(scanbumper->cov[3 * nps + 3]));
|
|
740
|
+
|
|
741
|
+
s0 = 0.5 * (sqrt(4 + xc * xc) + xc);
|
|
742
|
+
while (xc < 4 * sqrt(q) / (s0 * s0)) q *= 0.1;
|
|
743
|
+
s = s0 + 4 * sqrt(q) / (s0 * s0);
|
|
744
|
+
alpha = alpha0;
|
|
745
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2], pr[4], pr[5]);
|
|
746
|
+
s = s0 - 4 * sqrt(q) / (s0 * s0);
|
|
747
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2], pr[4], pr[5]);
|
|
748
|
+
|
|
749
|
+
s = 0.5 * (sqrt(4 + xc * xc) - xc);
|
|
750
|
+
|
|
751
|
+
while (xc < 2 * sqrt(q) / s) q *= 0.1;
|
|
752
|
+
alpha = alpha0 + M_PI + asin(fabs(2 * sqrt(q) / s) / xc);
|
|
753
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2], pr[4], pr[5]);
|
|
754
|
+
alpha = alpha0 + M_PI - asin(fabs(2 * sqrt(q) / s) / xc);
|
|
755
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2], pr[4], pr[5]);
|
|
756
|
+
}
|
|
757
|
+
scanbumper = scanbumper->next;
|
|
758
|
+
}
|
|
759
|
+
|
|
760
|
+
fclose(g);
|
|
761
|
+
free(peaks);
|
|
762
|
+
|
|
763
|
+
if (g = fopen("InitCondLS.txt", "r")) {
|
|
764
|
+
fclose(g);
|
|
765
|
+
remove("PreInitCondLX.txt");
|
|
766
|
+
rename("InitCondLX-2.txt", "PreInitCondLX.txt");
|
|
767
|
+
}
|
|
768
|
+
else {
|
|
769
|
+
rename("InitCondLX-2.txt", "InitCondLX.txt");
|
|
770
|
+
}
|
|
771
|
+
}
|
|
772
|
+
else {
|
|
773
|
+
if (f = fopen("PreInitCondLO.txt", "r")) {
|
|
774
|
+
int npeaks = 0;
|
|
775
|
+
double* peaks;
|
|
776
|
+
g = fopen("InitCondLO-2.txt", "w");
|
|
777
|
+
fscanf(f, "%d %d", &npeaks, &np);
|
|
778
|
+
fprintf(g, "%d %d\n", npeaks, np + 4 * nmod);
|
|
779
|
+
peaks = (double*)malloc(sizeof(double) * npeaks);
|
|
780
|
+
|
|
781
|
+
printf("\nNumber of initial conditions: %d", np + 4 * nmod);
|
|
782
|
+
for (int i = 0; i < npeaks; i++) {
|
|
783
|
+
fscanf(f, "%lg", &peaks[i]);
|
|
784
|
+
fprintf(g, "%le", peaks[i]);
|
|
785
|
+
fscanf(f, "%[^\n]s", &buffer);
|
|
786
|
+
fprintf(g, "%s\n", buffer);
|
|
787
|
+
}
|
|
788
|
+
for (int i = 0; i < np; i++) {
|
|
789
|
+
for (int j = 0; j < 12; j++) {
|
|
790
|
+
fscanf(f, "%lg", &pr[j]);
|
|
791
|
+
fprintf(g, "%.10le ", pr[j]);
|
|
792
|
+
}
|
|
793
|
+
fprintf(g, "\n");
|
|
794
|
+
}
|
|
795
|
+
fclose(f);
|
|
796
|
+
|
|
797
|
+
double mindpeak = 1.e100;
|
|
798
|
+
int idpeak = 0;
|
|
799
|
+
for (int ipeak = 0; ipeak < npeaks; ipeak++) {
|
|
800
|
+
double ddpeak = fabs(peaks[ipeak] - pr[2]);
|
|
801
|
+
if (ddpeak < mindpeak) {
|
|
802
|
+
idpeak = ipeak;
|
|
803
|
+
mindpeak = ddpeak;
|
|
804
|
+
}
|
|
805
|
+
}
|
|
806
|
+
|
|
807
|
+
scanbumper = bumperlist;
|
|
808
|
+
for (il = 1; il <= nmod; il++) {
|
|
809
|
+
for (int i = 0; i < nps; i++) {
|
|
810
|
+
pr[i] = scanbumper->p0[i];
|
|
811
|
+
}
|
|
812
|
+
|
|
813
|
+
double mindpeak = 1.e100;
|
|
814
|
+
int idpeak = 0;
|
|
815
|
+
for (int ipeak = 0; ipeak < npeaks; ipeak++) {
|
|
816
|
+
double ddpeak = fabs(peaks[ipeak] - pr[2]);
|
|
817
|
+
if (ddpeak < mindpeak) {
|
|
818
|
+
idpeak = ipeak;
|
|
819
|
+
mindpeak = ddpeak;
|
|
820
|
+
}
|
|
821
|
+
}
|
|
822
|
+
|
|
823
|
+
double u0 = exp(pr[0]);
|
|
824
|
+
double s0, s;
|
|
825
|
+
for (int ipeak = 0; ipeak < npeaks; ipeak++) {
|
|
826
|
+
if (ipeak == idpeak) continue;
|
|
827
|
+
double q = 0.001;
|
|
828
|
+
double dt = (peaks[ipeak] - pr[2]) / exp(pr[1]);
|
|
829
|
+
double xc = sqrt(u0 * u0 + dt * dt);
|
|
830
|
+
double alpha0 = atan2(u0, -dt), alpha;
|
|
831
|
+
double rho = 0.001; // exp(pr[3] - sqrt(scanbumper->cov[3 * nps + 3]));
|
|
832
|
+
|
|
833
|
+
s0 = 0.5 * (sqrt(4 + xc * xc) + xc);
|
|
834
|
+
while (xc < 4 * sqrt(q) / (s0 * s0)) q *= 0.1;
|
|
835
|
+
s = s0 + 4 * sqrt(q) / (s0 * s0);
|
|
836
|
+
alpha = alpha0;
|
|
837
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le 0.0001 0.0001 0.0001\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2], pr[4], pr[5]);
|
|
838
|
+
s = s0 - 4 * sqrt(q) / (s0 * s0);
|
|
839
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le 0.0001 0.0001 0.0001\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2], pr[4], pr[5]);
|
|
840
|
+
|
|
841
|
+
s = 0.5 * (sqrt(4 + xc * xc) - xc);
|
|
842
|
+
|
|
843
|
+
while (xc < 2 * sqrt(q) / s) q *= 0.1;
|
|
844
|
+
alpha = alpha0 + M_PI + asin(fabs(2 * sqrt(q) / s) / xc);
|
|
845
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le 0.0001 0.0001 0.0001\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2], pr[4], pr[5]);
|
|
846
|
+
alpha = alpha0 + M_PI - asin(fabs(2 * sqrt(q) / s) / xc);
|
|
847
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le 0.0001 0.0001 0.0001\n", s, q, u0, alpha, rho, exp(pr[1]), pr[2], pr[4], pr[5]);
|
|
848
|
+
}
|
|
849
|
+
scanbumper = scanbumper->next;
|
|
850
|
+
}
|
|
851
|
+
|
|
852
|
+
fclose(g);
|
|
853
|
+
free(peaks);
|
|
854
|
+
|
|
855
|
+
rename("InitCondLO-2.txt", "InitCondLO.txt");
|
|
856
|
+
}
|
|
857
|
+
}
|
|
858
|
+
}
|
|
859
|
+
break;
|
|
860
|
+
case 'B':
|
|
861
|
+
if (modelcode[1] == 'S') {
|
|
862
|
+
// Preparation of initial conditions for xallarap
|
|
863
|
+
printf("\n- Preparing initial conditions for xallarap");
|
|
864
|
+
if (f = fopen("PreInitCondBO.txt", "r")) {
|
|
865
|
+
g = fopen("InitCondBO.txt", "w");
|
|
866
|
+
fscanf(f, "%d", &np);
|
|
867
|
+
fprintf(g, "0 %d\n", np + 2 * nmod);
|
|
868
|
+
printf("\nNumber of initial conditions: %d", np + 2 * nmod);
|
|
869
|
+
for (int i = 0; i < np; i++) {
|
|
870
|
+
for (int j = 0; j < 10; j++) {
|
|
871
|
+
fscanf(f, "%lg", &pr[j]);
|
|
872
|
+
fprintf(g, "%.10le ", pr[j]);
|
|
873
|
+
}
|
|
874
|
+
fprintf(g, "\n");
|
|
875
|
+
}
|
|
876
|
+
fclose(f);
|
|
877
|
+
|
|
878
|
+
scanbumper = bumperlist;
|
|
879
|
+
for (il = 1; il <= nmod; il++) {
|
|
880
|
+
for (int i = 0; i < nps; i++) {
|
|
881
|
+
pr[i] = scanbumper->p0[i];
|
|
882
|
+
}
|
|
883
|
+
double u01 = pr[2];
|
|
884
|
+
double u02 = pr[3];
|
|
885
|
+
double tE = exp(pr[0]);
|
|
886
|
+
double qs = exp(pr[1]/4);
|
|
887
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", u01, pr[4], tE, exp(pr[6]), (pr[5] - pr[4]) / tE / (1 + qs) * qs, (-u02 + u01) / (1 + qs) * qs, 0.000001, 0.0001, 0.00001, qs);
|
|
888
|
+
// Reflected solution
|
|
889
|
+
fprintf(g, "%.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le %.10le\n", u01, pr[4], tE, exp(pr[6]), (pr[5] - pr[4]) / tE / (1 + qs) * qs, (u02 + u01) / (1 + qs) * qs, 0.000001, 0.0001, 0.00001, qs);
|
|
890
|
+
scanbumper = scanbumper->next;
|
|
891
|
+
}
|
|
892
|
+
fclose(g);
|
|
893
|
+
}
|
|
894
|
+
}
|
|
895
|
+
break;
|
|
896
|
+
}
|
|
897
|
+
|
|
898
|
+
printf("\n\n- Closing...");
|
|
899
|
+
|
|
900
|
+
scanbumper = bumperlist;
|
|
901
|
+
while (scanbumper) {
|
|
902
|
+
scanbumper2 = scanbumper->next;
|
|
903
|
+
delete scanbumper;
|
|
904
|
+
scanbumper = scanbumper2;
|
|
905
|
+
}
|
|
906
|
+
|
|
907
|
+
free(pr);
|
|
908
|
+
free(sigmapr);
|
|
909
|
+
free(Cov);
|
|
910
|
+
free(Curv);
|
|
911
|
+
|
|
912
|
+
return 0;
|
|
913
|
+
}
|