00001 #include "TTRDMuensterFrankfurtProc.h"
00002
00003 #include "TGo4Log.h"
00004
00005 #include "spadic/Message.h"
00006
00007 #define USED_SPADIC 13
00008
00009
00010 #define USED_SPADIC_2012 6 // subset of (must be <=) USED_SPADIC to limits histos in pictures
00011
00012 int numy_2012 = 3;
00013
00014
00015
00016
00017
00018 Int_t SpMap[MAX_SPADIC] = { 0, 11, 10, 18, 5, 19, 15, 2, 1, 2, 12, 6, 4, 16, 17, 3, 14, 7, 8, 9};
00019 Int_t SpaPosMap[USED_SPADIC] = { 0, 11, 10, 18, 5, 19, 15, 2, 1, 4, 12, 6, 16 };
00020
00021 Double_t minCorrMatrix[MAX_SPADIC][NUM_SPADIC_CHA] = {
00022 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00023 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00024 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00025 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00026 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00027 {0.120, 0.120, 0.120, 0.120, 0.120, 0.120, 0.120, 0.120},
00028 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00029 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00030 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00031 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00032 {0.110, 0.110, 0.110, 0.110, 0.110, 0.110, 0.110, 0.110},
00033 {0.119, 0.119, 0.119, 0.119, 0.119, 0.119, 0.119, 0.119},
00034 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00035 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00036 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00037 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00038 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00039 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00040 {0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000},
00041 {0.115, 0.115, 0.115, 0.115, 0.115, 0.115, 0.115, 0.115}
00042 };
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056 TPrincipal* principal = new TPrincipal(NUM_SPADIC_CHA,"ND");
00057 TMatrixD* cova = NULL;
00058 Int_t counter = 0;
00059
00060 void TTRDMuensterFrankfurtProc::PulseFitter(TH1* Pulse, Double_t hitTime, Double_t maxAmpl, Int_t sid)
00061 {
00062
00063 pulseFit[sid]->SetParameter(0,maxAmpl*10);
00064 pulseFit[sid]->SetParLimits(0,0,256*100);
00065 pulseFit[sid]->SetParameter(1,0.09*45);
00066 pulseFit[sid]->SetParLimits(1,0.07*45,0.12*45);
00067 pulseFit[sid]->SetParameter(2,(hitTime-5));
00068 pulseFit[sid]->SetParLimits(2,0.8*(hitTime-5),1.2*(hitTime-5));
00069 pulseFit[sid]->SetParameter(3,0);
00070 pulseFit[sid]->SetParLimits(3,-50,50);
00071 pulseFit[sid]->SetRange(hitTime-5,45);
00072 Pulse->Fit(pulseFit[sid],"QNR0");
00073 fSpadic_gainConstantFit[sid]->Fill(pulseFit[sid]->GetParameter(0));
00074 fSpadic_timeConstantFit[sid]->Fill(pulseFit[sid]->GetParameter(1) / 45.);
00075 fSpadic_delayFit[sid]->Fill(pulseFit[sid]->GetParameter(2));
00076 fSpadic_baselineFit[sid]->Fill(pulseFit[sid]->GetParameter(3));
00077 fSpadic_chiSquareFit[sid]->Fill(pulseFit[sid]->GetChisquare()/(Double_t)pulseFit[sid]->GetNDF());
00078
00079 }
00080
00081 void TTRDMuensterFrankfurtProc::CancelNoise_Cova(Int_t sid, TH1* inPulse[NUM_SPADIC_CHA],TH1* outPulse[NUM_SPADIC_CHA], TSpadicData* theSpadic, bool debug)
00082 {
00083
00084
00085
00086 Double_t cortest[NUM_SPADIC_CHA];
00087 Double_t inputarray[SPADIC_TRACE_SIZE][NUM_SPADIC_CHA] = {{0.0}};
00088 Double_t minIntegral = 265*45;
00089 Double_t tempIntegral = 0.0;
00090 int minch = -1;
00091 for(Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++){
00092 tempIntegral = 0.0;
00093 outPulse[ch]->Reset();
00094 theSpadic->fSpadicSignalCh[ch] = false;
00095 for(Int_t bin = 0; bin < SPADIC_TRACE_SIZE; bin++){
00096 inputarray[bin][ch] = inPulse[ch]->GetBinContent(inPulse[ch]->FindBin(bin));
00097 tempIntegral += inputarray[bin][ch];
00098 }
00099 if (tempIntegral < minIntegral){
00100 minIntegral = tempIntegral;
00101 minch = ch;
00102 }
00103 }
00104 int noise_ch_counter=0;
00105
00106 Double_t thisisnoise[SPADIC_TRACE_SIZE] = {0.0};
00107
00108
00109 for(int t=0;t<SPADIC_TRACE_SIZE;t++){
00110 principal->AddRow(inputarray[t]);
00111 }
00112 principal->MakePrincipals();
00113 cova = (TMatrixD*)principal->GetCovarianceMatrix();
00114
00115 Int_t lastSigCh = -1;
00116 for(int ch=0;ch<NUM_SPADIC_CHA;ch++){
00117 cortest[ch] = TMatrixDRow (*cova,minch)(ch);
00118 fSpadic_CorrMatrix[sid][ch]->Fill(cortest[ch]);
00119
00120 if (fSpadic_corrMatrixWindow[sid][ch]->Test(cortest[ch])) {
00121 theSpadic->fSpadicSignalCh[ch] = false;
00122 noise_ch_counter++;
00123 for(Int_t bin = 0; bin < SPADIC_TRACE_SIZE; bin++){
00124 thisisnoise[bin] += inputarray[bin][ch];
00125 }
00126 }
00127 else {
00128 theSpadic->fSpadicSignalCh[ch] = true;
00129 if (lastSigCh != -1)
00130 lastSigCh = ch;
00131 }
00132 }
00133 for(Int_t bin = 0; bin < SPADIC_TRACE_SIZE; bin++){
00134 thisisnoise[bin] /= (double)noise_ch_counter;
00135 }
00136 Int_t hitTime[NUM_SPADIC_CHA] = {0};
00137 Double_t maxAmpl[NUM_SPADIC_CHA] = {0.0};
00138 Double_t signal = 0.0;
00139 Int_t maxCh = 0;
00140 if (fSpadic_Clustersize[sid] != NULL) fSpadic_Clustersize[sid]->Fill(NUM_SPADIC_CHA - noise_ch_counter);
00141 for (int ch=0; ch<NUM_SPADIC_CHA; ch++){
00142 for (int k=0; k<SPADIC_TRACE_SIZE; k++){
00143 signal = inPulse[ch]->GetBinContent(inPulse[ch]->FindBin(k)) - thisisnoise[k];
00144 if (signal > maxAmpl[ch]) {
00145 maxAmpl[ch] = signal;
00146 hitTime[ch] = k;
00147 }
00148 outPulse[ch]->Fill(k, signal);
00149 }
00150 fSpadic_CorrMatrix_hitTime[sid][ch]->Fill(cortest[ch], hitTime[ch]);
00151 fSpadic_CorrMatrix_maxAmpl[sid][ch]->Fill(cortest[ch], maxAmpl[ch]);
00152 if (maxAmpl[ch] > maxAmpl[maxCh])
00153 maxCh = ch;
00154 }
00155 if (maxAmpl[maxCh] > 10) {
00156 PulseFitter(outPulse[maxCh], hitTime[maxCh], maxAmpl[maxCh], sid);
00157 }
00158 principal->Clear();
00159 }
00160
00161
00162 TTRDMuensterFrankfurtProc::TTRDMuensterFrankfurtProc(const char* name) : TCBMBeamtimeProc(name),
00163 fSpadicInputEvent(0),
00164 fOutputEvent(0),
00165 fBeamEvent(0),
00166 fHodo1(0),
00167 fHodo2(0)
00168 {
00169 TGo4Log::Info("TTRDMuensterFrankfurtProcTTRDSpadicProc: Create instance %s", name);
00170
00171 fPar = (TTRDMuensterFrankfurtParam*) MakeParameter("TRDMuensterFrankfurtPar", "TTRDMuensterFrankfurtParam");
00172
00173
00174 fEpicsTrdGasFlow = 0.0;
00175 fEpicsTrdIntegGasFlow = 0.0;
00176 for (int mst = 0; mst < MSTRDNUM; ++mst) {
00177 fEpicsMSTRD_Drift_U[mst] = 0;
00178 fEpicsMSTRD_Drift_I[mst] = 0;
00179 fEpicsMSTRD_Anode_U[mst] = 0;
00180 fEpicsMSTRD_Anode_I[mst] = 0;
00181 fEpicsMSTRD_Sus_U[mst] = 0;
00182 fEpicsMSTRD_Sus_I[mst] = 0;
00183 fEpicsMSTRD_Spa_U[mst] = 0;
00184 fEpicsMSTRD_Spa_I[mst] = 0;
00185 }
00186 for (int i = 0; i < MPOD01SLOT; i++)
00187 fEpicsMSTRD_Temp[i] = 0;
00188
00189 for (int i = 0; i < RICHNUM; ++i) {
00190 fEpics_Rich_U[i] = 0;
00191 fEpics_Rich_I[i] = 0;
00192 }
00193
00194
00195
00196
00197 TString obname;
00198 TString obtitle;
00199 TString foldername;
00200 TH1* his=0;
00201
00202 one = new TLine(0,1,45,1);
00203
00204 TString SuDeId[MAX_SPADIC] = { "dummy",
00205 "",
00206 "MiniTRD",
00207 "",
00208 "",
00209 "FFM_5+5",
00210 "",
00211 "",
00212 "",
00213 "",
00214 "MS_N_II",
00215 "MS_R_I",
00216 "",
00217 "",
00218 "",
00219 "MiniTRD",
00220 "",
00221 "",
00222 "MS_J_III",
00223 "FFM_4+4",
00224 "",
00225 "",
00226 "",
00227 ""
00228 };
00229
00230 fSpadic_MSxyHitPadplane[0] = MakeTH2('I',"MuensterFrankfurt/MSxyHitPadplaneTRD1_2","MS x y Hit Pad Plane TRD 1 2",65,-32.5,32.5,65,-32.5,32.5,"x [mm]","y [mm]");
00231 fSpadic_MSxyHitPadplane[0]->SetContour(99);
00232 fSpadic_MSxyHitPadplane[1] = MakeTH2('I',"MuensterFrankfurt/MSxyHitPadplaneTRD3_4","MS x y Hit Pad Plane TRD 3 4",65,-32.5,32.5,65,-32.5,32.5,"x [mm]","y [mm]");
00233 fSpadic_MSxyHitPadplane[1]->SetContour(99);
00234 fSpadic_MSxyHitplane[0] = MakeTH2('I',"MuensterFrankfurt/MSxyHitplaneTRD1_2","MS x y Hit Plane TRD 1 2",65,-32.5,32.5,65,-32.5,32.5,"x [mm]","y [mm]");
00235 fSpadic_MSxyHitplane[0]->SetContour(99);
00236 fSpadic_MSxyHitplane[1] = MakeTH2('I',"MuensterFrankfurt/MSxyHitplaneTRD3_4","MS x y Hit Plane TRD 3 4",65,-32.5,32.5,65,-32.5,32.5,"x [mm]","y [mm]");
00237 fSpadic_MSxyHitplane[1]->SetContour(99);
00238
00239 for (Int_t i = 0; i < 3; i++){
00240 obname.Form("MuensterFrankfurt/BeamProfile2D_TRD%d",i+1);
00241 obtitle.Form("2D Beam Profil of MS TRD %d",i+1);
00242 fSpadic_beamProfil[i] = MakeTH2('I',obname.Data(),obtitle.Data(),240,-60,60,240,-60,60,"x position [mm]","y position [mm]");
00243 fSpadic_beamProfil[i]->SetContour(99);
00244 obname.Form("MuensterFrankfurt/deltaPos_TRD%d",i+1);
00245 obtitle.Form("offset of reco. pos. of MS TRD %d",i+1);
00246 fSpadic_deltaPos[i] = MakeTH2('I',obname.Data(),obtitle.Data(),240,-60,60,240,-60,60,"x position [mm]","#delta x position [mm]");
00247 fSpadic_deltaPos[i]->SetContour(99);
00248 }
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264 TString MsId[MSTRDNUM] = {"dummy","336_2010","336_2011","444_2010","444_2011"};
00265 const Int_t timeMemory = 1800;
00266
00267 fSpadic_pidMixing = MakeTH1('I',"PIDmixing","PIDmixing",5,-2.5,2.5);
00268
00269 fEpics_TrdGasFlowMonitor = MakeTH1('D',"EPICS_TrdGasMonitor/GasFlowRate","TrdGasFlowMonitor", timeMemory,-timeMemory,0,"relative event id","XeCO_{2} flow [l/h]");
00270 fEpics_TrdIntegGasFlowMonitor = MakeTH1('D',"EPICS_TrdGasMonitor/IntegratedGasFlow","IntegTrdGasFlowMonitor", timeMemory,-timeMemory,0,"relative event id","integrated XeCO_{2} flow [l]");
00271
00272 fEpics_MonitorU[0] = MakeTH1('D',"EPICS_BeamMonitor/Cherenkov_1_U", "Cherenkov 1", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00273 fEpics_MonitorI[0] = MakeTH1('D',"EPICS_BeamMonitor/Cherenkov_1_I", "Cherenkov 1", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00274 fEpics_MonitorU[1] = MakeTH1('D',"EPICS_BeamMonitor/Cherenkov_2_U", "Cherenkov 2", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00275 fEpics_MonitorI[1] = MakeTH1('D',"EPICS_BeamMonitor/Cherenkov_2_I", "Cherenkov 2", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00276 fEpics_MonitorU[2] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_1x_U", "Hodoscope 1x", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00277 fEpics_MonitorI[2] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_1x_I", "Hodoscope 1x", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00278 fEpics_MonitorU[3] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_1y_U", "Hodoscope 1y", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00279 fEpics_MonitorI[3] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_1y_I", "Hodoscope 1y", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00280 fEpics_MonitorU[4] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_2x_U", "Hodoscope 2x", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00281 fEpics_MonitorI[4] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_2x_I", "Hodoscope 2x", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00282 fEpics_MonitorU[5] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_2y_U", "Hodoscope 2y", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00283 fEpics_MonitorI[5] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_2y_I", "Hodoscope 2y", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00284 fEpics_MonitorU[6] = MakeTH1('D',"EPICS_BeamMonitor/Calorimeter_Veto_U","Calorimeter Veto", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00285 fEpics_MonitorI[6] = MakeTH1('D',"EPICS_BeamMonitor/Calorimeter_Veto_I","Calorimeter Veto", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00286 fEpics_MonitorU[7] = MakeTH1('D',"EPICS_BeamMonitor/Calorimeter_U", "Calorimeter", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00287 fEpics_MonitorI[7] = MakeTH1('D',"EPICS_BeamMonitor/Calorimeter_I", "Calorimeter", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00288 fEpics_MonitorU[8] = MakeTH1('D',"EPICS_BeamMonitor/Scintillator_1_U", "Scintillator 1", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00289 fEpics_MonitorI[8] = MakeTH1('D',"EPICS_BeamMonitor/Scintillator_1_I", "Scintillator 1", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00290 fEpics_MonitorU[9] = MakeTH1('D',"EPICS_BeamMonitor/Scintillator_2_U", "Scintillator 2", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00291 fEpics_MonitorI[9] = MakeTH1('D',"EPICS_BeamMonitor/Scintillator_2_I", "Scintillator 2", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00292
00293 for (Int_t sl = 0; sl < MPOD00SLOT; sl++) {
00294 for (Int_t ch = 0; ch < MPOD00CHA; ch++) {
00295 obname.Form("EPICS_MS/MS_Mpod00/Slot%02i/00Slot%02iChannel%02i_U",sl,sl,ch);
00296 obtitle.Form("Mpod00 Slot%02i Channel%02i Voltage",sl,ch);
00297 fEpicsMSMpod00_Monitor_U[sl][ch] = MakeTH1('D',obname,obtitle,timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00298 obname.Form("EPICS_MS/MS_Mpod00/Slot%02i/00Slot%02iChannel%02i_I",sl,sl,ch);
00299 obtitle.Form("Mpod00 Slot%02i Channel%02i Current",sl,ch);
00300 fEpicsMSMpod00_Monitor_I[sl][ch] = MakeTH1('D',obname,obtitle,timeMemory,-timeMemory,0,"relative event id","LV current [A]");
00301 }
00302 }
00303
00304 for (Int_t sl = 0; sl < MPOD01SLOT; sl++) {
00305 for (Int_t ch = 0; ch < MPOD01CHA; ch++) {
00306 obname.Form("EPICS_MS/MS_Mpod01/Slot%02i/01Slot%02iChannel%02i_U",sl,sl,ch);
00307 obtitle.Form("Mpod01 Slot%02i Channel%02i Voltage",sl,ch);
00308 fEpicsMSMpod01_Monitor_U[sl][ch] = MakeTH1('D',obname,obtitle,timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00309 obname.Form("EPICS_MS/MS_Mpod01/Slot%02i/01Slot%02iChannel%02i_I",sl,sl,ch);
00310 obtitle.Form("Mpod01 Slot%02i Channel%02i Current",sl,ch);
00311 fEpicsMSMpod01_Monitor_I[sl][ch] = MakeTH1('D',obname,obtitle,timeMemory,-timeMemory,0,"relative event id","HV current [nA]");
00312 }
00313 }
00314
00315 obname.Form("MuensterFrankfurt/Spadic_S2Ncnt");
00316 obtitle.Form("Spadic S/N counter of good events");
00317 fSpadic_S2Ncnt = MakeTH1('D', obname.Data(), obtitle.Data(), MAX_SPADIC, 0.5, MAX_SPADIC+0.5,"Susibo ID", "S/N counter");
00318
00319 obname.Form("MuensterFrankfurt/Spadic_S2N");
00320 obtitle.Form("Spadic S/N");
00321 fSpadic_S2N = MakeTH1('D', obname.Data(), obtitle.Data(), MAX_SPADIC, 0.5, MAX_SPADIC+0.5,"Susibo ID", "S/N");
00322 for (UInt_t sid = 1; sid < MAX_SPADIC; sid++)
00323 fSpadic_S2N->GetXaxis()->SetBinLabel(sid, SuDeId[sid].Data());
00324
00325 obname.Form("MuensterFrankfurt/Spadic_S2Nclean");
00326 obtitle.Form("Spadic S/N after data cleaning");
00327 fSpadic_S2Ncleaned = MakeTH1('D', obname.Data(), obtitle.Data(), MAX_SPADIC, 0.5, MAX_SPADIC+0.5,"Susibo ID", "S/N");
00328 for (UInt_t sid = 1; sid < MAX_SPADIC; sid++)
00329 fSpadic_S2Ncleaned->GetXaxis()->SetBinLabel(sid, SuDeId[sid].Data());
00330
00331 for (int i = 1; i < RICHNUM; ++i) {
00332 obname.Form("EPICS_MS/MAPMT%02d_U",i);
00333 obtitle.Form("MAPMT%02d_U",i);
00334 fEpics_RichU[i] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00335 obname.Form("EPICS_MS/MAPMT%02d_I",i);
00336 obtitle.Form("MAPMT%02d_I",i);
00337 fEpics_RichI[i] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","current [nA]");
00338 }
00339
00340 for (int mst = 1; mst < MSTRDNUM; ++mst) {
00341 obname.Form("EPICS_MS/%s_AnodeU",MsId[mst].Data());
00342 obtitle.Form("MS%s_AnodeU",MsId[mst].Data());
00343 fEpicsMSTRD_AnodeU[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","anode voltage [V]");
00344 obname.Form("EPICS_MS/%s_AnodeI",MsId[mst].Data());
00345 obtitle.Form("MS%s_AnodeI",MsId[mst].Data());
00346 fEpicsMSTRD_AnodeI[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00347 obname.Form("EPICS_MS/%s_DriftU",MsId[mst].Data());
00348 obtitle.Form("MS%s_DriftU",MsId[mst].Data());
00349 fEpicsMSTRD_DriftU[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","drift voltage [V]");
00350 obname.Form("EPICS_MS/%s_DriftI",MsId[mst].Data());
00351 obtitle.Form("MS%s_DriftI",MsId[mst].Data());
00352 fEpicsMSTRD_DriftI[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","drift current [nA]");
00353 obname.Form("EPICS_MS/%s_SusiboU",MsId[mst].Data());
00354 obtitle.Form("MS%s_SusiboU",MsId[mst].Data());
00355 fEpicsMSTRD_SusU[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00356 obname.Form("EPICS_MS/%s_SusiboI",MsId[mst].Data());
00357 obtitle.Form("MS%s_SusiboI",MsId[mst].Data());
00358 fEpicsMSTRD_SusI[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","current [A]");
00359 obname.Form("EPICS_MS/%s_SpadicU",MsId[mst].Data());
00360 obtitle.Form("MS%s_SpadicU",MsId[mst].Data());
00361 fEpicsMSTRD_SpaU[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00362 obname.Form("EPICS_MS/%s_SpadicI",MsId[mst].Data());
00363 obtitle.Form("MS%s_SpadicI",MsId[mst].Data());
00364 fEpicsMSTRD_SpaI[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","current [A]");
00365 }
00366 for (Int_t i = 0; i < MPOD01SLOT; i++) {
00367 obname.Form("EPICS_MS/T%d",i);
00368 obtitle.Form("MST%d",i);
00369 fEpicsMSTRD_T[i] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","drift module temperatur [°C]");
00370 }
00371
00372 obname.Form("MuensterFrankfurt/Spadic_TriggerEfficiency");
00373 obtitle.Form("number of good events after all cuts");
00374 fSpadic_efficiency = MakeTH1('I', obname.Data(), obtitle.Data(), MAX_SPADIC, -0.5, MAX_SPADIC-0.5, "SuID", "good events after all cuts");
00375 fSpadic_efficiency->GetXaxis()->SetBinLabel( 1,"all");
00376
00377 obname.Form("MuensterFrankfurt/Alignment/Alignment_x_FiberHod1_Alignment_x_FiberHod2");
00378 obtitle.Form("x Alignment fiber hodoscope 1 to fiber hodoscope 2");
00379 fFiberHod1_2_x_alignment = MakeTH2('I', obname.Data(), obtitle.Data(), 70, -35, 35, 70, -35, 35,"x pos. Fiber Hodoscope 1","x pos. Fiber Hodoscope 2");
00380 fFiberHod1_2_x_alignment->SetContour(99);
00381
00382 obname.Form("MuensterFrankfurt/Alignment/Alignment_y_FiberHod1_Alignment_y_FiberHod2");
00383 obtitle.Form("y Alignment fiber hodoscope 1 to fiber hodoscope 2");
00384 fFiberHod1_2_y_alignment = MakeTH2('I', obname.Data(), obtitle.Data(), 70, -35, 35, 70, -35, 35,"y pos. Fiber Hodoscope 1","y pos. Fiber Hodoscope 2");
00385 fFiberHod1_2_y_alignment->SetContour(99);
00386
00387 obname.Form("MuensterFrankfurt/Alignment/Alignment_FiberHod_dx_vs_x");
00388 obtitle.Form("Alignment fiber hodoscope 2-1 dx vs fiber hodoscope 1 x");
00389 fFiberHod1_2_dx_vs_x_alignment = MakeTH2('I', obname.Data(), obtitle.Data(), 70, -35, 35, 140, -70, 70,"x pos. Fiber Hodoscope 1","dx pos. Fiber Hodoscope 2-1");
00390 fFiberHod1_2_dx_vs_x_alignment->SetContour(99);
00391
00392 obname.Form("MuensterFrankfurt/Alignment/Alignment_FiberHod_dy_vs_y");
00393 obtitle.Form("Alignment fiber hodoscope 2-1 dy vs fiber hodoscope 1 y");
00394 fFiberHod1_2_dy_vs_y_alignment = MakeTH2('I', obname.Data(), obtitle.Data(), 70, -35, 35, 140, -70, 70,"y pos. Fiber Hodoscope 1","dy pos. Fiber Hodoscope 2-1");
00395 fFiberHod1_2_dy_vs_y_alignment->SetContour(99);
00396
00397 for (UInt_t sid = 1; sid < MAX_SPADIC; sid++) {
00398
00399 if (TSpadicEvent::ConfigSpadics[sid] == 0) continue;
00400
00401 obname.Form("pulseFit%d",sid);
00402 pulseFit[sid] = new TF1(obname.Data(),"([0] / pow([1], 2)) * (x - [2]) * exp( -1.0 * (x - [2]) / [1]) + [3]",5,45);
00403 pulseFit[sid]->SetParName(0,"Gain");
00404 pulseFit[sid]->SetParName(1,"Time");
00405 pulseFit[sid]->SetParName(2,"Delay");
00406 pulseFit[sid]->SetParName(3,"Baseline");
00407 pulseFit[sid]->SetLineStyle(2);
00408 pulseFit[sid]->SetLineColor(1);
00409 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_gainConstantFit", sid, sid);
00410 obtitle.Form("gainConstant of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00411 fSpadic_gainConstantFit[sid] = MakeTH1('I', obname.Data(), obtitle.Data(), 501,-10,5000, "gain", "#");
00412
00413 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_timeConstantFit", sid, sid);
00414 obtitle.Form("timeConstant of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00415 fSpadic_timeConstantFit[sid] = MakeTH1('I', obname.Data(), obtitle.Data(), 500,0.05,0.15, "time constant", "#");
00416
00417 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_delayFit", sid, sid);
00418 obtitle.Form("delay of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00419 fSpadic_delayFit[sid] = MakeTH1('I', obname.Data(), obtitle.Data(), 450,0,45, "delay", "#");
00420
00421 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_baselineFit", sid, sid);
00422 obtitle.Form("baseline of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00423 fSpadic_baselineFit[sid] = MakeTH1('I', obname.Data(), obtitle.Data(), 600,-10,50, "baseline", "#");
00424
00425 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_chiSquareFit", sid, sid);
00426 obtitle.Form("chiSquare of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00427 fSpadic_chiSquareFit[sid] = MakeTH1('I', obname.Data(), obtitle.Data(), 160,-10,150, "chiSquare/NDF", "#");
00428
00429 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Clustersize", sid, sid);
00430 obtitle.Form("Clustersize of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00431 fSpadic_Clustersize[sid] = MakeTH1('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA+1, -0.5, NUM_SPADIC_CHA+0.5, "Cluster size [channels]", "#");
00432
00433 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_FingerCorr", sid, sid);
00434 obtitle.Form("correlation with finger sintilator spadic %d MF (%s)", sid, SuDeId[sid].Data());
00435 fSpadic_FingerCorr[sid] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA, -0.5, NUM_SPADIC_CHA-0.5,4,-0.5,3.5, "Spadic Channel Number", "Finger Sint. Channel Number");
00436 fSpadic_FingerCorr[sid]->SetContour(99);
00437
00438 obname.Form("%d (%s)",sid, SuDeId[sid].Data());
00439 fSpadic_efficiency->GetXaxis()->SetBinLabel(1+sid, obname.Data());
00440
00441 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_NoiseDistMF", sid, sid);
00442 obtitle.Form("RMS of ADC distribution of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00443 fSpadic_NoiseDistMF[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA, -0.5, NUM_SPADIC_CHA-0.5, "Channel Number", "RMS of ADC distribution [ADC values]");
00444
00445 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_NoiseDist2DMF", sid, sid);
00446 obtitle.Form("RMS of ADC distribution of spadic %d 2D MF (%s)", sid, SuDeId[sid].Data());
00447 fSpadic_NoiseDist2DMF[sid] = MakeTH2('D', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA, -0.5, NUM_SPADIC_CHA-0.5, 305, -50, 255, "Channel Number", "RMS of ADC distribution [ADC values]");
00448 fSpadic_NoiseDist2DMF[sid]->SetContour(99);
00449
00450 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PedelPosMF", sid, sid);
00451 obtitle.Form("Pedestal (Mean of ADC value distribution) of Spadic %d MF (%s)", sid, SuDeId[sid].Data());
00452 fSpadic_PedelPosMF[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA, -0.5, NUM_SPADIC_CHA-0.5, "Channel Number", "Mean of ADC distribution [ADC values]");
00453
00454 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PedelPos2DMF", sid, sid);
00455 obtitle.Form("Pedestal (Mean of ADC value distribution) of Spadic %d 2D MF (%s)", sid, SuDeId[sid].Data());
00456 fSpadic_PedelPos2DMF[sid] = MakeTH2('D', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA, -0.5, NUM_SPADIC_CHA-0.5, 305, -50, 255, "Channel Number", "Mean of ADC distribution [ADC values]");
00457 fSpadic_PedelPos2DMF[sid]->SetContour(99);
00458
00459 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
00460 obname.Form("MuensterFrankfurt/Spadic_%d/Channel%d/Spadic%d_ch%d_CorrMatrixMF", sid, ch, sid, ch);
00461 obtitle.Form("Correlation Matrix value distribution %2d %2d MF (%s)", sid, ch, SuDeId[sid].Data());
00462 fSpadic_CorrMatrix[sid][ch] = MakeTH1('I', obname.Data(), obtitle.Data(), 600, -0.1, 0.2, "Correlation", "Counts");
00463
00464 obname.Form("MuensterFrankfurt/Spadic_%d/Channel%d/Spadic%d_ch%d_CorrMatrix_hitTimeMF", sid, ch, sid, ch);
00465 obtitle.Form("Correlation Matrix value distribution vs. hit time %2d %2d MF (%s)", sid, ch, SuDeId[sid].Data());
00466 fSpadic_CorrMatrix_hitTime[sid][ch] = MakeTH2('I', obname.Data(), obtitle.Data(), 600, -0.1, 0.2, SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, "Correlation", "hit time [time bin]");
00467
00468 obname.Form("MuensterFrankfurt/Spadic_%d/Channel%d/Spadic%d_ch%d_CorrMatrix_maxAmplMF", sid, ch, sid, ch);
00469 obtitle.Form("Correlation Matrix value distribution vs. max. amplitude %2d %2d MF (%s)", sid, ch, SuDeId[sid].Data());
00470 fSpadic_CorrMatrix_maxAmpl[sid][ch] = MakeTH2('I', obname.Data(), obtitle.Data(), 600, -0.1, 0.2, 266,-10,256, "Correlation", "max. amplitude [ADCs]");
00471
00472 obname.Form("Spadic_%d/Channel%d/Spadic%d_ch%d_ADCdistMF", sid, ch, sid, ch);
00473 obtitle.Form("ADC value distribution %2d %2d MF (%s)", sid, ch, SuDeId[sid].Data());
00474 fSpadic_ADCdistMF[sid][ch] = MakeTH1('I', obname.Data(), obtitle.Data(), 256, -256/2, 256/2, "ADC value", "Counts");
00475 }
00476 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPE_pi2D", sid, sid);
00477 obtitle.Form("Average pulse shape of spadic %d (pion) 2D (%s)", sid, SuDeId[sid].Data());
00478 fSpadic_pi_shape2D[sid] = MakeTH2('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, 300, -44, 255);
00479 fSpadic_pi_shape2D[sid]->SetContour(99);
00480
00481 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPE_pi", sid, sid);
00482 obtitle.Form("Average pulse shape of spadic %d (pion) (%s)", sid, SuDeId[sid].Data());
00483 fSpadic_pi_shape[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00484
00485 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPEcnt_pi", sid, sid);
00486 obtitle.Form("Counts for average pulse shape of spadic %d (pion) (%s)", sid, SuDeId[sid].Data());
00487 fSpadic_pi_shapecnt[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00488
00489 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPE_el2D", sid, sid);
00490 obtitle.Form("Average pulse shape of spadic %d (electron) 2D (%s)", sid, SuDeId[sid].Data());
00491 fSpadic_el_shape2D[sid] = MakeTH2('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, 300, -44, 255);
00492 fSpadic_el_shape2D[sid]->SetContour(99);
00493
00494 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPE_el", sid, sid);
00495 obtitle.Form("Average pulse shape of spadic %d (electron) (%s)", sid, SuDeId[sid].Data());
00496 fSpadic_el_shape[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00497
00498 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPEcnt_el", sid, sid);
00499 obtitle.Form("Counts for average pulse shape of spadic %d (electron) (%s)", sid, SuDeId[sid].Data());
00500 fSpadic_el_shapecnt[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00501
00502 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PID", sid, sid);
00503 obtitle.Form("Spadic %d Particle ID (%s)", sid, SuDeId[sid].Data());
00504 fSpadic_pid[sid] = MakeTH1('I', obname.Data(), obtitle.Data(),4,-0.5,3.5);
00505 fSpadic_pid[sid]->GetXaxis()->SetBinLabel( 1,"all");
00506 fSpadic_pid[sid]->GetXaxis()->SetBinLabel( 2,"no PID");
00507 fSpadic_pid[sid]->GetXaxis()->SetBinLabel( 3,"electron");
00508 fSpadic_pid[sid]->GetXaxis()->SetBinLabel( 4,"pion");
00509
00510 S2N[sid] = new TLatex(0.1,0.8,"S/N=xy");
00511 S2N[sid]->SetTextAlign(12);
00512 S2N[sid]->SetTextSize(0.04);
00513 S2N[sid]->SetNDC();
00514 S2N[sid]->SetName(Form("S2N%dLatex",sid));
00515 if (sid == 10) {
00516 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el_00", sid, sid);
00517 obtitle.Form("Spadic %d intensity (%s) 00", sid, SuDeId[sid].Data());
00518 fSpadic_intens_el_00 = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00519 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el_10", sid, sid);
00520 obtitle.Form("Spadic %d intensity (%s) 10", sid, SuDeId[sid].Data());
00521 fSpadic_intens_el_10 = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00522 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el_01", sid, sid);
00523 obtitle.Form("Spadic %d intensity (%s) 01", sid, SuDeId[sid].Data());
00524 fSpadic_intens_el_01 = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00525 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el_11", sid, sid);
00526 obtitle.Form("Spadic %d intensity (%s) 11", sid, SuDeId[sid].Data());
00527 fSpadic_intens_el_11 = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00528
00529 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el_left", sid, sid);
00530 obtitle.Form("Spadic %d intensity (%s)", sid, SuDeId[sid].Data());
00531 fSpadic_intens_el_left = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00532 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el_right", sid, sid);
00533 obtitle.Form("Spadic %d intensity (%s)", sid, SuDeId[sid].Data());
00534 fSpadic_intens_el_right = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00535
00536 }
00537 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens", sid, sid);
00538 obtitle.Form("Spadic %d intensity (%s)", sid, SuDeId[sid].Data());
00539 fSpadic_intens[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00540
00541 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens3pad", sid, sid);
00542 obtitle.Form("Spadic %d intensity 3 pad cluster (%s)", sid, SuDeId[sid].Data());
00543 fSpadic_intens_3pad[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00544
00545 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_pi", sid, sid);
00546 obtitle.Form("Spadic %d intensity (pion) (%s)", sid, SuDeId[sid].Data());
00547 fSpadic_pi_intens[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00548
00549 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_pi_over", sid, sid);
00550 obtitle.Form("Spadic %d intensity (pion) (%s) overflow", sid, SuDeId[sid].Data());
00551 fSpadic_pi_intens_over[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00552
00553 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_pi_under", sid, sid);
00554 obtitle.Form("Spadic %d intensity (pion) (%s) underflow", sid, SuDeId[sid].Data());
00555 fSpadic_pi_intens_under[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00556
00557 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el", sid, sid);
00558 obtitle.Form("Spadic %d intensity (electron) (%s)", sid, SuDeId[sid].Data());
00559 fSpadic_el_intens[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00560
00561 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el_over", sid, sid);
00562 obtitle.Form("Spadic %d intensity (electron) (%s) overflow", sid, SuDeId[sid].Data());
00563 fSpadic_el_intens_over[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00564
00565 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el_under", sid, sid);
00566 obtitle.Form("Spadic %d intensity (electron) (%s) underflow", sid, SuDeId[sid].Data());
00567 fSpadic_el_intens_under[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 300, 0, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE / 6);
00568
00569 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PadMax", sid, sid);
00570 obtitle.Form("Spadic %d pad with maximum charge (%s)", sid, SuDeId[sid].Data());
00571 fSpadic_padMax[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),NUM_SPADIC_CHA, 0, NUM_SPADIC_CHA);
00572
00573 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_RecoPos", sid, sid);
00574 obtitle.Form("Spadic %d reco. position (%s)", sid, SuDeId[sid].Data());
00575 fSpadic_recoPos[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),NUM_SPADIC_CHA * fPar->fPadwidth[sid], 0, NUM_SPADIC_CHA * fPar->fPadwidth[sid]);
00576
00577
00578 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Statistics", sid, sid);
00579 obtitle.Form("Spadic %d statistics (%s)", sid, SuDeId[sid].Data());
00580 fSpadic_statistics[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 15, -0.5, 14.5);
00581 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 1,"all events");
00582 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 2,"noise");
00583 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 3,"above threshold");
00584 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 4,"in time window");
00585 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 5,"above intens");
00586 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 6,"wright pad max");
00587 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 7,"no overflow");
00588 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 8,"no undershoot");
00589 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 9,"not a border pad");
00590 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 10,"not multi hit");
00591 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 11,"good");
00592 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel(12,"pion");
00593 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel(13,"electron");
00594 fSpadic_statistics[sid]->GetXaxis()->SetBinLabel(14,"no ID");
00595
00596 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PRFMF", sid, sid);
00597 obtitle.Form("PRF of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00598 fSpadic_PRFMF[sid] = MakeTH2('D', obname.Data(), obtitle.Data(), 400, -1.5, 1.5, 100, 0, 1);
00599 fSpadic_PRFMF[sid]->SetContour(99);
00600
00601 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_maxAmplitude", sid, sid);
00602 obtitle.Form("Spadic %d amplitude of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00603 fSpadic_maxAmplitude[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),300, -44, 256);
00604
00605 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_el_maxAmplitude", sid, sid);
00606 obtitle.Form("Spadic %d electron amplitude of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00607 fSpadic_el_maxAmplitude[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),300, -44, 256);
00608
00609 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_pi_maxAmplitude", sid, sid);
00610 obtitle.Form("Spadic %d pion amplitude of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00611 fSpadic_pi_maxAmplitude[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),300, -44, 256);
00612
00613 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_hitTime", sid, sid);
00614 obtitle.Form("Spadic %d hit time of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00615 fSpadic_hitTime[sid] = MakeTH1('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00616
00617 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_el_hitTime", sid, sid);
00618 obtitle.Form("Spadic %d electron hit time of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00619 fSpadic_el_hitTime[sid] = MakeTH1('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00620
00621 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_pi_hitTime", sid, sid);
00622 obtitle.Form("Spadic %d pion hit time of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00623 fSpadic_pi_hitTime[sid] = MakeTH1('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00624
00625 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_hitTime_maxAmplitude", sid, sid);
00626 obtitle.Form("Spadic %d hit time of signal with maximum charge vs. maximum amplitude(%s)", sid, SuDeId[sid].Data());
00627 fSpadic_hitTime_maxAmplitude[sid] = MakeTH2('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE,300, -44, 256,"hit time [time bin]","max. ampl. [ADC values]");
00628
00629 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_hitTime_position", sid, sid);
00630 obtitle.Form("Spadic %d hit time of signal with maximum charge vs reco. position(%s)", sid, SuDeId[sid].Data());
00631 fSpadic_hitTime_position[sid] = MakeTH2('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE,NUM_SPADIC_CHA * fPar->fPadwidth[sid]*100, 0, NUM_SPADIC_CHA * fPar->fPadwidth[sid],"hit time [time bin]","reco. pos [mm]");
00632
00633 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_hitTime_Hodo1Yposition", sid, sid);
00634 obtitle.Form("Spadic %d hit time of signal with maximum charge vs Hodo 1 y position(%s)", sid, SuDeId[sid].Data());
00635 fSpadic_hitTime_Hodo1Yposition[sid] = MakeTH2('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, 70, -35, 35,"hit time [time bin]","y pos. Fiber Hodoscope 1 [mm]");
00636
00637 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_hitTime_Hodo2Yposition", sid, sid);
00638 obtitle.Form("Spadic %d hit time of signal with maximum charge vs Hodo 2 y position(%s)", sid, SuDeId[sid].Data());
00639 fSpadic_hitTime_Hodo2Yposition[sid] = MakeTH2('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, 70, -35, 35,"hit time [time bin]","y pos. Fiber Hodoscope 2 [mm]");
00640
00641 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_hitTime_Hodo1Xposition", sid, sid);
00642 obtitle.Form("Spadic %d hit time of signal with maximum charge vs Hodo 1 x position(%s)", sid, SuDeId[sid].Data());
00643 fSpadic_hitTime_Hodo1Xposition[sid] = MakeTH2('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, 70, -35, 35,"hit time [time bin]","x pos. Fiber Hodoscope 1 [mm]");
00644
00645 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_hitTime_Hodo2Xposition", sid, sid);
00646 obtitle.Form("Spadic %d hit time of signal with maximum charge vs Hodo 2 x position(%s)", sid, SuDeId[sid].Data());
00647 fSpadic_hitTime_Hodo2Xposition[sid] = MakeTH2('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, 70, -35, 35,"hit time [time bin]","x pos. Fiber Hodoscope 2 [mm]");
00648
00649 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_overflow_Hodo1position", sid, sid);
00650 obtitle.Form("Spadic %d hit time of signal with maximum charge vs Hodo 2 x position(%s)", sid, SuDeId[sid].Data());
00651 fSpadic_overflow_Hodo1position[sid] = MakeTH2('I', obname.Data(), obtitle.Data(), 70, -35, 35, 70, -35, 35,"x pos. Fiber Hodoscope 1 [mm]","y pos. Fiber Hodoscope 1 [mm]");
00652
00653 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_overflow_Hodo2position", sid, sid);
00654 obtitle.Form("Spadic %d hit time of signal with maximum charge vs Hodo 2 x position(%s)", sid, SuDeId[sid].Data());
00655 fSpadic_overflow_Hodo2position[sid] = MakeTH2('I', obname.Data(), obtitle.Data(), 70, -35, 35, 70, -35, 35,"x pos. Fiber Hodoscope 2 [mm]","y pos. Fiber Hodoscope 2 [mm]");
00656
00657
00658 obname.Form("Spadic%d/Spadic%d_minAmplitudeGate", sid, sid);
00659 obtitle.Form("minimum amplitude gate %d (%s)", sid, SuDeId[sid].Data());
00660 fSpadic_minAmplitudeCond[sid] = MakeWinCond(obname.Data(), 10, 255, fSpadic_maxAmplitude[sid]->GetName());
00661
00662 obname.Form("Spadic%d/Spadic%d_minIntensityGate", sid, sid);
00663 obtitle.Form("minimum intensity gate %d (%s)", sid, SuDeId[sid].Data());
00664 fSpadic_minIntensCond[sid] = MakeWinCond(obname.Data(), 50, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE, fSpadic_intens[sid]->GetName());
00665
00666 obname.Form("Spadic%d/Spadic%d_hitTimeGate", sid, sid);
00667 obtitle.Form("hit time gate %d (%s)", sid, SuDeId[sid].Data());
00668 fSpadic_hitTimeCond[sid] = MakeWinCond(obname.Data(), 12, 25, fSpadic_hitTime[sid]->GetName());
00669
00670 obname.Form("Spadic%d/Spadic%d_integWindow", sid, sid);
00671 obtitle.Form("integration window %d (%s)", sid, SuDeId[sid].Data());
00672 fSpadic_integWindow[sid] = MakeWinCond(obname.Data(), 0, SPADIC_TRACE_SIZE, fSpadic_el_shape[sid]->GetName());
00673
00674 obname.Form("Spadic%d/Spadic%d_padMaxWindow", sid, sid);
00675 obtitle.Form("used pad max %d (%s)", sid, SuDeId[sid].Data());
00676 fSpadic_padMaxWindow[sid] = MakeWinCond(obname.Data(), 1, NUM_SPADIC_CHA-1, fSpadic_padMax[sid]->GetName());
00677
00678 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
00679 obname.Form("Spadic%d/Channel%d/Spadic%d_ch%d_CorrMatrixWindowMF", sid, ch, sid, ch);
00680 obtitle.Form("used correlation to separate signal from noise ch %d SUSIBO %d (%s)", ch, sid, SuDeId[sid].Data());
00681 fSpadic_corrMatrixWindow[sid][ch] = MakeWinCond(obname.Data(), minCorrMatrix[sid][ch], 1.0, fSpadic_CorrMatrix[sid][ch]->GetName());
00682 }
00683
00684
00685 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
00686
00687 obname.Form("MuensterFrankfurt/Spadic_%d/Channel%d/Spadic%d_ch%d_input", sid, ch, sid, ch);
00688 obtitle.Form("MSFF Trace %2d %2d (%s)", sid, ch, SuDeId[sid].Data());
00689 fSpadic_input[sid][ch] = MakeTH1('F', obname.Data(), obtitle.Data(),
00690 SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, "time (40ns)");
00691
00692 obname.Form("MuensterFrankfurt/Spadic_%d/Channel%d/Spadic%d_ch%d_baseline", sid, ch, sid, ch);
00693 obtitle.Form("MSFF Trace %2d %2d (%s)", sid, ch, SuDeId[sid].Data());
00694 fSpadic_baseline[sid][ch] = MakeTH1('F', obname.Data(), obtitle.Data(),
00695 SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, "time (40ns)");
00696
00697 obname.Form("MuensterFrankfurt/Spadic_%d/Channel%d/Spadic%d_ch%d_output", sid, ch, sid, ch);
00698 obtitle.Form("MSFF Compensated %2d %2d (%s)", sid, ch, SuDeId[sid].Data());
00699 fSpadic_output[sid][ch] = MakeTH1('F', obname.Data(), obtitle.Data(),
00700 SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, "time (40ns)");
00701 }
00702
00703 obname.Form("MuensterFrankfurt/Alignment/Alignment_x_FiberHod1_Spadic%d", sid);
00704 obtitle.Form("x Alignment Spadic %d (%s) to fiber hodoscope 1", sid, SuDeId[sid].Data());
00705
00706 fFiberHod1_x_alignment[sid] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA * fPar->fPadwidth[sid], 0 * fPar->fPadwidth[sid], NUM_SPADIC_CHA * fPar->fPadwidth[sid], 70, -35, 35, SuDeId[sid].Data(),"x pos. Fiber Hodoscope 1");
00707 fFiberHod1_x_alignment[sid]->SetContour(99);
00708
00709 obname.Form("MuensterFrankfurt/Alignment/Alignment_y_FiberHod1_Spadic%d", sid);
00710 obtitle.Form("y Alignment Spadic %d (%s) to fiber hodoscope 1", sid, SuDeId[sid].Data());
00711
00712 fFiberHod1_y_alignment[sid] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA * fPar->fPadwidth[sid], 0 * fPar->fPadwidth[sid], NUM_SPADIC_CHA * fPar->fPadwidth[sid], 70, -35, 35, SuDeId[sid].Data(),"y pos. Fiber Hodoscope 1");
00713 fFiberHod1_y_alignment[sid]->SetContour(99);
00714
00715 obname.Form("MuensterFrankfurt/Alignment/Alignment_x_FiberHod2_Spadic%d", sid);
00716 obtitle.Form("x Alignment Spadic %d (%s) to fiber hodoscope 2", sid, SuDeId[sid].Data());
00717
00718 fFiberHod2_x_alignment[sid] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA * fPar->fPadwidth[sid], 0 * fPar->fPadwidth[sid], NUM_SPADIC_CHA * fPar->fPadwidth[sid], 70, -35, 35, SuDeId[sid].Data(),"x pos. Fiber Hodoscope 2");
00719 fFiberHod2_x_alignment[sid]->SetContour(99);
00720
00721 obname.Form("MuensterFrankfurt/Alignment/Alignment_y_FiberHod2_Spadic%d", sid);
00722 obtitle.Form("y Alignment Spadic %d (%s) to fiber hodoscope 2", sid, SuDeId[sid].Data());
00723
00724 fFiberHod2_y_alignment[sid] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA * fPar->fPadwidth[sid], 0 * fPar->fPadwidth[sid], NUM_SPADIC_CHA * fPar->fPadwidth[sid], 70, -35, 35, SuDeId[sid].Data(),"y pos. Fiber Hodoscope 2");
00725 fFiberHod2_y_alignment[sid]->SetContour(99);
00726
00727 }
00728
00729 Int_t i = 0;
00730 for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
00731 if (TSpadicEvent::ConfigSpadics[sid] == 0) continue;
00732 for (UInt_t sid2 = sid; sid2 < MAX_SPADIC; sid2++) {
00733 if (TSpadicEvent::ConfigSpadics[sid2] == 0) continue;
00734 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", sid, sid2);
00735 obtitle.Form("Correlations Spadic %d (%s) Spadic %d (%s)", sid, SuDeId[sid].Data(), sid2, SuDeId[sid2].Data());
00736 fSpadic_correlation[i] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA, -0.5, NUM_SPADIC_CHA-0.5, NUM_SPADIC_CHA, -0.5, NUM_SPADIC_CHA-0.5, SuDeId[sid].Data(), SuDeId[sid2]);
00737 fSpadic_correlation[i]->SetContour(99);
00738
00739 obname.Form("MuensterFrankfurt/Alignment/Alignment_Spadic%d_%d", sid, sid2);
00740 obtitle.Form("Alignment Spadic %d (%s) Spadic %d (%s)", sid, SuDeId[sid].Data(), sid2, SuDeId[sid2].Data());
00741
00742 fSpadic_alignment[i] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA * fPar->fPadwidth[sid], 0 * fPar->fPadwidth[sid], NUM_SPADIC_CHA * fPar->fPadwidth[sid], NUM_SPADIC_CHA * fPar->fPadwidth[sid2], 0 * fPar->fPadwidth[sid2], NUM_SPADIC_CHA * fPar->fPadwidth[sid2], SuDeId[sid].Data(), SuDeId[sid2]);
00743 fSpadic_alignment[i]->SetContour(99);
00744
00745 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", sid, sid, sid2);
00746 obtitle.Form("Average pulse shape of spadic %d (pion) (%s)", sid, SuDeId[sid].Data());
00747 fSpadic_pi_shapeRatio[i] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, SuDeId[sid].Data(), SuDeId[sid2] );
00748
00749 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", sid, sid, sid2);
00750 obtitle.Form("Average pulse shape of spadic %d (electron) (%s)", sid, SuDeId[sid].Data());
00751 fSpadic_el_shapeRatio[i] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, SuDeId[sid].Data(), SuDeId[sid2]);
00752
00753 i++;
00754
00755 }
00756 }
00757
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775 if (GetPicture("SpadicFiberHod1XAlignment")==0) {
00776 TGo4Picture* pic = new TGo4Picture("SpadicFiberHod1XAlignment","Hodo 1 X");
00777 int numy = numy_2012;
00778 int numx = (USED_SPADIC_2012-1) / numy;
00779 if (numx*numy < (USED_SPADIC_2012 - 1)) numx++;
00780 pic->SetDivision(numy, numx);
00781
00782 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
00783 int nx = (uid-1) / numy;
00784 int ny = (uid-1) % numy;
00785 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
00786 pic->Pic(ny, nx)->AddObject(fFiberHod1_x_alignment[SpaPosMap[uid]]);
00787 }
00788 AddPicture(pic,"MuensterFrankfurt");
00789 }
00790
00791 if (GetPicture("SpadicFiberHod1YAlignment")==0) {
00792 TGo4Picture* pic = new TGo4Picture("SpadicFiberHod1YAlignment","Hodo 1 Y");
00793 int numy = numy_2012;
00794 int numx = (USED_SPADIC_2012-1) / numy;
00795 if (numx*numy < (USED_SPADIC_2012 - 1))
00796 numx++;
00797 pic->SetDivision(numy, numx);
00798
00799 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
00800 int nx = (uid-1) / numy;
00801 int ny = (uid-1) % numy;
00802 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
00803 pic->Pic(ny, nx)->AddObject(fFiberHod1_y_alignment[SpaPosMap[uid]]);
00804 }
00805 AddPicture(pic,"MuensterFrankfurt");
00806 }
00807
00808 if (GetPicture("SpadicFiberHod2XAlignment")==0) {
00809 TGo4Picture* pic = new TGo4Picture("SpadicFiberHod2XAlignment","Hodo 2 X");
00810 int numy = numy_2012;
00811 int numx = (USED_SPADIC_2012-1) / numy;
00812 if (numx*numy < (USED_SPADIC_2012 - 1)) numx++;
00813 pic->SetDivision(numy, numx);
00814
00815 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
00816 int nx = (uid-1) / numy;
00817 int ny = (uid-1) % numy;
00818 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
00819 pic->Pic(ny, nx)->AddObject(fFiberHod2_x_alignment[SpaPosMap[uid]]);
00820 }
00821 AddPicture(pic,"MuensterFrankfurt");
00822 }
00823
00824 if (GetPicture("SpadicFiberHod2YAlignment")==0) {
00825 TGo4Picture* pic = new TGo4Picture("SpadicFiberHod2YAlignment","Hodo 2 Y");
00826 int numy = numy_2012;
00827 int numx = (USED_SPADIC_2012-1) / numy;
00828 if (numx*numy < (USED_SPADIC_2012 - 1))
00829 numx++;
00830 pic->SetDivision(numy, numx);
00831
00832 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
00833 int nx = (uid-1) / numy;
00834 int ny = (uid-1) % numy;
00835 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
00836 pic->Pic(ny, nx)->AddObject(fFiberHod2_y_alignment[SpaPosMap[uid]]);
00837 }
00838 AddPicture(pic,"MuensterFrankfurt");
00839 }
00840
00841 if (GetPicture("SpadicOverflowVsHodoposition")==0) {
00842 TGo4Picture* pic = new TGo4Picture("SpadicOverflowVsHodoposition","Gain vs. position");
00843 pic->SetDivision(4, 2);
00844 if (TSpadicEvent::ConfigSpadics[11] != 0){
00845 pic->Pic(0, 0)->AddObject(fSpadic_overflow_Hodo1position[11]);
00846 pic->Pic(0, 1)->AddObject(fSpadic_overflow_Hodo2position[11]);
00847 }
00848 if (TSpadicEvent::ConfigSpadics[10] != 0){
00849 pic->Pic(1, 0)->AddObject(fSpadic_overflow_Hodo1position[10]);
00850 pic->Pic(1, 1)->AddObject(fSpadic_overflow_Hodo2position[10]);
00851 }
00852 if (TSpadicEvent::ConfigSpadics[5] != 0){
00853 pic->Pic(2, 0)->AddObject(fSpadic_overflow_Hodo1position[5]);
00854 pic->Pic(2, 1)->AddObject(fSpadic_overflow_Hodo2position[5]);
00855 }
00856 if (TSpadicEvent::ConfigSpadics[19] != 0){
00857 pic->Pic(3, 0)->AddObject(fSpadic_overflow_Hodo1position[19]);
00858 pic->Pic(3, 1)->AddObject(fSpadic_overflow_Hodo2position[19]);
00859 }
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873 AddPicture(pic,"MuensterFrankfurt");
00874 }
00875
00876 if (GetPicture("SpadicHitPlane")==0) {
00877 TGo4Picture* pic = new TGo4Picture("SpadicHitPlane","Spadic Hit Plane");
00878 pic->SetDivision(2,2);
00879 pic->Pic(0, 0)->AddObject(fSpadic_MSxyHitPadplane[0]);
00880 pic->Pic(0, 1)->AddObject(fSpadic_MSxyHitPadplane[1]);
00881 pic->Pic(1, 0)->AddObject(fSpadic_MSxyHitplane[0]);
00882 pic->Pic(1, 0)->SetLogScale(2,1);
00883 pic->Pic(1, 1)->AddObject(fSpadic_MSxyHitplane[1]);
00884 pic->Pic(1, 0)->SetLogScale(2,1);
00885 AddPicture(pic,"MuensterFrankfurt/2011");
00886 }
00887
00888 if (GetPicture("MS3Summary")==0) {
00889 TGo4Picture* pic = new TGo4Picture("MS3Summary"," ");
00890 int numy = 4;
00891 int numx = 3;
00892 pic->SetDivision(numy, numx);
00893 int nx = 0;
00894 for (UInt_t sid = 1; sid < 4; sid++) {
00895 int ny = 0;
00896 pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00897 pic->Pic(ny, nx)->SetRangeY(-20, 255);
00898 pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape[SpMap[sid]]);
00899 pic->Pic(ny, nx)->AddObject(fSpadic_el_shape[SpMap[sid]]);
00900
00901 ny = 1;
00902
00903 pic->Pic(ny, nx)->SetRangeY(-20, 255);
00904 pic->Pic(ny, nx)->SetLogScale(2,1);
00905 pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape2D[SpMap[sid]]);
00906
00907 ny = 2;
00908
00909 pic->Pic(ny, nx)->SetRangeY(-20, 255);
00910 pic->Pic(ny, nx)->SetLogScale(2,1);
00911 pic->Pic(ny, nx)->AddObject(fSpadic_el_shape2D[SpMap[sid]]);
00912
00913 ny = 3;
00914 pic->Pic(ny, nx)->AddObject(fSpadic_intens[SpMap[sid]]);
00915
00916 pic->Pic(ny, nx)->AddObject(fSpadic_el_intens[SpMap[sid]]);
00917 pic->Pic(ny, nx)->AddObject(fSpadic_pi_intens[SpMap[sid]]);
00918
00919 nx++;
00920 }
00921 AddPicture(pic,"MuensterFrankfurt/2012");
00922 }
00923
00924 if (GetPicture("SpadicSignal2Noise")==0) {
00925 TGo4Picture* pic = new TGo4Picture("SpadicSignal2Noise","Signal to Noise");
00926 pic->SetDivision(1,1);
00927 pic->Pic(0, 0)->SetAutoScale(kFALSE);
00928 pic->Pic(0, 0)->SetRangeY(1, 255./20.);
00929 pic->Pic(0, 0)->AddObject(fSpadic_S2N);
00930 AddPicture(pic,"MuensterFrankfurt/kaputt");
00931 }
00932
00933 if (GetPicture("SpadicPID")==0) {
00934 TGo4Picture* pic = new TGo4Picture("SpadicPID", "Particle ID");
00935 int numy = numy_2012;
00936 int numx = (USED_SPADIC_2012-1) / numy;
00937 if (numx*numy < (USED_SPADIC_2012 - 1))
00938 numx++;
00939 pic->SetDivision(numy, numx);
00940
00941 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
00942 int nx = (uid-1) / numy;
00943 int ny = (uid-1) % numy;
00944
00945 pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00946 pic->Pic(ny, nx)->SetRangeY(1, 25000);
00947 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
00948 pic->Pic(ny, nx)->AddObject(fSpadic_pid[SpaPosMap[uid]]);
00949 }
00950 AddPicture(pic,"MuensterFrankfurt");
00951 }
00952 if (GetPicture("SpadicEfficiency")==0) {
00953 TGo4Picture* pic = new TGo4Picture("SpadicEfficiency", "Trigger Efficiency");
00954 pic->Pic(0, 0)->AddObject(fSpadic_efficiency);
00955 AddPicture(pic,"MuensterFrankfurt");
00956 }
00957 if (GetPicture("MFmaxAmplitude")==0) {
00958 TGo4Picture* pic = new TGo4Picture("MFmaxAmplitude","max. amplitude on pad max");
00959 int numy = numy_2012;
00960 int numx = (USED_SPADIC_2012-1) / numy;
00961 if (numx*numy < (USED_SPADIC_2012 - 1))
00962 numx++;
00963 pic->SetDivision(numy, numx);
00964
00965 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
00966 int nx = (uid-1) / numy;
00967 int ny = (uid-1) % numy;
00968 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
00969 pic->Pic(ny, nx)->AddObject(fSpadic_maxAmplitude[SpaPosMap[uid]]);
00970 pic->Pic(ny, nx)->AddObject(fSpadic_el_maxAmplitude[SpaPosMap[uid]]);
00971 pic->Pic(ny, nx)->AddObject(fSpadic_pi_maxAmplitude[SpaPosMap[uid]]);
00972 pic->Pic(ny, nx)->AddCondition(fSpadic_minAmplitudeCond[SpaPosMap[uid]]);
00973 }
00974 AddPicture(pic,"MuensterFrankfurt");
00975 }
00976
00977 if (GetPicture("MFhitTime")==0) {
00978 TGo4Picture* pic = new TGo4Picture("MFhitTime","hit time on pad max");
00979 int numy = numy_2012;
00980 int numx = (USED_SPADIC_2012-1) / numy;
00981 if (numx*numy < (USED_SPADIC_2012 - 1))
00982 numx++;
00983 pic->SetDivision(numy, numx);
00984
00985 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
00986 int nx = (uid-1) / numy;
00987 int ny = (uid-1) % numy;
00988 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
00989 pic->Pic(ny, nx)->AddObject(fSpadic_hitTime[SpaPosMap[uid]]);
00990 pic->Pic(ny, nx)->AddObject(fSpadic_el_hitTime[SpaPosMap[uid]]);
00991 pic->Pic(ny, nx)->AddObject(fSpadic_pi_hitTime[SpaPosMap[uid]]);
00992 pic->Pic(ny, nx)->AddCondition(fSpadic_hitTimeCond[SpaPosMap[uid]]);
00993 }
00994 AddPicture(pic,"MuensterFrankfurt");
00995 }
00996
00997 if (GetPicture("MFmaxIntensity")==0) {
00998 TGo4Picture* pic = new TGo4Picture("MFmaxIntensity","integrated intensity on 3 max pads");
00999 int numy = numy_2012;
01000 int numx = (USED_SPADIC_2012-1) / numy;
01001 if (numx*numy < (USED_SPADIC_2012 - 1))
01002 numx++;
01003 pic->SetDivision(numy, numx);
01004
01005 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01006 int nx = (uid-1) / numy;
01007 int ny = (uid-1) % numy;
01008 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01009 pic->Pic(ny, nx)->AddObject(fSpadic_intens[SpaPosMap[uid]]);
01010 pic->Pic(ny, nx)->AddCondition(fSpadic_minIntensCond[SpaPosMap[uid]]);
01011 }
01012 AddPicture(pic,"MuensterFrankfurt");
01013 }
01014
01015
01016 if (GetPicture("MFFingerCorr")==0) {
01017 TGo4Picture* pic = new TGo4Picture("MFFingerCorr","Correlation with Finger Sint.");
01018 int numy = numy_2012;
01019 int numx = (USED_SPADIC_2012-1) / numy;
01020 if (numx*numy < (USED_SPADIC_2012 - 1))
01021 numx++;
01022 pic->SetDivision(numy, numx);
01023
01024 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01025 int nx = (uid-1) / numy;
01026 int ny = (uid-1) % numy;
01027 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01028 pic->Pic(ny, nx)->AddObject(fSpadic_FingerCorr[SpaPosMap[uid]]);
01029 }
01030 AddPicture(pic,"MuensterFrankfurt/2011");
01031 }
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070 if (GetPicture("MS4Summary")==0) {
01071 TGo4Picture* pic = new TGo4Picture("MS4Summary"," ");
01072 int numy = 4;
01073 int numx = 4;
01074 pic->SetDivision(numy, numx);
01075 int nx = 0;
01076 for (UInt_t sid = 1; sid < 9; sid++) {
01077 int ny = 0;
01078 if (sid % 2 == 1)
01079 continue;
01080 if (TSpadicEvent::ConfigSpadics[SpMap[sid]] == 0) continue;
01081 pic->Pic(ny, nx)->SetAutoScale(kFALSE);
01082 pic->Pic(ny, nx)->SetRangeY(-20, 255);
01083 pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape[SpMap[sid]]);
01084 pic->Pic(ny, nx)->AddObject(fSpadic_el_shape[SpMap[sid]]);
01085 ny = 1;
01086
01087 pic->Pic(ny, nx)->SetRangeY(-20, 255);
01088 pic->Pic(ny, nx)->SetLogScale(2,1);
01089 pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape2D[SpMap[sid]]);
01090 ny = 2;
01091
01092 pic->Pic(ny, nx)->SetRangeY(-20, 255);
01093 pic->Pic(ny, nx)->SetLogScale(2,1);
01094 pic->Pic(ny, nx)->AddObject(fSpadic_el_shape2D[SpMap[sid]]);
01095 ny = 3;
01096 pic->Pic(ny, nx)->AddObject(fSpadic_intens[SpMap[sid]]);
01097 pic->Pic(ny, nx)->AddObject(fSpadic_el_intens[SpMap[sid]]);
01098 pic->Pic(ny, nx)->AddObject(fSpadic_pi_intens[SpMap[sid]]);
01099 nx++;
01100 }
01101 AddPicture(pic,"MuensterFrankfurt/2011");
01102 }
01103
01104
01105 if (GetPicture("MFShape")==0) {
01106 TGo4Picture* pic = new TGo4Picture("MFShape","Electron and Pion Pulse Shape");
01107 int numy = numy_2012;
01108 int numx = (USED_SPADIC_2012-1) / numy;
01109 if (numx*numy < (USED_SPADIC_2012 - 1))
01110 numx++;
01111 pic->SetDivision(numy, numx);
01112
01113 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01114 int nx = (uid-1) / numy;
01115 int ny = (uid-1) % numy;
01116
01117 pic->Pic(ny, nx)->SetAutoScale(kFALSE);
01118 pic->Pic(ny, nx)->SetRangeY(-20, 255);
01119 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01120 pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape[SpaPosMap[uid]]);
01121 pic->Pic(ny, nx)->AddObject(fSpadic_el_shape[SpaPosMap[uid]]);
01122 pic->Pic(ny, nx)->AddObject( S2N[SpaPosMap[uid]]);
01123 }
01124 AddPicture(pic,"MuensterFrankfurt");
01125 }
01126
01127 if (GetPicture("MFShapeRatio")==0) {
01128 const UInt_t first_MF_Spadic = 1;
01129 const UInt_t last_MF_Spadic = 5;
01130 Int_t d_MF_Spadic = last_MF_Spadic - first_MF_Spadic + 1;
01131 TGo4Picture* pic = new TGo4Picture("MFShapeRatio", "MF Signal Shape Ratio");
01132 pic->SetDivision(d_MF_Spadic, d_MF_Spadic);
01133
01134 for (UInt_t sid = first_MF_Spadic; sid <= last_MF_Spadic; sid++) {
01135 if (TSpadicEvent::ConfigSpadics[SpMap[sid]] == 0) continue;
01136 for (UInt_t sid2 = sid; sid2 <= last_MF_Spadic; sid2++) {
01137 if (TSpadicEvent::ConfigSpadics[SpMap[sid2]] == 0) continue;
01138 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->SetAutoScale(kFALSE);
01139 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->SetRangeY(-1, 3);
01140
01141 if (SpMap[sid] <= SpMap[sid2])
01142 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", SpMap[sid], SpMap[sid], SpMap[sid2]);
01143 else
01144 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", SpMap[sid2], SpMap[sid2], SpMap[sid]);
01145 his=GetHistogram(obname.Data());
01146 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(his);
01147 if (SpMap[sid] <= SpMap[sid2])
01148 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", SpMap[sid], SpMap[sid], SpMap[sid2]);
01149 else
01150 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", SpMap[sid2], SpMap[sid2], SpMap[sid]);
01151 his=GetHistogram(obname.Data());
01152
01153 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(his);
01154 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(one);
01155
01156 }
01157 }
01158 AddPicture(pic,"MuensterFrankfurt");
01159 }
01160
01161
01162 if (GetPicture("MFShapeP2D")==0) {
01163 TGo4Picture* pic = new TGo4Picture("MFShapeP2D","Pion Pulse Shape 2D");
01164 int numy = numy_2012;
01165 int numx = (USED_SPADIC_2012-1) / numy;
01166 if (numx*numy < (USED_SPADIC_2012 - 1))
01167 numx++;
01168 pic->SetDivision(numy, numx);
01169
01170 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01171
01172 int nx = (uid-1) / numy;
01173 int ny = (uid-1) % numy;
01174
01175 pic->Pic(ny, nx)->SetAutoScale(kFALSE);
01176 pic->Pic(ny, nx)->SetRangeY(-20, 255);
01177 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01178 pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape2D[SpaPosMap[uid]]);
01179 }
01180 AddPicture(pic,"MuensterFrankfurt");
01181 }
01182
01183
01184 if (GetPicture("MFShapeE2D")==0) {
01185 TGo4Picture* pic = new TGo4Picture("MFShapeE2D","Electron Pulse Shape 2D");
01186 int numy = numy_2012;
01187 int numx = (USED_SPADIC_2012-1) / numy;
01188 if (numx*numy < (USED_SPADIC_2012 - 1))
01189 numx++;
01190 pic->SetDivision(numy, numx);
01191
01192 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01193 int nx = (uid-1) / numy;
01194 int ny = (uid-1) % numy;
01195
01196 pic->Pic(ny, nx)->SetAutoScale(kFALSE);
01197 pic->Pic(ny, nx)->SetRangeY(-20, 255);
01198 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01199 pic->Pic(ny, nx)->AddObject(fSpadic_el_shape2D[SpaPosMap[uid]]);
01200 }
01201 AddPicture(pic,"MuensterFrankfurt");
01202 }
01203
01204
01205 if (GetPicture("MFSpectrum")==0) {
01206 TGo4Picture* pic = new TGo4Picture("MFSpectrum","Integrated and Clustered Intens for Electrons and Pions");
01207 int numy = (USED_SPADIC_2012-1);
01208 int numx = 2;
01209 pic->SetDivision(numy, numx);
01210
01211 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01212 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01213 int nx = 0;
01214 int ny = (uid-1);
01215
01216 pic->Pic(ny, nx)->AddObject(fSpadic_pi_intens[SpaPosMap[uid]]);
01217 pic->Pic(ny, nx)->AddObject(fSpadic_pi_intens_over[SpaPosMap[uid]]);
01218 pic->Pic(ny, nx)->AddObject(fSpadic_pi_intens_under[SpaPosMap[uid]]);
01219 nx = 1;
01220 ny = (uid-1);
01221 pic->Pic(ny, nx)->AddObject(fSpadic_el_intens[SpaPosMap[uid]]);
01222 pic->Pic(ny, nx)->AddObject(fSpadic_el_intens_over[SpaPosMap[uid]]);
01223 pic->Pic(ny, nx)->AddObject(fSpadic_el_intens_under[SpaPosMap[uid]]);
01224 }
01225 AddPicture(pic,"MuensterFrankfurt");
01226 }
01227
01228 if (GetPicture("MFSpectrumComparison")==0) {
01229 TGo4Picture* pic = new TGo4Picture("MFSpectrumComparison","Integrated and Clustered Intens for Electrons and Pions Comparison");
01230 pic->SetDivision(1, 2);
01231 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01232 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01233 pic->Pic(0, 0)->AddObject(fSpadic_el_intens[SpaPosMap[uid]]);
01234 pic->Pic(0, 1)->AddObject(fSpadic_pi_intens[SpaPosMap[uid]]);
01235 }
01236 AddPicture(pic,"MuensterFrankfurt");
01237 }
01238
01239
01240 if (GetPicture("MFInputSpadics")==0) {
01241 TGo4Picture* pic = new TGo4Picture("MFInputSpadics", "Input: MSFF Superposition of all shapes");
01242 int numy = numy_2012;
01243 int numx = (USED_SPADIC_2012-1) / numy;
01244 if (numx*numy < (USED_SPADIC_2012 - 1))
01245 numx++;
01246 pic->SetDivision(numy, numx);
01247
01248 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01249 int nx = (uid-1) / numy;
01250 int ny = (uid-1) % numy;
01251
01252 pic->Pic(ny, nx)->SetAutoScale(kFALSE);
01253 pic->Pic(ny, nx)->SetRangeY(-20, 255);
01254 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01255 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++)
01256 pic->Pic(ny, nx)->AddObject(fSpadic_input[SpaPosMap[uid]][ch]);
01257 }
01258 AddPicture(pic,"MuensterFrankfurt");
01259 }
01260
01261
01262 if (GetPicture("MFOutputSpadics")==0) {
01263 TGo4Picture* pic = new TGo4Picture("MFOutputSpadics", "Output: MSFF Superposition of all shapes");
01264 int numy = numy_2012;
01265 int numx = (USED_SPADIC_2012-1) / numy;
01266 if (numx*numy < (USED_SPADIC_2012 - 1))
01267 numx++;
01268 pic->SetDivision(numy, numx);
01269
01270 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01271 int nx = (uid-1) / numy;
01272 int ny = (uid-1) % numy;
01273
01274 pic->Pic(ny, nx)->SetAutoScale(kFALSE);
01275 pic->Pic(ny, nx)->SetRangeY(-20, 255);
01276 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01277 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01278 pic->Pic(ny, nx)->AddObject(fSpadic_output[SpaPosMap[uid]][ch]);
01279
01280 }
01281 }
01282 AddPicture(pic,"MuensterFrankfurt");
01283 }
01284
01285
01286 if (GetPicture("MFSpadicPRF")==0) {
01287 TGo4Picture* pic = new TGo4Picture("MFSpadicPRF", "PRF for noise correction quality test MF");
01288 int numy = numy_2012;
01289 int numx = (USED_SPADIC_2012-1) / numy;
01290 if (numx*numy < (USED_SPADIC_2012 - 1))
01291 numx++;
01292 pic->SetDivision(numy, numx);
01293
01294 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01295 int nx = (uid-1) / numy;
01296 int ny = (uid-1) % numy;
01297 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01298 pic->Pic(ny, nx)->AddObject(fSpadic_PRFMF[SpaPosMap[uid]]);
01299 }
01300 AddPicture(pic,"MuensterFrankfurt");
01301 }
01302
01303
01304 if (GetPicture("MFSpadicRecPos")==0) {
01305 TGo4Picture* pic = new TGo4Picture("MFSpadicRecPos", "PRF based position reconstruction");
01306 int numy = numy_2012;
01307 int numx = (USED_SPADIC_2012-1) / numy;
01308 if (numx*numy < (USED_SPADIC_2012 - 1))
01309 numx++;
01310 pic->SetDivision(numy, numx);
01311
01312 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01313 int nx = (uid-1) / numy;
01314 int ny = (uid-1) % numy;
01315 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01316 pic->Pic(ny, nx)->AddObject(fSpadic_recoPos[SpaPosMap[uid]]);
01317 }
01318 AddPicture(pic,"MuensterFrankfurt");
01319 }
01320
01321
01322 if (GetPicture("MFStatistics")==0) {
01323 TGo4Picture* pic = new TGo4Picture("MFStatistics", "Beam and Chamber Statistics");
01324 int numy = numy_2012;
01325 int numx = (USED_SPADIC_2012-1) / numy;
01326 if (numx*numy < (USED_SPADIC_2012 - 1))
01327 numx++;
01328 pic->SetDivision(numy, numx);
01329
01330 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01331 int nx = (uid-1) / numy;
01332 int ny = (uid-1) % numy;
01333 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01334 pic->Pic(ny, nx)->AddObject(fSpadic_statistics[SpaPosMap[uid]]);
01335 }
01336 AddPicture(pic,"MuensterFrankfurt");
01337 }
01338
01339 if (GetPicture("MFSpadicCorrMatrixdist")==0) {
01340 TGo4Picture* pic = new TGo4Picture("MFSpadicCorrMatrixdist", "Distribution of correlation matrix values, for noise analysis");
01341 int numy = USED_SPADIC_2012;
01342 int numx = NUM_SPADIC_CHA;
01343 pic->SetDivision(numy, numx);
01344 int nx = 0;
01345 int ny = 0;
01346 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01347 ny = uid-1;
01348 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01349 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01350 nx = ch;
01351 pic->Pic(ny, nx)->SetLogScale(2,1);
01352 pic->Pic(ny, nx)->AddObject(fSpadic_CorrMatrix[SpaPosMap[uid]][ch]);
01353 pic->Pic(ny, nx)->AddCondition(fSpadic_corrMatrixWindow[SpaPosMap[uid]][ch]);
01354 }
01355 }
01356 AddPicture(pic,"MuensterFrankfurt");
01357 }
01358
01359 if (GetPicture("MFSpadicCorrMatrix_hitTime")==0) {
01360 TGo4Picture* pic = new TGo4Picture("MFSpadicCorrMatrix_hitTime", "Distribution of correlation matrix values vs. hit time, for noise analysis");
01361 int numy = USED_SPADIC_2012;
01362 int numx = NUM_SPADIC_CHA;
01363 pic->SetDivision(numy, numx);
01364 int nx = 0;
01365 int ny = 0;
01366 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01367 ny = uid-1;
01368 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01369 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01370 nx = ch;
01371 pic->Pic(ny, nx)->SetLogScale(2,1);
01372 pic->Pic(ny, nx)->AddObject(fSpadic_CorrMatrix_hitTime[SpaPosMap[uid]][ch]);
01373
01374 }
01375 }
01376 AddPicture(pic,"MuensterFrankfurt");
01377 }
01378
01379 if (GetPicture("MFSpadicCorrMatrix_maxAmpl")==0) {
01380 TGo4Picture* pic = new TGo4Picture("MFSpadicCorrMatrix_maxAmpl", "Distribution of correlation matrix values vs. max. amplitude, for noise analysis");
01381 int numy = USED_SPADIC_2012;
01382 int numx = NUM_SPADIC_CHA;
01383 pic->SetDivision(numy, numx);
01384 int nx = 0;
01385 int ny = 0;
01386 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01387 ny = uid-1;
01388 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01389 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01390 nx = ch;
01391 pic->Pic(ny, nx)->SetLogScale(2,1);
01392 pic->Pic(ny, nx)->AddObject(fSpadic_CorrMatrix_maxAmpl[SpaPosMap[uid]][ch]);
01393
01394 }
01395 }
01396 AddPicture(pic,"MuensterFrankfurt");
01397 }
01398
01399
01400 if (GetPicture("MFSpadicADCdist")==0) {
01401 TGo4Picture* pic = new TGo4Picture("MFSpadicADCdist", "Distribution of ADC values, for noise analysis");
01402 int numy = numy_2012;
01403 int numx = (USED_SPADIC_2012-1) / numy;
01404 if (numx*numy < (USED_SPADIC_2012 - 1))
01405 numx++;
01406 pic->SetDivision(numy, numx);
01407
01408 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01409 int nx = (uid-1) / numy;
01410 int ny = (uid-1) % numy;
01411 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01412 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++)
01413 pic->Pic(ny, nx)->AddObject(fSpadic_ADCdistMF[SpaPosMap[uid]][ch]);
01414 }
01415 AddPicture(pic,"MuensterFrankfurt");
01416 }
01417
01418
01419 if (GetPicture("MFSpadicNoiseDist")==0) {
01420 TGo4Picture* pic = new TGo4Picture("MFSpadicNoiseDist", "Noise-Distribution (RMS) of ADC distribution");
01421 int numy = numy_2012;
01422 int numx = (USED_SPADIC_2012-1) / numy;
01423 if (numx*numy < (USED_SPADIC_2012 - 1))
01424 numx++;
01425 pic->SetDivision(numy, numx);
01426
01427 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01428 int nx = (uid-1) / numy;
01429 int ny = (uid-1) % numy;
01430 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01431 pic->Pic(ny, nx)->AddObject(fSpadic_NoiseDistMF[SpaPosMap[uid]]);
01432 }
01433 AddPicture(pic,"MuensterFrankfurt");
01434 }
01435
01436
01437 if (GetPicture("MFSpadicNoiseDist2D")==0) {
01438 TGo4Picture* pic = new TGo4Picture("MFSpadicNoiseDist2D", "Noise-Distribution (RMS) of ADC distribution 2D");
01439 int numy = numy_2012;
01440 int numx = (USED_SPADIC_2012-1) / numy;
01441 if (numx*numy < (USED_SPADIC_2012 - 1))
01442 numx++;
01443 pic->SetDivision(numy, numx);
01444
01445 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01446 int nx = (uid-1) / numy;
01447 int ny = (uid-1) % numy;
01448 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01449 pic->Pic(ny, nx)->AddObject(fSpadic_NoiseDist2DMF[SpaPosMap[uid]]);
01450 }
01451 AddPicture(pic,"MuensterFrankfurt");
01452 }
01453
01454
01455 if (GetPicture("MFSpadicPedePos")==0) {
01456 TGo4Picture* pic = new TGo4Picture("MFSpadicPedePos", "Pedestal Position (Mean) of ADC distribution");
01457 int numy = numy_2012;
01458 int numx = (USED_SPADIC_2012-1) / numy;
01459 if (numx*numy < (USED_SPADIC_2012 - 1))
01460 numx++;
01461 pic->SetDivision(numy, numx);
01462
01463 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01464 int nx = (uid-1) / numy;
01465 int ny = (uid-1) % numy;
01466 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01467 pic->Pic(ny, nx)->AddObject(fSpadic_PedelPosMF[SpaPosMap[uid]]);
01468 }
01469 AddPicture(pic,"MuensterFrankfurt");
01470 }
01471
01472
01473 if (GetPicture("MFSpadicPedePos2D")==0) {
01474 TGo4Picture* pic = new TGo4Picture("MFSpadicPedePos2D", "Pedestal Position (Mean) of ADC distribution 2D");
01475 int numy = numy_2012;
01476 int numx = (USED_SPADIC_2012-1) / numy;
01477 if (numx*numy < (USED_SPADIC_2012 - 1))
01478 numx++;
01479 pic->SetDivision(numy, numx);
01480
01481 for (UInt_t uid = 1; uid < USED_SPADIC_2012; uid++) {
01482 int nx = (uid-1) / numy;
01483 int ny = (uid-1) % numy;
01484 if (TSpadicEvent::ConfigSpadics[SpaPosMap[uid]] == 0) continue;
01485 pic->Pic(ny, nx)->AddObject(fSpadic_PedelPos2DMF[SpaPosMap[uid]]);
01486 }
01487 AddPicture(pic,"MuensterFrankfurt");
01488 }
01489
01490 if (GetPicture("TRD_Gas")==0) {
01491 TGo4Picture* pic = new TGo4Picture("TRD_Gas", "");
01492 pic->SetDivision(2, 1);
01493 pic->Pic(0, 0)->SetAutoScale(kFALSE);
01494 pic->Pic(0, 0)->SetRangeY(0, 15);
01495 pic->Pic(0, 0)->AddObject(fEpics_TrdGasFlowMonitor);
01496 pic->Pic(1, 0)->SetAutoScale(kFALSE);
01497 pic->Pic(1, 0)->SetRangeY(0, 3300);
01498 pic->Pic(1, 0)->AddObject(fEpics_TrdIntegGasFlowMonitor);
01499 AddPicture(pic,"MuensterEPICS");
01500 }
01501
01502 if (GetPicture("HV_LV")==0) {
01503 TGo4Picture* pic = new TGo4Picture("HV_LV", "HV: left: Drift - right: Anode -- LV: left: Spadic - right: Susibo");
01504
01505 int numx = 4;
01506 int numy = MSTRDNUM-1;
01507 pic->SetDivision(numy, numx);
01508
01509 for (Int_t i = 1; i < MSTRDNUM; i++) {
01510
01511 pic->Pic(0, i-1)->SetAutoScale(kFALSE);
01512 pic->Pic(0, i-1)->SetRangeY(-40, 800);
01513 pic->Pic(0, i-1)->AddObject(fEpicsMSTRD_DriftU[i]);
01514 pic->Pic(0, i-1)->AddObject(fEpicsMSTRD_DriftI[i]);
01515 pic->Pic(1, i-1)->SetAutoScale(kFALSE);
01516 pic->Pic(1, i-1)->SetRangeY(-100, 2200);
01517 pic->Pic(1, i-1)->AddObject(fEpicsMSTRD_AnodeU[i]);
01518 pic->Pic(1, i-1)->AddObject(fEpicsMSTRD_AnodeI[i]);
01519
01520 pic->Pic(2, i-1)->SetAutoScale(kFALSE);
01521 pic->Pic(2, i-1)->SetRangeY(-0.2, 6);
01522 pic->Pic(2, i-1)->AddObject(fEpicsMSTRD_SpaU[i]);
01523 pic->Pic(2, i-1)->AddObject(fEpicsMSTRD_SpaI[i]);
01524 pic->Pic(3, i-1)->SetAutoScale(kFALSE);
01525 pic->Pic(3, i-1)->SetRangeY(-0.2, 6);
01526 pic->Pic(3, i-1)->AddObject(fEpicsMSTRD_SusU[i]);
01527 pic->Pic(3, i-1)->AddObject(fEpicsMSTRD_SusI[i]);
01528 }
01529 AddPicture(pic,"MuensterEPICS");
01530 }
01531
01532 if (GetPicture("Mpod Temperatures")==0) {
01533 TGo4Picture* pic = new TGo4Picture("Mpod Temperatures", "Temperature of Mpod modules");
01534 pic->SetDivision(5, 2);
01535 pic->Pic(0, 0)->SetAutoScale(kFALSE);
01536 pic->Pic(0, 0)->SetRangeY(0, 70);
01537 pic->Pic(0, 0)->AddObject(fEpicsMSTRD_T[0]);
01538 pic->Pic(1, 0)->SetAutoScale(kFALSE);
01539 pic->Pic(1, 0)->SetRangeY(0, 70);
01540 pic->Pic(1, 0)->AddObject(fEpicsMSTRD_T[1]);
01541 pic->Pic(2, 0)->SetAutoScale(kFALSE);
01542 pic->Pic(2, 0)->SetRangeY(0, 70);
01543 pic->Pic(2, 0)->AddObject(fEpicsMSTRD_T[2]);
01544 pic->Pic(3, 0)->SetAutoScale(kFALSE);
01545 pic->Pic(3, 0)->SetRangeY(0, 70);
01546 pic->Pic(3, 0)->AddObject(fEpicsMSTRD_T[3]);
01547 pic->Pic(4, 0)->SetAutoScale(kFALSE);
01548 pic->Pic(4, 0)->SetRangeY(0, 70);
01549 pic->Pic(4, 0)->AddObject(fEpicsMSTRD_T[4]);
01550 pic->Pic(0, 1)->SetAutoScale(kFALSE);
01551 pic->Pic(0, 1)->SetRangeY(0, 70);
01552 pic->Pic(0, 1)->AddObject(fEpicsMSTRD_T[5]);
01553 pic->Pic(1, 1)->SetAutoScale(kFALSE);
01554 pic->Pic(1, 1)->SetRangeY(0, 70);
01555 pic->Pic(1, 1)->AddObject(fEpicsMSTRD_T[6]);
01556 pic->Pic(2, 1)->SetAutoScale(kFALSE);
01557 pic->Pic(2, 1)->SetRangeY(0, 70);
01558 pic->Pic(2, 1)->AddObject(fEpicsMSTRD_T[7]);
01559 pic->Pic(3, 1)->SetAutoScale(kFALSE);
01560 pic->Pic(3, 1)->SetRangeY(0, 70);
01561 pic->Pic(3, 1)->AddObject(fEpicsMSTRD_T[8]);
01562 pic->Pic(4, 1)->SetAutoScale(kFALSE);
01563 pic->Pic(4, 1)->SetRangeY(0, 70);
01564 pic->Pic(4, 1)->AddObject(fEpicsMSTRD_T[9]);
01565 AddPicture(pic,"MuensterEPICS");
01566 }
01567
01568 if (GetPicture("Beam_Monitor_HV")==0) {
01569 TGo4Picture* pic = new TGo4Picture("Beam_Monitor_HV", "Beam_Monitor_HV");
01570 pic->SetDivision(5, 2);
01571 pic->Pic(0, 0)->SetAutoScale(kFALSE);
01572 pic->Pic(0, 0)->SetRangeY(-100, 3000);
01573 pic->Pic(0, 0)->AddObject(fEpics_MonitorU[0]);
01574 pic->Pic(0, 0)->AddObject(fEpics_MonitorI[0]);
01575 pic->Pic(0, 1)->SetAutoScale(kFALSE);
01576 pic->Pic(0, 1)->SetRangeY(-100, 3000);
01577 pic->Pic(0, 1)->AddObject(fEpics_MonitorU[1]);
01578 pic->Pic(0, 1)->AddObject(fEpics_MonitorI[1]);
01579
01580 pic->Pic(1, 0)->SetAutoScale(kFALSE);
01581 pic->Pic(1, 0)->SetRangeY(-100, 3000);
01582 pic->Pic(1, 0)->AddObject(fEpics_MonitorU[2]);
01583 pic->Pic(1, 0)->AddObject(fEpics_MonitorI[2]);
01584 pic->Pic(1, 1)->SetAutoScale(kFALSE);
01585 pic->Pic(1, 1)->SetRangeY(-100, 3000);
01586 pic->Pic(1, 1)->AddObject(fEpics_MonitorU[3]);
01587 pic->Pic(1, 1)->AddObject(fEpics_MonitorI[3]);
01588
01589 pic->Pic(2, 0)->SetAutoScale(kFALSE);
01590 pic->Pic(2, 0)->SetRangeY(-100, 3000);
01591 pic->Pic(2, 0)->AddObject(fEpics_MonitorU[4]);
01592 pic->Pic(2, 0)->AddObject(fEpics_MonitorI[4]);
01593 pic->Pic(2, 1)->SetAutoScale(kFALSE);
01594 pic->Pic(2, 1)->SetRangeY(-100, 3000);
01595 pic->Pic(2, 1)->AddObject(fEpics_MonitorU[5]);
01596 pic->Pic(2, 1)->AddObject(fEpics_MonitorI[5]);
01597
01598 pic->Pic(3, 0)->SetAutoScale(kFALSE);
01599 pic->Pic(3, 0)->SetRangeY(-100, 3000);
01600 pic->Pic(3, 0)->AddObject(fEpics_MonitorU[6]);
01601 pic->Pic(3, 0)->AddObject(fEpics_MonitorI[6]);
01602 pic->Pic(3, 1)->SetAutoScale(kFALSE);
01603 pic->Pic(3, 1)->SetRangeY(-100, 3000);
01604 pic->Pic(3, 1)->AddObject(fEpics_MonitorU[7]);
01605 pic->Pic(3, 1)->AddObject(fEpics_MonitorI[7]);
01606
01607 pic->Pic(4, 0)->SetAutoScale(kFALSE);
01608 pic->Pic(4, 0)->SetRangeY(-100, 3000);
01609 pic->Pic(4, 0)->AddObject(fEpics_MonitorU[8]);
01610 pic->Pic(4, 0)->AddObject(fEpics_MonitorI[8]);
01611 pic->Pic(4, 1)->SetAutoScale(kFALSE);
01612 pic->Pic(4, 1)->SetRangeY(-100, 3000);
01613 pic->Pic(4, 1)->AddObject(fEpics_MonitorU[9]);
01614 pic->Pic(4, 1)->AddObject(fEpics_MonitorI[9]);
01615 AddPicture(pic,"MuensterEPICS");
01616 }
01617
01618 for (Int_t sl = 0; sl < MPOD00SLOT; sl++) {
01619 TString name;
01620 name.Form("MS_MPOD00_SLOT%02i U I",sl);
01621 if (GetPicture(name)==0) {
01622 TGo4Picture* pic = new TGo4Picture(name,name);
01623 Int_t nCol = Int_t(sqrt(MPOD00CHA) + 0.5);
01624 pic->SetDivision(nCol, nCol);
01625 Int_t iRow(0), iCol(0);
01626 for (Int_t ch = 0; ch < MPOD00CHA; ch++){
01627 if (iCol == nCol) {
01628 iRow++;
01629 iCol = 0;
01630 }
01631 pic->Pic(iRow, iCol)->SetAutoScale(kFALSE);
01632 pic->Pic(iRow, iCol)->SetRangeY(-100, 3000);
01633 pic->Pic(iRow, iCol)->AddObject(fEpicsMSMpod00_Monitor_U[sl][ch]);
01634 pic->Pic(iRow, iCol)->AddObject(fEpicsMSMpod00_Monitor_I[sl][ch]);
01635 iCol++;
01636 }
01637 AddPicture(pic,"MuensterEPICS");
01638 }
01639 }
01640
01641 for (Int_t sl = 0; sl < MPOD01SLOT; sl++) {
01642 TString name;
01643 name.Form("MS_MPOD01_SLOT%02i U I",sl);
01644 if (GetPicture(name)==0) {
01645 TGo4Picture* pic = new TGo4Picture(name,name);
01646 Int_t nCol = Int_t(sqrt(MPOD01CHA) + 0.5);
01647 pic->SetDivision(nCol, nCol);
01648 Int_t iRow(0), iCol(0);
01649 for (Int_t ch = 0; ch < MPOD01CHA; ch++){
01650 if (iCol == nCol) {
01651 iRow++;
01652 iCol = 0;
01653 }
01654 pic->Pic(iRow, iCol)->SetAutoScale(kFALSE);
01655 pic->Pic(iRow, iCol)->SetRangeY(-100, 3000);
01656 pic->Pic(iRow, iCol)->AddObject(fEpicsMSMpod01_Monitor_U[sl][ch]);
01657 pic->Pic(iRow, iCol)->AddObject(fEpicsMSMpod01_Monitor_I[sl][ch]);
01658 iCol++;
01659 }
01660 AddPicture(pic,"MuensterEPICS");
01661 }
01662 }
01663
01664
01665
01666
01667
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678
01679
01680
01681
01682
01683
01684
01685
01686
01687
01688
01689
01690
01691
01692
01693
01694
01695
01696
01697
01698 if (GetPicture("MFCorrelations")==0) {
01699 const UInt_t first_MF_Spadic = 1;
01700 const UInt_t last_MF_Spadic = 12;
01701 Int_t d_MF_Spadic = last_MF_Spadic - first_MF_Spadic + 1;
01702 TGo4Picture* pic = new TGo4Picture("MFCorrelations", "MF Beam and Chamber Correlation");
01703 pic->SetDivision(d_MF_Spadic, d_MF_Spadic);
01704 for (UInt_t sid = first_MF_Spadic; sid <= last_MF_Spadic; sid++) {
01705 if (TSpadicEvent::ConfigSpadics[SpMap[sid]] == 0) continue;
01706 for (UInt_t sid2 = sid; sid2 <= last_MF_Spadic; sid2++) {
01707 if (TSpadicEvent::ConfigSpadics[SpMap[sid2]] == 0) continue;
01708 if (SpMap[sid] <= SpMap[sid2])
01709 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01710 else
01711 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01712 his=GetHistogram(obname.Data());
01713 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(his, "colz");
01714
01715
01716 }
01717 }
01718 AddPicture(pic,"MuensterFrankfurt/2011");
01719 }
01720
01721 if (GetPicture("MFAlignment")==0) {
01722 const UInt_t first_MF_Spadic = 1;
01723 const UInt_t last_MF_Spadic = 12;
01724 Int_t d_MF_Spadic = last_MF_Spadic - first_MF_Spadic + 1;
01725 TGo4Picture* pic = new TGo4Picture("MFAlignment", "MF Beam and Chamber Alignment");
01726 pic->SetDivision(d_MF_Spadic, d_MF_Spadic);
01727 for (UInt_t sid = first_MF_Spadic; sid <= last_MF_Spadic; sid++) {
01728 if (TSpadicEvent::ConfigSpadics[SpMap[sid]] == 0) continue;
01729 for (UInt_t sid2 = sid; sid2 <= last_MF_Spadic; sid2++) {
01730 if (TSpadicEvent::ConfigSpadics[SpMap[sid2]] == 0) continue;
01731 if (SpMap[sid] <= SpMap[sid2])
01732 obname.Form("MuensterFrankfurt/Alignment/Alignment_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01733 else
01734 obname.Form("MuensterFrankfurt/Alignment/Alignment_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01735 his=GetHistogram(obname.Data());
01736 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(his, "colz");
01737 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->SetLogScale(2,1);
01738
01739 }
01740 }
01741 AddPicture(pic,"MuensterFrankfurt/2011");
01742 }
01743
01744 if (GetPicture("MS3Alignment")==0) {
01745 const UInt_t first_MS_Spadic = 1;
01746 const UInt_t last_MS_Spadic = 3;
01747 Int_t d_MS_Spadic = last_MS_Spadic - first_MS_Spadic + 1;
01748 TGo4Picture* pic = new TGo4Picture("MS3Alignment", "MS Beam and Chamber Alignment");
01749 pic->SetDivision(d_MS_Spadic, d_MS_Spadic);
01750 for (UInt_t sid = first_MS_Spadic; sid <= last_MS_Spadic; sid++) {
01751 for (UInt_t sid2 = sid; sid2 <= last_MS_Spadic; sid2++) {
01752 if (SpMap[sid] <= SpMap[sid2])
01753 obname.Form("MuensterFrankfurt/Alignment/Alignment_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01754 else
01755 obname.Form("MuensterFrankfurt/Alignment/Alignment_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01756 his=GetHistogram(obname.Data());
01757 pic->Pic(sid-first_MS_Spadic, sid2-first_MS_Spadic)->AddObject(his, "colz");
01758 pic->Pic(sid-first_MS_Spadic, sid2-first_MS_Spadic)->SetLogScale(2,1);
01759
01760 }
01761 }
01762 AddPicture(pic,"MuensterFrankfurt/2012");
01763 }
01764
01765
01766 if (GetPicture("MS3Correlations")==0) {
01767 const UInt_t first_M3_Spadic = 1;
01768 const UInt_t last_M3_Spadic = 3;
01769 Int_t d_M3_Spadic = last_M3_Spadic - first_M3_Spadic + 1;
01770 TGo4Picture* pic = new TGo4Picture("MS3Correlations", "MS 3 Beam and Chamber Correlation");
01771 pic->SetDivision(d_M3_Spadic, d_M3_Spadic);
01772 for (UInt_t sid = first_M3_Spadic; sid <= last_M3_Spadic; sid++) {
01773 if (TSpadicEvent::ConfigSpadics[SpMap[sid]] == 0) continue;
01774 for (UInt_t sid2 = sid; sid2 <= last_M3_Spadic; sid2++) {
01775 if (TSpadicEvent::ConfigSpadics[SpMap[sid2]] == 0) continue;
01776 if (SpMap[sid] <= SpMap[sid2])
01777 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01778 else
01779 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01780 his=GetHistogram(obname.Data());
01781 pic->Pic(sid-first_M3_Spadic, sid2-first_M3_Spadic)->AddObject(his, "colz");
01782
01783
01784 }
01785 }
01786 AddPicture(pic,"MuensterFrankfurt/2012");
01787 }
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802
01803
01804
01805
01806
01807
01808
01809
01810
01811
01812
01813
01814
01815
01816
01817
01818
01819
01820
01821
01822
01823
01824
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834
01835
01836
01837
01838
01839
01840
01841
01842
01843
01844
01845
01846
01847
01848
01849
01850
01851
01852
01853
01854
01855
01856
01857
01858
01859
01860
01861 if (GetPicture("MS3TopShapeRatio")==0) {
01862 const UInt_t first_MF_Spadic = 1;
01863 const UInt_t last_MF_Spadic = 3;
01864 Int_t d_MF_Spadic = last_MF_Spadic - first_MF_Spadic + 1;
01865 TGo4Picture* pic = new TGo4Picture("MS3TopShapeRatio", "MS 3 top Signal Shape Ratio");
01866 pic->SetDivision(d_MF_Spadic-1, d_MF_Spadic-1);
01867 for (UInt_t sid = first_MF_Spadic; sid <= last_MF_Spadic; sid++) {
01868 for (UInt_t sid2 = sid; sid2 <= last_MF_Spadic; sid2++) {
01869 if (sid == sid2) continue;
01870
01871 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->SetAutoScale(kFALSE);
01872 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->SetRangeY(-1, 3);
01873
01874 if (SpMap[sid] <= SpMap[sid2])
01875 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", SpMap[sid], SpMap[sid], SpMap[sid2]);
01876 else
01877 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", SpMap[sid2], SpMap[sid2], SpMap[sid]);
01878 his=GetHistogram(obname.Data());
01879 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->AddObject(his);
01880 if (SpMap[sid] <= SpMap[sid2])
01881 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", SpMap[sid], SpMap[sid], SpMap[sid2]);
01882 else
01883 obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", SpMap[sid2], SpMap[sid2], SpMap[sid]);
01884 his=GetHistogram(obname.Data());
01885
01886 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->AddObject(his);
01887 pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->AddObject(one);
01888
01889 }
01890 }
01891 AddPicture(pic,"MuensterFrankfurt/2012");
01892 }
01893
01894
01895 if (GetPicture("MS8Correlations")==0) {
01896 const UInt_t first_M8_Spadic = 1;
01897 const UInt_t last_M8_Spadic = 8;
01898 Int_t d_M8_Spadic = last_M8_Spadic - first_M8_Spadic + 1;
01899 TGo4Picture* pic = new TGo4Picture("MS8Correlations", "MS 8 Beam and Chamber Correlation");
01900 pic->SetDivision(d_M8_Spadic, d_M8_Spadic);
01901 for (UInt_t sid = first_M8_Spadic; sid <= last_M8_Spadic; sid++) {
01902 if (TSpadicEvent::ConfigSpadics[SpMap[sid]] == 0) continue;
01903 for (UInt_t sid2 = sid; sid2 <= last_M8_Spadic; sid2++) {
01904 if (TSpadicEvent::ConfigSpadics[SpMap[sid2]] == 0) continue;
01905 if (SpMap[sid] <= SpMap[sid2])
01906 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01907 else
01908 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01909 his=GetHistogram(obname.Data());
01910 pic->Pic(sid-first_M8_Spadic, sid2-first_M8_Spadic)->AddObject(his, "colz");
01911
01912
01913 }
01914 }
01915 AddPicture(pic,"MuensterFrankfurt/2011");
01916 }
01917
01918
01919 if (GetPicture("MS336Correlations")==0) {
01920 const UInt_t first_M336_Spadic = 1;
01921 const UInt_t last_M336_Spadic = 4;
01922 Int_t d_M336_Spadic = last_M336_Spadic - first_M336_Spadic + 1;
01923 TGo4Picture* pic = new TGo4Picture("MS336Correlations", "MS 336 Beam and Chamber Correlation");
01924 pic->SetDivision(d_M336_Spadic, d_M336_Spadic);
01925 for (UInt_t sid = first_M336_Spadic; sid <= last_M336_Spadic; sid++) {
01926 if (TSpadicEvent::ConfigSpadics[SpMap[sid]] == 0) continue;
01927 for (UInt_t sid2 = sid; sid2 <= last_M336_Spadic; sid2++) {
01928 if (TSpadicEvent::ConfigSpadics[SpMap[sid2]] == 0) continue;
01929 if (SpMap[sid] <= SpMap[sid2])
01930 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01931 else
01932 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01933 his=GetHistogram(obname.Data());
01934 pic->Pic(sid-first_M336_Spadic, sid2-first_M336_Spadic)->AddObject(his, "colz");
01935
01936
01937 }
01938 }
01939 AddPicture(pic,"MuensterFrankfurt/2011");
01940 }
01941
01942
01943 if (GetPicture("MS444Correlations")==0) {
01944 const UInt_t first_M444_Spadic = 5;
01945 const UInt_t last_M444_Spadic = 8;
01946 Int_t d_M444_Spadic = last_M444_Spadic - first_M444_Spadic + 1;
01947 TGo4Picture* pic = new TGo4Picture("MS444Correlations", "MS 444 Beam and Chamber Correlation");
01948 pic->SetDivision(d_M444_Spadic, d_M444_Spadic);
01949 for (UInt_t sid = first_M444_Spadic; sid <= last_M444_Spadic; sid++) {
01950 if (TSpadicEvent::ConfigSpadics[SpMap[sid]] == 0) continue;
01951 for (UInt_t sid2 = sid; sid2 <= last_M444_Spadic; sid2++) {
01952 if (TSpadicEvent::ConfigSpadics[SpMap[sid2]] == 0) continue;
01953 if (SpMap[sid] <= SpMap[sid2])
01954 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01955 else
01956 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01957 his=GetHistogram(obname.Data());
01958 pic->Pic(sid-first_M444_Spadic, sid2-first_M444_Spadic)->AddObject(his, "colz");
01959
01960
01961 }
01962 }
01963 AddPicture(pic,"MuensterFrankfurt/2011");
01964 }
01965
01966
01967 if (GetPicture("FF2Correlations")==0) {
01968 const UInt_t first_F_Spadic = 4;
01969 const UInt_t last_F_Spadic = 5;
01970 Int_t d_F_Spadic = last_F_Spadic - first_F_Spadic + 1;
01971 TGo4Picture* pic = new TGo4Picture("FF2Correlations", "F Beam and Chamber Correlation");
01972 pic->SetDivision(d_F_Spadic, d_F_Spadic);
01973 for (UInt_t sid = first_F_Spadic; sid <= last_F_Spadic; sid++) {
01974 if (TSpadicEvent::ConfigSpadics[SpMap[sid]] == 0) continue;
01975 for (UInt_t sid2 = sid; sid2 <= last_F_Spadic; sid2++) {
01976 if (TSpadicEvent::ConfigSpadics[SpMap[sid2]] == 0) continue;
01977 if (SpMap[sid] <= SpMap[sid2])
01978 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01979 else
01980 obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01981 his=GetHistogram(obname.Data());
01982 pic->Pic(sid-first_F_Spadic, sid2-first_F_Spadic)->AddObject(his, "colz");
01983
01984
01985 }
01986 }
01987 AddPicture(pic,"MuensterFrankfurt/2012");
01988 }
01989
01990 if (GetPicture("MFSpadicBeamProfile2D")==0) {
01991 TGo4Picture* pic = new TGo4Picture("MFSpadicBeamProfile2D", "MF Spadic Beam Profile 2D");
01992
01993 pic->SetDivision(2, 2);
01994
01995 for (UInt_t uid = 0; uid < 4; uid++) {
01996 int nx = (uid) / 2;
01997 int ny = (uid) % 2;
01998 if (TSpadicEvent::ConfigSpadics[uid] == 0) continue;
01999 pic->Pic(ny, nx)->AddObject(fSpadic_beamProfil[uid]);
02000 }
02001 AddPicture(pic,"MuensterFrankfurt");
02002 }
02003
02004 if (GetPicture("MFSpadicDeltaPos2D")==0) {
02005 TGo4Picture* pic = new TGo4Picture("MFSpadicDeltaPos2D", "MF Spadic delta pos. 2D");
02006
02007 pic->SetDivision(2, 2);
02008
02009 for (UInt_t uid = 0; uid < 4; uid++) {
02010 int nx = (uid) / 2;
02011 int ny = (uid) % 2;
02012 if (TSpadicEvent::ConfigSpadics[uid] == 0) continue;
02013 pic->Pic(ny, nx)->AddObject(fSpadic_deltaPos[uid]);
02014 }
02015 AddPicture(pic,"MuensterFrankfurt");
02016 }
02017
02018 TGo4Log::Info("TTRDMuensterFrankfurtProc: Histograms created");
02019 }
02020
02021 TTRDMuensterFrankfurtProc::~TTRDMuensterFrankfurtProc()
02022 {
02023 }
02024
02025 void TTRDMuensterFrankfurtProc::InitEvent(TGo4EventElement* outevnt)
02026 {
02027
02028
02029
02030 if(fSpadicInputEvent==0)
02031 {
02032 TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent());
02033 if(btevent)
02034 {
02035 fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(btevent->GetSubEvent("MBSCRATE"));
02036 fSpadicInputEvent=dynamic_cast<TSpadicEvent*>(btevent->GetSubEvent("SPADIC"));
02037 fSpadicV10InputEvent=dynamic_cast<TSpadicV10Event*>(btevent->GetSubEvent("SPADICV10"));
02038 fEpicsInputEvent=dynamic_cast<TEpicsEvent*>(btevent->GetSubEvent("EPICS"));
02039 }
02040 else
02041 {
02042 fSpadicInputEvent=dynamic_cast<TSpadicEvent*>(GetInputEvent());
02043
02044 }
02045 if(fSpadicInputEvent==0) {
02046 GO4_STOP_ANALYSIS_MESSAGE("**** TTRDMuensterFrankfurtProc: Fatal error: input event is not a TSpadicEvent!!! STOP GO4");
02047 }
02048 if(fEpicsInputEvent==0) {
02049 Message(2,"**** TBeamMonitorProc: could not find TEpicsEvent!");
02050 }
02051 if(fSpadicV10InputEvent==0) {
02052 Message(2,"**** TBeamMonitorProc: could not find Spadiv V1.0 input Event!");
02053 }
02054
02055 }
02056
02057
02058
02059
02060 if(fOutputEvent==0)
02061 {
02062 TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(outevnt);
02063 if(btevent)
02064 {
02065 fOutputEvent=dynamic_cast<TTRDMuensterFrankfurtEvent*>(btevent->GetSubEvent("TRDMSFFM"));
02066 fHodo1 = dynamic_cast<TFiberHodEvent*>(btevent->GetSubEvent("Hodo1"));
02067 fHodo2 = dynamic_cast<TFiberHodEvent*>(btevent->GetSubEvent("Hodo2"));
02068 fBeamEvent = dynamic_cast<TBeamMonitorEvent*>(btevent->GetSubEvent("BEAM"));
02069 }
02070 else
02071 {
02072 fOutputEvent= dynamic_cast<TTRDMuensterFrankfurtEvent*>(outevnt);
02073 }
02074 if(fOutputEvent==0) {
02075 GO4_STOP_ANALYSIS_MESSAGE("**** TTRDMuensterFrankfurtProc: Fatal error: output event is not a TTRDMuensterFrankfurtEvent!!! STOP GO4");
02076 }
02077 }
02078 }
02079
02080 void TTRDMuensterFrankfurtProc::FinalizeEvent()
02081 {
02082
02083
02084
02085
02086 Bool_t ChMap[MAX_SPADIC];
02087
02088 ChMap[SpMap[2]] = true;
02089 ChMap[SpMap[4]] = true;
02090 ChMap[SpMap[6]] = true;
02091 ChMap[SpMap[8]] = true;
02092
02093 ChMap[SpMap[1]] = false;
02094 ChMap[SpMap[3]] = false;
02095 ChMap[SpMap[5]] = false;
02096 ChMap[SpMap[7]] = false;
02097
02098 ChMap[SpMap[9]] = false;
02099 ChMap[SpMap[10]] = false;
02100 ChMap[SpMap[11]] = false;
02101 ChMap[SpMap[12]] = true;
02102
02103 Int_t PID[MAX_SPADIC] = {8};
02104 Int_t PIDV10[MAX_SPADICV10] = {8};
02105
02106 if(fEpicsInputEvent && fEpicsInputEvent->IsValid())
02107 {
02108
02109 TString varName;
02110 fEpicsTrdGasFlow = fEpicsInputEvent->GetDouble("CBM:TRD:GFM0:Flow");
02111 fEpicsTrdIntegGasFlow = fEpicsInputEvent->GetDouble("CBM:TRD:GFM0:Total");
02112 for (Int_t sl = 0; sl < MPOD00SLOT; sl++) {
02113 for (Int_t ch = 0; ch < MPOD00CHA; ch++) {
02114
02115 varName.Form("CBM:TRD:WIENLV_U%i%02i:vmon",sl,ch);
02116 fEpicsMSMpod00_U[sl][ch] = fEpicsInputEvent->GetDouble(varName.Data());
02117 varName.Form("CBM:TRD:WIENLV_U%i%02i:imon",sl,ch);
02118 fEpicsMSMpod00_I[sl][ch] = fEpicsInputEvent->GetDouble(varName.Data());
02119 }
02120 }
02121 for (Int_t sl = 0; sl < MPOD01SLOT; sl++) {
02122 for (Int_t ch = 0; ch < MPOD01CHA; ch++) {
02123
02124 varName.Form("CBM:TRD:ISEGHV_U%i%02i:vmon",sl,ch);
02125 fEpicsMSMpod01_U[sl][ch] = fEpicsInputEvent->GetDouble(varName.Data());
02126 varName.Form("CBM:TRD:ISEGHV_U%i%02i:imon",sl,ch);
02127 fEpicsMSMpod01_I[sl][ch] = fEpicsInputEvent->GetDouble(varName.Data());
02128 }
02129 }
02130 fEpicsMSTRD_Drift_U[1] = fEpicsMSMpod01_U[2][0];
02131 fEpicsMSTRD_Drift_I[1] = fEpicsMSMpod01_I[2][0];
02132 fEpicsMSTRD_Anode_U[1] = fEpicsMSMpod01_U[3][0];
02133 fEpicsMSTRD_Anode_I[1] = fEpicsMSMpod01_I[3][0];
02134 fEpicsMSTRD_Drift_U[2] = fEpicsMSMpod01_U[2][1];
02135 fEpicsMSTRD_Drift_I[2] = fEpicsMSMpod01_I[2][1];
02136 fEpicsMSTRD_Anode_U[2] = fEpicsMSMpod01_U[3][1];
02137 fEpicsMSTRD_Anode_I[2] = fEpicsMSMpod01_I[3][1];
02138 fEpicsMSTRD_Drift_U[3] = fEpicsMSMpod01_U[2][2];
02139 fEpicsMSTRD_Drift_I[3] = fEpicsMSMpod01_I[2][2];
02140 fEpicsMSTRD_Anode_U[3] = fEpicsMSMpod01_U[3][2];
02141 fEpicsMSTRD_Anode_I[3] = fEpicsMSMpod01_I[3][2];
02142 fEpicsMSTRD_Drift_U[4] = fEpicsMSMpod01_U[2][3];
02143 fEpicsMSTRD_Drift_I[4] = fEpicsMSMpod01_I[2][3];
02144 fEpicsMSTRD_Anode_U[4] = fEpicsMSMpod01_U[3][3];
02145 fEpicsMSTRD_Anode_I[4] = fEpicsMSMpod01_I[3][3];
02146
02147 fEpicsMSTRD_Temp[0] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U000:temp");
02148 fEpicsMSTRD_Temp[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U100:temp");
02149 fEpicsMSTRD_Temp[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U200:temp");
02150 fEpicsMSTRD_Temp[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U300:temp");
02151 fEpicsMSTRD_Temp[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U400:temp");
02152 fEpicsMSTRD_Temp[5] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U500:temp");
02153 fEpicsMSTRD_Temp[6] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U600:temp");
02154 fEpicsMSTRD_Temp[7] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U700:temp");
02155 fEpicsMSTRD_Temp[8] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U800:temp");
02156 fEpicsMSTRD_Temp[9] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U900:temp");
02157
02158 fEpicsMSTRD_Sus_U[1] = fEpicsMSMpod01_U[0][1];
02159 fEpicsMSTRD_Sus_I[1] = fEpicsMSMpod01_I[0][1];
02160 fEpicsMSTRD_Spa_U[1] = fEpicsMSMpod01_U[0][0];
02161 fEpicsMSTRD_Spa_I[1] = fEpicsMSMpod01_I[0][0];
02162 fEpicsMSTRD_Sus_U[2] = fEpicsMSMpod01_U[0][3];
02163 fEpicsMSTRD_Sus_I[2] = fEpicsMSMpod01_I[0][3];
02164 fEpicsMSTRD_Spa_U[2] = fEpicsMSMpod01_U[0][2];
02165 fEpicsMSTRD_Spa_I[2] = fEpicsMSMpod01_I[0][2];
02166 fEpicsMSTRD_Sus_U[3] = fEpicsMSMpod01_U[0][5];
02167 fEpicsMSTRD_Sus_I[3] = fEpicsMSMpod01_I[0][5];
02168 fEpicsMSTRD_Spa_U[3] = fEpicsMSMpod01_U[0][4];
02169 fEpicsMSTRD_Spa_I[3] = fEpicsMSMpod01_I[0][4];
02170 fEpicsMSTRD_Sus_U[4] = fEpicsMSMpod01_U[0][7];
02171 fEpicsMSTRD_Sus_I[4] = fEpicsMSMpod01_I[0][7];
02172 fEpicsMSTRD_Spa_U[4] = fEpicsMSMpod01_U[0][6];
02173 fEpicsMSTRD_Spa_I[4] = fEpicsMSMpod01_I[0][6];
02174
02175 fEpics_Monitor_U[0] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U500:vmon");
02176 fEpics_Monitor_I[0] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U500:imon");
02177 fEpics_Monitor_U[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U501:vmon");
02178 fEpics_Monitor_I[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U501:imon");
02179 fEpics_Monitor_U[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U502:vmon");
02180 fEpics_Monitor_I[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U502:imon");
02181 fEpics_Monitor_U[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U503:vmon");
02182 fEpics_Monitor_I[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U503:imon");
02183 fEpics_Monitor_U[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U504:vmon");
02184 fEpics_Monitor_I[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U504:imon");
02185 fEpics_Monitor_U[5] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U505:vmon");
02186 fEpics_Monitor_I[5] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U505:imon");
02187 fEpics_Monitor_U[6] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U506:vmon");
02188 fEpics_Monitor_I[6] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U506:imon");
02189 fEpics_Monitor_U[7] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U507:vmon");
02190 fEpics_Monitor_I[7] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U507:imon");
02191 fEpics_Monitor_U[8] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U600:vmon");
02192 fEpics_Monitor_I[8] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U600:imon");
02193 fEpics_Monitor_U[9] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U601:vmon");
02194 fEpics_Monitor_I[9] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U601:imon");
02195
02196
02197
02198
02199
02200
02201
02202
02203
02204
02205
02206
02207
02208
02209
02210
02211
02212
02213
02214
02215
02216
02217
02218
02219
02220
02221
02222
02223
02224
02225
02226
02227
02228
02229
02230
02231
02232
02233
02234
02235
02236
02237
02238
02239
02240
02241
02242
02243
02244
02245
02246
02247
02248
02249
02250
02251
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264
02265
02266
02267
02268
02269
02270 }
02271
02272 if(fEpicsInputEvent && fEpicsInputEvent->IsValid()){
02273 Int_t nBin = fEpics_TrdGasFlowMonitor->GetNbinsX();
02274 for (Int_t ibin = 1; ibin <= nBin; ibin++){
02275 if (ibin < nBin) {
02276 fEpics_TrdGasFlowMonitor->SetBinContent(ibin,fEpics_TrdGasFlowMonitor->GetBinContent(ibin + 1));
02277 fEpics_TrdIntegGasFlowMonitor->SetBinContent(ibin,fEpics_TrdIntegGasFlowMonitor->GetBinContent(ibin + 1));
02278 } else {
02279 fEpics_TrdGasFlowMonitor->SetBinContent(ibin,fEpicsTrdGasFlow);
02280 fEpics_TrdIntegGasFlowMonitor->SetBinContent(ibin,fEpicsTrdIntegGasFlow);
02281 }
02282 }
02283 for (Int_t sl = 0; sl < MPOD00SLOT; sl++) {
02284 for (Int_t ch = 0; ch < MPOD00CHA; ch++) {
02285 Int_t nbin = fEpicsMSMpod00_Monitor_U[sl][ch]->GetNbinsX();
02286 for (Int_t ibin = 1; ibin <= nbin; ibin++){
02287 if (ibin < nbin) {
02288 fEpicsMSMpod00_Monitor_U[sl][ch]->SetBinContent(ibin,fEpicsMSMpod00_Monitor_U[sl][ch]->GetBinContent(ibin + 1));
02289 fEpicsMSMpod00_Monitor_I[sl][ch]->SetBinContent(ibin,fEpicsMSMpod00_Monitor_I[sl][ch]->GetBinContent(ibin + 1));
02290 }
02291 else {
02292 fEpicsMSMpod00_Monitor_U[sl][ch]->SetBinContent(ibin,fEpicsMSMpod00_U[sl][ch]);
02293 fEpicsMSMpod00_Monitor_I[sl][ch]->SetBinContent(ibin,fEpicsMSMpod00_I[sl][ch]);
02294 }
02295 }
02296 }
02297 }
02298
02299 for (Int_t sl = 0; sl < MPOD01SLOT; sl++) {
02300 for (Int_t ch = 0; ch < MPOD01CHA; ch++) {
02301 Int_t nbin = fEpicsMSMpod01_Monitor_U[sl][ch]->GetNbinsX();
02302 for (Int_t ibin = 1; ibin <= nbin; ibin++){
02303 if (ibin < nbin) {
02304 fEpicsMSMpod01_Monitor_U[sl][ch]->SetBinContent(ibin,fEpicsMSMpod01_Monitor_U[sl][ch]->GetBinContent(ibin + 1));
02305 fEpicsMSMpod01_Monitor_I[sl][ch]->SetBinContent(ibin,fEpicsMSMpod01_Monitor_I[sl][ch]->GetBinContent(ibin + 1));
02306 }
02307 else {
02308 fEpicsMSMpod01_Monitor_U[sl][ch]->SetBinContent(ibin,fEpicsMSMpod01_U[sl][ch]);
02309 fEpicsMSMpod01_Monitor_I[sl][ch]->SetBinContent(ibin,fEpicsMSMpod01_I[sl][ch] * 1e9 );
02310 }
02311 }
02312 }
02313 }
02314
02315 for (Int_t i = 0; i < 8; i++) {
02316 Int_t nbin = fEpics_MonitorU[i]->GetNbinsX();
02317 for (Int_t ibin = 1; ibin <= nbin; ibin++){
02318 if (ibin < nbin) {
02319 fEpics_MonitorU[i]->SetBinContent(ibin, fEpics_MonitorU[i]->GetBinContent(ibin + 1));
02320 fEpics_MonitorI[i]->SetBinContent(ibin, fEpics_MonitorI[i]->GetBinContent(ibin + 1));
02321 }
02322 else {
02323 fEpics_MonitorU[i]->SetBinContent(ibin, fEpics_Monitor_U[i]);
02324 if (fPar->show_currentSpikes)
02325 fEpics_MonitorI[i]->SetBinContent(ibin, fEpics_Monitor_I[i] * 1e9 );
02326 else
02327 if (fEpics_Monitor_I[i] < 0.5)
02328 fEpics_MonitorI[i]->SetBinContent(ibin, fEpics_Monitor_I[i] * 1e9 );
02329 else
02330 fEpics_MonitorI[i]->SetBinContent(ibin, fEpics_MonitorI[i]->GetBinContent(ibin - 1) );
02331 }
02332 }
02333 }
02334
02335 for (Int_t mstrd = 1; mstrd < MSTRDNUM; mstrd++) {
02336 Int_t nbin = fEpicsMSTRD_AnodeU[mstrd]->GetNbinsX();
02337 for (Int_t ibin = 1; ibin <= nbin; ibin++){
02338 if (ibin < nbin) {
02339 fEpicsMSTRD_DriftU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_DriftU[mstrd]->GetBinContent(ibin + 1));
02340 fEpicsMSTRD_DriftI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_DriftI[mstrd]->GetBinContent(ibin + 1));
02341 fEpicsMSTRD_AnodeU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_AnodeU[mstrd]->GetBinContent(ibin + 1));
02342 fEpicsMSTRD_AnodeI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_AnodeI[mstrd]->GetBinContent(ibin + 1));
02343 fEpicsMSTRD_SpaU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_SpaU[mstrd]->GetBinContent(ibin + 1));
02344 fEpicsMSTRD_SpaI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_SpaI[mstrd]->GetBinContent(ibin + 1));
02345 fEpicsMSTRD_SusU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_SusU[mstrd]->GetBinContent(ibin + 1));
02346 fEpicsMSTRD_SusI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_SusI[mstrd]->GetBinContent(ibin + 1));
02347 if (mstrd == 1){
02348 fEpicsMSTRD_T[0]->SetBinContent(ibin, fEpicsMSTRD_T[0]->GetBinContent(ibin + 1));
02349 fEpicsMSTRD_T[1]->SetBinContent(ibin, fEpicsMSTRD_T[1]->GetBinContent(ibin + 1));
02350 fEpicsMSTRD_T[2]->SetBinContent(ibin, fEpicsMSTRD_T[2]->GetBinContent(ibin + 1));
02351 fEpicsMSTRD_T[3]->SetBinContent(ibin, fEpicsMSTRD_T[3]->GetBinContent(ibin + 1));
02352 fEpicsMSTRD_T[4]->SetBinContent(ibin, fEpicsMSTRD_T[4]->GetBinContent(ibin + 1));
02353 fEpicsMSTRD_T[5]->SetBinContent(ibin, fEpicsMSTRD_T[5]->GetBinContent(ibin + 1));
02354 fEpicsMSTRD_T[6]->SetBinContent(ibin, fEpicsMSTRD_T[6]->GetBinContent(ibin + 1));
02355 fEpicsMSTRD_T[7]->SetBinContent(ibin, fEpicsMSTRD_T[7]->GetBinContent(ibin + 1));
02356 fEpicsMSTRD_T[8]->SetBinContent(ibin, fEpicsMSTRD_T[8]->GetBinContent(ibin + 1));
02357 fEpicsMSTRD_T[9]->SetBinContent(ibin, fEpicsMSTRD_T[9]->GetBinContent(ibin + 1));
02358 }
02359 }
02360 else {
02361
02362 fEpicsMSTRD_DriftU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Drift_U[mstrd]);
02363 if (fPar->show_currentSpikes)
02364 fEpicsMSTRD_DriftI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Drift_I[mstrd] * 1e9);
02365 else
02366 if (fEpicsMSTRD_Drift_I[mstrd] < 0.5)
02367 fEpicsMSTRD_DriftI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Drift_I[mstrd] * 1e9);
02368
02369 fEpicsMSTRD_AnodeU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Anode_U[mstrd]);
02370 if (fPar->show_currentSpikes)
02371 fEpicsMSTRD_AnodeI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Anode_I[mstrd] * 1e9);
02372 else
02373 if (fEpicsMSTRD_Anode_I[mstrd] < 0.5)
02374 fEpicsMSTRD_AnodeI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Anode_I[mstrd] * 1e9);
02375
02376 fEpicsMSTRD_SpaU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Spa_U[mstrd]);
02377 fEpicsMSTRD_SpaI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Spa_I[mstrd] * 10);
02378 fEpicsMSTRD_SusU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Sus_U[mstrd]);
02379 fEpicsMSTRD_SusI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Sus_I[mstrd]);
02380 if (mstrd == 1){
02381 fEpicsMSTRD_T[0]->SetBinContent(ibin, fEpicsMSTRD_Temp[0]);
02382 fEpicsMSTRD_T[1]->SetBinContent(ibin, fEpicsMSTRD_Temp[1]);
02383 fEpicsMSTRD_T[2]->SetBinContent(ibin, fEpicsMSTRD_Temp[2]);
02384 fEpicsMSTRD_T[3]->SetBinContent(ibin, fEpicsMSTRD_Temp[3]);
02385 fEpicsMSTRD_T[4]->SetBinContent(ibin, fEpicsMSTRD_Temp[4]);
02386 fEpicsMSTRD_T[5]->SetBinContent(ibin, fEpicsMSTRD_Temp[5]);
02387 fEpicsMSTRD_T[6]->SetBinContent(ibin, fEpicsMSTRD_Temp[6]);
02388 fEpicsMSTRD_T[7]->SetBinContent(ibin, fEpicsMSTRD_Temp[7]);
02389 fEpicsMSTRD_T[8]->SetBinContent(ibin, fEpicsMSTRD_Temp[8]);
02390 fEpicsMSTRD_T[9]->SetBinContent(ibin, fEpicsMSTRD_Temp[9]);
02391 }
02392 }
02393 }
02394 }
02395
02396
02397 for (Int_t irich = 1; irich < RICHNUM; irich++) {
02398 Int_t nbin = fEpics_RichU[irich]->GetNbinsX();
02399 for (Int_t ibin = 1; ibin <= nbin; ibin++){
02400 if (ibin < nbin) {
02401 fEpics_RichU[irich]->SetBinContent(ibin, fEpics_RichU[irich]->GetBinContent(ibin + 1));
02402 fEpics_RichI[irich]->SetBinContent(ibin, fEpics_RichI[irich]->GetBinContent(ibin + 1));
02403 } else {
02404
02405 fEpics_RichU[irich]->SetBinContent(ibin, fEpics_Rich_U[irich]);
02406 if (fPar->show_currentSpikes)
02407 fEpics_RichI[irich]->SetBinContent(ibin, fEpics_Rich_I[irich] * 1e7);
02408 else
02409 if (fEpics_Rich_I[irich] < 0.5)
02410 fEpics_RichI[irich]->SetBinContent(ibin, fEpics_Rich_I[irich] * 1e7);
02411 }
02412 }
02413 }
02414 }
02415
02416
02417
02418
02419
02420
02421 if(fCrateInputEvent && fCrateInputEvent->IsPulser()) {
02422
02423
02424
02425
02426 return;
02427 }
02428
02429 if (fBeamEvent) {
02430
02431
02433
02434 Int_t xNrFiberHod1Cluster(0); Int_t xNrFiberHod2Cluster(0);
02435 Int_t yNrFiberHod1Cluster(0); Int_t yNrFiberHod2Cluster(0);
02436 Double_t xPosFiberHod1(0); Double_t xPosFiberHod2(0);
02437 Double_t yPosFiberHod1(0); Double_t yPosFiberHod2(0);
02438 if (fHodo1 && (fHodo1->NumHits()>0)) {
02439 xNrFiberHod1Cluster = fHodo1->NumHits();
02440 yNrFiberHod1Cluster = fHodo1->NumHits();
02441 xPosFiberHod1 = fHodo1->Hit(0).X;
02442 yPosFiberHod1 = fHodo1->Hit(0).Y;
02443
02444 }
02445
02446
02447 if (fHodo2 && (fHodo2->NumHits()>0)) {
02448 xNrFiberHod2Cluster = fHodo2->NumHits();
02449 yNrFiberHod2Cluster = fHodo2->NumHits();
02450 xPosFiberHod2 = fHodo2->Hit(0).X;
02451 yPosFiberHod2 = fHodo2->Hit(0).Y;
02452 }
02453 else {
02454
02455 }
02456 if (fHodo1 && (fHodo1->NumHits()>0) && fHodo2 && (fHodo2->NumHits()>0)){
02457 fFiberHod1_2_x_alignment->Fill(xPosFiberHod1,xPosFiberHod2);
02458 fFiberHod1_2_y_alignment->Fill(yPosFiberHod1,yPosFiberHod2);
02459
02460 fFiberHod1_2_dx_vs_x_alignment->Fill(xPosFiberHod1,xPosFiberHod2-xPosFiberHod1);
02461 fFiberHod1_2_dy_vs_y_alignment->Fill(yPosFiberHod1,yPosFiberHod2-yPosFiberHod1);
02462 }
02464
02465
02466
02467
02468 if (fSpadicV10InputEvent) {
02469
02470 for (UInt_t sid = 0; sid < MAX_SPADICV10; sid++) {
02471 TSpadicV10Data* theSpadicOne =
02472 dynamic_cast<TSpadicV10Data*>(fSpadicV10InputEvent->getEventElement(
02473 sid));
02474 if (theSpadicOne == 0)
02475 continue;
02476 if (!theSpadicOne->IsValid())
02477 continue;
02478
02479
02480
02481
02482 if (!fBeamEvent->fIsElectron && !fBeamEvent->fIsPion)
02483 PIDV10[sid] = 0;
02484 if (fBeamEvent->fIsPion)
02485 PIDV10[sid] = -1;
02486 if (fBeamEvent->fIsElectron)
02487 PIDV10[sid] = 1;
02488
02489
02490
02491 for (UInt_t MessageNr = 0;
02492 MessageNr < theSpadicOne->fExtMessages.size(); MessageNr++) {
02493
02494
02495 TSpadicV10MessageExtended msg = theSpadicOne->fExtMessages.at(
02496 MessageNr);
02497 if (msg.GetMessageType() != sp605::MSG_HIT)
02498 continue;
02499
02500
02501 UInt_t spadicNr = msg.GetSpadicNumber();
02502 UInt_t channel = msg.GetFullChNum();
02503 if(spadicNr>MAX_SPADICV10 || channel>MAX_SPADICV10CHANNELS)
02504 {
02505 std::cout<<"Spadic 1.0 indices in message out of range: ("<<spadicNr<<","<<channel<<"), skip message" << std::endl;
02506 continue;
02507 }
02508
02509
02510
02511 sp605::Message & data = msg.GetSpadicV10Message();
02512 for (UInt_t bin = 0; bin < data.getTraceSize(); bin++) {
02513 int16_t val = data.getTrace(bin);
02514 fSpadicV10_input[spadicNr][channel]->SetBinContent(bin + 1, (int) val);
02515
02516
02517
02518
02520 }
02521 }
02522 }
02523 }
02524
02525
02527
02528 fSpadic_efficiency->Fill(0);
02529 Double_t rawData[NUM_SPADIC_CHA][SPADIC_TRACE_SIZE] = {{0.0}};
02530 Double_t cleanData[NUM_SPADIC_CHA][SPADIC_TRACE_SIZE] = {{0.0}};
02531 Double_t intensCh[NUM_SPADIC_CHA] = {0};
02532
02533 Int_t maxChCorr[MAX_SPADIC] = {-1};
02534 Double_t dxPosCorr[MAX_SPADIC] = {0};
02535 Bool_t overnflowtingTB[NUM_SPADIC_CHA][SPADIC_TRACE_SIZE] = {{false}};
02536 Double_t intens[MAX_SPADIC] = {0};
02537 Double_t rowIntens[MAX_SPADIC] = {0};
02538
02539 for (UInt_t sid = 1; sid < MAX_SPADIC; sid++)
02540 {
02541 TSpadicData* theSpadic=dynamic_cast<TSpadicData*>(fSpadicInputEvent->getEventElement(sid));
02542 if(theSpadic==0) continue;
02543 if(!theSpadic->IsValid()) continue;
02544
02545 if (!fBeamEvent->fIsElectron && !fBeamEvent->fIsPion)
02546 PID[sid] = 0;
02547 if (fBeamEvent->fIsPion)
02548 PID[sid] = -1;
02549 if (fBeamEvent->fIsElectron)
02550 PID[sid] = 1;
02551
02552 if (fPar->reSortChannel){
02553 if (fPar->ChMap[sid]) {
02554 Double_t tempSpadic[NUM_SPADIC_CHA][SPADIC_TRACE_SIZE];
02555 for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
02556 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02557 tempSpadic[ch][bin] = theSpadic->fSpadicCompensated[ch][bin];
02558 }
02559 }
02560 for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
02561 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02562
02563 theSpadic->fSpadicCompensated[ch][bin] = tempSpadic[UInt_t((NUM_SPADIC_CHA-1)-ch)][bin];
02564 }
02565 }
02566 }
02567 }
02568
02569
02570 Bool_t overflow = false;
02571 Bool_t undershoot = false;
02572 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
02573 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02574 if (theSpadic->fSpadicOverflows[ch][bin]){
02575 overflow = true;
02576 overnflowtingTB[ch][bin] = true;
02577 }
02578 if (theSpadic->fSpadicUndershoots[ch][bin]){
02579 undershoot = true;
02580 }
02581 }
02582 }
02583
02584 if (!fPar->Use_OverflowEvents && overflow)
02585 continue;
02586
02587 Int_t maxCh(-1), maxSignal(0);
02588 Double_t baseline(0.0), signal(0.0);
02589 for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
02590 baseline = 0.0;
02591 signal = 0.0;
02592
02593
02594 if (fPar->Run_PedestleCorrection) {
02595 for (unsigned bin = 0; (Int_t)bin <= fPar->pedestalTB; bin++) {
02596 if (fPar->Run_SimpleNoiseReduction)
02597 baseline += theSpadic->fSpadicCompensated[ch][bin];
02598 else
02599 baseline += theSpadic->fSpadicPulse[ch][bin];
02600 }
02601 if (fPar->pedestalTB > 0 && fPar->pedestalTB < SPADIC_TRACE_SIZE)
02602 baseline /= (Double_t)fPar->pedestalTB;
02603 else
02604 baseline = 0.0;
02605 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02606 if (fPar->Run_SimpleNoiseReduction)
02607 rawData[ch][bin] = theSpadic->fSpadicCompensated[ch][bin];
02608 else
02609 rawData[ch][bin] = theSpadic->fSpadicPulse[ch][bin];
02610 }
02611 }
02613 Float_t pedestal[NUM_SPADIC_CHA] = {0.0};
02614 if (!theSpadic->fSpadicSignalCh[ch]){
02615 for (UInt_t bin = 0; bin < SPADIC_TRACE_SIZE-1; bin++){
02616 if (fPar->Run_SimpleNoiseReduction)
02617 fSpadic_input[sid][ch]->SetBinContent(bin + 1,theSpadic->fSpadicCompensated[ch][bin]);
02618 else
02619 fSpadic_input[sid][ch]->SetBinContent(bin + 1,theSpadic->fSpadicPulse[ch][bin]);
02620 pedestal[ch] += rawData[ch][bin];
02621 fSpadic_ADCdistMF[sid][ch]->Fill(rawData[ch][bin]);
02622 }
02623 pedestal[ch] /= SPADIC_TRACE_SIZE;
02624 fSpadic_PedelPos2DMF[sid]->Fill(ch,pedestal[ch]);
02625 }
02626 fSpadic_NoiseDistMF[sid]->SetBinContent(ch+1, fSpadic_ADCdistMF[sid][ch]->GetRMS());
02627 fSpadic_NoiseDist2DMF[sid]->Fill(ch, fSpadic_ADCdistMF[sid][ch]->GetRMS());
02628 fSpadic_PedelPosMF[sid]->SetBinContent(ch+1, fSpadic_ADCdistMF[sid][ch]->GetMean());
02629
02631 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02632 rawData[ch][bin] -= baseline;
02633 fSpadic_baseline[sid][ch]->SetBinContent(bin + 1,rawData[ch][bin]);
02634 signal += rawData[ch][bin];
02635
02636 }
02637
02638
02639 if (signal > maxSignal){
02640 maxSignal = signal;
02641 maxCh = ch;
02642 }
02643 }
02644
02645 if (!fPar->Run_SimpleNoiseReduction) {
02646 if (!fSpadic_baseline[sid] || !fSpadic_output[sid] || !(TSpadicData*)theSpadic) continue;
02647 CancelNoise_Cova((Int_t)sid, fSpadic_baseline[sid], fSpadic_output[sid], (TSpadicData*)theSpadic, false);
02648 for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
02649 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02650 cleanData[ch][bin] = fSpadic_output[sid][ch]->GetBinContent(bin + 1);
02651 }
02652 }
02653 }
02654
02655
02656
02657
02658 Int_t nSignalChannel = 0;
02659 Bool_t channelSignal[NUM_SPADIC_CHA] = {false};
02660 for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
02661 if (theSpadic->fSpadicSignalCh[ch]) {
02662 nSignalChannel++;
02663 channelSignal[ch] = true;
02664 }
02665 }
02666
02667
02668
02669
02670
02671
02672
02673
02674
02675
02676
02677
02678
02679
02680
02681
02682
02683
02684
02685
02686
02687
02688
02689
02690
02691
02692
02693
02694
02695
02696
02697
02698
02699
02700
02701
02702
02703
02704
02705
02706
02707
02708
02709
02710
02711
02712 Double_t maxAmp[NUM_SPADIC_CHA] = {0};
02713 Int_t hitTime[NUM_SPADIC_CHA] = {0};
02714 Double_t average;
02715
02716 Double_t intens3pads = 0;
02717 Double_t intensSignalPads = 0;
02718 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02719 average = 0.;
02720 for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
02721
02722
02723
02724 if (!channelSignal[ch])
02725 average += rawData[ch][bin];
02726 }
02727 average /= (Double_t(NUM_SPADIC_CHA - nSignalChannel));
02728 for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
02729
02730
02731 if (fPar->Run_SimpleNoiseReduction){
02732 cleanData[ch][bin] = rawData[ch][bin] - average;
02733
02734
02735
02736 fSpadic_output[sid][ch]->SetBinContent(bin + 1, cleanData[ch][bin]);
02737 }
02738 if (fSpadic_integWindow[sid]->Test(bin)) {
02739 intensCh[ch] += cleanData[ch][bin];
02740 if (theSpadic->fSpadicSignalCh[ch])
02741 intensSignalPads += cleanData[ch][bin];
02742 if (ch >= maxCh-1 && ch <= maxCh+1)
02743 intens3pads += cleanData[ch][bin];
02744 }
02745
02746 if (cleanData[ch][bin] > maxAmp[ch]){
02747 maxAmp[ch] = cleanData[ch][bin];
02748 hitTime[ch] = bin;
02749 }
02750 rowIntens[sid] += intensCh[ch];
02751 }
02752
02753 }
02754 fSpadic_maxAmplitude[sid]->Fill(maxAmp[maxCh]);
02755 fSpadic_hitTime[sid]->Fill(hitTime[maxCh]);
02756 fSpadic_hitTime_maxAmplitude[sid]->Fill(hitTime[maxCh],maxAmp[maxCh]);
02757 if (fHodo1 && (fHodo1->NumHits()>0) && fHodo2 && (fHodo2->NumHits()>0)){
02758 fSpadic_hitTime_Hodo1Xposition[sid]->Fill(hitTime[maxCh],xPosFiberHod1);
02759 fSpadic_hitTime_Hodo2Xposition[sid]->Fill(hitTime[maxCh],xPosFiberHod2);
02760 fSpadic_hitTime_Hodo1Yposition[sid]->Fill(hitTime[maxCh],yPosFiberHod1);
02761 fSpadic_hitTime_Hodo2Yposition[sid]->Fill(hitTime[maxCh],yPosFiberHod2);
02762 if (overflow){
02763 fSpadic_overflow_Hodo1position[sid]->Fill(xPosFiberHod1,yPosFiberHod1);
02764 fSpadic_overflow_Hodo2position[sid]->Fill(xPosFiberHod2,yPosFiberHod2);
02765 }
02766 }
02767 if (fBeamEvent->fIsPion){
02768 fSpadic_pi_maxAmplitude[sid]->Fill(maxAmp[maxCh]);
02769 fSpadic_pi_hitTime[sid]->Fill(hitTime[maxCh]);
02770 }
02771 if (fBeamEvent->fIsElectron){
02772 fSpadic_el_maxAmplitude[sid]->Fill(maxAmp[maxCh]);
02773 fSpadic_el_hitTime[sid]->Fill(hitTime[maxCh]);
02774 }
02775 maxChCorr[sid] = maxCh;
02776 fSpadic_padMax[sid]->Fill(maxCh);
02777
02778 if(fPar->Use_ClusteredSignal)
02779 intens[sid] = intensSignalPads;
02780 else
02781 intens[sid] = intens3pads;
02782
02783
02784
02785
02786
02787
02788
02789
02790 if (fBeamEvent->fIsElectron){
02791 if (sid == 10) {
02792 if (fSpadic_hitTimeCond[sid]->Test(hitTime[maxCh])){
02793 if (fSpadic_minAmplitudeCond[sid]->Test(maxAmp[maxCh])){
02794 if (fSpadic_padMaxWindow[sid]->Test(maxCh)) {
02795 if ((xPosFiberHod1 < 0 && xPosFiberHod2 < 0) && (yPosFiberHod1 < 0 && yPosFiberHod2 < 0))
02796 fSpadic_intens_el_00->Fill(intens[sid]);
02797 else if ((xPosFiberHod1 >= 0 && xPosFiberHod2 >= 0) && (yPosFiberHod1 < 0 && yPosFiberHod2 < 0))
02798 fSpadic_intens_el_10->Fill(intens[sid]);
02799 else if ((xPosFiberHod1 < 0 && xPosFiberHod2 < 0 ) && (yPosFiberHod1 >= 0 && yPosFiberHod2 >= 0))
02800 fSpadic_intens_el_01->Fill(intens[sid]);
02801 else if ((xPosFiberHod1 >= 0 && xPosFiberHod2 >= 0) && (yPosFiberHod1 >= 0 && yPosFiberHod2 >= 0))
02802 fSpadic_intens_el_11->Fill(intens[sid]);
02803 if (maxCh < 4)
02804 fSpadic_intens_el_left->Fill(intens[sid]);
02805 else
02806 fSpadic_intens_el_right->Fill(intens[sid]);
02807 }
02808 }
02809 }
02810 }
02811 }
02812 if (fSpadic_hitTimeCond[sid]->Test(hitTime[maxCh])){
02813 if (fSpadic_minAmplitudeCond[sid]->Test(maxAmp[maxCh])){
02814
02815 if (!fPar->Merge_Rows) {
02816 if (fSpadic_padMaxWindow[sid]->Test(maxCh)) {
02817 if (intensCh[maxCh] / (intensCh[maxCh-1] + intensCh[maxCh] + intensCh[maxCh+1]) > 0.33) {
02818
02819 Int_t intensBin = fSpadic_intens[sid]->FindBin(intens[sid]);
02820 Int_t pidBin = 1;
02821 Int_t nBin = fSpadic_intens[sid]->GetNbinsX();
02822 Int_t nEntries;
02823 Double_t value(0), value_over(0), value_under(0), value_3pad(0);
02824 TH1 *spectrum=0;
02825 TH1 *spectrum_over = NULL;
02826 TH1 *spectrum_under = NULL;
02827 TH1 *spectrum_3pad = NULL;
02828 if (fBeamEvent->fIsPion){
02829 spectrum = fSpadic_pi_intens[sid];
02830 spectrum_over = fSpadic_pi_intens_over[sid];
02831 spectrum_under = fSpadic_pi_intens_under[sid];
02832
02833 pidBin = fSpadic_pid[sid]->FindBin(3);
02834 }
02835 if (fBeamEvent->fIsElectron){
02836 spectrum = fSpadic_el_intens[sid];
02837 spectrum_over = fSpadic_el_intens_over[sid];
02838 spectrum_under = fSpadic_el_intens_under[sid];
02839 pidBin = fSpadic_pid[sid]->FindBin(2);
02840 }
02841 if (!(fBeamEvent->fIsPion) && !(fBeamEvent->fIsElectron)){
02842 pidBin = fSpadic_pid[sid]->FindBin(1);
02843 nEntries = fSpadic_pid[sid]->GetBinContent(pidBin);
02844 fSpadic_pid[sid]->SetBinContent(pidBin, nEntries + 1);
02845 }
02846 for (Int_t iBin = 1; iBin <= nBin; iBin++) {
02847 nEntries = fSpadic_pid[sid]->GetBinContent(fSpadic_pid[sid]->FindBin(0));
02848 value = fSpadic_intens[sid]->GetBinContent(iBin) * nEntries;
02849 if (iBin == intensBin){
02850 value++;
02851 fSpadic_pid[sid]->SetBinContent(1, nEntries + 1);
02852 }
02853 fSpadic_intens[sid]->SetBinContent(iBin, value / (nEntries + 1));
02854 if (pidBin > 2) {
02855 nEntries = fSpadic_pid[sid]->GetBinContent(pidBin);
02856 value = spectrum->GetBinContent(iBin) * nEntries;
02857 value_over = spectrum_over->GetBinContent(iBin) * nEntries;
02858 value_under = spectrum_under->GetBinContent(iBin) * nEntries;
02859
02860 if (iBin == intensBin){
02861 value++;
02862
02863 if (overflow)
02864 value_over++;
02865 if (undershoot)
02866 value_under++;
02867 fSpadic_pid[sid]->SetBinContent(pidBin, nEntries + 1);
02868 }
02869 spectrum->SetBinContent(iBin, value / (nEntries + 1));
02870 spectrum_over->SetBinContent(iBin, value_over / (nEntries + 1));
02871 spectrum_under->SetBinContent(iBin, value_under / (nEntries + 1));
02872
02873 }
02874 }
02875 }
02876 }
02877 }
02878 if (fSpadic_minIntensCond[sid]->Test(intens[sid])){
02879
02880 Double_t avNoise = 0;
02881 Double_t maxNoise = 0;
02882 Double_t minNoise = 255;
02883 Double_t avSignal = 0;
02884 Double_t avNoiseClean = 0;
02885 Double_t avSignalClean = 0;
02886 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02887 if (bin < 5){
02888 avNoise += uint8_t(theSpadic->fSpadicPulse[maxCh][bin]);
02889 if (uint8_t(theSpadic->fSpadicPulse[maxCh][bin]) > maxNoise)
02890 maxNoise = uint8_t(theSpadic->fSpadicPulse[maxCh][bin]);
02891 if (uint8_t(theSpadic->fSpadicPulse[maxCh][bin]) < minNoise)
02892 minNoise = uint8_t(theSpadic->fSpadicPulse[maxCh][bin]);
02893 avNoiseClean += cleanData[maxCh][bin];
02894 }
02895 if (bin > 14 && bin < 20){
02896 avSignal += uint8_t(theSpadic->fSpadicPulse[maxCh][bin]);
02897 avSignalClean += cleanData[maxCh][bin];
02898 }
02899 }
02900 TString s2n = ("S/N=xx");
02901 if (avNoise != 0){
02902 double val = avSignal / (maxNoise - minNoise);
02903 double weight = fSpadic_S2Ncnt->GetBinContent(sid);
02904 double value0 = fSpadic_S2N->GetBinContent(sid);
02905 s2n.Form("S/N=%f",(value0 * weight + val) / (weight + 1.));
02906 fSpadic_S2N->SetBinContent(sid, (value0 * weight + val) / (weight + 1.));
02907 fSpadic_S2Ncnt->SetBinContent(sid, weight + 1);
02908 }
02909 if (avNoiseClean != 0){
02910 double val = avSignalClean/avNoiseClean;
02911 double weight = fSpadic_S2Ncnt->GetBinContent(sid) -1;
02912 double value0 = fSpadic_S2Ncleaned->GetBinContent(sid);
02913 fSpadic_S2Ncleaned->SetBinContent(sid, (value0 * weight + val) / (weight + 1.));
02914 }
02915 S2N[sid]->SetText(0.1,0.8,s2n.Data());
02916
02917
02918
02919
02920
02921 if (fSpadic_padMaxWindow[sid]->Test(maxCh)) {
02922 fSpadic_efficiency->Fill(sid);
02923 Double_t dxPos = 0.5 * log((intensCh[maxCh+1] / intensCh[maxCh-1])) / log((pow(intensCh[maxCh],2) / (intensCh[maxCh+1] * intensCh[maxCh-1])));
02924
02925
02926
02927
02928 dxPosCorr[sid] = (dxPos + maxCh + 0.5) * fPar->fPadwidth[sid];
02929 fSpadic_recoPos[sid]->Fill( dxPosCorr[sid] );
02930 fSpadic_hitTime_position[sid]->Fill(hitTime[maxCh], dxPosCorr[sid]);
02931 Double_t chargePercent = intensCh[maxCh-1] / (intensCh[maxCh-1] + intensCh[maxCh] + intensCh[maxCh+1]);
02932 fSpadic_PRFMF[sid]->Fill(-dxPos-1,chargePercent);
02933
02934 chargePercent = intensCh[maxCh] / (intensCh[maxCh-1] + intensCh[maxCh] + intensCh[maxCh+1]);
02935 fSpadic_PRFMF[sid]->Fill(dxPos,chargePercent);
02936
02937 chargePercent = intensCh[maxCh+1] / (intensCh[maxCh-1] + intensCh[maxCh] + intensCh[maxCh+1]);
02938 fSpadic_PRFMF[sid]->Fill(-dxPos+1,chargePercent);
02939
02940
02941 }
02942
02943
02944
02945 if (fBeamEvent->fIsPion) {
02946 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02947 double val = cleanData[maxCh][bin];
02948 fSpadic_pi_shape2D[sid]->Fill(bin, val);
02949
02950 double weight = fSpadic_pi_shapecnt[sid]->GetBinContent(bin+1);
02951 double value0 = fSpadic_pi_shape[sid]->GetBinContent(bin+1);
02952
02953 fSpadic_pi_shape[sid]->SetBinContent(bin+1, (value0 * weight + val) / (weight + 1.));
02954 fSpadic_pi_shapecnt[sid]->SetBinContent(bin+1, weight+1.);
02955 }
02956 }
02957 if (fBeamEvent->fIsElectron) {
02958 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02959 double val = cleanData[maxCh][bin];
02960 fSpadic_el_shape2D[sid]->Fill(bin, val);
02961
02962 double weight = fSpadic_el_shapecnt[sid]->GetBinContent(bin+1);
02963 double value0 = fSpadic_el_shape[sid]->GetBinContent(bin+1);
02964
02965 fSpadic_el_shape[sid]->SetBinContent(bin+1, (value0 * weight + val) / (weight + 1.));
02966 fSpadic_el_shapecnt[sid]->SetBinContent(bin+1, weight+1.);
02967 }
02968 }
02969
02970
02971 }
02972 }
02973 }
02974
02975
02976
02977 Bool_t multiHit = false;
02978
02979
02980
02981
02982
02983
02984
02985
02986
02987
02988
02989
02990
02991
02992
02993
02994
02995
02996
02997
02998
02999
03000
03001
03002
03003
03004
03005
03006 fSpadic_statistics[sid]->Fill(0);
03007 if (fSpadic_minAmplitudeCond[sid]->Test(maxAmp[maxCh]))
03008 {
03009 fSpadic_statistics[sid]->Fill(2);
03010 if (fSpadic_hitTimeCond[sid]->Test(hitTime[maxCh]))
03011 {
03012 fSpadic_statistics[sid]->Fill(3);
03013 if (fSpadic_minIntensCond[sid]->Test(intens[sid]))
03014 {
03015 fSpadic_statistics[sid]->Fill(4);
03016 if (intensCh[maxCh] / (intensCh[maxCh-1] + intensCh[maxCh] + intensCh[maxCh+1]) > 0.33) {
03017 fSpadic_statistics[sid]->Fill(5);
03018 if (!overflow) fSpadic_statistics[sid]->Fill(6);
03019 if (!undershoot) fSpadic_statistics[sid]->Fill(7);
03020
03021 if (fSpadic_padMaxWindow[sid]->Test(maxCh))
03022 {
03023 fSpadic_statistics[sid]->Fill(8);
03024 if (!multiHit)
03025 {
03026 fSpadic_statistics[sid]->Fill(9);
03027 fSpadic_statistics[sid]->Fill(10);
03028 if (fBeamEvent->fIsPion) fSpadic_statistics[sid]->Fill(11);
03029 if (fBeamEvent->fIsElectron) fSpadic_statistics[sid]->Fill(12);
03030 if (!fBeamEvent->fIsPion && !fBeamEvent->fIsElectron)
03031 {
03032 fSpadic_statistics[sid]->Fill(13);
03033 }
03034 }
03035 }
03036 }
03037 }
03038 }
03039 }
03040
03041
03042 if (!fSpadic_minAmplitudeCond[sid]->Test(maxAmp[maxCh]) ||
03043 !fSpadic_hitTimeCond[sid]->Test(hitTime[maxCh]) ||
03044 !fSpadic_minIntensCond[sid]->Test(intens[sid]) ||
03045 !(intensCh[maxCh] / (intensCh[maxCh-1] + intensCh[maxCh] + intensCh[maxCh+1]) > 0.33)||
03046 overflow ||
03047 multiHit
03048 ){
03049 fSpadic_statistics[sid]->Fill(1);
03050 }
03051
03052 }
03053
03054 for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
03055 if (fPar->Merge_Rows) {
03056
03057
03058 Int_t intensBin=0;
03059 if (sid == 4 || sid == 16 || sid == 17|| sid == 5)
03060 intensBin = fSpadic_intens[sid]->FindBin(intens[sid]);
03061 else {
03062 if (sid == 1 || sid == 2)
03063 intensBin = fSpadic_intens[sid]->FindBin(intens[1] + intens[2]);
03064 if (sid == 11 || sid == 12)
03065 intensBin = fSpadic_intens[sid]->FindBin(intens[11] + intens[12]);
03066 if (sid == 3 || sid == 6)
03067 intensBin = fSpadic_intens[sid]->FindBin(intens[3] + intens[6]);
03068 if (sid == 15 || sid == 18)
03069 intensBin = fSpadic_intens[sid]->FindBin(intens[15] + intens[18]);
03070 }
03071
03072 Int_t pidBin = 1;
03073 Int_t nBin = fSpadic_intens[sid]->GetNbinsX();
03074 Int_t nEntries;
03075 Double_t value;
03076 TH1 *spectrum=0;
03077 if (fBeamEvent->fIsPion){
03078 spectrum = fSpadic_pi_intens[sid];
03079 pidBin = fSpadic_pid[sid]->FindBin(3);
03080 }
03081 if (fBeamEvent->fIsElectron){
03082 spectrum = fSpadic_el_intens[sid];
03083 pidBin = fSpadic_pid[sid]->FindBin(2);
03084 }
03085 if (!(fBeamEvent->fIsPion) && !(fBeamEvent->fIsElectron)){
03086 pidBin = fSpadic_pid[sid]->FindBin(1);
03087 nEntries = fSpadic_pid[sid]->GetBinContent(pidBin);
03088 fSpadic_pid[sid]->SetBinContent(pidBin, nEntries + 1);
03089 }
03090 for (Int_t iBin = 1; iBin <= nBin; iBin++) {
03091 nEntries = fSpadic_pid[sid]->GetBinContent(fSpadic_pid[sid]->FindBin(0));
03092 value = fSpadic_intens[sid]->GetBinContent(iBin) * nEntries;
03093 if (iBin == intensBin){
03094 value++;
03095 fSpadic_pid[sid]->SetBinContent(1, nEntries + 1);
03096 }
03097 fSpadic_intens[sid]->SetBinContent(iBin, value / (nEntries + 1));
03098 if (pidBin > 2) {
03099 nEntries = fSpadic_pid[sid]->GetBinContent(pidBin);
03100 value = spectrum->GetBinContent(iBin) * nEntries;
03101 if (iBin == intensBin){
03102 value++;
03103 fSpadic_pid[sid]->SetBinContent(pidBin, nEntries + 1);
03104 }
03105 spectrum->SetBinContent(iBin, value / (nEntries + 1));
03106 }
03107 }
03108
03109 }
03110 }
03111 Bool_t mixing = false;
03112 for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
03113 for (UInt_t sid2 = 1; sid2 < MAX_SPADIC; sid2++) {
03114 if (PID[sid] != PID[sid2])
03115 mixing = true;
03116 fSpadic_pidMixing->Fill(PID[sid] - PID[sid2]);
03117 }
03118 }
03119
03120
03121
03122
03123
03124
03125
03126
03127
03128 Int_t i = 0;
03129 for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
03130 if (TSpadicEvent::ConfigSpadics[sid] == 0) continue;
03131
03132
03133
03134
03135
03136
03137
03138
03139
03140
03141 for (UInt_t sid2 = sid; sid2 < MAX_SPADIC; sid2++) {
03142 if (TSpadicEvent::ConfigSpadics[sid2] == 0) continue;
03143 if (maxChCorr[sid] > -1 && maxChCorr[sid2] > -1){
03144 if (fPar->Run_SpadicCorrelation)
03145 if (!(maxChCorr[sid] == 0 && maxChCorr[sid2] == 0))
03146 fSpadic_correlation[i]->Fill(maxChCorr[sid],maxChCorr[sid2]);
03147 if (fPar->Run_Alignment)
03148 if (!(dxPosCorr[sid] == 0 && dxPosCorr[sid2] == 0))
03149 fSpadic_alignment[i]->Fill(dxPosCorr[sid],dxPosCorr[sid2]);
03150 for (Int_t bin = 0; bin <= SPADIC_TRACE_SIZE; bin++) {
03151 if (fSpadic_el_shape[sid2]->GetBinContent(bin+1) != 0)
03152 fSpadic_el_shapeRatio[i]->SetBinContent(bin+1, fSpadic_el_shape[sid]->GetBinContent(bin+1) / fSpadic_el_shape[sid2]->GetBinContent(bin+1));
03153 if (fSpadic_pi_shape[sid2]->GetBinContent(bin+1) != 0)
03154 fSpadic_pi_shapeRatio[i]->SetBinContent(bin+1, fSpadic_pi_shape[sid]->GetBinContent(bin+1) / fSpadic_pi_shape[sid2]->GetBinContent(bin+1));
03155 }
03156 }
03157 i++;
03158 }
03159 }
03160
03161 Int_t pairs[4][2] = {{ 1, 2},{11,12},{10, 6},{15,18}};
03162 Float_t yPos[4] = {0.0};
03163
03164 for (Int_t pid = 0; pid < 4; pid++) {
03165 if (TSpadicEvent::ConfigSpadics[pairs[pid][0]] == 0 || TSpadicEvent::ConfigSpadics[pairs[pid][1]] == 0 || TSpadicEvent::ConfigSpadics[pairs[pid+2][1]]) continue;
03166
03167
03168
03169
03170
03171
03172
03173
03174
03175
03176
03177 yPos[pid] = fPar->sigmaPRF[pid] * sqrt(-2.0 * log (rowIntens[pairs[pid][0]] / rowIntens[pairs[pid][1]]));
03178
03179 Float_t averageX = 0;
03180 Int_t counter = 0;
03181 if (dxPosCorr[pairs[pid][0]] > 0){
03182 averageX += dxPosCorr[pairs[pid][0]];
03183 counter++;
03184 }
03185 if (dxPosCorr[pairs[pid][1]] > 0){
03186 averageX += dxPosCorr[pairs[pid][1]];
03187 counter++;
03188 }
03189 averageX /= counter;
03190 if (intens[pairs[pid][0]] < intens[pairs[pid][1]])
03191 yPos[pid] *= -1.;
03192 fSpadic_beamProfil[pid]->Fill(averageX, yPos[pid]);
03193 }
03194
03195
03196
03197
03198
03199
03200
03201
03202
03203
03204
03205
03206
03207
03208
03209
03210
03211
03212
03213
03214
03215
03216
03217
03218
03219
03220 if (xNrFiberHod1Cluster > 0)
03221 for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
03222 if (TSpadicEvent::ConfigSpadics[sid] == 0) continue;
03223 fFiberHod1_x_alignment[sid]->Fill(dxPosCorr[sid],xPosFiberHod1);
03224 }
03225
03226 if (yNrFiberHod1Cluster > 0)
03227 for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
03228 if (TSpadicEvent::ConfigSpadics[sid] == 0) continue;
03229 fFiberHod1_y_alignment[sid]->Fill(dxPosCorr[sid],yPosFiberHod1);
03230 }
03231
03232
03233
03234 if (xNrFiberHod2Cluster > 0)
03235 for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
03236 if (TSpadicEvent::ConfigSpadics[sid] == 0) continue;
03237 fFiberHod2_x_alignment[sid]->Fill(dxPosCorr[sid],xPosFiberHod2);
03238 }
03239
03240 if (yNrFiberHod2Cluster > 0)
03241 for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
03242 if (TSpadicEvent::ConfigSpadics[sid] == 0) continue;
03243 fFiberHod2_y_alignment[sid]->Fill(dxPosCorr[sid],yPosFiberHod2);
03244 }
03245
03246
03247 }
03248 }
