~christopher-hunt08/maus/maus_analysis_devel
» Revision
1258
: src/reduce/ReduceCppEVExport/EVHepRepExporter.cc
« back to all changes in this revision
Viewing changes to src/reduce/ReduceCppEVExport/EVHepRepExporter.cc
- browse files at revision 1258
- compare with another revision
- download diff
- download tarball
- view history from revision 1258
- Committer: Christopher Hunt
- Date: 2018-04-05 10:33:21 UTC
- mfrom: (697.23.8 merge3)
- Revision ID: christopher.hunt08@imperial.ac.uk-20180405103321-3q8yf42av2jrqw6o
Merged Trunk
- files added:
- bin/utilities/execute_data_recon.py
- src/reduce/ReduceCppEVExport
- files modified:
- README
added
removed
src/reduce/ReduceCppEVExport/EVHepRepExporter.cc
1
/* This file is part of MAUS: http://micewww.pp.rl.ac.uk:8080/projects/maus
2
*
3
* MAUS is free software: you can redistribute it and/or modify
4
* it under the terms of the GNU General Public License as published by
5
* the Free Software Foundation, either version 3 of the License, or
6
* (at your option) any later version.
7
*
8
* MAUS is distributed in the hope that it will be useful,
9
* but WITHOUT ANY WARRANTY; without even the implied warranty of
10
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
* GNU General Public License for more details.
12
*
13
* You should have received a copy of the GNU General Public License
14
* along with MAUS. If not, see <http://www.gnu.org/licenses/>.
15
*
16
*/
17
18
19
#include "src/reduce/ReduceCppEVExport/EVHepRepExporter.hh"
20
21
#include <unistd.h>
22
#include <string>
23
#include <sstream>
24
#include <fstream>
25
#include <vector>
26
27
namespace EventViewer {
28
29
EVHepRepExporter::EVHepRepExporter(EVEvent evEvent) {
30
event = evEvent;
31
}
32
33
EVHepRepExporter::~EVHepRepExporter() {
34
delete mm; // is this really necessary?
35
// Do nothing
36
}
37
38
void EVHepRepExporter::Export(int display) {
39
40
HepRepXMLWriter* writer = new HepRepXMLWriter();
41
std::stringstream ssOutFileName;
42
43
// - retrieve destination directory
44
char *destDir = getenv("EV_DEST_DIR");
45
if (destDir != NULL)
46
ssOutFileName << destDir << "/";
47
else
48
ssOutFileName << "./";
49
50
// - open output heprep file
51
ssOutFileName << "MICEEvent_" << event.runNumber << "_" << event.spillNumber
52
<< "_" << event.eventNumber << ".heprep";
53
std::string dataFileName = "data.heprep";
54
writer->open(dataFileName.c_str());
55
56
// - define tof points
57
writer->addType("TOFPoints", 0);
58
writer->addInstance();
59
writer->addAttValue("DrawAs", "Point");
60
writer->addAttValue("MarkName", "Box");
61
writer->addAttValue("MarkColor", 0., 1., 1.);
62
for (int point = 0; point < 3; ++point) {
63
double x = event.tofPoints[point][0];
64
double y = event.tofPoints[point][1];
65
double z = event.tofPoints[point][2];
66
if (z != 5673390) {
67
writer->addPrimitive();
68
writer->addPoint(x, y, z);
69
}
70
}
71
72
// - define track points
73
writer->addType("TrackPoints", 0);
74
writer->addInstance();
75
writer->addAttValue("DrawAs", "Point");
76
77
// - plot TKU track points in HepRApp
78
writer->addType("TKUTrackPoints", 1);
79
writer->addInstance();
80
writer->addAttValue("MarkName", "Cross");
81
writer->addAttValue("MarkColor", 1., 1., 0.);
82
for (int point = 0; point < 5; ++point) {
83
writer->addType("TKUTrackPoint", 2); // add layer of depth to apply attibutes
84
writer->addInstance();
85
86
double x = event.scifiUSTrackerPoints[point][0];
87
double y = event.scifiUSTrackerPoints[point][1];
88
double z = event.scifiUSTrackerPoints[point][2];
89
90
// attributes - momentum components
91
writer->addAttDef("Px", "Track momentum x component", "Physics", "GeV");
92
writer->addAttDef("Py", "Track momentum y component", "Physics", "GeV");
93
writer->addAttDef("Pz", "Track momentum z component", "Physics", "GeV");
94
writer->addAttValue("Px", event.scifiUSTrackerPointsMomenta[point][0]);
95
writer->addAttValue("Py", event.scifiUSTrackerPointsMomenta[point][1]);
96
writer->addAttValue("Pz", event.scifiUSTrackerPointsMomenta[point][2]);
97
98
if (z != 5673390) {
99
writer->addPrimitive();
100
writer->addPoint(x, y, z);
101
}
102
}
103
104
// - plot TKD track points in HepRApp
105
writer->addType("TKDTrackPoints", 1);
106
writer->addInstance();
107
writer->addAttValue("MarkName", "Cross");
108
writer->addAttValue("MarkColor", 1., 1., 0.);
109
for (int point = 0; point < 5; ++point) {
110
writer->addType("TKDTrackPoint", 2); // add layer of depth to apply attibutes
111
writer->addInstance();
112
113
double x = event.scifiDSTrackerPoints[point][0];
114
double y = event.scifiDSTrackerPoints[point][1];
115
double z = event.scifiDSTrackerPoints[point][2];
116
117
// attributes - momentum components
118
writer->addAttDef("Px", "Track momentum x component", "Physics", "GeV");
119
writer->addAttDef("Py", "Track momentum y component", "Physics", "GeV");
120
writer->addAttDef("Pz", "Track momentum z component", "Physics", "GeV");
121
writer->addAttValue("Px", event.scifiUSTrackerPointsMomenta[point][0]);
122
writer->addAttValue("Py", event.scifiUSTrackerPointsMomenta[point][1]);
123
writer->addAttValue("Pz", event.scifiUSTrackerPointsMomenta[point][2]);
124
125
if (z != 5673390) {
126
writer->addPrimitive();
127
writer->addPoint(x, y, z);
128
}
129
}
130
131
// - define space points
132
writer->addType("SpacePoints", 0);
133
writer->addInstance();
134
writer->addAttValue("DrawAs", "Point");
135
136
// - plot TKU space points in HepRApp
137
writer->addType("TKUSpacePoints", 1);
138
writer->addInstance();
139
writer->addAttValue("MarkName", "Cross");
140
writer->addAttValue("MarkColor", 1., 0.3, 0.);
141
for (std::vector<MAUS::ThreeVector>::iterator it = event.scifiUSTrackerSpacePoints.begin(),
142
end = event.scifiUSTrackerSpacePoints.end(); it != end; ++it) {
143
writer->addType("TKUSpacePoint", 2); // add layer of depth to apply attibutes
144
writer->addInstance();
145
146
double x = it->x();
147
double y = it->y();
148
double z = it->z();
149
150
writer->addAttDef("alpha P0", "Cluster info for plane 0 - alpha", "Physics", "channel");
151
writer->addAttDef("z P0", "Cluster info for plane 0 - z", "Physics", "mm");
152
writer->addAttDef("alpha P1", "Cluster info for plane 1", "Physics", "channel");
153
writer->addAttDef("z P1", "Cluster info for plane 1 - z", "Physics", "mm");
154
writer->addAttDef("alpha P2", "Cluster info for plane 2", "Physics", "channel");
155
writer->addAttDef("z P2", "Cluster info for plane 2 - z", "Physics", "mm");
156
unsigned int station = it - event.scifiUSTrackerSpacePoints.begin();
157
if (station < event.scifiUSTrackerClusters[0][0].size()) {
158
writer->addAttValue("alpha P0", event.scifiUSTrackerClusters[0][0][station]);
159
writer->addAttValue("z P0", event.scifiUSTrackerClusters[0][1][station]);
160
}
161
if (station < event.scifiUSTrackerClusters[1][0].size()) {
162
writer->addAttValue("alpha P1", event.scifiUSTrackerClusters[1][0][station]);
163
writer->addAttValue("z P1", event.scifiUSTrackerClusters[1][1][station]);
164
}
165
if (station < event.scifiUSTrackerClusters[2][0].size()) {
166
writer->addAttValue("alpha P2", event.scifiUSTrackerClusters[2][0][station]);
167
writer->addAttValue("z P2", event.scifiUSTrackerClusters[2][1][station]);
168
}
169
170
if (z != 5673390) { // should be 5673390
171
writer->addPrimitive();
172
writer->addPoint(x, y, z);
173
}
174
}
175
176
// - plot TKD space points in HepRApp
177
writer->addType("TKDSpacePoints", 1);
178
writer->addInstance();
179
writer->addAttValue("MarkName", "Cross");
180
writer->addAttValue("MarkColor", 1., 0.3, 0.);
181
for (std::vector<MAUS::ThreeVector>::iterator it = event.scifiDSTrackerSpacePoints.begin(),
182
end = event.scifiDSTrackerSpacePoints.end(); it != end; ++it) {
183
writer->addType("TKDSpacePoint", 2); // add layer of depth to apply attibutes
184
writer->addInstance();
185
186
double x = it->x();
187
double y = it->y();
188
double z = it->z();
189
190
writer->addAttDef("alpha P0", "Cluster info for plane 0 - alpha", "Physics", "channel");
191
writer->addAttDef("z P0", "Cluster info for plane 0 - z", "Physics", "mm");
192
writer->addAttDef("alpha P1", "Cluster info for plane 1", "Physics", "channel");
193
writer->addAttDef("z P1", "Cluster info for plane 1 - z", "Physics", "mm");
194
writer->addAttDef("alpha P2", "Cluster info for plane 2", "Physics", "channel");
195
writer->addAttDef("z P2", "Cluster info for plane 2 - z", "Physics", "mm");
196
unsigned int station = it - event.scifiDSTrackerSpacePoints.begin();
197
if (station < event.scifiDSTrackerClusters[0][0].size()) {
198
writer->addAttValue("alpha P0", event.scifiDSTrackerClusters[0][0][station]);
199
writer->addAttValue("z P0", event.scifiDSTrackerClusters[0][1][station]);
200
}
201
if (station < event.scifiDSTrackerClusters[1][0].size()) {
202
writer->addAttValue("alpha P1", event.scifiDSTrackerClusters[1][0][station]);
203
writer->addAttValue("z P1", event.scifiDSTrackerClusters[1][1][station]);
204
}
205
if (station < event.scifiDSTrackerClusters[2][0].size()) {
206
writer->addAttValue("alpha P2", event.scifiDSTrackerClusters[2][0][station]);
207
writer->addAttValue("z P2", event.scifiDSTrackerClusters[2][1][station]);
208
}
209
210
if (z != 5673390) { // should be 5673390
211
writer->addPrimitive();
212
writer->addPoint(x, y, z);
213
}
214
}
215
216
// - define straight track
217
writer->addType("StraightTrack", 0);
218
writer->addInstance();
219
writer->addAttValue("DrawAs", "Line");
220
writer->addAttValue("LineColor", 1., 0., 0.);
221
222
// - plot TKU straight track(s)
223
writer->addType("TKUStraightTrack", 1);
224
writer->addInstance();
225
writer->addPrimitive();
226
for (int point = 0; point < 2; ++point) {
227
double x = event.scifiUSTrackerStraightTrackPoints[point][0];
228
double y = event.scifiUSTrackerStraightTrackPoints[point][1];
229
double z = event.scifiUSTrackerStraightTrackPoints[point][2];
230
if (z != 5673390) { // ToDo: define dummy value at one place and use through out
231
writer->addPoint(x, y, z);
232
}
233
}
234
235
236
// - load parent geometry mice module (needed for helical track transformations)
237
std::stringstream modulePath;
238
if (getenv("EV_GEOM_HOME"))
239
modulePath << getenv("EV_GEOM_HOME") << "/ParentGeometryFile.dat";
240
else
241
modulePath << getenv("MAUS_ROOT_DIR") << "/files/geometry/download/ParentGeometryFile.dat";
242
243
// - Adam's fix (redirecting stdout/stderr)
244
std::ostream* stdout = new std::ofstream();
245
stdout->rdbuf(std::cout.rdbuf());
246
std::ostream* stderr = new std::ofstream();
247
stderr->rdbuf(std::cerr.rdbuf());
248
249
// - leaving this commented out code in case OnRec crashes debugging is resumed
250
/*try {
251
std::cout << "Run: " << event.runNumber << " Spill: " << event.spillNumber
252
<< " Event: " << event.eventNumber << " Try MM" << std::endl;
253
mm = new MiceModule(modulePath.str());
254
std::cout << "Just MM init" << std::endl;
255
std::cout.rdbuf(stdout->rdbuf());
256
std::cerr.rdbuf(stderr->rdbuf());
257
std::cout << "Just before catch" << std::endl;
258
} catch (MAUS::Exceptions::Exception e) {
259
std::cerr << "[EVHepRepExporter]Caught exception while building MiceModules! "
260
<< "Possibly ParentGeometryFile.dat missing! Using default geometry!" << std::endl;
261
e.what();
262
e.Print();
263
modulePath.str("");
264
modulePath << getenv("MAUS_ROOT_DIR") << "/src/utilities/event-viewer/ParentGeometryFile.dat";
265
try {
266
mm = new MiceModule(modulePath.str());
267
std::cout.rdbuf(stdout->rdbuf());
268
std::cerr.rdbuf(stderr->rdbuf());
269
} catch (MAUS::Exceptions::Exception e) {
270
std::cerr << "[EVHepRepExporter]Caught exception while building MiceModules! "
271
<< "Possibly ParentGeometryFile.dat missing! Using default geometry!" << std::endl;
272
e.what();
273
e.Print();
274
return;
275
}
276
}
277
278
if (mm) {// substitute this with simple check
279
std::cout << "MM path: " << modulePath.str() << " MM name: " << mm->name() << std::endl;
280
} else {
281
std::cerr << "Bad mm pointer: " << mm << std::endl;
282
return;
283
}*/
284
285
try {
286
mm = new MiceModule(modulePath.str());
287
std::cout.rdbuf(stdout->rdbuf());
288
std::cerr.rdbuf(stderr->rdbuf());
289
} catch (MAUS::Exceptions::Exception e) {
290
std::cerr << "Caught exception while building MiceModules" << std::endl;
291
e.what();
292
e.Print();
293
modulePath.str("");
294
// this file should be included in the release so no try/catch neccessary
295
// (file in this dir not referenced? remove?)
296
modulePath << getenv("MAUS_ROOT_DIR") << "/src/utilities/event-viewer/ParentGeometryFile.dat";
297
mm = new MiceModule(modulePath.str());
298
std::cout.rdbuf(stdout->rdbuf());
299
std::cerr.rdbuf(stderr->rdbuf());
300
}/**/
301
302
303
// --- fetch US tracker global geometry
304
mmTrackerUS = mm->findModulesByName("ParentGeometryFile.dat/Tracker0.dat");
305
306
// - get TrackerRef0 position
307
double trackerRef0posX = mmTrackerUS[0]->daughter(0)->globalPosition().x();
308
double trackerRef0posY = mmTrackerUS[0]->daughter(0)->globalPosition().y();
309
double trackerRef0posZ = mmTrackerUS[0]->daughter(0)->globalPosition().z();
310
311
// - get rotation matrix
312
double xx = mmTrackerUS[0]->globalRotation().xx();
313
double xy = mmTrackerUS[0]->globalRotation().xy();
314
double xz = mmTrackerUS[0]->globalRotation().xz();
315
double yx = mmTrackerUS[0]->globalRotation().yx();
316
double yy = mmTrackerUS[0]->globalRotation().yy();
317
double yz = mmTrackerUS[0]->globalRotation().yz();
318
double zx = mmTrackerUS[0]->globalRotation().zx();
319
double zy = mmTrackerUS[0]->globalRotation().zy();
320
double zz = mmTrackerUS[0]->globalRotation().zz();
321
322
// - fill matrix elements (for VectorTransform)
323
std::vector<double> matrixElements;
324
matrixElements.push_back(xx);
325
matrixElements.push_back(xy);
326
matrixElements.push_back(xz);
327
matrixElements.push_back(yx);
328
matrixElements.push_back(yy);
329
matrixElements.push_back(yz);
330
matrixElements.push_back(zx);
331
matrixElements.push_back(zy);
332
matrixElements.push_back(zz);/**/
333
334
// - dimensions (y coordinate is length)
335
Hep3Vector dimensions = mmTrackerUS[0]->dimensions();
336
double trackerLength = dimensions.y();
337
338
// - plot TKU helical track(s)
339
writer->addType("TKUHelicalTrackTest", 1);
340
writer->addInstance();
341
writer->addPrimitive();
342
double circle_x0 = event.scifiUSTrackerHelicalTrackParameters[0];
343
double circle_y0 = event.scifiUSTrackerHelicalTrackParameters[1];
344
double radius = event.scifiUSTrackerHelicalTrackParameters[2];
345
double dsdz = event.scifiUSTrackerHelicalTrackParameters[3];
346
double line_dz_c = event.scifiUSTrackerHelicalTrackParameters[4];
347
double posZ = event.scifiUSTrackerHelicalTrackParameters[7];
348
349
double zLocal = posZ;
350
int zStep = trackerLength/300;
351
while (zLocal < trackerLength) {
352
zLocal += zStep; // z value in tracker local reference system
353
// x value in tracker local reference system
354
double upstream_helix_x_value
355
= circle_x0 + (radius*cos((1/radius)*(dsdz*zLocal+line_dz_c)));
356
// y value in tracker local reference system
357
double upstream_helix_y_value
358
= circle_y0 + (radius*sin((1/radius)*(dsdz*zLocal+line_dz_c)));
359
360
// transformation to global coordinate system
361
std::vector<double> vSpacePoint
362
= {upstream_helix_x_value, upstream_helix_y_value, zLocal};
363
VectorTransform trans(vSpacePoint);
364
trans.Rotate(matrixElements, "reg");
365
trans.Translate(trackerRef0posX, trackerRef0posY, trackerRef0posZ, "reg");
366
367
double x = trans.GetX();
368
double y = trans.GetY();
369
double z = trans.GetZ();
370
371
writer->addPoint(x, y, z);
372
}
373
374
375
// - plot TKD straight track(s)
376
writer->addType("TKDStraightTrack", 1);
377
writer->addInstance();
378
writer->addPrimitive();
379
for (int point = 0; point < 2; ++point) {
380
double x = event.scifiDSTrackerStraightTrackPoints[point][0];
381
double y = event.scifiDSTrackerStraightTrackPoints[point][1];
382
double z = event.scifiDSTrackerStraightTrackPoints[point][2];
383
if (z != 5673390) {
384
writer->addPoint(x, y, z);
385
}
386
}
387
388
389
// --- fetch DS tracker global geometry
390
mmTrackerDS = mm->findModulesByName("ParentGeometryFile.dat/Tracker1.dat");
391
392
// - get TrackerRef1 position
393
double trackerRef1posX = mmTrackerDS[0]->daughter(0)->globalPosition().x();
394
double trackerRef1posY = mmTrackerDS[0]->daughter(0)->globalPosition().y();
395
double trackerRef1posZ = mmTrackerDS[0]->daughter(0)->globalPosition().z();
396
397
// - get rotation matrix
398
xx = mmTrackerDS[0]->globalRotation().xx();
399
xy = mmTrackerDS[0]->globalRotation().xy();
400
xz = mmTrackerDS[0]->globalRotation().xz();
401
yx = mmTrackerDS[0]->globalRotation().yx();
402
yy = mmTrackerDS[0]->globalRotation().yy();
403
yz = mmTrackerDS[0]->globalRotation().yz();
404
zx = mmTrackerDS[0]->globalRotation().zx();
405
zy = mmTrackerDS[0]->globalRotation().zy();
406
zz = mmTrackerDS[0]->globalRotation().zz();
407
408
// - fill matrix elements (for VectorTransform)
409
matrixElements.clear();
410
matrixElements.push_back(xx);
411
matrixElements.push_back(xy);
412
matrixElements.push_back(xz);
413
matrixElements.push_back(yx);
414
matrixElements.push_back(yy);
415
matrixElements.push_back(yz);
416
matrixElements.push_back(zx);
417
matrixElements.push_back(zy);
418
matrixElements.push_back(zz);
419
420
421
// - plot TKD helical track(s)
422
writer->addType("TKDHelicalTrackTest", 1);
423
writer->addInstance();
424
writer->addPrimitive();
425
circle_x0 = event.scifiDSTrackerHelicalTrackParameters[0];
426
circle_y0 = event.scifiDSTrackerHelicalTrackParameters[1];
427
radius = event.scifiDSTrackerHelicalTrackParameters[2];
428
dsdz = event.scifiDSTrackerHelicalTrackParameters[3];
429
line_dz_c = event.scifiDSTrackerHelicalTrackParameters[4];
430
posZ = event.scifiDSTrackerHelicalTrackParameters[7];
431
zLocal = posZ;
432
433
while (zLocal < trackerLength) {
434
zLocal += zStep; // z value in tracker local reference system
435
// x value in tracker local reference system
436
double downstream_helix_x_value
437
= circle_x0 + (radius*cos((1/radius)*(dsdz*zLocal+line_dz_c)));
438
// y value in tracker local reference system
439
double downstream_helix_y_value
440
= circle_y0 + (radius*sin((1/radius)*(dsdz*zLocal+line_dz_c)));
441
442
// transformation to global coordinate system
443
std::vector<double> vSpacePoint
444
= {downstream_helix_x_value, downstream_helix_y_value, zLocal};
445
VectorTransform trans(vSpacePoint);
446
trans.Rotate(matrixElements, "reg");
447
trans.Translate(trackerRef1posX, trackerRef1posY, trackerRef1posZ, "reg");
448
449
double x = trans.GetX();
450
double y = trans.GetY();
451
double z = trans.GetZ();
452
453
writer->addPoint(x, y, z);
454
}
455
456
writer->close();
457
458
char *detGeomFileName = getenv("EV_DETGEOM_FILE");
459
// disable writing to HepRep options if geometry file is not selected
460
if (detGeomFileName == NULL) {
461
std::cerr << "WARNING: Detector geometry file not defined! Modify and source configure.sh or "
462
<< "choose geometry file using selection button (if using GUI). "
463
<< "Not writting output heprep file!" << std::endl;
464
} else {
465
std::string sOutFileName = ssOutFileName.str();
466
std::string sDetGeomFileName(detGeomFileName);
467
Concatenate(sDetGeomFileName, dataFileName, sOutFileName);
468
}
469
470
// - remove MAUS data heprep file
471
std::stringstream cmdRemove;
472
cmdRemove << "rm " << dataFileName;
473
system(cmdRemove.str().c_str());
474
475
// - open the file for viewing
476
if (display) {
477
std::cout << display << std::endl;
478
std::stringstream cmdDisplay;
479
int displayCheck = 1;
480
481
char *javaDir = getenv("EV_JAVA_DIR");
482
if (javaDir != NULL) {
483
cmdDisplay << javaDir << "/bin/java -jar ";
484
} else {
485
std::cerr << "WARNING: No java directory selected! HepRApp display unavailable! "
486
<< "Select directory in which your JRE can be found!" << std::endl;
487
displayCheck = 0;
488
}
489
490
char *heprappDir = getenv("EV_HEPRAPP_DIR");
491
if (heprappDir != NULL) {
492
cmdDisplay << heprappDir << "/HepRApp.jar -file ";
493
} else {
494
std::cerr << "WARNING: No HepRapp directory selected! HepRApp display unavailable! "
495
<< "Select directory in which your HepRApp.jar can be found!" << std::endl;
496
displayCheck = 0;
497
}
498
499
cmdDisplay << ssOutFileName.str();
500
std::cout << cmdDisplay.str() << std::endl;
501
if (displayCheck)
502
system(cmdDisplay.str().c_str());
503
}
504
}
505
506
int EVHepRepExporter::Concatenate(std::string& geometryFileName, std::string& dataFileName,
507
std::string& outFileName) {
508
std::ifstream geomFile;
509
geomFile.open(geometryFileName.c_str(), std::ifstream::in);
510
if (!geomFile.is_open()) {
511
std::cerr << "ERROR: Could not open geometry file needed for output to heprep!" << std::endl;
512
return 0;
513
}
514
515
std::ifstream dataFile;
516
dataFile.open(dataFileName.c_str(), std::fstream::in);
517
if (!dataFile.is_open()) {
518
std::cerr << "ERROR: Could not open data file needed for output to heprep!" << std::endl;
519
return 0;
520
}
521
522
std::ofstream outFile;
523
outFile.open(outFileName.c_str(), std::ifstream::out);
524
if (!outFile.is_open()) {
525
std::cerr << "ERROR: Could not open temporary file needed for output to heprep!" << std::endl;
526
return 0;
527
}
528
529
530
while (!geomFile.eof()) {
531
std::string line, target;
532
std::getline(geomFile, line);
533
target = line.substr(0, 16);
534
if (target != "</heprep:heprep>")
535
outFile << line << std::endl;
536
}
537
538
int counter = 0;
539
while (!dataFile.eof()) {
540
++counter;
541
std::string line;
542
std::getline(dataFile, line);
543
if (counter > 3)
544
outFile << line << std::endl;
545
}
546
547
return 1;
548
}
549
550
} // ~namespace EventViewer
551
Loggerhead is a web-based interface for Breezy
Version: 2.0.1