diff --git a/slsDetectorCalibration/moench03Ctb10GbData.h b/slsDetectorCalibration/moench03Ctb10GbData.h
new file mode 100644
index 000000000..68ab2e167
--- /dev/null
+++ b/slsDetectorCalibration/moench03Ctb10GbData.h
@@ -0,0 +1,225 @@
+#ifndef MOENCH03CTB10GBDATA_H
+#define  MOENCH03CTB10GBDATA_H
+#include "slsReceiverData.h"
+
+
+
+class moench03Ctb10GbData : public slsReceiverData<uint16_t> {
+ 
+ private:
+  
+  int iframe;
+  int nadc;
+  int sc_width;
+  int sc_height;
+ public:
+
+
+
+
+  /**
+     Implements the slsReceiverData structure for the moench02 prototype read out by a module i.e. using the slsReceiver
+     (160x160 pixels, 40 packets 1286 large etc.)
+     \param c crosstalk parameter for the output buffer
+
+  */
+  
+
+  //  moench03Ctb10GbData(int ns=5000): slsDetectorData<uint16_t>(400, 400, 8208*40, NULL, NULL) , nadc(32), sc_width(25), sc_height(200) {
+ moench03Ctb10GbData(int ns=5000): slsReceiverData<uint16_t>(400, 400, 40, 8208), nadc(32), sc_width(25), sc_height(200) {
+
+    int adc_nr[32]={200,225,250,275,300,325,350,375,\
+		    0,25,50,75,100,125,150,175,\
+		    175,150,125,100,75,50,25,0,\
+		    375,350,325,300,275,250,225,200};
+    int row, col;
+
+    int isample;
+    int iadc;
+    int ix, iy;
+    
+    int npackets=40;
+    int i;
+
+
+    for (int ip=0; ip<npackets; ip++) {
+      for (int is=0; is<128; is++) {
+
+	for (iadc=0; iadc<nadc; iadc++) {
+	  i=128*ip+is;
+	  if (i<sc_width*sc_height) {
+	    //  for (int i=0; i<sc_width*sc_height; i++) {
+	    col=adc_nr[iadc]+(i%sc_width);
+	    if (iadc<16) {
+	      row=199-i/sc_width;
+	    } else {
+	      row=200+i/sc_width;
+	    }
+	    dataMap[row][col]=(nadc*i+iadc)*2+16*(ip+1);
+	    if (dataMap[row][col]<0 || dataMap[row][col]>=8208*40)
+	      cout << "Error: pointer " << dataMap[row][col] << " out of range "<< endl;
+	  }
+	}
+      }
+    }
+
+    int ipacket;
+    int ibyte;
+    int ii=0;
+    for (int ipacket=0; ipacket<npackets; ipacket++) {
+      for (int ibyte=0;  ibyte< 8208/2; ibyte++) {
+	i=ipacket*8208/2+ibyte;
+	if (ibyte<8) {
+	//header!
+	  xmap[i]=-1;
+	  ymap[i]=-1;
+	} else {
+	  // ii=ibyte+128*32*ipacket;
+	  isample=ii/nadc;
+	  iadc=ii%nadc;
+	
+	  ix=isample%sc_width;
+	  iy=isample/sc_width;
+	  if (iadc<(nadc/2)) {
+	    xmap[i]=adc_nr[iadc]+ix;
+	    ymap[i]=ny/2-1-iy;
+	  } else {
+	    xmap[i]=adc_nr[iadc]+ix;
+	    ymap[i]=ny/2+iy;
+	  }
+	  
+	ii++;
+	}
+      }
+    }
+    
+
+    
+    
+    iframe=0;
+    //  cout << "data struct created" << endl;
+  };
+    
+
+     /**
+
+     Returns the frame number for the given dataset. Purely virtual func.
+     \param buff pointer to the dataset
+     \returns frame number
+
+  */
+
+
+  int getFrameNumber(char *buff){return *((int*)buff)&0xffffffff;};   
+
+  /**
+
+     Returns the packet number for the given dataset. purely virtual func
+     \param buff pointer to the dataset
+     \returns packet number number
+
+
+
+  */
+  int getPacketNumber(char *buff){return ((*(((int*)(buff+4))))&0xff)+1;};   
+
+/*    /\** */
+
+/*      Loops over a memory slot until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). purely virtual func */
+/*      \param data pointer to the memory to be analyzed */
+/*      \param ndata reference to the amount of data found for the frame, in case the frame is incomplete at the end of the memory slot */
+/*      \param dsize size of the memory slot to be analyzed */
+/*      \returns pointer to the beginning of the last good frame (might be incomplete if ndata smaller than dataSize), or NULL if no frame is found  */
+
+/*   *\/ */
+/*     virtual  char *findNextFrame(char *data, int &ndata, int dsize){ndata=dsize; setDataSize(dsize);  return data;}; */
+
+
+/*    /\** */
+
+/*      Loops over a file stream until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). Can be overloaded for different kind of detectors!  */
+/*      \param filebin input file stream (binary) */
+/*      \returns pointer to the begin of the last good frame, NULL if no frame is found or last frame is incomplete */
+
+/*   *\/ */
+/*     virtual char *readNextFrame(ifstream &filebin){ */
+/*       //	int afifo_length=0;   */
+/*       uint16_t *afifo_cont;  */
+/*       int ib=0; */
+/*       if (filebin.is_open()) { */
+/* 	afifo_cont=new uint16_t[dataSize/2]; */
+/*  	while (filebin.read(((char*)afifo_cont)+ib,2)) { */
+/* 	  ib+=2; */
+/* 	  if (ib==dataSize) break; */
+/* 	} */
+/* 	if (ib>0) { */
+/* 	  iframe++; */
+/* 	  // cout << ib << "-" << endl; */
+/* 	  return (char*)afifo_cont; */
+/* 	} else { */
+/* 	  delete [] afifo_cont; */
+/* 	  return NULL; */
+/* 	} */
+/*       }      */
+/*       return NULL; */
+/*     }; */
+
+
+  	virtual char *readNextFrame(ifstream &filebin, int& fnum) {
+	  char *data=new char[packetSize*nPackets];
+	  char *retval=0;
+	  int np=0, nd;
+	  fnum = -1;
+	  int  pn;
+	  char aa[8224];
+	  char *packet=(char *)aa;
+
+	  if (filebin.is_open()) {
+
+
+
+
+	    while(filebin.read((char*)packet, 8208) && np<nPackets){
+	      pn=getPacketNumber(packet);
+	      
+	      if (pn==1 && fnum<0)
+		fnum= getFrameNumber(packet);
+	      
+	      // cout << "fn: " << fnum << "\t pn: " << pn << endl;
+	      if (fnum>=0) {
+		if (getFrameNumber(packet) !=fnum) { 
+		  
+		  if (np==0){
+		    delete [] data;
+		    return NULL;
+		  } else
+		    return data;
+		}
+		
+		memcpy(data+(pn-1)*packetSize, packet, packetSize);
+		np++;
+		
+	      }
+	    }
+	    
+	  }
+
+	  if (np==0){
+	    delete [] data;
+	    return NULL;
+	  }
+
+	};
+
+
+  	virtual char *readNextFrame(ifstream &filebin) {
+	  int fnum;
+	  return readNextFrame(filebin, fnum);
+	};
+
+};
+
+
+
+
+#endif
diff --git a/slsDetectorCalibration/moench03ReadData10Gb.C b/slsDetectorCalibration/moench03ReadData10Gb.C
new file mode 100644
index 000000000..2b67f35f9
--- /dev/null
+++ b/slsDetectorCalibration/moench03ReadData10Gb.C
@@ -0,0 +1,455 @@
+#include <TH1D.h>
+#include <TH2D.h>
+#include <TPad.h>
+#include <TDirectory.h>
+#include <TEntryList.h>
+#include <TFile.h>
+#include <TMath.h>
+#include <TTree.h>
+#include <TChain.h>
+#include <THStack.h>
+#include <TCanvas.h>
+#include <stdio.h>
+//#include <deque>
+//#include <list>
+//#include <queue>
+#include <fstream>
+#include "moench03Ctb10GbData.h"
+#include "moench03CommonMode.h"
+#define MYROOT1
+#include "singlePhotonDetector.h"
+
+//#include "MovingStat.h"
+
+using namespace std;
+
+#define NC 400
+#define NR 400
+
+
+//#define MY_DEBUG 1
+
+#ifdef MY_DEBUG
+#include <TCanvas.h>
+#endif
+
+
+
+TH2F *readImage(ifstream &filebin,   TH2F *h2=NULL, TH2F *hped=NULL) {
+   moench03Ctb10GbData *decoder=new moench03Ctb10GbData();
+  char *buff=decoder->readNextFrame(filebin);
+  
+
+//   TH1F *h1=new TH1F("h1","",400*400,0,400*400);
+//   int ip=0;
+  if (buff) {
+    if (h2==NULL) {
+      h2=new TH2F("h2","",400,0,400,400,0,400);
+      h2->SetStats(kFALSE);
+    }
+    //  cout << "." << endl;
+    for (int ix=0; ix<400; ix++) {
+      for (int iy=0; iy<400; iy++) {
+	//	cout <<  decoder->getDataSize() << " " << decoder->getValue(buff,ix,iy)<< endl;
+	h2->SetBinContent(ix+1,iy+1,decoder->getValue(buff,ix,iy));
+	//	h1->SetBinContent(++ip,decoder->getValue(buff,ix,iy));
+      }
+    }
+    if (hped) h2->Add(hped,-1);
+    return h2;
+  }
+  return NULL;
+}
+
+
+TH2F *readImage(char *fname, int iframe=0, TH2F *hped=NULL) {
+  ifstream filebin;
+  filebin.open((const char *)(fname), ios::in | ios::binary);
+  TH2F *h2=new TH2F("h2","",400,0,400,400,0,400);
+  TH2F *hh;
+  hh=readImage(filebin, h2, hped );
+  if (hh==NULL) {
+
+    delete h2;
+    return NULL;
+  }
+  for (int i=0; i<iframe; i++) {
+    if (hh==NULL) break;
+    hh=readImage(filebin, h2, hped );
+    if (hh)
+      ;// cout << "="<< endl;
+    else {
+      delete h2;
+      return NULL;
+    }
+  }
+  if (filebin.is_open())
+    filebin.close();
+  if (hped!=NULL)
+    h2->Add(hped,-1);
+
+  return h2;
+}
+
+
+TH2F *calcPedestal(char *fformat, int runmin, int runmax){
+  ifstream filebin;
+  char fname[10000];
+   moench03Ctb10GbData *decoder=new  moench03Ctb10GbData();
+  singlePhotonDetector<uint16_t> *filter=new singlePhotonDetector<uint16_t>(decoder, 3, 5, 1, NULL);
+  char *buff;
+  int ix,iy;
+  int ii=0;
+  TH2F* h2=NULL;
+
+  for (int irun=runmin; irun<=runmax; irun++) {
+    sprintf(fname,fformat,irun);
+    
+    cout << fname << endl;
+
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    while ((buff=decoder->readNextFrame(filebin))) {
+      for (ix=0; ix<400; ix++) {
+	for (iy=0; iy<400; iy++) {
+	  if (decoder->getValue(buff,ix,iy)>1000)
+	    filter->addToPedestal(decoder->getValue(buff,ix,iy), ix, iy);
+	}
+      }
+      delete [] buff;
+      //cout << "="<< endl;
+      ii++;
+    }
+    if (filebin.is_open())
+      filebin.close(); 
+    
+  }
+  if (ii>0) {
+    h2=new TH2F("hped","",400,0,400,400,0,400);
+    
+      for (ix=0; ix<400; ix++) {
+	for (iy=0; iy<400; iy++) {
+	  h2->SetBinContent(ix+1, iy+1,filter->getPedestal(ix,iy));
+	}
+      }
+
+  }
+  return h2;
+
+}
+
+
+TH1D *calcSpectrum(char *fformat, int runmin, int runmax, TH2F *hped=NULL){
+  ifstream filebin;
+  char fname[10000];
+  moench03Ctb10GbData *decoder=new  moench03Ctb10GbData();
+  TH1D *hspectrum=new TH1D("hsp","hsp",2500,-500,10000);
+  char *buff;
+  int ix,iy;
+  int ii=0;
+  TH2F* h2=NULL;
+  int ich=0;
+  Double_t ped=0;
+  
+  for (int irun=runmin; irun<=runmax; irun++) {
+    sprintf(fname,fformat,irun);
+    
+    cout << fname << endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    while ((buff=decoder->readNextFrame(filebin))) {
+      for (ix=0; ix<200; ix++) {
+	for (iy=200; iy<400; iy++) {
+	  if (decoder->getValue(buff,ix,iy)>1000) {
+	    if(hped) ped=hped->GetBinContent(ix+1,iy+1);
+	    hspectrum->Fill(decoder->getValue(buff,ix,iy)-ped);
+	  }
+	  ich++;
+	}
+      }
+      delete [] buff;
+      //cout << "="<< endl;
+      ii++;
+    }
+    if (filebin.is_open())
+      filebin.close(); 
+    
+  }
+  return hspectrum;
+
+}
+TH2F *drawImage(char *fformat, int runmin, int runmax, TH2F *hped=NULL){
+  ifstream filebin;
+  char fname[10000];
+  moench03Ctb10GbData *decoder=new  moench03Ctb10GbData();
+  TH2F *hspectrum=new TH2F("hsp","hsp",400,0,400,400,0,400);
+  char *buff;
+  int ix,iy;
+  int ii=0;
+  TH2F* h2=NULL;
+  int ich=0;
+  Double_t ped=0;
+  
+  for (int irun=runmin; irun<=runmax; irun++) {
+    sprintf(fname,fformat,irun);
+    
+    cout << fname << endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    while ((buff=decoder->readNextFrame(filebin))) {
+      for (ix=0; ix<400; ix++) {
+	for (iy=0; iy<400; iy++) {
+	  if (decoder->getValue(buff,ix,iy)>1000) {
+	    if(hped) ped=hped->GetBinContent(ix+1,iy+1);
+	    hspectrum->Fill(ix, iy, decoder->getValue(buff,ix,iy)-ped);
+	  }
+	  ich++;
+	}
+      }
+      delete [] buff;
+      //cout << "="<< endl;
+      ii++;
+    }
+    if (filebin.is_open())
+      filebin.close(); 
+    
+  }
+  return hspectrum;
+
+}
+
+
+
+
+
+/**
+
+Loops over data file to find single photons, fills the tree (and writes it to file, althoug the root file should be opened before) and creates 1x1, 2x2, 3x3 cluster histograms with ADCu on the x axis, channel number (160*x+y) on the y axis.
+
+  \param fformat file name format
+  \param tit title of the tree etc.
+  \param runmin minimum run number
+  \param runmax max run number
+  \param nbins  number of bins for spectrum hists
+  \param hmin histo minimum for spectrum hists
+  \param hmax histo maximum for spectrum hists
+  \param xmin minimum x coordinate
+  \param xmax maximum x coordinate
+  \param ymin minimum y coordinate
+  \param ymax maximum y coordinate
+  \param cmsub  enable commonmode subtraction
+  \returns pointer to histo stack with cluster spectra
+*/
+
+THStack *moench03ReadData(char *fformat, char *tit, int runmin, int runmax, int nbins=1500, int hmin=-500, int hmax=1000,  int xmin=1, int xmax=NC-1, int ymin=1, int ymax=NR-1, int cmsub=0, int hitfinder=1) {
+  double hc=0;
+  int sign=1;
+
+   moench03Ctb10GbData *decoder=new  moench03Ctb10GbData();
+  cout << "decoder allocated " << endl;
+
+   moench03CommonMode *cmSub=NULL;
+   if (cmsub) {
+     cmSub=new moench03CommonMode(100);
+     cout << "common mode allocated " << endl;
+
+   } else {
+     
+     cout << "non allocating common mode  " << endl;
+   }
+   int iev=0;
+  int nph=0;
+
+  singlePhotonDetector<uint16_t> *filter=new singlePhotonDetector<uint16_t>(decoder, 3, 5, sign, cmSub, 100, 10);
+  cout << "filter allocated " << endl;
+
+  char *buff;
+  char fname[10000];
+  int nf=0;
+  
+  eventType thisEvent=PEDESTAL;
+
+  // int iframe;
+  // double *data, ped, sigma;
+
+  // data=decoder->getCluster();
+
+
+  THStack *hs=new THStack("hs",fformat);
+
+  cout << "hstack allocated " << endl;
+
+
+  TH2F *h1=new TH2F("h1",tit,nbins,hmin-0.5,hmax-0.5,NC*NR,-0.5,NC*NR-0.5);
+  hs->Add(h1);
+  cout << "h1 allocated " << endl;
+
+  TH2F *h2;
+  TH2F *h3;
+  if (hitfinder) {
+    h2=new TH2F("h2",tit,nbins,hmin-0.5,hmax-0.5,NC*NR,-0.5,NC*NR-0.5);
+  cout << "h2 allocated " << endl;
+    h3=new TH2F("h3",tit,nbins,hmin-0.5,hmax-0.5,NC*NR,-0.5,NC*NR-0.5);
+  cout << "h3 allocated " << endl;
+    // hetaX=new TH2F("hetaX",tit,nbins,-1,2,NC*NR,-0.5,NC*NR-0.5);
+    //  hetaY=new TH2F("hetaY",tit,nbins,-1,2,NC*NR,-0.5,NC*NR-0.5);
+    hs->Add(h2);
+    hs->Add(h3);
+    // hs->Add(hetaX);
+    // hs->Add(hetaY);
+  }
+  if (hs->GetHists()) {
+    for (int i=0; i<3; i++)
+      if (hs->GetHists()->At(1)) cout << i << " " ; 
+    cout << " histos allocated " << endl;
+  } else
+    cout << "no hists in stack " << endl;
+  
+  
+  ifstream filebin;
+
+
+  int ix=20, iy=20, ir, ic;
+
+
+  Int_t iFrame;
+  TTree *tall;
+  if (hitfinder)
+    tall=filter->initEventTree(tit, &iFrame);
+
+
+  
+
+#ifdef MY_DEBUG
+
+  cout << "debug mode " << endl;
+  
+  TCanvas *myC;
+  TH2F *he;
+  TCanvas *cH1;
+  TCanvas *cH2;
+  TCanvas *cH3;
+
+  if (hitfinder) {
+    myC=new TCanvas("myc");
+    he=new TH2F("he","Event Mask",xmax-xmin, xmin, xmax, ymax-ymin, ymin, ymax);
+    he->SetStats(kFALSE);
+    he->Draw("colz");
+    cH1=new TCanvas("ch1");
+    cH1->SetLogz();
+    h1->Draw("colz");
+    cH2=new TCanvas("ch2");
+    cH2->SetLogz();
+    h2->Draw("colz");
+    cH3=new TCanvas("ch3");
+    cH3->SetLogz();
+    h3->Draw("colz");
+  }
+#endif
+
+  filter->newDataSet();
+
+
+  for (int irun=runmin; irun<runmax; irun++) {
+    sprintf(fname,fformat,irun);
+    cout << "file name " << fname << endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    nph=0;
+    while ((buff=decoder->readNextFrame(filebin))) {
+      
+      filter->newFrame();
+
+	if (cmsub) {
+	//	cout << "cm" << endl;
+	  for (ix=xmin-1; ix<xmax+1; ix++)
+	    for (iy=ymin-1; iy<ymax+1; iy++) {
+	      thisEvent=filter->getEventType(buff, ix, iy,0);
+	    }
+	}
+      // if (hitfinder) {
+
+      // 	//calculate pedestals and common modes
+      // }
+
+      //   cout << "new frame " << endl;
+
+      for (ix=xmin-1; ix<xmax+1; ix++)
+	for (iy=ymin-1; iy<ymax+1; iy++) {
+	  //	  cout << ix << " " << iy << endl;
+	    thisEvent=filter->getEventType(buff, ix, iy, cmsub);
+	  //  if (nf>10) {
+	    h1->Fill(filter->getClusterTotal(1), iy+NR*ix);
+
+#ifdef MY_DEBUG
+	    //  if (iev%10==0)
+	    he->SetBinContent(ix+1-xmin, iy+1-ymin, (int)thisEvent);
+#endif	  
+	  
+	  if (hitfinder) {
+	      
+	      if (thisEvent==PHOTON_MAX ) {
+		nph++;
+
+		h2->Fill(filter->getClusterTotal(2), iy+NR*ix);
+		h3->Fill(filter->getClusterTotal(3), iy+NR*ix);
+		iFrame=decoder->getFrameNumber(buff);
+
+		tall->Fill();
+	   
+       
+	      }
+	  
+	    
+	  } // else {
+	  //   filter->addToPedestal(decoder->getValue(buff,ix,iy, cmsub));
+	    
+	  // }
+	    
+
+	    // }
+	}
+	  //////////////////////////////////////////////////////////
+    
+#ifdef MY_DEBUG
+      //    cout << iev << " " << h1->GetEntries() << " " << h2->GetEntries() << endl;
+//       if (iev%10==0) {
+// 	myC->Modified();
+// 	myC->Update();
+// 	cH1->Modified();
+// 	cH1->Update();
+// 	cH2->Modified();
+// 	cH2->Update();
+// 	cH3->Modified();
+// 	cH3->Update();
+//       }
+      iev++;
+#endif		    
+      nf++;
+      
+      // cout << "=" ;
+      delete [] buff;
+    }
+    //  cout << nph << endl;
+    if (filebin.is_open())
+    filebin.close();	  
+    else
+      cout << "could not open file " << fname << endl;
+  } 
+  if (hitfinder)
+    tall->Write(tall->GetName(),TObject::kOverwrite);
+  
+   //////////////////////////////////////////////////////////
+    
+#ifdef MY_DEBUG  
+	myC->Modified();
+	myC->Update();
+	cH1->Modified();
+	cH1->Update();
+	cH2->Modified();
+	cH2->Update();
+	cH3->Modified();
+	cH3->Update();
+#endif	
+  
+  delete decoder;
+  cout << "Read " << nf << " frames" << endl;
+  return hs;
+}
+  
diff --git a/slsDetectorCalibration/slsDetectorData.h b/slsDetectorCalibration/slsDetectorData.h
index 3da6a0407..b46f59f38 100644
--- a/slsDetectorCalibration/slsDetectorData.h
+++ b/slsDetectorCalibration/slsDetectorData.h
@@ -40,8 +40,8 @@ class slsDetectorData {
   slsDetectorData(int npx, int npy, int dsize, int **dMap=NULL, dataType **dMask=NULL, int **dROI=NULL): nx(npx), ny(npy), dataSize(dsize) {
 
    
-    xmap=new int[nx*ny];
-    ymap=new int[nx*ny];
+    xmap=new int[dsize/sizeof(dataType)];
+    ymap=new int[dsize/sizeof(dataType)];
 
     dataMask=new dataType*[ny];
     for(int i = 0; i < ny; i++) {
@@ -228,42 +228,44 @@ class slsDetectorData {
   virtual dataType getChannel(char *data, int ix, int iy, int dr) {
 	  dataType m=0;
 	  uint64_t t;
-	  int numBytes,divFactor,newix,pixelval;
 
-//cout <<"ix:"<<ix<<" nx:"<<nx<<" iy:"<<ny<<" ny:"<<ny<<" datamap[iy][ix]:"<< dataMap[iy][ix] <<"datasize:"<< dataSize <<endl;
-	  if (ix>=0 && ix<nx && iy>=0 && iy<ny && dataMap[iy][ix]>=0 && dataMap[iy][ix]<dataSize) {
-		  m=dataMask[iy][ix];
+	  /////All this stuff should go to eiger detector!!!!!!!!!!!!!!!
+/* 	  int numBytes,divFactor,newix,pixelval; */
 
-		  numBytes = (nx * iy + ix);
-		  divFactor=2;
-		  if(dr == 4) divFactor = 16;
-		  else if (dr == 8) divFactor = 8;
-		  else if (dr == 16) divFactor = 4;
+/* //cout <<"ix:"<<ix<<" nx:"<<nx<<" iy:"<<ny<<" ny:"<<ny<<" datamap[iy][ix]:"<< dataMap[iy][ix] <<"datasize:"<< dataSize <<endl; */
+/* 	  if (ix>=0 && ix<nx && iy>=0 && iy<ny && dataMap[iy][ix]>=0 && dataMap[iy][ix]<dataSize) { */
+/* 		  m=dataMask[iy][ix]; */
 
-		  pixelval = numBytes % divFactor;
-		  newix = ix - pixelval;
+/* 		  numBytes = (nx * iy + ix); */
+/* 		  divFactor=2; */
+/* 		  if(dr == 4) divFactor = 16; */
+/* 		  else if (dr == 8) divFactor = 8; */
+/* 		  else if (dr == 16) divFactor = 4; */
 
-		  //cout <<"pixelval:"<<pixelval<<" newix:"<<newix<<endl;
-		  //cout <<"64:"<< hex<<((uint64_t)(*((uint64_t*)(((char*)data)+(dataMap[iy][newix])))))<<endl;
-		  t = (be64toh((uint64_t)(*((uint64_t*)(((char*)data)+(dataMap[iy][newix]))))));
-		  //cout<<"t:"<<t<<endl;
+/* 		  pixelval = numBytes % divFactor; */
+/* 		  newix = ix - pixelval; */
 
-	  }else
-		  cprintf(RED,"outside limits\n");
+/* 		  //cout <<"pixelval:"<<pixelval<<" newix:"<<newix<<endl; */
+/* 		  //cout <<"64:"<< hex<<((uint64_t)(*((uint64_t*)(((char*)data)+(dataMap[iy][newix])))))<<endl; */
+/* 		  t = (be64toh((uint64_t)(*((uint64_t*)(((char*)data)+(dataMap[iy][newix])))))); */
+/* 		  //cout<<"t:"<<t<<endl; */
 
-	  if(dr == 4)
-		  //uint8_t value =  t >> (pixelval*4); cout <<"value:"<< value << endl;
-		  return ((t >> (pixelval*4)) & 0xf)^m;
-	  else if(dr == 8)
-		  //uint8_t value =  t >> (pixelval*8); cout <<"value:"<< value << endl;
-		  return ((t >> (pixelval*8)) & 0xff)^m;
-	  else if(dr == 16){
-		  //uint16_t value =  t >> (pixelval*16); cout <<"value:"<< value << endl;
-		  return ((t >> (pixelval*16)) & 0xffff)^m;
-	  }else{
-		  //uint32_t value =  t >> (pixelval*32); cout <<"value:"<< value << endl;
-		  return ((t >> (pixelval*32)) & 0xffffffff)^m;
-	  }
+/* 	  }/\* else *\/ */
+/* 	   /\* 	  cprintf(RED,"outside limits\n"); *\/ */
+
+/* 	  if(dr == 4) */
+/* 		  //uint8_t value =  t >> (pixelval*4); cout <<"value:"<< value << endl; */
+/* 		  return ((t >> (pixelval*4)) & 0xf)^m; */
+/* 	  else if(dr == 8) */
+/* 		  //uint8_t value =  t >> (pixelval*8); cout <<"value:"<< value << endl; */
+/* 		  return ((t >> (pixelval*8)) & 0xff)^m; */
+/* 	  else if(dr == 16){ */
+/* 		  //uint16_t value =  t >> (pixelval*16); cout <<"value:"<< value << endl; */
+/* 		  return ((t >> (pixelval*16)) & 0xffff)^m; */
+/* 	  }else{ */
+/* 		  //uint32_t value =  t >> (pixelval*32); cout <<"value:"<< value << endl; */
+/* 		  return ((t >> (pixelval*32)) & 0xffffffff)^m; */
+/* 	  } */
   };
 
   /**
diff --git a/slsDetectorCalibration/slsReceiverData.h b/slsDetectorCalibration/slsReceiverData.h
index bfe7a88c5..c62e79ec7 100644
--- a/slsDetectorCalibration/slsReceiverData.h
+++ b/slsDetectorCalibration/slsReceiverData.h
@@ -67,10 +67,10 @@ public:
 		while (dd<=(dsize-packetSize)) {
 			pnum=getPacketNumber(p);
 			fn=getFrameNumber(p);
-			//cout <<"pnum:"<<pnum<<" fn:"<<fn<<"\t";
+			cout <<"pnum:"<<pnum<<" fn:"<<fn<<"\t "<< np << endl;;
 
 			if (pnum<1 || pnum>nPackets) {
-				cout << "Bad packet number " << pnum << " frame "<< fn << endl;
+				cout << "Bad packet number " << pnum << " frame "<< fn  << endl;
 				retval=NULL;
 				np=0;
 			}     else if  (pnum==1) {
diff --git a/slsDetectorCalibration/viewMoenchDRXRays.C b/slsDetectorCalibration/viewMoenchDRXRays.C
new file mode 100644
index 000000000..7df5b926e
--- /dev/null
+++ b/slsDetectorCalibration/viewMoenchDRXRays.C
@@ -0,0 +1,178 @@
+
+#define MYROOT1
+
+#include <TH1D.h>
+#include <TF1.h>
+#include <TH2D.h>
+#include <TPad.h>
+#include <TDirectory.h>
+#include <TEntryList.h>
+#include <TFile.h>
+#include <TMath.h>
+#include <TTree.h>
+#include <TChain.h>
+#include <THStack.h>
+#include <TCanvas.h>
+#include <stdio.h>
+#include <fstream>
+#include "moench03CtbData.h"
+//#include "moench03CommonMode.h"
+//#include "singlePhotonDetector.h"
+
+
+using namespace std;
+
+
+THStack *viewMoenchDRXRays(int ix=70, int iy=88){
+
+  TF1 *poiss = new TF1("poiss", "[0]*TMath::Power(([1]/[2]),(x/[2]))*(TMath::Exp( ([1]/[2])))/TMath::Gamma((x/[2])+1)", 0, 5);
+
+
+  int thick[]={1700,1500,1300,1100,900,700};
+  int nt=6;
+  int nf=5;
+  char fname[1000];
+  char *data;
+  char tit[100];
+  TH1F *hh[nt], *hh3[nt], *hh5[nt];
+  TH2F *h2[nt], *hpix[nt];
+  Double_t val, val3, val5, val1;
+  int it=0;
+  Double_t ped[25];
+  TH1D *p;
+
+  THStack *hs=new THStack();
+  cout << nt << endl;
+  ifstream filebin;
+  moench03CtbData *decoder=new moench03CtbData();
+
+  sprintf(tit,"hpix_%dumSi_g1",thick[it]);
+  cout << tit << endl;
+
+
+  hpix[it]=new TH2F(tit,tit,2500,6000,16000,25,0,25);
+    hs->Add(hpix[it]);
+  
+    sprintf(tit,"%dumSi_g1",thick[it]);
+    cout << tit << endl;
+
+    for (int iff=0; iff<nf; iff++) {
+      // cout << tit << " " << iff << endl;
+      sprintf(fname,"/mnt/moench/Moench03_MS_20150606/direct_beam_12.4keV_filter_scan/direct_beam_12.4keV_%s_400clk_f0_%d.raw",tit,iff);
+      
+      filebin.open((const char *)(fname), ios::in | ios::binary);
+      if (filebin.is_open()) cout << "ok "<< fname << endl;
+      else  cout << "could not open "<< fname << endl;
+      
+      while ((data=decoder->readNextFrame(filebin))) {
+	
+	for (int iiy=-2; iiy<3; iiy++)
+	  for (int iix=-2; iix<3; iix++)
+	    hpix[it]->Fill(decoder->getChannel(data,ix+iix,iy+iiy), (iiy+2)*5+iix+2);
+	
+	delete [] data;
+      }
+      filebin.close();
+      cout << endl;
+      
+      
+      
+    }
+   
+
+	for (int iix=-2; iix<3; iix++) {
+	for (int iiy=-2; iiy<3; iiy++) {
+	  cout << iix << " " << iiy << " " ;// <<endl;
+	  p=hpix[0]->ProjectionX("p",(iiy+2)*5+iix+2+1,(2+iiy)*5+iix+2+1);
+
+	  ped[(iiy+2)*5+iix+2]=p->GetBinCenter(p->GetMaximumBin());
+
+	   cout << ped[(iiy+2)*5+iix+2] <<endl; 
+	}
+	}
+
+
+
+    for (it=0; it<nt; it++) {
+
+    sprintf(tit,"hh_%dumSi_g1",thick[it]);
+    cout << tit << endl;
+    hh[it]=new TH1F(tit,tit,5000,0,10000);
+    hs->Add(hh[it]);
+    sprintf(tit,"hh3_%dumSi_g1",thick[it]);
+    hh3[it]=new TH1F(tit,tit,5000,0,30000);
+    hs->Add(hh3[it]);
+
+    sprintf(tit,"hh5_%dumSi_g1",thick[it]);
+    hh5[it]=new TH1F(tit,tit,5000,0,50000);
+    hs->Add(hh5[it]);
+
+    sprintf(tit,"%dumSi_g1",thick[it]);
+    cout << tit << endl;
+    hs->Add(hh[it]);
+    for (int iff=0; iff<nf; iff++) {
+      // cout << tit << " " << iff << endl;
+      sprintf(fname,"/mnt/moench/Moench03_MS_20150606/direct_beam_12.4keV_filter_scan/direct_beam_12.4keV_%s_400clk_f0_%d.raw",tit,iff);
+      
+      filebin.open((const char *)(fname), ios::in | ios::binary);
+      if (filebin.is_open()) cout << "ok "<< fname << endl;
+      else  cout << "could not open "<< fname << endl;
+
+      while ((data=decoder->readNextFrame(filebin))) {
+	cout << "-" ;
+	//	for (int iy=0; iy<40; iy++)
+	//  for (int ix=0; ix<350; ix++){
+
+
+	    
+
+	val1=0;
+	val3=0;
+	val5=0;
+	
+
+	for (int iix=-2; iix<3; iix++) {
+	for (int iiy=-2; iiy<3; iiy++) {
+	  // cout << iix << " " << iiy << " " ;// <<endl;
+	  // p=hpix[]->ProjectionX("p",(iiy+2)*5+iix+2+1,(2+iiy)*5+iix+2+1);
+
+	  // ped[it]=p->GetBinCenter(p->GetMaximumBin());
+
+	  // cout << ped[it] <<endl;
+	  val=decoder->getChannel(data,ix+iix,iy+iiy)-ped[(iiy+2)*5+iix+2];
+	    if ((iix<-1 || iix>1) || (iiy<-1 || iiy>1))
+	      val5+=val;
+	    else if (iix!=0 || iiy!=0) {
+	      val5+=val;
+	      val3+=val;
+	    } else {
+	      val5+=val;
+	      val3+=val;
+	      val1+=val;
+	    }
+	    // if (iiy==1 && iix==0)
+	    //   h2[it]->Fill(val1,val);
+	      
+	}
+	}
+	      hh5[it]->Fill(val5);
+	      hh3[it]->Fill(val3);
+	      hh[it]->Fill(val1);
+
+      
+
+	delete [] data;
+      }
+      filebin.close();
+      cout << endl;
+
+    }
+
+
+    }
+  
+
+
+  return hs;
+
+}