#include <PndMQMvdPixelDigiProcessorBursts.h>

Inheritance diagram for PndMQMvdPixelDigiProcessorBursts:

Public Member Functions
	PndMQMvdPixelDigiProcessorBursts ()

virtual	~PndMQMvdPixelDigiProcessorBursts ()

virtual void	SetParameters ()

virtual void	ProcessData ()

virtual void	UpdateParameters ()

virtual FairParGenericSet *	UpdateParameter (FairParGenericSet *thisPar)

template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Static Public Member Functions
static void	CustomCleanupParameters (void data, void hint)

static void	free_string (void data, void hint)

Protected Member Functions
virtual void	Run ()

Protected Attributes
BurstData	fBurstDataIn

BurstData	fBurstDataOut

int	fCurrentRunId

int	fNewRunId

TList *	fParCList

Private Attributes
FairGeoParSet *	fGeoPar

PndSdsPixelDigiPar *	fDigiPar

PndSdsTotDigiPar *	fTotPar

PndSensorNamePar *	fSensorPar

PndMQGapEventBuilder	fEventBuilder

PndMapSorter	fMapSorter

PndMvdPixelClusterFinder	fClusterFinder

PndMQMvdChargeWeightedPixelMapping *	fPixelMapping

PndGeoHandling *	fGeoHandler

Detailed Description

Definition at line 59 of file PndMQMvdPixelDigiProcessorBursts.h.

Constructor & Destructor Documentation

PndMQMvdPixelDigiProcessorBursts::PndMQMvdPixelDigiProcessorBursts ( )

inline

Definition at line 62 of file PndMQMvdPixelDigiProcessorBursts.h.

                                        : PndMQBurstProcessor(), fPixelMapping(0), fGeoHandler(0)
     {
         fGeoPar = new FairGeoParSet("FairGeoParSet");
         fParCList = new TList();
         fParCList->Add(fGeoPar);
 
         fDigiPar = new PndSdsPixelDigiPar("MVDPixelDigiPar");
         fParCList->Add(fDigiPar);
 
         fTotPar = new PndSdsTotDigiPar("MVDPixelTotDigiPar");
         fParCList->Add(fTotPar);
 
         fSensorPar = new PndSensorNamePar("PndSensorNamePar");
         fParCList->Add(fSensorPar);
     }

virtual PndMQMvdPixelDigiProcessorBursts::~PndMQMvdPixelDigiProcessorBursts ( )

inlinevirtual

Definition at line 78 of file PndMQMvdPixelDigiProcessorBursts.h.

     {
         if (fGeoPar != 0)
                 delete fGeoPar;
         if (fDigiPar != 0)
                 delete fDigiPar;
         if (fTotPar != 0)
                 delete fTotPar;
         if (fSensorPar != 0)
                 delete fSensorPar;
         if (fPixelMapping != 0)
                 delete fPixelMapping;
         if (fGeoHandler != 0)
                 delete fGeoHandler;
     }

Member Function Documentation

void PndMQBurstProcessor::CustomCleanupParameters	(	void *	data,
		void *	hint
	)

staticinherited

Definition at line 26 of file PndMQBurstProcessor.cxx.

Referenced by PndMQBurstProcessor::UpdateParameter().

 {
     delete (std::string*)hint;
 }

void PndMQBurstProcessor::free_string	(	void *	data,
		void *	hint
	)

staticinherited

Definition at line 31 of file PndMQBurstProcessor.cxx.

Referenced by PndMQBurstProcessor::Run().

 {
         delete static_cast<std::string*>(hint);
 }

void PndMQMvdPixelDigiProcessorBursts::ProcessData ( )

virtual

Implements PndMQBurstProcessor.

Definition at line 38 of file PndMQMvdPixelDigiProcessorBursts.cxx.

