Added multithreaded readout

Author: coderdj

DAQController.cc

@@ -7,7 +7,7 @@
 // 3-running
 // 4-error
 
-DAQController::DAQController(MongoLog *log){
+DAQController::DAQController(MongoLog *log, std::string hostname){
   fLog=log;
   fHelper = new DAXHelpers();
   fOptions = NULL;
@@ -18,6 +18,7 @@ DAQController::DAQController(MongoLog *log){
   fRunStartController = NULL;
   fRawDataBuffer = NULL;
   fDatasize=0.;
+  fHostname = hostname;
 }
 
 DAQController::~DAQController(){
@@ -39,7 +40,7 @@ std::string DAQController::run_mode(){
   }
 }
 
-int DAQController::InitializeElectronics(std::string opts, std::string override){
+int DAQController::InitializeElectronics(std::string opts, std::vector<int>&keys, std::string override){
 
   // Load options including override if any
   if(fOptions != NULL)
@@ -51,14 +52,18 @@ int DAQController::InitializeElectronics(std::string opts, std::string override)
 
   // Initialize digitizers
   fStatus = 1;
-  for(auto d : fOptions->GetBoards("V1724")){
+  for(auto d : fOptions->GetBoards("V1724", fHostname)){
 
     V1724 *digi = new V1724(fLog);
-    if(digi->Init(d.link, d.crate, d.board, d.vme_address)==0){
-      fDigitizers.push_back(digi);
-      std::stringstream mess;
-      mess<<"Initialized digitizer "<<d.board;
-      fLog->Entry(mess.str(), MongoLog::Debug);
+    if(digi->Init(d.link, d.crate, d.board, d.vme_address)==0){      
+	fDigitizers[d.link].push_back(digi);
+	if(std::find(keys.begin(), keys.end(), d.link) == keys.end()){
+	  std::cout<<"Defining new optical link "<<d.link<<std::endl;
+	  keys.push_back(d.link);
+	}    
+	std::stringstream mess;
+	mess<<"Initialized digitizer "<<d.board;
+	fLog->Entry(mess.str(), MongoLog::Debug);
     }
     else{
       std::stringstream err;
@@ -70,25 +75,30 @@ int DAQController::InitializeElectronics(std::string opts, std::string override)
   }
 
   // Load registers into digitizers
-  for(auto digi : fDigitizers){
-    int success=0;
-    for(auto regi : fOptions->GetRegisters(digi->bid())){
-      unsigned int reg = fHelper->StringToHex(regi.reg);
-      unsigned int val = fHelper->StringToHex(regi.val);
-      success+=digi->WriteRegister(reg, val);
-    }
-    if(success!=0){
-      //LOG
-      fStatus = 0;
+  for( auto const& link : fDigitizers )    {
+    for(auto digi : link.second){
+      int success=0;
+      for(auto regi : fOptions->GetRegisters(digi->bid())){
+	unsigned int reg = fHelper->StringToHex(regi.reg);
+	unsigned int val = fHelper->StringToHex(regi.val);
+	success+=digi->WriteRegister(reg, val);
+      }
+      if(success!=0){
+	//LOG
+	fStatus = 0;
       fLog->Entry("Failed to write registers.", MongoLog::Warning);
       return -1;
+      }
     }
   }
 
   // Look at this later! This initializes all boards to SW controlled
   // and inactive. Will need option for HW control.
-  for(unsigned int x=0;x<fDigitizers.size();x++)
-    fDigitizers[x]->WriteRegister(0x8100, 0x0);
+  for( auto const& link : fDigitizers ) {
+    for(auto digi : link.second){
+      digi->WriteRegister(0x8100, 0x0);
+    }
+  }
   fStatus = 2;
 
   std::cout<<fOptions->ExportToString()<<std::endl;
@@ -97,8 +107,10 @@ int DAQController::InitializeElectronics(std::string opts, std::string override)
 
 void DAQController::Start(){
   if(fRunStartController==NULL){
-    for(unsigned int x=0;x<fDigitizers.size(); x++){            
-      fDigitizers[x]->WriteRegister(0x8100, 0x4);
+    for( auto const& link : fDigitizers ){      
+      for(auto digi : link.second){
+	digi->WriteRegister(0x8100, 0x4);
+      }
     }
   }
   fStatus = 3;
@@ -108,8 +120,11 @@ void DAQController::Start(){
 void DAQController::Stop(){
 
   if(fRunStartController==NULL){
-    for(unsigned int x=0;x<fDigitizers.size();x++)
-      fDigitizers[x]->WriteRegister(0x8100, 0x0);
+    for( auto const& link : fDigitizers ){      
+      for(auto digi : link.second){
+	digi->WriteRegister(0x8100, 0x0);
+      }
+    }    
   }
   fLog->Entry("Stopped digitizers", MongoLog::Debug);
 
@@ -119,10 +134,12 @@ void DAQController::Stop(){
 }
 void DAQController::End(){
   CloseProcessingThreads();
-  for(unsigned int x=0; x<fDigitizers.size(); x++){
-    fDigitizers[x]->End();
-    delete fDigitizers[x];
-  }
+  for( auto const& link : fDigitizers ){
+    for(auto digi : link.second){
+      digi->End();
+      delete digi;
+    }
+  } 
   fDigitizers.clear();
   fStatus = 0;
 
@@ -140,13 +157,13 @@ void DAQController::End(){
   }
 }
 
-void* DAQController::ReadThreadWrapper(void* data){
+void* DAQController::ReadThreadWrapper(void* data, int link){
   DAQController *dc = static_cast<DAQController*>(data);
-  dc->ReadData();
+  dc->ReadData(link);
   return dc;
 }  
 
-void DAQController::ReadData(){
+void DAQController::ReadData(int link){
   fReadLoop = true;
   CloseProcessingThreads();
   OpenProcessingThreads();
@@ -170,12 +187,12 @@ void DAQController::ReadData(){
     //lastRead = 0;
 
     vector<data_packet> local_buffer;
-    for(unsigned int x=0; x<fDigitizers.size(); x++){
+    for(unsigned int x=0; x<fDigitizers[link].size(); x++){
       data_packet d;
       d.buff=NULL;
       d.size=0;
-      d.bid = fDigitizers[x]->bid();
-      d.size = fDigitizers[x]->ReadMBLT(d.buff);
+      d.bid = fDigitizers[link][x]->bid();
+      d.size = fDigitizers[link][x]->ReadMBLT(d.buff);
 
       // Here's the fancy part. We gotta grab the header of the first
       // event in the buffer and get the clock reset counter from the
@@ -184,7 +201,7 @@ void DAQController::ReadData(){
       while(idx < d.size/sizeof(u_int32_t)){
 	if(d.buff[idx]>>20==0xA00){
 	  d.header_time = d.buff[idx+3]&0x7FFFFFFF;
-	  d.clock_counter = fDigitizers[x]->GetClockCounter(d.header_time);
+	  d.clock_counter = fDigitizers[link][x]->GetClockCounter(d.header_time);
 	  break;
 	}
 	idx++;

DAQController.hh

@@ -22,10 +22,11 @@ class DAQController{
   */
 
 public:
-  DAQController(MongoLog *log=NULL);
+  DAQController(MongoLog *log=NULL, std::string hostname="DEFAULT");
   ~DAQController();
 
-  int InitializeElectronics(std::string opts, std::string override = "");
+  int InitializeElectronics(std::string opts, std::vector<int> &keys,
+			    std::string override = "");
 
   // Get data (return new buffer and size)
   double data_rate(){
@@ -41,13 +42,13 @@ public:
 
   void Start();
   void Stop();
-  void ReadData();
+  void ReadData(int link);
   void End();
 
   int GetData(std::vector <data_packet> *&retVec);
 
   // Statis wrapper so we can call ReadData in a std::thread
-  static void* ReadThreadWrapper(void* data);
+  static void* ReadThreadWrapper(void* data, int link);
   static void* ProcessingThreadWrapper(void* data);
 
   u_int64_t GetDataSize(){ u_int64_t ds = fDatasize; fDatasize=0; return ds;};
@@ -61,7 +62,7 @@ private:
   void OpenProcessingThreads();
   void CloseProcessingThreads();
 
-  std::vector <V1724*> fDigitizers;
+  std::map<int, std::vector <V1724*>> fDigitizers;
   std::mutex fBufferMutex;
   MongoLog *fLog;
 
@@ -73,6 +74,7 @@ private:
   int fNProcessingThreads;
   u_int64_t fBufferLength;
   u_int64_t fDatasize;
+  string fHostname;
 
   V2718 *fRunStartController;
 

Options.cc

@@ -133,13 +133,20 @@ std::string Options::GetString(std::string path, std::string default_value){
   return "";
 }
 
-std::vector<BoardType> Options::GetBoards(std::string type){
+std::vector<BoardType> Options::GetBoards(std::string type, std::string hostname){
   std::vector<BoardType> ret;
   bsoncxx::array::view subarr = bson_options["boards"].get_array().value;
 
   for(bsoncxx::array::element ele : subarr){
     if(type != "" && type != ele["type"].get_utf8().value.to_string())
       continue;
+    try{
+      if(ele["host"].get_utf8().value.to_string() != hostname)
+	continue;
+    }
+    catch(const std::exception &e){
+      // If there is no host field then no biggie. Assume we have just 1 host.
+    };
     BoardType bt;
     bt.link = ele["link"].get_int32();
     bt.crate = ele["crate"].get_int32();

Options.hh

@@ -43,7 +43,7 @@ public:
   int GetInt(std::string key, int default_value=-1);
   std::string GetString(std::string key, std::string default_value="");
 
-  std::vector<BoardType> GetBoards(std::string type="");
+  std::vector<BoardType> GetBoards(std::string type="", std::string hostname="DEFAULT");
   std::vector<RegisterType> GetRegisters(int board=-1);
 
   std::string ExportToString();

V1724.cc

@@ -10,9 +10,10 @@ V1724::~V1724(){
 }
 
 int V1724::Init(int link, int crate, int bid, unsigned int address=0){  
-  if(CAENVME_Init(cvV2718, link, crate, &fBoardHandle)
-     != cvSuccess){
-    cout<<"Failed to init board"<<endl;
+  int a = CAENVME_Init(cvV2718, link, crate, &fBoardHandle);
+  if(a != cvSuccess){
+    cout<<"Failed to init board, error code: "<<a<<", handle: "<<fBoardHandle<<
+      " at link "<<link<<" and bdnum "<<crate<<endl;
     fBoardHandle = -1;
     return -1;
   }
@@ -97,7 +98,7 @@ int V1724::GetClockCounter(u_int32_t timestamp){
 }
 
 int V1724::WriteRegister(unsigned int reg, unsigned int value){
-  std::cout<<"Writing reg:val: "<<hex<<reg<<":"<<value<<dec<<std::endl;
+  //std::cout<<"Writing reg:val: "<<hex<<reg<<":"<<value<<dec<<std::endl;
   if(CAENVME_WriteCycle(fBoardHandle,fBaseAddress+reg,
 			&value,cvA32_U_DATA,cvD32) != cvSuccess){
     std::stringstream err;
@@ -178,6 +179,106 @@ int V1724::ConfigureBaselines(int nominal_value,
 			      int ntries,
 			      vector <unsigned int> start_values,
 			      vector <unsigned int> &end_values){
+
+  // Baseline configuration routine. The V1724 has a DAC offset setting that
+  // biases the ADC, allowing you to effectively move the 'zero level' of the
+  // acquisition up or down. But keep in mind this is a bit limited. It's not
+  // designed to correct large offsets O(~volts) (i.e. your detector ground very far
+  // from ADC ground) but rather to move the baseline to the location best
+  // suited to your acquisition (positive, negative, bipolar logic)
+
+  // n.b. hard-coding guess to 16000 for testing
+  u_int32_t target_value = 16000;
+  int max_deviation = 5;
+
+  // We can adjust a DAC offset register, which is 0xffff in range, is inversely
+  // proportional to the baseline position, and has ~5% overshoot on either end.
+  // So we use this information to get starting values:
+  u_int32_t starting_value = u_int32_t( (0x3fff-target_value)*((0.9*0xffff)/0x3fff)) + 3277;
+  int nChannels = 8;
+  vector<u_int32_t> dac_values(nChannels, starting_value);
+  vector<bool> channel_finished(nChannels, false);
+  
+  // Now we need to load a simple configuration to the board in order to read
+  // some data. try/catch cause CAENVMElib fails poorly (segfault) sometimes
+  // in case the hardware has an issue.
+  write_success = 0;
+  try{    
+    write_success += WriteRegister(0x8000, 0x10);      // Channel configuration
+    write_success += WriteRegister(0x8080, 0x800000);  // DPP
+    write_success += WriteRegister(0x8100, 0x0);       // Acq. control
+    write_success += WriteRegister(0x810C, 0x80000000);// Trigger source
+    write_success += WriteRegister(0xEF24, 0x1);       // Global reset
+    write_success += WriteRegister(0xEF1C, 0x1);       // BERR
+    write_success += WriteRegister(0xEF00, 0x10);      // Channel memory
+    write_success += WriteRegister(0x8120, 0xFF);      // Channel mask
+  }
+  catch(const std::exception &e){
+    std::stringstream error;
+    error<<"Digitizer "<<fBID<<" CAEN fault during initial register adjustment in baseline routine";
+    fLog->Entry(error.str(), MongoLog::Error);
+    return -1;
+  }
+
+  // Slightly more palatable error, at least CAENVMElib is recognizing a failure
+  // and not just seg faulting
+  if(write_success!=0){
+    std::stringstream error;
+    error<<"Digitizer "<<fBID<<" unable to load registers for baselines.";
+    fLog->Entry(error.str(), MongoLog::Error);
+    return -1;
+  }
+
+  // Now we'll iterate for a while. It should be pretty quick since starting values
+  // should be quite close to true.
+  int currentIteration = 0;
+  int maxIterations = 100;
+  while(currentIteration < maxIterations){
+    currentIteration++;
+    bool breakout = true;
+    
+    for(unsigned int channel=0; channel<nChannels; channel++){
+      if(channel_finished[channel])
+	continue;
+      breakout = false;
+
+      // Load DAC for this channel
+      if(LoadDAC(channel, dac_values[channel])!=0){
+	std::stringstream error;
+	error<<"Digitizer "<<fBID<<" channel "<<channel<<" failed to load DAC in baseline routine.";
+	fLog->Entry(error.str(), MongoLog::Error);
+	return -1;
+      }
+
+      // Tell board to read out this channel only
+      unsigned short channel_mask = 1 << channel;
+      if(WriteRegister(0x8120, channel_mask)!=0){
+	stringstream error;
+	error<<"Digitizer "<<fBID<<" channel "<<channel<<" failed to set channel mask in baseline.";
+	fLog->Entry(error.str(), MongoLog::Error);
+	return -1;
+      }
+
+      // Trigger the board with software trigger
+      WriteRegister(CBV1724_AcquisitionControlReg,0x24);
+      WriteRegister(CBV1724_SoftwareTriggerReg,0x1);
+      usleep(50); // paranoia. Like, you need some time to acquire right?
+      WriteRegister(CBV1724_AcquisitionControlReg,0x0);
+
+      
+      // Sample Samples
+      // Good? then finish
+      // Else twiddle DAC offset
+      // Repeat
+    }
+
+    if(breakout)
+      break;
+  }
+  
+    
+  // 0x1n88 channel n DAC busy 0b001 (1 - yes)
+  // 0x1n98, 0x8098 DAC value 0xffff
   cout<<"Not implemented"<<endl;
   return 0;
 }