← Back to branch summary

~christopher-hunt08/maus/maus_integrated_kalman

« back to all changes in this revision

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

  • Committer: Durga Rajaram
  • Date: 2014-07-16 15:13:05 UTC
  • mfrom: (659.1.92 cand)
  • Revision ID: durga@fnal.gov-20140716151305-q27rv1y9p03v9lks
Tags: MAUS-v0.9, MAUS-v0.9.0
MAUS-v0.9.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/map/MapCppGlobalTrackMatching/MapCppGlobalTrackMatching.cc
21
21
#include "Interface/Squeak.hh"
22
22
#include "src/common_cpp/Converter/DataConverters/JsonCppSpillConverter.hh"
23
23
#include "src/common_cpp/Converter/DataConverters/CppJsonSpillConverter.hh"
 
24
#include "src/common_cpp/API/PyWrapMapBase.hh"
 
25
 
24
26
 
25
27
namespace MAUS {
26
 
  MapCppGlobalTrackMatching::MapCppGlobalTrackMatching() {
27
 
    _classname = "MapCppGlobalTrackMatching";
28
 
  }
29
 
 
30
 
  bool MapCppGlobalTrackMatching::birth(std::string argJsonConfigDocument) {
 
28
 
 
29
  PyMODINIT_FUNC init_MapCppGlobalTrackMatching(void) {
 
30
    PyWrapMapBase<MAUS::MapCppGlobalTrackMatching>::PyWrapMapBaseModInit
 
31
                                    ("MapCppGlobalTrackMatching", "", "", "", "");
 
32
  }
 
33
 
 
34
  MapCppGlobalTrackMatching::MapCppGlobalTrackMatching()
 
35
    : MapBase<Data>("MapCppGlobalTrackMatching"), _configCheck(false) {
 
36
  }
 
37
 
 
38
  void MapCppGlobalTrackMatching::_birth(const std::string& argJsonConfigDocument) {
31
39
    // Check if the JSON document can be parsed, else return error only.
 
40
    _configCheck = false;
32
41
    bool parsingSuccessful = _reader.parse(argJsonConfigDocument, _configJSON);
33
42
    if (!parsingSuccessful) {
34
 
      _configCheck = false;
35
 
      return false;
 
43
        throw MAUS::Exception(Exception::recoverable,
 
44
                              "Failed to parse configuration",
 
45
                              "MapCppGlobalTrackMatching::birth");
36
46
    }
37
47
    _configCheck = true;
38
 
    return true;
39
 
  }
40
 
 
41
 
  bool MapCppGlobalTrackMatching::death() {
42
 
    return true;
43
 
  }
44
 
 
45
 
  std::string MapCppGlobalTrackMatching::process(std::string document) const {
46
 
    Json::FastWriter writer;
47
 
    Json::Value root;
48
 
 
49
 
    if (document.empty()) {
50
 
      Json::Value errors;
51
 
      std::stringstream ss;
52
 
      ss << _classname << " says: Empty document passed to process";
53
 
      errors["bad_json_document"] = ss.str();
54
 
      root["errors"] = errors;
55
 
      return writer.write(root);
56
 
    }
57
 
 
58
 
    if (!_configCheck) {
59
 
      Json::Value errors;
60
 
      std::stringstream ss;
61
 
      ss << _classname << " says: process passed an invalid configuration";
62
 
      errors["bad_json_document"] = ss.str();
63
 
      root["errors"] = errors;
64
 
      return writer.write(root);
65
 
    }
66
 
 
67
 
    // Prepare converters, spill and json objects
68
 
    JsonCppSpillConverter json2cppconverter;
69
 
    CppJsonSpillConverter cpp2jsonconverter;
70
 
    Json::Value *data_json = NULL;
71
 
    MAUS::Data *data_cpp = NULL;
72
 
 
 
48
    _classname = "MapCppGlobalTrackMatching";
 
49
  }
 
50
 
 
51
  void MapCppGlobalTrackMatching::_death() {
 
52
  }
 
53
 
 
54
  void MapCppGlobalTrackMatching::_process(MAUS::Data* data_cpp) const {
73
55
    // Read string and convert to a Json object
74
 
    try {
75
 
      Json::Value imported_json = JsonWrapper::StringToJson(document);
76
 
      data_json = new Json::Value(imported_json);
77
 
    } catch (Exception& exception) {
78
 
      MAUS::CppErrorHandler::getInstance()->
79
 
        HandleExceptionNoJson(exception, _classname);
80
 
      Squeak::mout(Squeak::error) << "String to Json conversion failed,"
81
 
                << "MapCppGlobalTrackMatching::process" << std::endl;
82
 
      Json::Value errors;
83
 
      std::stringstream ss;
84
 
      ss << _classname << " says: Bad json document";
85
 
      errors["bad_json_document"] = ss.str();
86
 
      root["errors"] = errors;
87
 
      delete data_json;
88
 
      return writer.write(root);
89
 
    } catch (std::exception& exc) {
90
 
      MAUS::CppErrorHandler::getInstance()->HandleStdExcNoJson(exc, _classname);
91
 
      Squeak::mout(Squeak::error) << "String to Json conversion failed,"
92
 
                                  << "MapCppGlobalTrackMatching::process"
93
 
                                  << std::endl;
94
 
      Json::Value errors;
95
 
      std::stringstream ss;
96
 
      ss << _classname << " says: Bad json document";
97
 
      errors["bad_json_document"] = ss.str();
98
 
      root["errors"] = errors;
99
 
      delete data_json;
100
 
      return writer.write(root);
101
 
    }
102
 
 
103
 
    if (!data_json || data_json->isNull()) {
104
 
      if (data_json) delete data_json;
105
 
      return std::string("{\"errors\":{\"bad_json_document\":")+
106
 
        std::string("\"Failed to parse input document\"}}");
107
 
    }
108
 
 
109
 
    if (data_json->empty()) {
110
 
      delete data_json;
111
 
      return std::string("{\"errors\":{\"bad_json_document\":")+
112
 
        std::string("\"Failed to parse input document\"}}");
113
 
    }
114
 
 
115
 
    std::string maus_event = JsonWrapper::GetProperty(
116
 
        *data_json, "maus_event_type",
117
 
        JsonWrapper::stringValue).asString();
118
 
 
119
 
    if ( maus_event.compare("Spill") != 0 ) {
120
 
      Squeak::mout(Squeak::error) << "Line of json document did not contain "
121
 
          << "a Spill" << std::endl;
122
 
      delete data_json;
123
 
      return document;
124
 
    }
125
 
 
126
 
    std::string daq_event = JsonWrapper::GetProperty(
127
 
        *data_json, "daq_event_type",
128
 
        JsonWrapper::stringValue).asString();
129
 
 
130
 
    if ( daq_event.compare("physics_event") != 0 ) {
131
 
      Squeak::mout(Squeak::error) << "daq_event_type did not return a "
132
 
          << "physics event" << std::endl;
133
 
      delete data_json;
134
 
      return document;
135
 
    }
136
 
 
137
 
    // Convert Json into MAUS::Spill object.  In future, this will all
138
 
    // be done for me, and process will take/return whichever object we
139
 
    // prefer.
140
 
    try {
141
 
      data_cpp = json2cppconverter(data_json);
142
 
      delete data_json;
143
 
    } catch (...) {
144
 
      Squeak::mout(Squeak::error) << "Missing required branch daq_event_type"
145
 
          << "converting json->cpp, MapCppGlobalTrackMatching" << std::endl;
146
 
    }
147
 
 
148
56
    if (!data_cpp) {
149
 
      return std::string("{\"errors\":{\"failed_json_cpp_conversion\":")+
150
 
        std::string("\"Failed to convert Json to Cpp Spill object\"}}");
 
57
        throw MAUS::Exception(Exception::recoverable,
 
58
                              "data_cpp was NULL",
 
59
                              "MapCppGlobalTrackMatching::_process");
 
60
    }
 
61
    if (!_configCheck) {
 
62
        throw MAUS::Exception(Exception::recoverable,
 
63
                              "Birth has not been successfully called",
 
64
                              "MapCppGlobalTrackMatching::_process");
151
65
    }
152
66
 
153
67
    const MAUS::Spill* spill = data_cpp->GetSpill();
155
69
    MAUS::ReconEventPArray* recon_events = spill->GetReconEvents();
156
70
 
157
71
    if (!recon_events) {
158
 
      delete data_cpp;
159
 
      return document;
 
72
      return;
160
73
    }
161
74
 
162
75
    MAUS::GlobalEvent* global_event;
168
81
      MAUS::ReconEvent* recon_event = (*recon_event_iter);
169
82
      global_event = MakeTracks(recon_event);
170
83
    }
171
 
 
172
 
    data_json = cpp2jsonconverter(data_cpp);
173
 
 
174
 
    if (!data_json) {
175
 
      delete data_cpp;
176
 
      return std::string("{\"errors\":{\"failed_cpp_json_conversion\":")+
177
 
        std::string("\"Failed to convert Cpp to Json Spill object\"}}");
178
 
    }
179
 
 
180
 
    std::string output_document = JsonWrapper::JsonToString(*data_json);
181
 
    delete data_json;
182
 
    delete data_cpp;
183
 
    return output_document;
184
84
  }
185
85
 
186
86
  MAUS::GlobalEvent*
187
87
  MapCppGlobalTrackMatching::MakeTracks(MAUS::ReconEvent* recon_event) const {
188
88
    if (!recon_event) {
189
89
      throw(Exception(Exception::recoverable,
190
 
                      "Trying to import an empty recon event.",
191
 
                      "MapCppGlobalTrackMatching::Import"));
 
90
                      "Trying to use an empty recon event.",
 
91
                      "MapCppGlobalTrackMatching::MakeTracks"));
192
92
    }
193
93
 
194
94
    MAUS::GlobalEvent* global_event = recon_event->GetGlobalEvent();