References PndMapSorter::AddElements(), BurstHeader::fBranchName, PndMQBurstProcessor::fBurstDataIn, PndMQBurstProcessor::fBurstDataOut, fClusterFinder, BurstData::fData, fEventBuilder, BurstData::fHeader, PndMQGapEventBuilder::FillData(), fMapSorter, fPixelMapping, PndMQSdsChargeWeightedPixelMapping::GetCluster(), PndMvdPixelClusterFinder::GetClusters(), PndMQGapEventBuilder::GetLastData(), PndMapSorter::GetOutputData(), PndMQGapEventBuilder::GetSeparatedData(), hit(), hits, pos, BurstData::Reset(), and PndMapSorter::WriteOutAll().

 {
 
         fBurstDataOut.Reset();
         for (auto dataItr : fBurstDataIn.fData)
                 fMapSorter.AddElements(dataItr);
          fMapSorter.WriteOutAll();
          std::vector<FairTimeStamp*> sortedData = fMapSorter.GetOutputData();
 
 //       for (auto dataItr: sortedData)
 //               LOG(INFO) << "DataAfterSorter " << dataItr->GetTimeStamp() ;
 
 
          fEventBuilder.FillData(sortedData);
          std::vector<std::vector<FairTimeStamp*> > gapData = fEventBuilder.GetSeparatedData();
          std::vector<std::vector<FairTimeStamp*> > lastData = fEventBuilder.GetLastData();
          gapData.insert(gapData.end(), lastData.begin(), lastData.end());
 //       for (auto eventItr : gapData)
 //               for (auto dataItr : eventItr)
 //                       LOG(INFO) << "DataAfterEventBuilder: " << dataItr->GetTimeStamp();
          if (fBurstDataIn.fHeader.fBranchName == "MVDPixelDigis"){
                  std::vector<std::vector<FairTimeStamp*> > hitsInGaps;
                  for (auto gapIter : gapData){
                          std::vector<PndSdsDigiPixel*> digiPixel;
                          std::vector<FairTimeStamp*> hits;
                          if (gapIter.size() > 0){
                                 // LOG(INFO) << "GapSize > 0 " << gapIter.size();
                                  for (auto dataIter : gapIter){                         //iterate hits in gap
                                          digiPixel.push_back((PndSdsDigiPixel*) dataIter);
 //                                                               LOG(INFO) << "DataInGap: " << *(PndSdsDigiPixel*) dataIter;
                                  }
                                  std::vector<std::vector< Int_t> > clusterInts = fClusterFinder.GetClusters(digiPixel);
 
                                  for (auto clusterIter : clusterInts)           //iterate all found cluster
                                  {
                                          //LOG(INFO) << "ClusterSize: " << clusterIter.size();
                                          std::vector<PndSdsDigiPixel*> digiInCluster;
                                          for (auto digiInClusterItr : clusterIter){             //iterate digisInt in one cluster
                                                  int pos = digiInClusterItr;
                                                  digiInCluster.push_back(digiPixel[pos]);
                                          }
 //                                       LOG(INFO) << "DigisInCluster: ";
                                          if (digiInCluster.size() > 0){
 //                                               for (auto digiIter : digiInCluster)
 //                                                       LOG(INFO) << digiIter->GetTimeStamp();
                                                  PndSdsHit* hit = new PndSdsHit(fPixelMapping->GetCluster(digiInCluster));
                                                  hits.push_back(hit);
 //                                               LOG(INFO) << "Hit: " << hit->GetTimeStamp();
                                                  digiInCluster.clear();
                                                 // LOG(INFO) << "Hit: " << *(PndSdsHit*)(*hits.rbegin());
                                          }
                                  }
                                  hitsInGaps.push_back(hits);
                          }
                  }
                  fBurstDataOut.fHeader.fBranchName = "MVDHitsPixel";
                  fBurstDataOut.fData = hitsInGaps;
          }
 }

void PndMQBurstProcessor::Run ( )

protectedvirtualinherited

Definition at line 36 of file PndMQBurstProcessor.cxx.

References PndMQBurstProcessor::fBurstDataIn, PndMQBurstProcessor::fBurstDataOut, BurstHeader::fBurstID, PndMQBurstProcessor::fCurrentRunId, BurstData::fData, PndMQBurstProcessor::fHasBoostSerialization, BurstData::fHeader, PndMQBurstProcessor::fNewRunId, PndMQBurstProcessor::free_string(), BurstHeader::fRunID, PndMQBurstProcessor::ProcessData(), PndMQBurstProcessor::SetParameters(), and PndMQBurstProcessor::UpdateParameters().

 {
     if (fHasBoostSerialization)
     {
         while (CheckCurrentState(RUNNING))
         {
                  FairMQParts parts;
                  std::unique_ptr<FairMQMessage> msg(fTransportFactory->CreateMessage());
                  if (Receive(msg, "data-in") >= 0)
                  {
                          LOG(INFO) << "Received data! " <<  msg->GetSize() << std::endl;
                                  string msgStr(static_cast<char*>(msg->GetData()), msg->GetSize());
                                  istringstream ibuffer(msgStr);
                                  if(!ibuffer.good())
                                          LOG(INFO) << "IBUFFER IS BAD!";
                                  try {
                                          boost::archive::binary_iarchive InputArchive(ibuffer);
 
                                         InputArchive >> fBurstDataIn;
                                  }
                                  catch (boost::archive::archive_exception& e)
                                 {
                                         LOG(ERROR) << e.what();
 //                                      continue;
                                 }
                                 fNewRunId = fBurstDataIn.fHeader.fRunID;
                                 if (fNewRunId != fCurrentRunId) {
                                         fCurrentRunId = fNewRunId;
                                         UpdateParameters();
                                         SetParameters();
                                 }
 
                                 if (fBurstDataIn.fData.size() < 1) continue;
 //                              LOG(INFO) << "BurstData size: " << fBurstDataIn.fData[0].size() << " BurstID: " << fBurstDataIn.fHeader.fBurstID;
 
                                 ProcessData();
                  }
                  if (fBurstDataOut.fData.size() > 0){
                          fBurstDataOut.fHeader.fBurstID = fBurstDataIn.fHeader.fBurstID;
                                 std::ostringstream obuffer;
                                 boost::archive::binary_oarchive OutputArchive(obuffer);
                                 OutputArchive << fBurstDataOut;
                                 std::string* strMsg = new std::string(obuffer.str());
                                 unique_ptr<FairMQMessage> msgOut(NewMessage(const_cast<char*>(strMsg->c_str()), strMsg->length(), free_string, strMsg));
                                 LOG(INFO) << "Data sent: " << fBurstDataOut.fHeader.fBranchName << " BurstID: " << fBurstDataOut.fHeader.fBurstID << " size: " << msgOut->GetSize();
                                 int event = 0;
 //                              for (auto eventItr : fBurstDataOut->fData){
 //                                      for (auto dataItr : eventItr){
 //                                              LOG(INFO) << event << " : " << dataItr->GetTimeStamp();
 //                                      }
 //                                      event++;
 //                              }
                                 Send(msgOut, "data-out");
                  }
         }
     }
     else
     {
         LOG(ERROR) << " Boost Serialization not ok";
     }
 }

