← Back to branch summary

~christopher-hunt08/maus/maus_integrated_kalman

« back to all changes in this revision

Viewing changes to src/map/MapCppGlobalReconImport/MapCppGlobalReconImport.cc

merging in changes in merge branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/map/MapCppGlobalReconImport/MapCppGlobalReconImport.cc
34
34
    : MapBase<Data>("MapCppGlobalReconImport"), _configCheck(false) {
35
35
  }
36
36
 
 
37
  MapCppGlobalReconImport::~MapCppGlobalReconImport() {
 
38
  }
 
39
 
37
40
  void MapCppGlobalReconImport::_birth(const std::string& argJsonConfigDocument) {
38
41
    // Check if the JSON document can be parsed, else return error only.
39
42
    _configCheck = false;
40
43
    bool parsingSuccessful = _reader.parse(argJsonConfigDocument, _configJSON);
41
44
    if (!parsingSuccessful) {
42
 
        throw MAUS::Exception(Exception::recoverable,
43
 
                              "Failed to parse configuration",
44
 
                              "MapCppGlobalReconImport::birth");
45
 
    }
 
45
      throw MAUS::Exception(Exception::recoverable,
 
46
                            "Failed to parse configuration",
 
47
                            "MapCppGlobalReconImport::birth");
 
48
    }
 
49
 
 
50
    char* pMAUS_ROOT_DIR = getenv("MAUS_ROOT_DIR");
 
51
    if (!pMAUS_ROOT_DIR) {
 
52
      throw MAUS::Exception(Exception::recoverable,
 
53
                  std::string("Could not find the $MAUS_ROOT_DIR env variable. ")+\
 
54
            std::string("Did you try running: source env.sh?"),
 
55
            "MapCppGlobalReconImport::_birth");
 
56
    }
 
57
 
46
58
    _configCheck = true;
47
59
    _classname = "MapCppGlobalReconImport";
48
60
  }
77
89
         ++recon_event_iter) {
78
90
      // Load the ReconEvent, and import it into the GlobalEvent
79
91
      MAUS::ReconEvent* recon_event = (*recon_event_iter);
80
 
      MAUS::GlobalEvent* global_event = recon_event->GetGlobalEvent();
81
 
      MAUS::TOFEvent* tof_event = recon_event->GetTOFEvent();
82
 
      MAUS::SciFiEvent* scifi_event = recon_event->GetSciFiEvent();
83
 
      MAUS::CkovEvent* ckov_event = recon_event->GetCkovEvent();
84
 
      MAUS::KLEvent* kl_event = recon_event->GetKLEvent();
85
 
 
86
 
      if (tof_event) {
87
 
        MAUS::recon::global::ImportTOFRecon tofrecon_importer;
88
 
        tofrecon_importer.process((*tof_event), global_event, _classname);
89
 
      }
90
 
      if (scifi_event) {
91
 
        MAUS::recon::global::ImportSciFiRecon scifirecon_importer;
92
 
        scifirecon_importer.process((*scifi_event), global_event, _classname);
93
 
      }
94
 
      if (ckov_event) {
95
 
        MAUS::recon::global::ImportCkovRecon ckovrecon_importer;
96
 
        ckovrecon_importer.process((*ckov_event), global_event, _classname);
97
 
      }
98
 
      if (kl_event) {
99
 
        MAUS::recon::global::ImportKLRecon klrecon_importer;
100
 
        klrecon_importer.process((*kl_event), global_event, _classname);
 
92
      if (recon_event->GetGlobalEvent()) {
 
93
        MAUS::GlobalEvent* global_event = recon_event->GetGlobalEvent();
 
94
        if (recon_event->GetTOFEvent()) {
 
95
          MAUS::TOFEvent* tof_event = recon_event->GetTOFEvent();
 
96
          MAUS::recon::global::ImportTOFRecon tofrecon_importer;
 
97
          tofrecon_importer.process((*tof_event), global_event, _classname);
 
98
        }
 
99
        if (recon_event->GetSciFiEvent()) {
 
100
          MAUS::SciFiEvent* scifi_event = recon_event->GetSciFiEvent();
 
101
          MAUS::recon::global::ImportSciFiRecon scifirecon_importer;
 
102
          scifirecon_importer.process((*scifi_event), global_event, _classname);
 
103
        }
 
104
        if (recon_event->GetCkovEvent()) {
 
105
          MAUS::CkovEvent* ckov_event = recon_event->GetCkovEvent();
 
106
          MAUS::recon::global::ImportCkovRecon ckovrecon_importer;
 
107
          ckovrecon_importer.process((*ckov_event), global_event, _classname);
 
108
        }
 
109
        if (recon_event->GetKLEvent()) {
 
110
          MAUS::KLEvent* kl_event = recon_event->GetKLEvent();
 
111
          MAUS::recon::global::ImportKLRecon klrecon_importer;
 
112
          klrecon_importer.process((*kl_event), global_event, _classname);
 
113
        }
 
114
        if (recon_event->GetEMREvent()) {
 
115
          MAUS::EMREvent* emr_event = recon_event->GetEMREvent();
 
116
          MAUS::recon::global::ImportEMRRecon emrrecon_importer;
 
117
          emrrecon_importer.process((*emr_event), global_event, _classname);
 
118
        }
101
119
      }
102
120
    }
103
121
  }