def run(): """ Run the macro """ # This input generates empty spills, to be filled by the beam maker later on my_input = MAUS.InputPySpillGenerator() # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapPyBeamMaker()) # beam construction my_map.append(MAUS.MapCppSimulation()) # geant4 simulation my_map.append(MAUS.MapCppTOFMCDigitizer()) # TOF MC Digitizer #my_map.append(MAUS.MapCppTOFSlabHits()) # TOF SlabHit Reco #my_map.append(MAUS.MapCppTOFSpacePoints()) # TOF SpacePoint Reco my_map.append(MAUS.MapCppKLMCDigitizer()) # KL MC Digitizer my_map.append(MAUS.MapCppKLCellHits()) # KL CellHit Reco # can specify datacards here or by using appropriate command line calls datacards = io.StringIO(u"") reducer = MAUS.ReducePyDoNothing() # Then construct a MAUS output component - filename comes from datacards my_output = MAUS.OutputPyJSON() # The Go() drives all the components you pass in, then check the file # (default simulation.out) for output MAUS.Go(my_input, my_map, reducer, my_output, datacards)
def run(): """ Run the macro """ # This input generates empty spills, to be filled by the beam maker later on my_input = MAUS.InputPySpillGenerator() # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() # GEANT4 my_map.append(MAUS.MapPyBeamMaker()) # beam construction my_map.append(MAUS.MapCppSimulation()) # geant4 simulation # Pre detector set up # my_map.append(MAUS.MapPyMCReconSetup()) # geant4 simulation my_map.append(MAUS.MapCppMCReconSetup()) # geant4 simulation # SciFi my_map.append( MAUS.MapCppTrackerVirtualsDigitization()) # SciFi electronics model my_map.append(MAUS.MapCppTrackerRecon()) # SciFi Recon # Then construct a MAUS output component - filename comes from datacards my_output = MAUS.OutputCppRoot() # can specify datacards here or by using appropriate command line calls datacards = io.StringIO(u"") # The Go() drives all the components you pass in, then check the file # (default simulation.out) for output MAUS.Go(my_input, my_map, MAUS.ReducePyDoNothing(), my_output, datacards)
def run(input_beam, configuration, out_file): """run""" document_file = io.StringIO(unicode(input_beam)) my_input = MAUS.InputPyJSON(document_file) my_map = MAUS.MapCppSimulation() my_output = MAUS.OutputPyJSON(open(out_file, 'w')) MAUS.Go(my_input, my_map, MAUS.ReducePyDoNothing(), my_output, io.StringIO(unicode(configuration)))
def setUpClass(cls): # pylint: disable = C0103 """Sets a mapper and configuration""" cls.mappers = [MAUS.MapCppTrackerClusterRecon(), \ MAUS.MapCppTrackerSpacePointRecon()] cls.test_config = "" if maus_cpp.globals.has_instance(): cls.test_config = maus_cpp.globals.get_configuration_cards() maus_cpp.globals.death()
def run(): """ Analyze data from the MICE experiment This reads in and processes data taken from the MICE experiment. """ # Set up data cards. data_cards_list = [] # batch mode = runs ROOT in batch mode so that canvases are not displayed # 1 = True, Batch Mode # 0 = False, Interactive Mode # setting it to false/0 will cause canvases to pop up on screen and # will get refreshed every N spills set by the refresh_rate data # card. data_cards_list.append("root_batch_mode='%d'\n" % 1) # refresh_rate = once in how many spills should canvases be updated data_cards_list.append("refresh_rate='%d'\n" % 1) # Add auto-numbering to the image tags. If False then each # histogram output for successive spills will have the same tag # so there are no spill-specific histograms. This is the # recommended use for online reconstruction. data_cards_list.append("histogram_auto_number=%s\n" % False) # Default image type is eps. For online use, use PNG. data_cards_list.append("histogram_image_type=\"png\"\n") # Directory for images. Default: $MAUS_WEB_MEDIA_RAW if set # else the current directory is used. # Uncomment and change the following if you want to hard # code a different default path. # data_cards_list.append("image_directory='%s'\n" % os.getcwd()) # Convert data_cards to string. data_cards = io.StringIO(unicode("".join(data_cards_list))) # Set up the input that reads from DAQ # my_input = MAUS.InputCppDAQData() # my_input = MAUS.InputCppDAQOnlineData() my_input = MAUS.InputCppDAQOnlineData() # pylint: disable = E1101 # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() # add ReconSetup map -- analyze_data_offline seems to have it already my_map.append(MAUS.MapCppReconSetup()) my_map.append(MAUS.MapCppTOFDigits()) my_map.append(MAUS.MapCppTOFSlabHits()) my_map.append(MAUS.MapCppTOFSpacePoints()) my_map.append(MAUS.MapCppCkovDigits()) # Histogram reducer. reducer = MAUS.ReducePyDoNothing() #reducer = MAUS.ReducePyDoNothing() # Save images as EPS and meta-data as JSON. #output_worker = MAUS.OutputPyDoNothing() output_worker = MAUS.OutputPyJSON() # Run the workflow. MAUS.Go(my_input, my_map, reducer, output_worker, data_cards)
def run(): """ Run the macro """ # This input generates empty spills, to be filled by the beam maker later on my_input = MAUS.InputPySpillGenerator() # my_input = MAUS.InputCppRoot() # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapPyBeamMaker()) # beam construction my_map.append(MAUS.MapCppSimulation()) # geant4 simulation # my_map.append(MAUS.MapCppTrackerMCNoise()) # SciFi noise my_map.append(MAUS.MapCppTrackerMCDigitization()) # SciFi electronics my_map.append(MAUS.MapCppTrackerRecon()) # SciFi recon # can specify datacards here or by using appropriate command line calls datacards = io.StringIO(u"") # reducer = MAUS.ReduceCppPatternRecognition() # Turn on event display reducer = MAUS.ReducePyDoNothing() # Then construct a MAUS output component - filename comes from datacards # my_output = MAUS.OutputPyJSON() my_output = MAUS.OutputCppRoot() # The Go() drives all the components you pass in, then check the file # (default simulation.out) for output MAUS.Go(my_input, my_map, reducer, my_output, datacards)
def run(): """Run the macro""" # This generates events (usually spills) from a root binary file my_input = MAUS.InputCppRoot() # This outputs events (usually spills) to a json ascii file my_output = MAUS.OutputPyJSON() # Execute inputter and outputter # Mapper and Reducer does nothing MAUS.Go(my_input, MAUS.MapPyDoNothing(), MAUS.ReducePyDoNothing(), \ my_output, io.StringIO(u""))
def run(): """ Analyze data from the MICE experiment This reads in and processes data taken from the MICE experiment. """ # Set up data cards. data_cards_list = [] data_cards_list.append("output_file_name='scalers'\n") # Convert data_cards to string. data_cards = io.StringIO(unicode("".join(data_cards_list))) # Set up the input that reads from DAQ my_input = MAUS.InputCppDAQOfflineData() # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapCppTOFDigits()) my_map.append(MAUS.MapCppTOFSlabHits()) my_map.append(MAUS.MapCppTOFSpacePoints()) # Histogram reducer. reducer = MAUS.ReducePyScalersTable() # Save images as EPS and meta-data as JSON. output_worker = MAUS.OutputPyFile() # Run the workflow. MAUS.Go(my_input, my_map, reducer, output_worker, data_cards)
def run(): """ Run the macro """ # Take as input a maus root file. my_input = MAUS.InputCppRootData() my_output = MAUS.OutputPyDoNothing() # datacard specifies the hypothesis for which PDFs are to be made datacards = io.StringIO(u"") # The Go() drives all the components you pass in MAUS.Go(my_input, MAUS.MapPyDoNothing(), MAUS.ReduceCppGlobalPID(), my_output, datacards)
def setUp(self): # pylint: disable=C0103, C0202 """ Define cards and initialise Output """ self.output = MAUS.OutputCppRoot() self.outdir = os.environ["MAUS_ROOT_DIR"]+"/tmp/test_output_cpp_root/" self.outfile = self.outdir+"test_outputCppRoot.root" try: os.mkdir(self.outdir) except OSError: pass try: os.mkdir(self.outdir+"/end_of_run/") except OSError: pass self.on_error_standard = ErrorHandler.DefaultHandler().on_error #ref = {"$ref":"#test_branch/double_by_value"} self.test_data = { "scalars":{}, "spill_number":1, "run_number":1, "daq_event_type":"physics_event", "recon_events":[], "mc_events":[], "maus_event_type":"Spill", } self.test_job_header = { "start_of_job":{"date_time":"1976-04-04T00:00:00.000000"}, "bzr_configuration":"", "bzr_revision":"", "bzr_status":"", "maus_version":"", "json_configuration":"output cpp root test", "maus_event_type":"JobHeader", } self.test_run_header = { "run_number":1, "maus_event_type":"RunHeader" } self.test_run_footer = { "run_number":-1, "maus_event_type":"RunFooter" } self.test_job_footer = { "end_of_job":{"date_time":"1977-04-04T00:00:00.000000"}, "maus_event_type":"JobFooter", } self.cards = Configuration.Configuration().getConfigJSON() self.cards = json.loads(self.cards) self.cards["output_root_file_name"] = self.outfile self.cards["output_root_file_mode"] = "one_big_file" self.cards["end_of_run_output_root_directory"] = \ self.outdir+"/end_of_run/" self.cards["verbose_level"] = 2 self.cards = json.dumps(self.cards) if maus_cpp.globals.has_instance(): maus_cpp.globals.death() maus_cpp.globals.birth(self.cards) self.output.birth(self.cards)
def run(): """ Run the macro """ # This input generates empty spills, to be filled by the beam maker later on input_file = open('maus_output.json', 'r') # my_input = MAUS.InputPyJSON(input_file) #my_input = MAUS.InputPySpillGenerator() # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() #my_map.append(MAUS.MapPyBeamMaker()) # beam construction #my_map.append(MAUS.MapCppSimulation()) # geant4 simulation my_map.append( MAUS.MapCppTrackerMCDigitization()) # SciFi electronics model my_map.append(MAUS.MapCppTrackerRecon()) # SciFi recon # can specify datacards here or by using appropriate command line calls datacards = io.StringIO(u"") #reducer = MAUS.ReduceCppTracker() reducer = MAUS.ReducePyDoNothing() output_file = open("recon_mc", 'w') # Uncompressed # Then construct a MAUS output component my_output = MAUS.OutputPyJSON(output_file) # The Go() drives all the components you pass in, then check the file # (default simulation.out) for output MAUS.Go(my_input, my_map, reducer, my_output, datacards)
def run(data_path, run_num): """Analyze data from the MICE experiment This will read in and process data taken from the MICE experiment. It will eventually include things like cabling information, calibrations, and fits. """ # Here you specify the path to the data and also the file you want to # analyze. my_input = MAUS.InputCppDAQOfflineData(data_path, data_file) # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapCppTrackerDigits()) my_map.append(MAUS.MapCppTrackerRecon()) reducer = MAUS.ReduceCppTracker() #reducer = MAUS.ReducePyDoNothing() # reducer = MAUS.ReduceCppTrackerErrorLog() output_file = open("unpacked_1901", 'w') # Uncompressed my_output = MAUS.OutputPyJSON(output_file) # The Go() drives all the components you pass in then put all the output # into a file called 'mausput' MAUS.Go(my_input, my_map, reducer, my_output)
def run(): """ Run the macro """ # This input generates empty spills, to be filled by the beam maker later on my_input = MAUS.InputCppRootData() # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() # Global my_map.append(MAUS.MapCppGlobalReconImport()) my_map.append(MAUS.MapCppGlobalTrackMatching()) my_reduce = MAUS.ReducePyDoNothing() # Then construct a MAUS output component - filename comes from datacards my_output = MAUS.OutputCppRoot() # can specify datacards here or by using appropriate command line calls datacards = io.StringIO(u"") # The Go() drives all the components you pass in, then check the file # (default simulation.out) for output MAUS.Go(my_input, my_map, my_reduce, my_output, datacards)
def setUpClass(cls): # pylint: disable-msg=C0103 """ Class Initializer. The set up is called before each test function is called. """ cls.mapper = MAUS.MapCppKLMCDigitizer() conf_json = json.loads(Configuration().getConfigJSON()) conf_json["simulation_geometry_filename"] = "Stage6.dat" # Test whether the configuration files were loaded correctly at birth cls.mapper.birth(json.dumps(conf_json))
def setUpClass(cls): #pylint: disable = C0103 """Construct for MapPyScalersDump """ if not os.environ.get("MAUS_ROOT_DIR"): raise Exception('InitializeFail', 'MAUS_ROOT_DIR unset!') cls.mapper = MAUS.MapPyScalersDump() # Set our data path & filename # It would be nicer to test with a smaller data file! cls._datapath = '%s/src/input/InputCppDAQData' % \ os.environ.get("MAUS_ROOT_DIR") cls._datafile = '06008' cls._c = Configuration()
def tearDownClass(cls): # pylint: disable = C0103 """Sets a mapper and configuration, and checks that we can death() MapCppTrackerPatternRecognition""" cls.mapper = MAUS.MapCppTrackerPatternRecognition() if maus_cpp.globals.has_instance(): maus_cpp.globals.death() if cls.test_config != "": maus_cpp.globals.birth(cls.test_config) # Check we death() the mapper cls.mapper.death() cls.mapper = None
def run(): """ Create a JSON document and create a histogram. """ if not os.environ.get("MAUS_ROOT_DIR"): raise Exception('InitializeFail', 'MAUS_ROOT_DIR unset!') config = Configuration().getConfigJSON() config_json = json.loads(config) datapath = '%s/src/input/InputCppDAQData' % \ os.environ.get("MAUS_ROOT_DIR") # Set up a run configuration datafile = '05466' if os.environ['MAUS_UNPACKER_VERSION'] == "StepIV": datafile = '06008' config_json["daq_data_path"] = datapath config_json["daq_data_file"] = datafile # Set up data cards. data_cards_list = [] data_cards_list.append("output_file_name='%s'\n" % "scalers") data_cards_list.append("output_file_auto_number=%s\n" % True) data_cards_list.append("daq_data_path='%s'\n" % datapath) data_cards_list.append("daq_data_file='%s'\n" % datafile) data_cards_list.append("DAQ_cabling_by='%s'\n" % "date") data_cards = io.StringIO(unicode("".join(data_cards_list))) print data_cards # Create workers. # inputter = InputCppDAQOfflineData(datapath, datafile) # inputter.birth(json.dumps(config_json)) inputter = InputCppDAQOfflineData() mappers = MAUS.MapPyGroup() mappers.append(MAUS.MapPyDoNothing()) reducer = MAUS.ReducePyScalersTable() outputter = MAUS.OutputPyFile() # Execute the workers. MAUS.Go(inputter, mappers, reducer, outputter, data_cards)
def run(): """Analyze data from the MICE experiment This will read in and process data taken from the MICE experiment. It will eventually include things like cabling information, calibrations, and fits. """ # Here you specify the path to the data and also the file you want to # analyze. my_input = MAUS.InputCppDAQOnlineData() # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapPyScalersDump()) #my_map.append(MAUS.MapCppTOFDigits()) #my_map.append(MAUS.MapCppTOFSlabHits()) #my_map.append(MAUS.MapCppTOFSpacePoints()) #my_map.append(MAUS.MapPyTOFPlot()) # The Go() drives all the components you pass in then put all the output # into a file called 'mausput' MAUS.Go(my_input, my_map, MAUS.ReducePyDoNothing(), MAUS.OutputPyJSON())
def setUpClass(cls): # pylint: disable-msg=C0103 """ Class Initializer. The set up is called before each test function is called. """ cls.mapper = MAUS.MapCppCkovMCDigitizer() conf_json = json.loads(Configuration().getConfigJSON()) root_dir = os.environ.get("MAUS_ROOT_DIR") geom_file = \ '%s/src/map/MapCppCkovMCDigitizer/ckov_geom.dat' % root_dir conf_json["reconstruction_geometry_filename"] = geom_file # Test whether the configuration files were loaded correctly at birth cls.mapper.birth(json.dumps(conf_json))
def tearDownClass(cls): # pylint: disable = C0103 """Sets a mapper and configuration, and checks that we can death() MapCppGlobalTrackMatching""" cls.mapper = MAUS.MapCppGlobalTrackMatching() if maus_cpp.globals.has_instance(): maus_cpp.globals.death() if cls.test_config != "": maus_cpp.globals.birth(cls.test_config) else: maus_cpp.globals.birth(json.dumps(MapCppGlobalTMTestCase.cfg)) # Check we death() the mapper cls.mapper.death() cls.mapper = None
def test_end_of_run_file_per_run(self): """ test_OutputCppRoot.test_one_file_per_run: end_of_run_file_per_run option """ my_output = MAUS.OutputCppRoot() cards_py = json.loads(self.cards) cards_py["output_root_file_mode"] = "end_of_run_file_per_run" cards_py["output_root_file_name"] = "test_outputCppRoot.root" cards_py["end_of_run_output_root_directory"] = \ self.outdir+"/end_of_run/" self.cards = json.dumps(cards_py) my_output.birth(self.cards) self.test_data["run_number"] = 10 self.test_run_header["run_number"] = 10 for i in range(3): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_data) )) for i in range(2): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_run_header) )) for i in range(3): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_data) )) self.test_run_header["run_number"] = 9 for i in range(3): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_run_header) )) self.assertTrue(my_output.save( json.dumps(self.test_job_footer) )) self.test_run_footer["run_number"] = 9 self.assertTrue(my_output.save( json.dumps(self.test_run_footer) )) for i in range(3): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_job_header) )) my_output.death() self.__check_job_header("output cpp root test", 3, 0, self.outdir+"/end_of_run/0/test_outputCppRoot.root") self.__check_run_header(10, 2, 0, self.outdir+"/end_of_run/10/test_outputCppRoot.root") self.__check_run_header(9, 3, 0, self.outdir+"/end_of_run/9/test_outputCppRoot.root") self.__check_job_footer("1977-04-04T00:00:00.000000", 1, 0, self.outdir+"/end_of_run/0/test_outputCppRoot.root")
def run(number_of_spills): """ Run the macro """ # Here we create a pseudo-file with an event in it. If you were to copy # and paste this to a file, then you could also do: # # input_file = open('myFileName.txt', 'r') # # where the file format has a JSON document per line. I just toss the file # in here for simplicity. input_file = io.StringIO( number_of_spills * u"""{"mc": [{"primary":{"position": { "x": 0.0, "y": -0.0, "z": -5000.0 },"particle_id" : 13,"energy" : 210.0, "random_seed" : 10, "momentum" : { "x":0.0, "y":0.0, "z":1.0 }, "time" : 0.0}}]}\n""" ) # pylint: disable=C0301 my_input = MAUS.InputPyJSON(input_file) # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapCppSimulation()) # geant4 simulation my_map.append(MAUS.MapCppTOFMCDigitizer()) # TOF electronics model my_map.append(MAUS.MapCppTrackerMCDigitization()) # SCiFi electronics datacards = io.StringIO(u"keep_steps = True") # You may specify datacards if you wish. To do so you create a file object # which can either be a StringIO object or a native python file. If you # want to store your datacards in a file 'datacards.dat' then uncomment: # datacards = open('datacards.dat', 'r') # Choose from either a compressed or uncompressed output file # output_file = open(os.environ["MAUS_ROOT_DIR"] + "/tmp/simulation.out", 'w') # Uncompressed #output_file = gzip.GzipFile("mausput.gz", 'wb') # Compressed # # Then construct a MAUS output component my_output = MAUS.OutputPyJSON(output_file) # The Go() drives all the components you pass in, then check the file # 'mausput' for the output MAUS.Go(my_input, my_map, MAUS.ReducePyDoNothing(), my_output, datacards)
def run(): """Analyze data from the MICE experiment This will read in and process data taken from the MICE experiment. It will eventually include things like cabling information, calibrations, and fits. """ # Set up the input that reads from DAQ #my_input = MAUS.InputCppDAQData() my_input = MAUS.InputCppDAQOfflineData() # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapCppTOFDigits()) my_map.append(MAUS.MapCppTOFSlabHits()) my_map.append(MAUS.MapCppTOFSpacePoints()) my_map.append(MAUS.MapCppCkovDigits()) reducer = MAUS.ReducePyCkov() # The Go() drives all the components you pass in then put all the output # into a file called 'mausput' MAUS.Go(my_input, my_map, reducer, MAUS.OutputPyImage())
def run(number_of_spills): #pylint: disable =W0621 """Simulate the MICE experiment This will simulate 'number_of_spills' MICE events through the entirity of MICE using Geant4. At present, TOF and Tracker hits will be digitized. """ # Here we create a pseudo-file with an event in it. If you were to copy # and paste this to a file, then you could also do: # # documentFile = open('myFileName.txt', 'r') # # where the file format has a JSON document per line. I just toss the file # in here for simplicity. document_file = io.StringIO( number_of_spills * u"""{"mc": [{"position": { "x": 0.0, "y": -0.0, "z": -5000 },"particle_id" : 13,"energy" : 210, "random_seed" : 10, "unit_momentum" : { "x":0, "y":0, "z":1 }}]}\n""" ) #pylint: disable =C0301 my_input = MAUS.InputPyJSON(document_file) # Create an empty array of mappers, then populate it # with the functionality you want to use. my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapCppSimulation()) # geant4 simulation my_map.append(MAUS.MapCppTOFMCDigitizer()) # TOF detector digitization my_map.append(MAUS.MapCppTrackerMCDigitization()) # tracker digitization datacards = io.StringIO(u"keep_tracks = False\n"\ "simulation_geometry_filename = \"Stage5.dat\"") # You may specify datacards if you wish. To do so you create a file object # which can either be a StringIO object or a native python file. If you # want to store your datacards in a file 'datacards.dat' then uncomment: # datacards = open('datacards.dat', 'r') # The Go() drives all the components you pass in, then check the file # 'mausput' for the output MAUS.Go(my_input, my_map, MAUS.ReducePyDoNothing(), MAUS.OutputPyJSON(), datacards)
def test_something(self): """ Check against different issues""" inputter = MAUS.InputCppDAQOfflineData(self._datapath, self._datafile) conf_json = json.loads(self._c.getConfigJSON()) conf_json["DAQ_cabling_by"] = "date" inputter.birth(json.dumps(conf_json)) success = self.mapper.birth("{}") self.assertFalse(success) success = self.mapper.add("") self.assertFalse(success) success = self.mapper.add("{}") self.assertFalse(success) success = self.mapper.dump() self.assertTrue(success) result = self.mapper.process("{}") self.assertEqual(len(result), 2)
def test_one_file_per_run(self): """ test_OutputCppRoot.test_one_file_per_run: one_file_per_run option """ my_output = MAUS.OutputCppRoot() cards_py = json.loads(self.cards) cards_py["output_root_file_mode"] = "one_file_per_run" self.cards = json.dumps(cards_py) my_output.birth(self.cards) self.test_data["run_number"] = 10 self.test_run_header["run_number"] = 10 for i in range(3): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_data) )) for i in range(2): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_run_header) )) for i in range(3): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_data) )) self.test_run_header["run_number"] = 9 for i in range(3): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_run_header) )) for i in range(3): # pylint: disable = W0612 self.assertTrue(my_output.save( json.dumps(self.test_job_header) )) my_output.death() self.__check_job_header("output cpp root test", 3, 0, self.outdir+"test_outputCppRoot_0.root") self.__check_run_header(10, 2, 0, self.outdir+"test_outputCppRoot_10.root") self.__check_run_header(9, 3, 0, self.outdir+"test_outputCppRoot_9.root")
def run(): """ Run the macro """ my_input = MAUS.InputCppDAQOfflineData() # my_input = MAUS.InputPyJSON() my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapCppTrackerDigits()) my_map.append(MAUS.MapCppTrackerRecon()) # SciFi recon datacards = io.StringIO(u"") # my_output = MAUS.OutputPyJSON() my_output = MAUS.OutputCppRoot() # my_reduce = MAUS.ReducePyDoNothing() my_reduce = MAUS.ReduceCppPatternRecognition() MAUS.Go(my_input, my_map, my_reduce, my_output, datacards)
def test_birth_death(self): """ Check that we can birth and death properly """ an_output = MAUS.OutputCppRoot() # for now this does NOT return an exception... looks like it is caught # by the API... set ErrorHandler.on_error to 'raise' and we raise a # std::exception killing the tests (oops) an_output.birth(json.dumps({})) an_output.birth(json.dumps({'output_root_file_name':'', 'output_root_file_mode':'one_big_file', 'end_of_run_output_root_directory':'tmp'})) an_output.birth(json.dumps({'output_root_file_name':'test.root', 'output_root_file_mode':'', 'end_of_run_output_root_directory':'tmp'})) an_output.birth(json.dumps({'output_root_file_name':'test.root', 'output_root_file_mode':'one', 'end_of_run_output_root_directory':'tmp'})) # this is okay (dir can just be '') an_output.birth(json.dumps({'output_root_file_name':'test.root', 'output_root_file_mode':'one_big_file', 'end_of_run_output_root_directory':''})) an_output.birth(self.cards) an_output.death()
def setUpClass(cls): # pylint: disable = C0103 """Initialize a Ckov object""" cls.mapper = MAUS.MapPyCkov() cls.c = Configuration()
def run(): """ Run the macro """ my_input = MAUS.InputPySpillGenerator() my_map = MAUS.MapPyGroup() my_map.append(MAUS.MapPyBeamMaker()) # beam construction my_map.append(MAUS.MapCppSimulation()) # geant4 simulation my_map.append( MAUS.MapCppTrackerMCDigitization()) # SciFi electronics model my_map.append(MAUS.MapCppTrackerClusterRecon()) # SciFi channel clustering my_map.append( MAUS.MapCppTrackerSpacePointRecon()) # SciFi spacepoint recon my_map.append( MAUS.MapCppTrackerPatternRecognition()) # SciFi track finding my_map.append(MAUS.MapCppTrackerTrackFit()) # SciFi track fit datacards = io.StringIO(u"") # reducer = MAUS.ReduceCppPatternRecognition() reducer = MAUS.ReducePyDoNothing() # my_output = MAUS.OutputPyJSON() my_output = MAUS.OutputCppRoot() MAUS.Go(my_input, my_map, reducer, my_output, datacards)