template<class Archive >

void PndMQBurstProcessor::serialize	(	Archive &	ar,
		const unsigned int	version
	)

inlineinherited

Definition at line 89 of file PndMQBurstProcessor.h.

     {
         ar& fBurstDataIn;
         ar& fBurstDataOut;
     }

void PndMQMvdPixelDigiProcessorBursts::SetParameters ( )

virtual

Reimplemented from PndMQBurstProcessor.

Definition at line 13 of file PndMQMvdPixelDigiProcessorBursts.cxx.

References fDigiPar, fGeoHandler, fGeoPar, PndSensorNamePar::FillMap(), PndMQBurstProcessor::fParCList, fPixelMapping, fSensorPar, fTotPar, PndMQMvdChargeWeightedPixelMapping::SetDigiPar(), PndMQSdsPixelBackMapping::SetGeoHandling(), PndGeoHandling::SetSensorNamePar(), and PndMQMvdChargeWeightedPixelMapping::SetTotPar().

 {
         fGeoPar->GetGeometry();
         fDigiPar = (PndSdsPixelDigiPar*)fParCList->FindObject("MVDPixelDigiPar");
         fTotPar = (PndSdsTotDigiPar*)fParCList->FindObject("MVDPixelTotDigiPar");
     fSensorPar = (PndSensorNamePar*)fParCList->FindObject("PndSensorNamePar");
     fSensorPar->FillMap();
     if (fGeoHandler == 0){
                 fGeoHandler = new PndGeoHandling(fSensorPar);
         } else {
                 fGeoHandler->SetSensorNamePar(fSensorPar);
         }
 
         LOG(INFO) << "Conversion Method: " << *fDigiPar;
         LOG(INFO) << "Tot Info: " << *fTotPar;
         if (fPixelMapping == 0){
                 fPixelMapping = new PndMQMvdChargeWeightedPixelMapping(fGeoHandler, fDigiPar, fTotPar);
         } else {
                 fPixelMapping->SetDigiPar(fDigiPar);
                 fPixelMapping->SetTotPar(fTotPar);
                 fPixelMapping->SetGeoHandling(fGeoHandler);
         }
 }

FairParGenericSet * PndMQBurstProcessor::UpdateParameter ( FairParGenericSet * thisPar )

virtualinherited

Definition at line 106 of file PndMQBurstProcessor.cxx.

References PndMQBurstProcessor::CustomCleanupParameters(), and PndMQBurstProcessor::fCurrentRunId.

Referenced by PndMQBurstProcessor::UpdateParameters().

                                                                                   {
   std::string paramName = thisPar->GetName();
   //  boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
   std::string* reqStr = new std::string(paramName + "," + std::to_string(fCurrentRunId));
   LOG(WARN) << "Requesting parameter \"" << paramName << "\" for Run ID " << fCurrentRunId << " (" << thisPar << ")";
   std::unique_ptr<FairMQMessage> req(NewMessage(const_cast<char*>(reqStr->c_str()), reqStr->length(), CustomCleanupParameters, reqStr));
   std::unique_ptr<FairMQMessage> rep(NewMessage());
 
   if (Send(req,"param") > 0)
     {
       if (Receive(rep,"param") > 0)
         {
           TMessage2 tm(rep->GetData(), rep->GetSize());
           thisPar = (FairParGenericSet*)tm.ReadObject(tm.GetClass());
           LOG(WARN) << "Received parameter"<< paramName <<" from the server (" << thisPar << ")" << tm.GetClass()->GetName() << " DataSize: " << rep->GetSize();
           thisPar->print();
           return thisPar;
         }
     }
   return NULL;
 }

void PndMQBurstProcessor::UpdateParameters ( )

virtualinherited

Definition at line 98 of file PndMQBurstProcessor.cxx.

References PndMQBurstProcessor::fParCList, and PndMQBurstProcessor::UpdateParameter().

Referenced by PndMQBurstProcessor::Run().

                                            {
   for ( int iparC = 0 ; iparC < fParCList->GetEntries() ; iparC++ ) {
     FairParGenericSet* tempObj = (FairParGenericSet*)(fParCList->At(iparC));
     fParCList->Remove(tempObj);
     fParCList->AddAt(UpdateParameter(tempObj),iparC);
   }
 }