flight/macros/fillpedsig.cpp

#include <utils/yodaUtility.h>
#include "TrkFunctions.cpp"
#include <iostream>
#include <fstream>
#include <TPaveText.h>
#include <TLatex.h>
#include <TCanvas.h>
#include <TGraph.h>
#include <TStyle.h>
#include <TObjString.h>
#include <PscuHeader.h>
#include <EventHeader.h>
#include <CalibTrk1Event.h>
#include <CalibTrk2Event.h>

/**
 * fillpedsig  --> is a function to calculate the mean value for
 *                 sigma, variance of sigma, pedestal and variance of pedestal
 *                 and fill a root.file whit these values
 *
 * autor: D.Fedele
 * version 1.0
 * Parameters:
 *      file - the path to the root file to analyse
 *      outdir - total path of output file 
 * 
 */

void fillpedsig(TString file,TString outdir)
{
  // 
  //   obtain information about the data file and select the output file
  const string filepath=file.Data(); 
  Int_t dwpos = filepath.find("DW_");
  Int_t dwpos1 = filepath.find(".root");
  TString fpath=(filepath.c_str());
  TString base,ffile,date1,date2,date;
  stringcopy(base,fpath,0,dwpos);
  stringcopy(ffile,fpath,dwpos,dwpos1);

  stringcopy(date1,fpath,dwpos+3,dwpos+9);
  stringcopy(date2,fpath,dwpos+10,dwpos1);

  TString out;
  stringstream outfile;
  if(outdir.Length()==0){
    out = base;
  }else{
    out = outdir;
  };
  outfile<<out.Data()<<"pedsig.root";
  
  //
  //  initialise structure where data will store 
  struct caltrk_def ctrk;
  Int_t nevents=0;
  Float_t OBT[2];
  
  OBT[0]=0;
  OBT[1]=0;
  ctrk.good0[0]=0;
  ctrk.good0[1]=0;
  for(Int_t i=0;i<12;i++){ 
    ctrk.daqmode[i]=0;
    ctrk.dspnum[i]=0;
    ctrk.calibnum[i]=0;
    ctrk.ncalev[i]=0;
    ctrk.calfl[i]=0;
    ctrk.ped1[i]=0;
    ctrk.ped2[i]=0;
    ctrk.ped3[i]=0;
    ctrk.sig1[i]=0;
    ctrk.sig2[i]=0;
    ctrk.sig3[i]=0;
    ctrk.nbad1[i]=0;
    ctrk.nbad2[i]=0;
    ctrk.nbad3[i]=0;
    ctrk.crc_hc[i]=0;
    ctrk.crc_c[i][0]=0;
    ctrk.crc_c[i][1]=0;
    ctrk.crc_c[i][2]=0;
    for(Int_t iii=0;iii<3072;iii++){
      ctrk.dspped[i][iii]=0;
      ctrk.dspsig[i][iii]=0;
      ctrk.dspbad[i][iii]=0;
    }
  }

  //
  // open data files
  pamela::EventHeader *eh1=0,*eh2=0;
  pamela::PscuHeader *ph1=0,*ph2=0;
  pamela::CalibTrk1Event *trk1 = 0;
  pamela::CalibTrk2Event *trk2 = 0;

  TFile *datafile = new TFile(file);
  if ( !datafile ){
    //  printf("No data file, exiting...\n");
    return;
  };  
  TTree *otr1,*otr2;
  
  otr1 = (TTree*)datafile->Get("CalibTrk1");
  otr1->SetBranchAddress("CalibTrk1", &trk1);
  otr1->SetBranchAddress("Header",&eh1);
  otr2 = (TTree*)datafile->Get("CalibTrk2");
  otr2->SetBranchAddress("CalibTrk2", &trk2);
  otr2->SetBranchAddress("Header",&eh2);
  

  if(otr1->GetEntries()==otr2->GetEntries())
    nevents = otr1->GetEntries();
  else{
    //    printf("WARNING: CalibTrk1 entries is different from CalibTrk2 entries");
    return;}

  if (nevents<=0) {
    datafile->Close();
    //    printf("No calibration packets found, exiting...\n");
    return;
  };

  //
  // Define variables
  Int_t ndsp =0,numbad[12][12];
  Float_t pedav[12][12],pedavtemp[12][12],sigav[12][12],sigavtemp[12][12];
  Float_t pedvar[12][12],pedvartemp[12][12],sigvar[12][12],sigvartemp[12][12];
  Long64_t datefile=0;


  //
  // open output files
  TFile *pedsig;
  TTree *pstree;
  ifstream pedsigtmp(outfile.str().c_str());
  if(pedsigtmp.fail()){
    pedsigtmp.close();
    pedsig = new TFile(outfile.str().c_str(),"new");
    pstree=new TTree("pstree","pedsig");
    pstree->Branch("pedav",pedav,"pedav[12][12]/F");
    pstree->Branch("pedvar",pedvar,"pedvar[12][12]/F");
    pstree->Branch("sigav",sigav,"sigav[12][12]/F");
    pstree->Branch("sigvar",sigvar,"sigvar[12][12]/F");
    pstree->Branch("datefile",&datefile,"datefile/L");
    pstree->Branch("numbad",numbad,"numbad[12][12]/I");
  }
  if(!pedsigtmp.fail()){
    pedsigtmp.close();
    pedsig = new TFile(outfile.str().c_str(),"update");
    pstree = (TTree*)pedsig->Get("pstree");
    pstree->SetBranchAddress("pedav",pedav);
    pstree->SetBranchAddress("pedvar",pedvar);
    pstree->SetBranchAddress("sigav",sigav);
    pstree->SetBranchAddress("sigvar",sigvar);
    pstree->SetBranchAddress("datefile",&datefile);
    pstree->SetBranchAddress("numbad",numbad);
  }

  datefile=atoll(date1+date2);
  //**********************************************************************
  //
  //   LOOP OVER EVENTS
  //
  //**********************************************************************

  for (Int_t i = 0; i < nevents; i++){     
      
    otr1->GetEntry(i); 
    otr2->GetEntry(i); 
      
    //
    // fill data storage structure
    ctrk.good0[0]=trk1->good0;
    ctrk.good0[1]=trk2->good0;
    for (Int_t m = 0; m < 6; m++){
      Int_t plane=m;
      ph1 = eh1->GetPscuHeader();
      OBT[0]= ph1->GetOrbitalTime();
      ctrk.daqmode[trk1->DSPnumber[m]-1]=trk1->DAQmode[m];
      ctrk.dspnum[trk1->DSPnumber[m]-1]=trk1->DSPnumber[m];
      ctrk.calibnum[trk1->DSPnumber[m]-1]=trk1->calibnumber[m];
      ctrk.ncalev[trk1->DSPnumber[m]-1]=trk1->ncalib_event[m];
      ctrk.ped1[trk1->DSPnumber[m]-1]=trk1->ped_l1[m];
      ctrk.ped2[trk1->DSPnumber[m]-1]=trk1->ped_l2[m];
      ctrk.ped3[trk1->DSPnumber[m]-1]=trk1->ped_l3[m];
      ctrk.sig1[trk1->DSPnumber[m]-1]=trk1->sig_l1[m];
      ctrk.sig2[trk1->DSPnumber[m]-1]=trk1->sig_l2[m];
      ctrk.sig3[trk1->DSPnumber[m]-1]=trk1->sig_l3[m];
      ctrk.nbad1[trk1->DSPnumber[m]-1]=trk1->nbad_l1[m];
      ctrk.nbad2[trk1->DSPnumber[m]-1]=trk1->nbad_l2[m];
      ctrk.nbad3[trk1->DSPnumber[m]-1]=trk1->nbad_l3[m];
      ctrk.calfl[trk1->DSPnumber[m]-1]=trk1->cal_flag[m];
      ctrk.crc_c[trk1->DSPnumber[m]-1][0]=trk1->crc_cal[m][0];
      ctrk.crc_c[trk1->DSPnumber[m]-1][1]=trk1->crc_cal[m][1];
      ctrk.crc_c[trk1->DSPnumber[m]-1][2]=trk1->crc_cal[m][2];
      ctrk.crc_hc[trk1->DSPnumber[m]-1]=trk1->crc_hcal[m];
      for (Int_t j = 0; j < 3072; j++){
        ctrk.dspped[trk1->DSPnumber[m]-1][j]=trk1->DSPped_par[m][j];
        ctrk.dspsig[trk1->DSPnumber[m]-1][j]=trk1->DSPsig_par[m][j];
        ctrk.dspbad[trk1->DSPnumber[m]-1][j]=trk1->DSPbad_par[m][j];
      }
      ph2 = eh2->GetPscuHeader();
      OBT[1]= ph2->GetOrbitalTime();
      ctrk.daqmode[trk2->DSPnumber[m]-1]=trk2->DAQmode[m];
      ctrk.dspnum[trk2->DSPnumber[m]-1]=trk2->DSPnumber[m];
      ctrk.calibnum[trk2->DSPnumber[m]-1]=trk2->calibnumber[m];
      ctrk.ncalev[trk2->DSPnumber[m]-1]=trk2->ncalib_event[m];
      ctrk.ped1[trk2->DSPnumber[m]-1]=trk2->ped_l1[m];
      ctrk.ped2[trk2->DSPnumber[m]-1]=trk2->ped_l2[m];
      ctrk.ped3[trk2->DSPnumber[m]-1]=trk2->ped_l3[m];
      ctrk.sig1[trk2->DSPnumber[m]-1]=trk2->sig_l1[m];
      ctrk.sig2[trk2->DSPnumber[m]-1]=trk2->sig_l2[m];
      ctrk.sig3[trk2->DSPnumber[m]-1]=trk2->sig_l3[m];
      ctrk.nbad1[trk2->DSPnumber[m]-1]=trk2->nbad_l1[m];
      ctrk.nbad2[trk2->DSPnumber[m]-1]=trk2->nbad_l2[m];
      ctrk.nbad3[trk2->DSPnumber[m]-1]=trk2->nbad_l3[m];
      ctrk.calfl[trk2->DSPnumber[m]-1]=trk2->cal_flag[m];
      ctrk.crc_c[trk1->DSPnumber[m]-1][0]=trk2->crc_cal[m][0];
      ctrk.crc_c[trk1->DSPnumber[m]-1][1]=trk2->crc_cal[m][1];
      ctrk.crc_c[trk1->DSPnumber[m]-1][2]=trk2->crc_cal[m][2];
      ctrk.crc_hc[trk1->DSPnumber[m]-1]=trk2->crc_hcal[m];
      for (Int_t j = 0; j < 3072; j++){
        ctrk.dspped[trk2->DSPnumber[m]-1][j]=trk2->DSPped_par[m][j];
        ctrk.dspsig[trk2->DSPnumber[m]-1][j]=trk2->DSPsig_par[m][j];
        ctrk.dspbad[trk2->DSPnumber[m]-1][j]=trk2->DSPbad_par[m][j];
      }
    }      
  
    //
    // inizialise variables
    for(Int_t n = 0; n<12; n++){
      for(Int_t nm = 0; nm<12; nm++){
        pedav[n][nm]=0;
        pedavtemp[n][nm]=0;
        sigav[n][nm]=0;
        sigavtemp[n][nm]=0;
        pedvar[n][nm]=0;
        pedvartemp[n][nm]=0;
        sigvar[n][nm]=0;
        sigvartemp[n][nm]=0;
        numbad[n][nm]=0;
      }
    }

    //
    //  calculate the mean value for sigma, variance of sigma, pedestal, variance of pedestal
    Int_t nn=0;
    for(Int_t n = 0; n<12; n++){
      
      ndsp = ctrk.dspnum[n];
      nn = ndsp-1;

      for(Int_t j = 0; j < 3072; j++){
        if(ctrk.dspbad[nn][j]==0){
          sigavtemp[nn][j/256]+=ctrk.dspsig[nn][j];
          pedavtemp[nn][j/256]+=ctrk.dspped[nn][j];
        }
        else 
          numbad[nn][j/256]+=1;
      }
      for(Int_t ii=0;ii<12;ii++){
        pedav[nn][ii]=pedavtemp[nn][ii]/256;  
        sigav[nn][ii]=sigavtemp[nn][ii]/256;  
      }
      for(Int_t j = 0; j < 3072; j++){
        if(ctrk.dspbad[nn][j]==0){
          sigvartemp[nn][j/256]+=pow((ctrk.dspsig[nn][j]-sigav[nn][j/256]),2);
          pedvartemp[nn][j/256]+=pow((ctrk.dspped[nn][j]-pedav[nn][j/256]),2);
        };
      }
      for(Int_t ii=0;ii<12;ii++){
        pedvar[nn][ii]=sqrt(pedvartemp[nn][ii]/255); 
        sigvar[nn][ii]=sqrt(sigvartemp[nn][ii]/255); 
      }
    }

    //
    // Fill the output Tree
    pstree->Fill();    

  };//end loop on events

  //
  //close all files
  datafile->Close();  
  pedsig->Write();
  pedsig->Close();  
  
  return;
}
1	pam-fi	1.1	#include <utils/yodaUtility.h>
2			#include "TrkFunctions.cpp"
3			#include <iostream>
4			#include <fstream>
5			#include <TPaveText.h>
6			#include <TLatex.h>
7			#include <TCanvas.h>
8			#include <TGraph.h>
9			#include <TStyle.h>
10			#include <TObjString.h>
11			#include <PscuHeader.h>
12			#include <EventHeader.h>
13			#include <CalibTrk1Event.h>
14			#include <CalibTrk2Event.h>
15
16			/**
17			* fillpedsig --> is a function to calculate the mean value for
18			* sigma, variance of sigma, pedestal and variance of pedestal
19			* and fill a root.file whit these values
20			*
21			* autor: D.Fedele
22			* version 1.0
23			* Parameters:
24			* file - the path to the root file to analyse
25			* outdir - total path of output file
26			*
27			*/
28
29			void fillpedsig(TString file,TString outdir)
30			{
31			//
32			// obtain information about the data file and select the output file
33			const string filepath=file.Data();
34			Int_t dwpos = filepath.find("DW_");
35			Int_t dwpos1 = filepath.find(".root");
36			TString fpath=(filepath.c_str());
37			TString base,ffile,date1,date2,date;
38			stringcopy(base,fpath,0,dwpos);
39			stringcopy(ffile,fpath,dwpos,dwpos1);
40
41			stringcopy(date1,fpath,dwpos+3,dwpos+9);
42			stringcopy(date2,fpath,dwpos+10,dwpos1);
43
44			TString out;
45			stringstream outfile;
46			if(outdir.Length()==0){
47			out = base;
48			}else{
49			out = outdir;
50			};
51			outfile<<out.Data()<<"pedsig.root";
52
53			//
54			// initialise structure where data will store
55			struct caltrk_def ctrk;
56			Int_t nevents=0;
57			Float_t OBT[2];
58
59			OBT[0]=0;
60			OBT[1]=0;
61			ctrk.good0[0]=0;
62			ctrk.good0[1]=0;
63			for(Int_t i=0;i<12;i++){
64			ctrk.daqmode[i]=0;
65			ctrk.dspnum[i]=0;
66			ctrk.calibnum[i]=0;
67			ctrk.ncalev[i]=0;
68			ctrk.calfl[i]=0;
69			ctrk.ped1[i]=0;
70			ctrk.ped2[i]=0;
71			ctrk.ped3[i]=0;
72			ctrk.sig1[i]=0;
73			ctrk.sig2[i]=0;
74			ctrk.sig3[i]=0;
75			ctrk.nbad1[i]=0;
76			ctrk.nbad2[i]=0;
77			ctrk.nbad3[i]=0;
78			ctrk.crc_hc[i]=0;
79			ctrk.crc_c[i][0]=0;
80			ctrk.crc_c[i][1]=0;
81			ctrk.crc_c[i][2]=0;
82			for(Int_t iii=0;iii<3072;iii++){
83			ctrk.dspped[i][iii]=0;
84			ctrk.dspsig[i][iii]=0;
85			ctrk.dspbad[i][iii]=0;
86			}
87			}
88
89			//
90			// open data files
91			pamela::EventHeader eh1=0,eh2=0;
92			pamela::PscuHeader ph1=0,ph2=0;
93			pamela::CalibTrk1Event *trk1 = 0;
94			pamela::CalibTrk2Event *trk2 = 0;
95
96			TFile *datafile = new TFile(file);
97			if ( !datafile ){
98			// printf("No data file, exiting...\n");
99			return;
100			};
101			TTree otr1,otr2;
102
103			otr1 = (TTree*)datafile->Get("CalibTrk1");
104			otr1->SetBranchAddress("CalibTrk1", &trk1);
105			otr1->SetBranchAddress("Header",&eh1);
106			otr2 = (TTree*)datafile->Get("CalibTrk2");
107			otr2->SetBranchAddress("CalibTrk2", &trk2);
108			otr2->SetBranchAddress("Header",&eh2);
109
110
111			if(otr1->GetEntries()==otr2->GetEntries())
112			nevents = otr1->GetEntries();
113			else{
114			// printf("WARNING: CalibTrk1 entries is different from CalibTrk2 entries");
115			return;}
116
117			if (nevents<=0) {
118			datafile->Close();
119			// printf("No calibration packets found, exiting...\n");
120			return;
121			};
122
123			//
124			// Define variables
125			Int_t ndsp =0,numbad[12][12];
126			Float_t pedav[12][12],pedavtemp[12][12],sigav[12][12],sigavtemp[12][12];
127			Float_t pedvar[12][12],pedvartemp[12][12],sigvar[12][12],sigvartemp[12][12];
128			Long64_t datefile=0;
129
130
131			//
132			// open output files
133			TFile *pedsig;
134			TTree *pstree;
135			ifstream pedsigtmp(outfile.str().c_str());
136			if(pedsigtmp.fail()){
137			pedsigtmp.close();
138			pedsig = new TFile(outfile.str().c_str(),"new");
139			pstree=new TTree("pstree","pedsig");
140			pstree->Branch("pedav",pedav,"pedav[12][12]/F");
141			pstree->Branch("pedvar",pedvar,"pedvar[12][12]/F");
142			pstree->Branch("sigav",sigav,"sigav[12][12]/F");
143			pstree->Branch("sigvar",sigvar,"sigvar[12][12]/F");
144			pstree->Branch("datefile",&datefile,"datefile/L");
145			pstree->Branch("numbad",numbad,"numbad[12][12]/I");
146			}
147			if(!pedsigtmp.fail()){
148			pedsigtmp.close();
149			pedsig = new TFile(outfile.str().c_str(),"update");
150			pstree = (TTree*)pedsig->Get("pstree");
151			pstree->SetBranchAddress("pedav",pedav);
152			pstree->SetBranchAddress("pedvar",pedvar);
153			pstree->SetBranchAddress("sigav",sigav);
154			pstree->SetBranchAddress("sigvar",sigvar);
155			pstree->SetBranchAddress("datefile",&datefile);
156			pstree->SetBranchAddress("numbad",numbad);
157			}
158
159			datefile=atoll(date1+date2);
160			//**********************************************************************
161			//
162			// LOOP OVER EVENTS
163			//
164			//**********************************************************************
165
166			for (Int_t i = 0; i < nevents; i++){
167
168			otr1->GetEntry(i);
169			otr2->GetEntry(i);
170
171			//
172			// fill data storage structure
173			ctrk.good0[0]=trk1->good0;
174			ctrk.good0[1]=trk2->good0;
175			for (Int_t m = 0; m < 6; m++){
176			Int_t plane=m;
177			ph1 = eh1->GetPscuHeader();
178			OBT[0]= ph1->GetOrbitalTime();
179			ctrk.daqmode[trk1->DSPnumber[m]-1]=trk1->DAQmode[m];
180			ctrk.dspnum[trk1->DSPnumber[m]-1]=trk1->DSPnumber[m];
181			ctrk.calibnum[trk1->DSPnumber[m]-1]=trk1->calibnumber[m];
182			ctrk.ncalev[trk1->DSPnumber[m]-1]=trk1->ncalib_event[m];
183			ctrk.ped1[trk1->DSPnumber[m]-1]=trk1->ped_l1[m];
184			ctrk.ped2[trk1->DSPnumber[m]-1]=trk1->ped_l2[m];
185			ctrk.ped3[trk1->DSPnumber[m]-1]=trk1->ped_l3[m];
186			ctrk.sig1[trk1->DSPnumber[m]-1]=trk1->sig_l1[m];
187			ctrk.sig2[trk1->DSPnumber[m]-1]=trk1->sig_l2[m];
188			ctrk.sig3[trk1->DSPnumber[m]-1]=trk1->sig_l3[m];
189			ctrk.nbad1[trk1->DSPnumber[m]-1]=trk1->nbad_l1[m];
190			ctrk.nbad2[trk1->DSPnumber[m]-1]=trk1->nbad_l2[m];
191			ctrk.nbad3[trk1->DSPnumber[m]-1]=trk1->nbad_l3[m];
192			ctrk.calfl[trk1->DSPnumber[m]-1]=trk1->cal_flag[m];
193			ctrk.crc_c[trk1->DSPnumber[m]-1][0]=trk1->crc_cal[m][0];
194			ctrk.crc_c[trk1->DSPnumber[m]-1][1]=trk1->crc_cal[m][1];
195			ctrk.crc_c[trk1->DSPnumber[m]-1][2]=trk1->crc_cal[m][2];
196			ctrk.crc_hc[trk1->DSPnumber[m]-1]=trk1->crc_hcal[m];
197			for (Int_t j = 0; j < 3072; j++){
198			ctrk.dspped[trk1->DSPnumber[m]-1][j]=trk1->DSPped_par[m][j];
199			ctrk.dspsig[trk1->DSPnumber[m]-1][j]=trk1->DSPsig_par[m][j];
200			ctrk.dspbad[trk1->DSPnumber[m]-1][j]=trk1->DSPbad_par[m][j];
201			}
202			ph2 = eh2->GetPscuHeader();
203			OBT[1]= ph2->GetOrbitalTime();
204			ctrk.daqmode[trk2->DSPnumber[m]-1]=trk2->DAQmode[m];
205			ctrk.dspnum[trk2->DSPnumber[m]-1]=trk2->DSPnumber[m];
206			ctrk.calibnum[trk2->DSPnumber[m]-1]=trk2->calibnumber[m];
207			ctrk.ncalev[trk2->DSPnumber[m]-1]=trk2->ncalib_event[m];
208			ctrk.ped1[trk2->DSPnumber[m]-1]=trk2->ped_l1[m];
209			ctrk.ped2[trk2->DSPnumber[m]-1]=trk2->ped_l2[m];
210			ctrk.ped3[trk2->DSPnumber[m]-1]=trk2->ped_l3[m];
211			ctrk.sig1[trk2->DSPnumber[m]-1]=trk2->sig_l1[m];
212			ctrk.sig2[trk2->DSPnumber[m]-1]=trk2->sig_l2[m];
213			ctrk.sig3[trk2->DSPnumber[m]-1]=trk2->sig_l3[m];
214			ctrk.nbad1[trk2->DSPnumber[m]-1]=trk2->nbad_l1[m];
215			ctrk.nbad2[trk2->DSPnumber[m]-1]=trk2->nbad_l2[m];
216			ctrk.nbad3[trk2->DSPnumber[m]-1]=trk2->nbad_l3[m];
217			ctrk.calfl[trk2->DSPnumber[m]-1]=trk2->cal_flag[m];
218			ctrk.crc_c[trk1->DSPnumber[m]-1][0]=trk2->crc_cal[m][0];
219			ctrk.crc_c[trk1->DSPnumber[m]-1][1]=trk2->crc_cal[m][1];
220			ctrk.crc_c[trk1->DSPnumber[m]-1][2]=trk2->crc_cal[m][2];
221			ctrk.crc_hc[trk1->DSPnumber[m]-1]=trk2->crc_hcal[m];
222			for (Int_t j = 0; j < 3072; j++){
223			ctrk.dspped[trk2->DSPnumber[m]-1][j]=trk2->DSPped_par[m][j];
224			ctrk.dspsig[trk2->DSPnumber[m]-1][j]=trk2->DSPsig_par[m][j];
225			ctrk.dspbad[trk2->DSPnumber[m]-1][j]=trk2->DSPbad_par[m][j];
226			}
227			}
228
229			//
230			// inizialise variables
231			for(Int_t n = 0; n<12; n++){
232			for(Int_t nm = 0; nm<12; nm++){
233			pedav[n][nm]=0;
234			pedavtemp[n][nm]=0;
235			sigav[n][nm]=0;
236			sigavtemp[n][nm]=0;
237			pedvar[n][nm]=0;
238			pedvartemp[n][nm]=0;
239			sigvar[n][nm]=0;
240			sigvartemp[n][nm]=0;
241			numbad[n][nm]=0;
242			}
243			}
244
245			//
246			// calculate the mean value for sigma, variance of sigma, pedestal, variance of pedestal
247			Int_t nn=0;
248			for(Int_t n = 0; n<12; n++){
249
250			ndsp = ctrk.dspnum[n];
251			nn = ndsp-1;
252
253			for(Int_t j = 0; j < 3072; j++){
254			if(ctrk.dspbad[nn][j]==0){
255			sigavtemp[nn][j/256]+=ctrk.dspsig[nn][j];
256			pedavtemp[nn][j/256]+=ctrk.dspped[nn][j];
257			}
258			else
259			numbad[nn][j/256]+=1;
260			}
261			for(Int_t ii=0;ii<12;ii++){
262			pedav[nn][ii]=pedavtemp[nn][ii]/256;
263			sigav[nn][ii]=sigavtemp[nn][ii]/256;
264			}
265			for(Int_t j = 0; j < 3072; j++){
266			if(ctrk.dspbad[nn][j]==0){
267			sigvartemp[nn][j/256]+=pow((ctrk.dspsig[nn][j]-sigav[nn][j/256]),2);
268			pedvartemp[nn][j/256]+=pow((ctrk.dspped[nn][j]-pedav[nn][j/256]),2);
269			};
270			}
271			for(Int_t ii=0;ii<12;ii++){
272			pedvar[nn][ii]=sqrt(pedvartemp[nn][ii]/255);
273			sigvar[nn][ii]=sqrt(sigvartemp[nn][ii]/255);
274			}
275			}
276
277			//
278			// Fill the output Tree
279			pstree->Fill();
280
281			};//end loop on events
282
283			//
284			//close all files
285			datafile->Close();
286			pedsig->Write();
287			pedsig->Close();
288
289			return;
290			}