← Back to branch summary

~mwinter4/maus/ckov_0_9_3

« back to all changes in this revision

Viewing changes to src/common_cpp/Recon/Global/TrackMatching.cc

  • Committer: Adam Dobbs
  • Date: 2015-02-06 16:23:48 UTC
  • mfrom: (663.46.25 1389a)
  • Revision ID: phuccj@gmail.com-20150206162348-z20wowbwbbosybb2
Merged in TrackingMatching fix for Global, and updated main installer script to allow user to select number of cores to build on

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common_cpp/Recon/Global/TrackMatching.cc
36
36
 
37
37
    MAUS::DataStructure::Global::TrackPArray *ImportedTracks = global_event->get_tracks();
38
38
    MAUS::DataStructure::Global::TrackPArray::iterator ImportedTrackIterator;
39
 
    MAUS::DataStructure::Global::TrackPArray *SciFiTrackArray =
40
 
      new MAUS::DataStructure::Global::TrackPArray();
 
39
    MAUS::DataStructure::Global::Track* ImportedSciFiTrack =
 
40
      new MAUS::DataStructure::Global::Track();
41
41
    for (ImportedTrackIterator = ImportedTracks->begin();
42
42
         ImportedTrackIterator != ImportedTracks->end();
43
43
         ++ImportedTrackIterator) {
45
45
        (*ImportedTrackIterator);
46
46
      if (ImportedTrack->HasDetector(MAUS::DataStructure::Global::kTracker0) ||
47
47
          ImportedTrack->HasDetector(MAUS::DataStructure::Global::kTracker1)) {
48
 
        SciFiTrackArray->push_back(ImportedTrack);
 
48
        std::vector<const MAUS::DataStructure::Global::TrackPoint*>
 
49
          tempSciFiTrackPointArray = ImportedTrack->GetTrackPoints();
 
50
        for (unsigned int i = 0; i < tempSciFiTrackPointArray.size(); i++) {
 
51
          MAUS::DataStructure::Global::TrackPoint* tempSciFiTrackPoint =
 
52
            const_cast<MAUS::DataStructure::Global::TrackPoint*>
 
53
            (tempSciFiTrackPointArray[i]);
 
54
          tempSciFiTrackPoint->set_mapper_name(mapper_name);
 
55
          ImportedSciFiTrack->AddTrackPoint(tempSciFiTrackPoint);
 
56
        }
 
57
      }
 
58
      if (ImportedSciFiTrack->GetTrackPoints().size() == 0) {
 
59
        delete ImportedSciFiTrack;
 
60
        ImportedSciFiTrack = NULL;
49
61
      }
50
62
    }
51
63
 
56
68
    MAUS::DataStructure::Global::Track* KLTrack =
57
69
      new MAUS::DataStructure::Global::Track();
58
70
    MakeKLTracks(global_event, GlobalSpacePointArray, KLTrack);
59
 
    if (KLTrack->GetTrackPoints().size() == 0) delete KLTrack;
 
71
    if (KLTrack->GetTrackPoints().size() == 0) {
 
72
      delete KLTrack;
 
73
      KLTrack = NULL;
 
74
    }
60
75
 
61
76
    // Adding global tracks for case where global event contains both SciFi and TOF tracks
62
77
    // (And KL track if applicable)
