const Tracks& NearestNeighborTracker::processCycle(double currentTime, const Observations& newObservations, const Observations& additionalLowConfidenceObservations)
{
beginCycle(currentTime);
predictTrackStates();
m_occlusionManager->manageOcclusionsBeforeDataAssociation(m_tracks, ros::Time(currentTime), m_frameID);
predictMeasurements();
Pairings pairings = performDataAssociation(m_tracks, newObservations);
// Extension to default NNT: If there are additional low-confidence observations (e.g. from a high-recall blob detector),
// try to match these against the tracks which are so far unmatched (but only if we are sufficiently sure that it is a valid track).
if(!additionalLowConfidenceObservations.empty())
{
int minNumMatchesToAllowLowConfidenceMatch = Params::get<int>("min_num_matches_to_allow_low_confidence_match", 10);
Tracks unmatchedTracks;
foreach(Track::Ptr track, m_tracks) {
if(track->trackStatus == Track::OCCLUDED && track->numberOfTotalMatches >= minNumMatchesToAllowLowConfidenceMatch) {
unmatchedTracks.push_back(track);
}
}
if(!unmatchedTracks.empty()) {
Pairings additionalPairings = performDataAssociation(unmatchedTracks, additionalLowConfidenceObservations);
pairings.insert(pairings.end(), additionalPairings.begin(), additionalPairings.end());
}
}
void GetTracksTabSeparated(string const& path, Tracks& tracks, vector<string>& names)
{
tracks.clear();
// Read the file to get our tracks
ifstream ifs(path);
string line;
int idx = 0;
while (getline(ifs, line)) {
stringstream ss(line);
string name;
getline(ss, name, '\t');
string key_str;
getline(ss, key_str, '\t');
Key key = Key::KeyFromString(key_str);
double bpm;
ss >> bpm;
// Allow commenting out tracks
if (!name.substr(0, 2).compare("//")) {
continue;
}
tracks.push_back(Track(idx++, bpm, key));
names.push_back(name);
}
ifs.close();
}
Tracks * loadTracks(Int_t Runs, Int_t dataType, Float_t energy) {
TString sDataType = (dataType == 0) ? "_MC_" : "_data_";
TString sAbsThick = Form("_%.0fmm", kAbsorbatorThickness);
TString sEnergy = Form("_%.2fMeV", energy);
TString fileName = "Data/Tracks/tracks";
TString sMaterial = getMaterialChar();
fileName.Append(sDataType);
fileName.Append(sMaterial);
fileName.Append(sAbsThick);
fileName.Append(sEnergy);
fileName.Append(".root");
TFile *f = new TFile(fileName);
if (!f) return 0;
TTree *T = (TTree*) f->Get("T");
Tracks * tracks = new Tracks();
T->GetBranch("tracks")->SetAutoDelete(kFALSE);
T->SetBranchAddress("tracks",&tracks);
T->GetEntry(0);
cout << "There are " << tracks->GetEntriesFast() << " tracks in " << fileName << ".\n";
return tracks;
}
int CreateDVD_Thread::
option_presets()
{
if( !mwindow->edl ) return 1;
Tracks *tracks = mwindow->edl->tracks;
int max_w = 0, max_h = 0;
int has_deinterlace = 0, has_scale = 0;
for( Track *trk=tracks->first; trk; trk=trk->next ) {
if( !trk->record ) continue;
Edits *edits = trk->edits;
switch( trk->data_type ) {
case TRACK_VIDEO:
for( Edit *edit=edits->first; edit; edit=edit->next ) {
Indexable *indexable = edit->get_source();
int w = indexable->get_w();
if( w > max_w ) max_w = w;
if( w != DVD_WIDTH ) use_scale = 1;
int h = indexable->get_h();
if( h > max_h ) max_h = h;
if( h != DVD_HEIGHT ) use_scale = 1;
}
for( int i=0; i<trk->plugin_set.size(); ++i ) {
for(Plugin *plugin = (Plugin*)trk->plugin_set[i]->first;
plugin;
plugin = (Plugin*)plugin->next) {
if( !strcmp(plugin->title, "Deinterlace") )
has_deinterlace = 1;
if( !strcmp(plugin->title, "Scale") )
has_scale = 1;
}
}
break;
}
}
if( has_scale ) use_scale = 0;
for( Track *trk=tracks->first; trk && !use_resize_tracks; trk=trk->next ) {
if( !trk->record ) continue;
switch( trk->data_type ) {
case TRACK_VIDEO:
if( trk->track_w != max_w ) use_resize_tracks = 1;
if( trk->track_h != max_h ) use_resize_tracks = 1;
break;
}
}
if( !has_deinterlace && max_h > 2*DVD_HEIGHT ) use_deinterlace = 1;
Labels *labels = mwindow->edl->labels;
use_label_chapters = labels && labels->first ? 1 : 0;
float w, h;
MWindow::create_aspect_ratio(w, h, max_w, max_h);
if( w == DVD_WIDE_ASPECT_WIDTH && h == DVD_WIDE_ASPECT_HEIGHT )
use_wide_aspect = 1;
if( tracks->recordable_audio_tracks() == DVD_WIDE_CHANNELS )
use_wide_audio = 1;
return 0;
}
bool MidiPlayerThread::start( const QString &path, int volume, double seek /* = -1 */ )
{
qDebug() << "MidiPlayerThread::start";
unsigned short int mixer_options = 0;
m_path = path;
if ( open_alsa_output() == ( -1 ) ) {
qDebug() << "MidiPlayerThread::start: error of open_alsa_output()...";
return false;
}
if ( WildMidi_Init( qPrintable( m_configFile ), m_sample_rate, mixer_options ) < 0 ) {
qWarning( "MidiPlayerThread::start: unable to initialize WildMidi library" );
close_output();
return false;
}
m_midiPtr = WildMidi_Open ( qPrintable( m_path ) );
if ( !m_midiPtr ) {
qWarning("MidiPlayerThread::start: unable to open file");
WildMidi_Shutdown();
close_output();
return false;
}
Tracks audios;
audios.addID( 0 );
_WM_Info *wm_info = WildMidi_GetInfo( m_midiPtr );
m_totalTime = ( qint64 )wm_info->approx_total_samples / m_sample_rate;
qDebug() << "total time is " << m_totalTime << " sec";
m_md->reset();
m_md->duration = m_totalTime;
m_md->audio_rate = m_sample_rate;
m_md->novideo = true;
m_md->audios = audios;
// m_md->type = TYPE_FILE;
setVolume( volume );
if ( seek != ( -1 ) ) {
goToSec( seek );
}
QThread::start();
qDebug( "MidiPlayerThread: thread started" );
emit audioInfoChanged( audios );
return true;
}
Tracks * loadOrCreateTracks(Bool_t recreate, Int_t Runs, Int_t dataType, Float_t energy, Float_t *x, Float_t *y) {
Tracks * tracks = nullptr;
if (recreate) {
printf("kUseAlpide = %d\n", kUseAlpide);
if (!kUseAlpide) {
tracks = getTracks(Runs, dataType, kCalorimeter, energy, x, y);
}
else {
tracks = getTracksFromClusters(Runs, dataType, kCalorimeter, energy);
}
if (tracks->GetEntries()) {
cout << "Saving " << tracks->GetEntries() << " tracks.\n";
saveTracks(tracks, dataType, energy);
}
}
else {
tracks = loadTracks(Runs, dataType, energy);
if (!tracks) {
cout << "!tracks, creating new file\n";
if (!kUseAlpide) {
tracks = getTracks(Runs, dataType, kCalorimeter, energy, x, y);
}
else {
tracks = getTracksFromClusters(Runs, dataType, kCalorimeter, energy);
}
saveTracks(tracks, dataType, energy);
}
}
return tracks;
}
/** Returns the number of tracks. */
size_t getNumberOfTracks() const { return m_tracks.size(); }
int main(int argc, char* argv[])
{
RunTests();
// Our tracks
Tracks tracks;
vector<string> names;
//GetTracks("tracks.txt", tracks);
GetTracksTabSeparated("tracks_tsv.txt", tracks, names);
//// Write separate values out
//ofstream names("names.txt");
//ofstream bpms("bpms.txt");
//ofstream keys("keys.txt");
//for (auto t : tracks) {
// names << t.name << endl;
// bpms << t.bpm << endl;
// keys << t.key.short_name << endl;
//}
//names.close();
//bpms.close();
//keys.close();
// Collect stats on how many tracks are in which keys
KeyCount key_counts;
for (auto t : tracks) {
//key_counts[t.key].push_back(t);
key_counts[t.key]++;
}
// Write the key counts
for (auto k : key_counts) {
cout << Key::GetShortName(k.first.num, k.first.type) << ": " << k.second << endl;
}
// Exhaustive solution
// Start at each track and try to get as many tracks into a mix as possible
// We will exhaustively try to join into each possible next track that is compatible
Tracks available = tracks;
Tracks best;
double best_cost = DBL_MAX;
for (size_t i = 0; i < available.size(); ++i) {
Tracks chosen;
Tracks this_best;
double cost = 0;
double this_best_cost = DBL_MAX;
int its = 0;
Tracks now_available = available;
Track t = now_available[i];
now_available.erase(now_available.begin() + i);
Tracks now_chosen = chosen;
now_chosen.push_back(t);
cout << "Starting with " << names[t.idx] << endl;
ChooseTrack(names, now_available, now_chosen, t.idx, t.key, t.bpm, cost, this_best_cost, kMixSongLen, this_best, its);
if (this_best.size() > best.size()) {
best = this_best;
cout << "New OVERALL best of " << best.size() << " found!" << endl;
}
else if (this_best.size() == best.size() && this_best_cost < best_cost) {
best_cost = this_best_cost;
best = this_best;
cout << "New OVERALL best cost of " << best_cost << " found!" << endl;
}
}
// Show our results
for (auto t : best) {
cout
<< setw(3) << Key::GetShortName(t.key.num, t.key.type) << " @ "
<< setw(3) << static_cast<int>(t.bpm) << "bpm"
<< ", " << names[t.idx] << endl;
}
cout << "Cost is " << best_cost << endl;
return EXIT_SUCCESS;
//// Sort by BPM
//sort(tracks.begin(), tracks.end(), [](Track const& a, Track const& b)
//{
// return a.bpm < b.bpm;
//});
//// Interactive selection
//vector<Track> order;
//int idx = 0;
//for (;;) {
// // Mark our work
// Track selected = tracks[idx];
// tracks.erase(tracks.begin() + idx);
// order.push_back(selected);
// cout << "Your current track: " << selected.name << endl;
// // Get options...
// vector<TrackOption> options;
// for (size_t i = 0; i < tracks.size(); ++i) {
// // Must be compatible
// if (!AreCompatibleKeys(selected.key, tracks[i].key)) {
// continue;
// }
// // Get the BPM ratio
// double bpm_ratio = max(selected.bpm, tracks[i].bpm) / min(selected.bpm, tracks[i].bpm);
// //double bpm_ratio_st = log(bpm_ratio) / log(Utils::GetSemitoneRatio());
// // We have an option
// TrackOption option(tracks[i], bpm_ratio, i);
// options.push_back(option);
// }
// // Sort by BPM ratio
// sort(options.begin(), options.end(), [](TrackOption const& a, TrackOption const& b)
// {
// return a.bpm_ratio < b.bpm_ratio;
// }
// );
// // Print options
// cout << "Options: " << endl;
// for (size_t i = 0; i < options.size(); ++i) {
// cout << i << "\t" << fixed << setw(4) << options[i].bpm_ratio << "\t" << options[i].track.name << " (" << options[i].track.key.short_name << ")" << endl;
// }
// cout << "You have selected " << order.size() << " tracks" << endl;
// string choice;
// getline(cin, choice);
// if (!choice.compare("q")) {
// break;
// }
// stringstream ss(choice);
// ss >> idx;
// idx = options[idx].idx;
//}
//// Write our order
//ofstream order_f("order.txt");
//for (auto t : order) {
// order_f << t.bpm << "\t" << t.name << " (" << t.key.short_name << ")" << endl;
//}
//order_f.close();
//// Start by just choosing a base track (try each one)
//vector<Tracks> options;
//// Our starting track
//for (auto t : tracks) {
// cout << "Starting with " << t.name << endl;
// Tracks order;
// if (ChooseTrack(t, tracks, order)) {
// options.push_back(order);
// cout << "Found " << options.size() << " solutions!" << endl;
// }
//}
//// Select a key ordering
//vector<Keys> options;
//int max_depth = 0;
//for (auto k : key_counts) {
// cout << "Starting with " << k.first.short_name << endl;
// Keys order;
// if (ChooseKey(KeyFromString("Dbm") /*k.first*/, key_counts, order, 1, max_depth)) {
// options.push_back(order);
// cout << "Found " << options.size() << " solutions!" << endl;
// }
//}
// Find a mix that works!
MixAnt ma;
Mix m = ma.FindMix(tracks);
// Print the mix
//cout << m << endl;
cout << "Mix uses " << m.steps.size() << " of " << tracks.size() << " input tracks" << endl << endl;
// Save the mix to a file
ofstream ofs("mix.txt");
ofs << m;
ofs.close();
// write our unused tracks
Tracks unused(tracks);
for (auto s : m.steps) {
for (auto it = unused.begin(); it != unused.end(); ++it) {
if (*it == s.track) {
unused.erase(it);
break;
}
}
}
ofstream unused_f("unused.txt");
for (auto u : unused) {
//unused_f << u.name << endl;
//unused_f << u.key.short_name << endl;
unused_f << u.bpm << endl;
}
unused_f.close();
//cin.get();
}
void ChooseTrack(
vector<string> names,
Tracks& available,
Tracks& chosen,
int prev_idx,
Key prev_key,
double prev_bpm,
double cost,
double& best_cost,
int max_len,
Tracks& best,
int& its
)
{
// We're too long!
if (chosen.size() >= static_cast<size_t>(max_len)) {
return;
}
// We have a new best length (more important than cost)
if (chosen.size() > best.size()) {
best_cost = cost;
best = chosen;
cout << "New best of length " << best.size() << " found." << endl;
its = 0;
}
// Mix length is the same, but less cost
else if (chosen.size() == best.size() && cost < best_cost && !chosen.empty()) {
best_cost = cost;
cout << "New best cost of " << best_cost << " found." << endl;
best = chosen;
its = 0;
}
// No improvement!
else {
++its;
}
// We've spent too long, so bail!
if (its >= 1000000) {
cout << "Too many iterations without improvement!" << endl;
return;
}
// Nothing to look at
if (available.empty()) {
cout << "No more tracks to choose." << endl;
return;
}
Track prev(prev_idx, prev_bpm, prev_key);
// Go through all available and find those compatible
Tracks candidates;
Keys candidates_adj;
vector<double> candidate_costs;
for (auto t : available) {
Key candidate_adj;
double this_cost;
if (AreCompatibleTracks(
prev,
t,
kBPMThresh,
kKeyShiftThresh,
candidate_adj,
this_cost
)) {
candidates.push_back(t);
candidates_adj.push_back(candidate_adj);
candidate_costs.push_back(this_cost);
}
}
for (size_t i = 0; i < candidates.size(); ++i) {
Tracks now_available = available;
Track t = candidates[i];
// Erase the candidate from the now available list
for (size_t j = 0; j < now_available.size(); ++j) {
if (now_available[j] == t) {
now_available.erase(now_available.begin() + j);
break;
}
}
// Set to our new key
t.key = candidates_adj[i];
Tracks now_chosen = chosen;
now_chosen.push_back(t);
// NOTE: We send in an ADJUSTED key for this track!
ChooseTrack(names, now_available, now_chosen, t.idx, t.key, t.bpm, cost + candidate_costs[i], best_cost, max_len, best, its);
}
}
void makeTracks(Int_t Runs, Int_t dataType, Bool_t recreate, Float_t energy) {
Tracks * tracks = loadOrCreateTracks(recreate, Runs, dataType, energy);
tracks->extrapolateToLayer0();
}
Tracks * getTracks(Int_t Runs, Int_t dataType, Int_t frameType, Float_t energy, Float_t *x, Float_t *y) {
run_energy = energy;
DataInterface * di = new DataInterface();
Misalign * m = new Misalign();
Int_t nClusters = kEventsPerRun * 5 * nLayers;
Int_t nHits = kEventsPerRun * 50;
Int_t nTracks = kEventsPerRun * 2;
Bool_t breakSignal = false;
CalorimeterFrame *cf = new CalorimeterFrame();
Clusters * clusters = new Clusters(nClusters);
Clusters * trackerClusters = new Clusters(nClusters);
Hits * hits = new Hits(nHits);
Hits * eventIDs = new Hits(kEventsPerRun * sizeOfEventID);
Int_t eventID = -1;
Hits * trackerHits = new Hits(nHits);
Tracks * calorimeterTracks = nullptr;
Tracks * trackerTracks = new Tracks(nTracks);
Tracks * allTracks = new Tracks(nTracks * Runs);
TRandom3 * gRandom = new TRandom3(0);
TStopwatch t1, t2, t3, t4, t5, t6;
ofstream file("OutputFiles/efficiency.csv", ofstream::out | ofstream::app);
Int_t totalNumberOfFrames = 0;
Int_t tracksTotalNumberAfterRecon = 0;
Int_t tracksRemovedDueToBadChannels = 0;
Int_t tracksGivenToReconstruction = 0;
Int_t tracksRemovedDueToLeavingDetector = 0;
Int_t tracksRemovedDueToNuclearInteractions = 0;
Int_t clustersInFirstLayer = 0;
Int_t tracksRemovedDueToCollisions = 0;
// file: np; number of reconstructed tracks; tracks after removeTracksLeavingDetector; tracks after removeTrackCollisions
for (Int_t i=0; i<Runs; i++) {
cout << "Finding track " << (i+1)*kEventsPerRun << " of " << Runs*kEventsPerRun << "... ";
if (dataType == kMC) {
t1.Start();
eventID = di->getMCFrame(i, cf, x, y);
di->getEventIDs(i, eventIDs);
t1.Stop(); t2.Start();
showDebug("Start diffuseFrame\n");
cf->diffuseFrame(gRandom);
showDebug("End diffuseFrame, start findHits\n");
t2.Stop(); t3.Start();
hits = cf->findHits(eventID);
showDebug("Number of hits in frame: " << hits->GetEntriesFast() << endl);
t3.Stop(); t4.Start();
clusters = hits->findClustersFromHits(); // badly optimized
cout << "Found " << clusters->GetEntriesInLayer(0) << " clusters in the first layer.\n";
cout << "Found " << clusters->GetEntriesInLayer(1) << " clusters in the second layer.\n";
clusters->removeSmallClusters(2);
cout << "Found " << clusters->GetEntriesInLayer(0) << " clusters in the first layer after removeSmallClusters.\n";
t4.Stop();
clusters->matchWithEventIDs(eventIDs);
eventIDs->Clear();
}
else if (dataType == kData) {
t1.Start(); di->getDataFrame(i, cf, energy); t1.Stop();
t3.Start(); hits = cf->findHits(); t3.Stop();
t4.Start(); clusters = hits->findClustersFromHits(); t4.Stop();
clusters->removeSmallClusters(2);
clusters->removeAllClustersAfterLayer(8); // bad data in layer 10 and 11
cout << "Found " << clusters->GetEntriesInLayer(0) << " clusters in the first layer.\n";
cout << "Found " << clusters->GetEntriesInLayer(1) << " clusters in the second layer.\n";
m->correctClusters(clusters);
}
t5.Start();
calorimeterTracks = clusters->findCalorimeterTracks();
t5.Stop();
tracksTotalNumberAfterRecon += calorimeterTracks->GetEntries();
if (calorimeterTracks->GetEntriesFast() == 0) breakSignal = kTRUE; // to stop running
// Track improvements
Int_t nTracksBefore = 0, nTracksAfter = 0;
Int_t nIsInelastic = 0, nIsNotInelastic = 0;
calorimeterTracks->extrapolateToLayer0();
calorimeterTracks->splitSharedClusters();
nTracksBefore = calorimeterTracks->GetEntries();
calorimeterTracks->removeTracksLeavingDetector();
nTracksAfter = calorimeterTracks->GetEntries();
tracksRemovedDueToLeavingDetector += nTracksBefore - nTracksAfter;
cout << "Of " << nTracksBefore << " tracks, " << nTracksBefore - nTracksAfter << " (" << 100* ( nTracksBefore - nTracksAfter) / ( (float) nTracksBefore ) << "%) were lost when leaving the detector.\n";
nTracksBefore = calorimeterTracks->GetEntries();
calorimeterTracks->removeTrackCollisions();
nTracksAfter = calorimeterTracks->GetEntries();
tracksRemovedDueToCollisions += nTracksBefore - nTracksAfter;
if (kDataType == kData) {
nTracksBefore = calorimeterTracks->GetEntries();
calorimeterTracks->removeTracksEndingInBadChannels();
nTracksAfter = calorimeterTracks->GetEntries();
cout << "Of " << nTracksBefore << " tracks, " << nTracksBefore - nTracksAfter << " (" << 100* ( nTracksBefore - nTracksAfter) / ( (float) nTracksBefore ) << "%) were removed due to ending just before a bad channel.\n";
tracksRemovedDueToBadChannels += nTracksBefore - nTracksAfter;
}
for (Int_t k=0; k<calorimeterTracks->GetEntriesFast(); k++) {
if (calorimeterTracks->At(k)) {
if (calorimeterTracks->At(k)->doesTrackEndAbruptly()) {
nIsInelastic++;
}
else nIsNotInelastic++;
}
}
tracksRemovedDueToNuclearInteractions += nIsInelastic;
cout << "Of these, " << nIsInelastic << " end abruptly and " << nIsNotInelastic << " does not.\n";
file << energy << " " << kEventsPerRun << " " << nTracksBefore << " " << nTracksAfter << " " << calorimeterTracks->GetEntries() << " " << nIsInelastic << " " << nIsNotInelastic << endl;
// calorimeterTracks->retrogradeTrackImprovement(clusters);
calorimeterTracks->Compress();
calorimeterTracks->CompressClusters();
for (Int_t j=0; j<calorimeterTracks->GetEntriesFast(); j++) {
if (!calorimeterTracks->At(j)) continue;
allTracks->appendTrack(calorimeterTracks->At(j));
tracksGivenToReconstruction++;
}
allTracks->appendClustersWithoutTrack(clusters->getClustersWithoutTrack());
cout << Form("Timing: getMCframe (%.2f sec), diffuseFrame (%.2f sec), findHits (%.2f sec), findClustersFromHits (%.2f sec), findTracks (%.2f sec)\n",
t1.RealTime(), t2.RealTime(), t3.RealTime(), t4.RealTime(), t5.RealTime());
cf->Reset();
hits->clearHits();
trackerHits->clearHits();
clusters->clearClusters();
trackerClusters->clearClusters();
calorimeterTracks->Clear();
trackerTracks->Clear();
if (breakSignal) break;
}
printf("\033[1mTrack statics for article. Clusters found in first layer (= N protons) = %d. Total number of tracks found = %d. Total number of tracks given to reconstruction = %d. Tracks removed due to bad channels = %d. Tracks removed due to nuclear interactions = %d. Tracks removed due to leaving the detector laterally = %d. Tracks removed due to collisions = %d. Sum = %d.\033[0m\n", clustersInFirstLayer, tracksTotalNumberAfterRecon, tracksGivenToReconstruction, tracksRemovedDueToBadChannels, tracksRemovedDueToNuclearInteractions, tracksRemovedDueToLeavingDetector, tracksRemovedDueToCollisions, tracksGivenToReconstruction + tracksRemovedDueToBadChannels + tracksRemovedDueToLeavingDetector + tracksRemovedDueToCollisions);
file.close();
delete cf;
delete clusters;
delete trackerClusters;
delete hits;
delete trackerHits;
delete calorimeterTracks;
delete trackerTracks;
delete di;
return allTracks;
}
Tracks * getTracksFromClusters(Int_t Runs, Int_t dataType, Int_t frameType, Float_t energy) {
run_energy = energy;
DataInterface * di = new DataInterface();
Int_t nClusters = kEventsPerRun * 5 * nLayers;
Int_t nTracks = kEventsPerRun * 2;
Bool_t breakSignal = false;
Clusters * clusters = new Clusters(nClusters);
Tracks * tracks = new Tracks(nTracks);
Tracks * allTracks = new Tracks(nTracks * Runs);
for (Int_t i=0; i<Runs; i++) {
showDebug("Start getMCClusters\n");
di->getMCClusters(i, clusters);
showDebug("Finding calorimeter tracks\n");
tracks = clusters->findCalorimeterTracksWithMCTruth();
if (tracks->GetEntriesFast() == 0) breakSignal = kTRUE; // to stop running
// Track improvements
Int_t nTracksBefore = 0, nTracksAfter = 0;
Int_t nIsInelastic = 0, nIsNotInelastic = 0;
tracks->extrapolateToLayer0();
nTracksBefore = tracks->GetEntries();
tracks->removeTracksLeavingDetector();
nTracksAfter = tracks->GetEntries();
cout << "Of " << nTracksBefore << " tracks, " << nTracksBefore - nTracksAfter << " (" << 100* ( nTracksBefore - nTracksAfter) / ( (float) nTracksBefore ) << "%) were lost when leaving the detector.\n";
tracks->removeTrackCollisions();
// tracks->retrogradeTrackImprovement(clusters);
tracks->Compress();
tracks->CompressClusters();
for (Int_t j=0; j<tracks->GetEntriesFast(); j++) {
if (!tracks->At(j)) continue;
allTracks->appendTrack(tracks->At(j));
}
allTracks->appendClustersWithoutTrack(clusters->getClustersWithoutTrack());
clusters->clearClusters();
tracks->Clear();
if (breakSignal) break;
}
delete clusters;
delete tracks;
delete di;
return allTracks;
}