63
 
    if (!SciFiTrackArray->empty() && !TOFTrackArray.empty()) {
64
 
      for (unsigned int i = 0; i < SciFiTrackArray->size(); i++) {
65
 
        for (unsigned int j = 0; j < TOFTrackArray.size(); j++) {
66
 
          MAUS::DataStructure::Global::Track* GlobalTrack =
67
 
            new MAUS::DataStructure::Global::Track();
68
 
          GlobalTrack->set_mapper_name(mapper_name);
69
 
          MAUS::DataStructure::Global::Track* tempSciFiTrack =
70
 
            SciFiTrackArray->at(i);
71
 
    if (!tempSciFiTrack) {
72
 
      throw(Exception(Exception::recoverable,
73
 
                      "Found an empty SciFi track pointer.",
74
 
                      "MapCppGlobalPID::TrackMatching"));
75
 
    }
76
 
          MAUS::DataStructure::Global::Track* tempTOFTrack = TOFTrackArray[j];
77
 
    if (!tempTOFTrack) {
78
 
      throw(Exception(Exception::recoverable,
79
 
                      "Found an empty TOF track pointer.",
80
 
                      "MapCppGlobalPID::TrackMatching"));
81
 
    }
82
 
          std::vector<const MAUS::DataStructure::Global::TrackPoint*>
83
 
            tempSciFiTrackPointArray = tempSciFiTrack->GetTrackPoints();
84
 
          std::vector<const MAUS::DataStructure::Global::TrackPoint*>
85
 
            tempTOFTrackPointArray = tempTOFTrack->GetTrackPoints();
86
 
          for (unsigned int k = 0; k < tempTOFTrackPointArray.size(); k++) {
87
 
            MAUS::DataStructure::Global::TrackPoint* tempTOFTrackPoint =
88
 
              const_cast<MAUS::DataStructure::Global::TrackPoint*>
89
 
              (tempTOFTrackPointArray[k]);
90
 
            tempTOFTrackPoint->set_mapper_name(mapper_name);
91
 
            GlobalTrack->AddTrackPoint(tempTOFTrackPoint);
92
 
          }
93
 
          for (unsigned int k = 0; k < tempSciFiTrackPointArray.size(); k++) {
94
 
            MAUS::DataStructure::Global::TrackPoint* tempSciFiTrackPoint =
95
 
              const_cast<MAUS::DataStructure::Global::TrackPoint*>
96
 
              (tempSciFiTrackPointArray[k]);
97
 
            tempSciFiTrackPoint->set_mapper_name(mapper_name);
98
 
            GlobalTrack->AddTrackPoint(tempSciFiTrackPoint);
99
 
          }
100
 
          if (KLTrack/*->GetTrackPoints().size() > 0*/) {
101
 
            std::vector<const MAUS::DataStructure::Global::TrackPoint*>
102
 
              tempKLTrackPointArray = KLTrack->GetTrackPoints();
103
 
            for (unsigned int l = 0; l < tempKLTrackPointArray.size(); l++) {
104
 
              MAUS::DataStructure::Global::TrackPoint* tempKLTrackPoint =
105
 
                const_cast<MAUS::DataStructure::Global::TrackPoint*>
106
 
                (tempKLTrackPointArray[l]);
107
 
              tempKLTrackPoint->set_mapper_name(mapper_name);
108
 
              GlobalTrack->AddTrackPoint(tempKLTrackPoint);
109
 
            }
110
 
          }
111
 
          global_event->add_track_recursive(GlobalTrack);
112
 
        }
 
78
    if (ImportedSciFiTrack != NULL && !TOFTrackArray.empty()) {
 
79
      for (unsigned int j = 0; j < TOFTrackArray.size(); j++) {
 
80
        MAUS::DataStructure::Global::Track* GlobalTrack = TOFTrackArray[j]->Clone();
 
81
        GlobalTrack->set_mapper_name(mapper_name);
 
82
        std::vector<const MAUS::DataStructure::Global::TrackPoint*>
 
83
          tempSciFiTrackPointArray = ImportedSciFiTrack->GetTrackPoints();
 
84
        for (unsigned int k = 0; k < tempSciFiTrackPointArray.size(); k++) {
 
85
          MAUS::DataStructure::Global::TrackPoint* tempSciFiTrackPoint =
 
86
            const_cast<MAUS::DataStructure::Global::TrackPoint*>
 
87
            (tempSciFiTrackPointArray[k]);
 
88
          tempSciFiTrackPoint->set_mapper_name(mapper_name);
 
89
          GlobalTrack->AddTrackPoint(tempSciFiTrackPoint);
 
90
        }
 
91
        if (KLTrack != NULL) {
 
92
          std::vector<const MAUS::DataStructure::Global::TrackPoint*>
 
93
            tempKLTrackPointArray = KLTrack->GetTrackPoints();
 
94
          for (unsigned int l = 0; l < tempKLTrackPointArray.size(); l++) {
 
95
            MAUS::DataStructure::Global::TrackPoint* tempKLTrackPoint =
 
96
              const_cast<MAUS::DataStructure::Global::TrackPoint*>
 
97
              (tempKLTrackPointArray[l]);
 
98
            tempKLTrackPoint->set_mapper_name(mapper_name);
 
99
            GlobalTrack->AddTrackPoint(tempKLTrackPoint);
 
100
          }
 
101
        }
 
102
        global_event->add_track_recursive(GlobalTrack);
113
103
      }
114
104
    }
115
105
 
116
106
    // Adding global tracks for case where global event contains only TOF tracks
117
107
    // (And KL track if applicable)
118
 
    if (SciFiTrackArray->empty() && !TOFTrackArray.empty()) {
 
108
    if (ImportedSciFiTrack == NULL && !TOFTrackArray.empty()) {
119
109
      for (unsigned int i = 0; i < TOFTrackArray.size(); i++) {
120
 
        MAUS::DataStructure::Global::Track* GlobalTrack =
121
 
          new MAUS::DataStructure::Global::Track();
 
110
        MAUS::DataStructure::Global::Track* GlobalTrack = TOFTrackArray[i]->Clone();
122
111
        GlobalTrack->set_mapper_name(mapper_name);
123
 
        MAUS::DataStructure::Global::Track* tempTOFTrack = TOFTrackArray[i];
124
 
  if (!tempTOFTrack) {
125
 
      throw(Exception(Exception::recoverable,
126
 
                      "Found an empty TOF track pointer.",
127
 
          "MapCppGlobalPID::TrackMatching"));
128
 
  }
129
 
        std::vector<const MAUS::DataStructure::Global::TrackPoint*>
130
 
          tempTOFTrackPointArray = tempTOFTrack->GetTrackPoints();
131
 
        for (unsigned int j = 0; j < tempTOFTrackPointArray.size(); j++) {
132
 
          MAUS::DataStructure::Global::TrackPoint* tempTOFTrackPoint =
133
 
            const_cast<MAUS::DataStructure::Global::TrackPoint*>
134
 
            (tempTOFTrackPointArray[j]);
135
 
          GlobalTrack->AddTrackPoint(tempTOFTrackPoint);
136
 
        }
137
 
        if (KLTrack/*->GetTrackPoints().size() > 0*/) {
 
112
        if (KLTrack != NULL) {
138
113
            std::vector<const MAUS::DataStructure::Global::TrackPoint*>
139
114
              tempKLTrackPointArray = KLTrack->GetTrackPoints();
140
115
            for (unsigned int l = 0; l < tempKLTrackPointArray.size(); l++) {
151
126
 
152
127
    // Adding global tracks for case where global event contains only SciFi tracks
153
128
    // (And KL track if applicable)
154
 
    if (!SciFiTrackArray->empty() && TOFTrackArray.empty()) {
155
 
      for (unsigned int i = 0; i < SciFiTrackArray->size(); i++) {
156
 
        MAUS::DataStructure::Global::Track* GlobalTrack =
157
 
          new MAUS::DataStructure::Global::Track();
158
 
        GlobalTrack->set_mapper_name(mapper_name);
159
 
        MAUS::DataStructure::Global::Track* tempSciFiTrack =
160
 
          SciFiTrackArray->at(i);
161
 
  if (!tempSciFiTrack) {
162
 
    throw(Exception(Exception::recoverable,
163
 
                    "Found an empty SciFi track pointer.",
164
 
                    "MapCppGlobalPID::TrackMatching"));
165
 
  }
 
129
    if (ImportedSciFiTrack != NULL && TOFTrackArray.empty()) {
 
130
      MAUS::DataStructure::Global::Track* GlobalTrack = ImportedSciFiTrack->Clone();
 
131
      GlobalTrack->set_mapper_name(mapper_name);
 
132
     if (KLTrack != NULL) {
166
133
        std::vector<const MAUS::DataStructure::Global::TrackPoint*>
167
 
          tempSciFiTrackPointArray = tempSciFiTrack->GetTrackPoints();
168
 
        for (unsigned int j = 0; j < tempSciFiTrackPointArray.size(); j++) {
169
 
          MAUS::DataStructure::Global::TrackPoint* tempSciFiTrackPoint =
 
134
          tempKLTrackPointArray = KLTrack->GetTrackPoints();
 
135
        for (unsigned int l = 0; l < tempKLTrackPointArray.size(); l++) {
 
136
          MAUS::DataStructure::Global::TrackPoint* tempKLTrackPoint =
170
137
            const_cast<MAUS::DataStructure::Global::TrackPoint*>
171
 
            (tempSciFiTrackPointArray[j]);
172
 
          tempSciFiTrackPoint->set_mapper_name(mapper_name);
173
 
          GlobalTrack->AddTrackPoint(tempSciFiTrackPoint);
174
 
        }
175
 
        if (KLTrack/*->GetTrackPoints().size() > 0*/) {
176
 
            std::vector<const MAUS::DataStructure::Global::TrackPoint*>
177
 
              tempKLTrackPointArray = KLTrack->GetTrackPoints();
178
 
            for (unsigned int l = 0; l < tempKLTrackPointArray.size(); l++) {
179
 
              MAUS::DataStructure::Global::TrackPoint* tempKLTrackPoint =
180
 
                const_cast<MAUS::DataStructure::Global::TrackPoint*>
181
 
                (tempKLTrackPointArray[l]);
182
 
              tempKLTrackPoint->set_mapper_name(mapper_name);
183
 
              GlobalTrack->AddTrackPoint(tempKLTrackPoint);
184
 
            }
185
 
        }
186
 
        global_event->add_track_recursive(GlobalTrack);
 
138
            (tempKLTrackPointArray[l]);
 
139
          tempKLTrackPoint->set_mapper_name(mapper_name);
 
140
          GlobalTrack->AddTrackPoint(tempKLTrackPoint);
 
141
        }
187
142
      }
 
143
      global_event->add_track_recursive(GlobalTrack);
188
144
    }
189
145
 
190
146
    // Adding global tracks for case where global event contains only a KL track
191
 
    if (SciFiTrackArray->empty() && TOFTrackArray.empty() && KLTrack) {
192
 
      MAUS::DataStructure::Global::Track* GlobalTrack =
193
 
        new MAUS::DataStructure::Global::Track();
 
147
    if (ImportedSciFiTrack == NULL && TOFTrackArray.empty() && KLTrack != NULL) {
 
148
      MAUS::DataStructure::Global::Track* GlobalTrack = KLTrack->Clone();
194
149
      GlobalTrack->set_mapper_name(mapper_name);
195
 
      std::vector<const MAUS::DataStructure::Global::TrackPoint*>
196
 
        tempKLTrackPointArray = KLTrack->GetTrackPoints();
197
 
      for (unsigned int l = 0; l < tempKLTrackPointArray.size(); l++) {
198
 
        MAUS::DataStructure::Global::TrackPoint* tempKLTrackPoint =
199
 
          const_cast<MAUS::DataStructure::Global::TrackPoint*>
200
 
          (tempKLTrackPointArray[l]);
201
 
        tempKLTrackPoint->set_mapper_name(mapper_name);
202
 
        GlobalTrack->AddTrackPoint(tempKLTrackPoint);
203
 
      }
204
150
      global_event->add_track_recursive(GlobalTrack);
205
151
    }
206
152
  }
280
226
        }
281
227
        TOFTrackArray.push_back(TOFtrack);
282
228
      } else {
283
 
        Squeak::mout(Squeak::error) << "Global event returned multiple possible"
 
229
        Squeak::mout(Squeak::debug) << "Global event returned multiple possible"
284
230
                                    << " TOF0 and/or TOF2 space points that "
285
231
                                    << "could not be separated into tracks."
286
232
                                    << std::endl;
327
273
} // ~namespace global
328
274
} // ~namespace recon
329
275
} // ~namespace MAUS
 
276