ROCsoft: beamtime/cern-oct11/go4/MSFFM/TTRDMuensterFrankfurtProc.cxx (r4864/r3461) Source File

Go to the documentation of this file.
00001 /* Generated by Together */
00002 
00003 #include "TTRDMuensterFrankfurtProc.h"
00004 
00005 #include "spadic/Message.h"
00006 
00007 #define USED_SPADIC          13
00008 // number (+1) of used spadics during CERN Oct 2011 beamtime
00009 // NOTE: since susibo index starts with one, we do not use index 0, but assign one more
00010 
00011 
00012   // 19.10.2011                      // MS                           // FF           // unused
00013   Int_t SpMap[MAX_SPADIC]      = {  0,  1,  2, 11, 12, 10,  6, 15, 18,  4, 16, 17,  5,  3, 14,  7,  8,  9, 13, 19 };  // map of Spadics in TRD order
00014   Int_t StMap[MAX_SPADIC]      = {  0,  1, 11, 10, 15,  0,  0,  0,  0,  4, 16, 17,  5,  3, 14,  7,  8,  9, 13, 19 };  // map of top    Spadics 
00015   Int_t SbMap[MAX_SPADIC]      = {  0,  2, 12,  6, 18,  0,  0,  0,  0,  4, 16, 17,  5,  3, 14,  7,  8,  9, 13, 19 };  // map of bottom Spadics 
00016   Int_t SuMap[MAX_SPADIC]      = {  0,  1,  5, 10,  9, 12,  7, 17, 18, 15, 13,  2,  6, 16, 14,  4,  3, 11,  8, 19 };  // histo mapping
00017   //                                0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
00018   Int_t SpaPosMap[USED_SPADIC] = {  0,  1, 11, 10, 15,  2, 12,  6, 18,  4, 16, 17,  5 };  // map of 12 used Spadics
00019 
00020 
00021 TTRDMuensterFrankfurtProc::TTRDMuensterFrankfurtProc(const char* name) : TCBMBeamtimeProc(name),
00022                                                                          fSpadicInputEvent(0), 
00023                                                                          fOutputEvent(0),
00024                                                                          fBeamEvent(0),
00025                                                                          fHodo1(0)
00026 {
00027   cout << "**** TTRDMuensterFrankfurtProcTTRDSpadicProc: Create instance " << name << endl;
00028    
00029 
00030   fPar = (TTRDMuensterFrankfurtParam*) MakeParameter("TRDMuensterFrankfurtPar", "TTRDMuensterFrankfurtParam");
00031 
00032   // reset slow control variables:
00033   for (int mst = 0; mst < MSTRDNUM; ++mst) {
00034     fEpicsMSTRD_Drift_U[mst] = 0;
00035     fEpicsMSTRD_Drift_I[mst] = 0;
00036     fEpicsMSTRD_Anode_U[mst] = 0;
00037     fEpicsMSTRD_Anode_I[mst] = 0;
00038     fEpicsMSTRD_Sus_U[mst] = 0;
00039     fEpicsMSTRD_Sus_I[mst] = 0;
00040     fEpicsMSTRD_Spa_U[mst] = 0;
00041     fEpicsMSTRD_Spa_I[mst] = 0;
00042   }
00043   for (int i = 0; i < 4; i++)
00044     fEpicsMSTRD_Temp[i] = 0;
00045 
00046   for (int i = 0; i < RICHNUM; ++i) {
00047     fEpics_Rich_U[i] = 0;
00048     fEpics_Rich_I[i] = 0;
00049   }
00050 
00051   // end epics slow control init
00052  
00053   /* simple SPADIC online JAM:*/
00054   TString obname;
00055   TString obtitle;
00056   TString foldername;
00057   TH1* his=0;
00058 
00059   one = new TLine(0,1,45,1);
00060 
00061   TString SuDeId[MAX_SPADIC] = {"dummy",            //00
00062                                 "MS_TRD1_T",        //01
00063                                 "MS_TRD1_B",        //02
00064                                 //                              "MS_TRD3_T",        //03
00065                                 "",                 //03
00066                                 "FFM_POS1_SUS04",   //04  Pos 1
00067                                 "FFM_POS4_SUS05",   //05  Pos 4
00068                                 "MS_TRD3_B",        //06
00069                                 "",                 //07
00070                                 "",                 //08
00071                                 "",                 //09
00072                                 //                              "",                 //10
00073                                 "MS_TRD3_T",        //10
00074                                 "MS_TRD2_T",        //11
00075                                 "MS_TRD2_B",        //12
00076                                 "",                 //13
00077                                 "",                 //14
00078                                 "MS_TRD4_T",        //15
00079                                 "FFM_POS2_SUS16",   //16  Pos 2
00080                                 "FFM_POS3_SUS17",   //17  Pos 3
00081                                 "MS_TRD4_B",        //18
00082                                 ""                  //19
00083   };
00084 
00085   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]");
00086   fSpadic_MSxyHitPadplane[0]->SetContour(99);
00087   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]");
00088   fSpadic_MSxyHitPadplane[1]->SetContour(99);
00089   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]");
00090   fSpadic_MSxyHitplane[0]->SetContour(99);
00091   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]");
00092   fSpadic_MSxyHitplane[1]->SetContour(99);
00093 
00094   for (Int_t i = 0; i < 4; i++){
00095     obname.Form("MuensterFrankfurt/BeamProfile2D_TRD%d",i+1);
00096     obtitle.Form("2D Beam Profil of MS TRD %d",i+1);
00097     fSpadic_beamProfil[i] = MakeTH2('I',obname.Data(),obtitle.Data(),240,-60,60,240,-60,60,"x position [mm]","y position [mm]");
00098     fSpadic_beamProfil[i]->SetContour(99);  
00099     obname.Form("MuensterFrankfurt/deltaPos_TRD%d",i+1);
00100     obtitle.Form("offset of reco. pos. of MS TRD %d",i+1);
00101     fSpadic_deltaPos[i] = MakeTH2('I',obname.Data(),obtitle.Data(),240,-60,60,240,-60,60,"x position [mm]","#delta x position [mm]");
00102     fSpadic_deltaPos[i]->SetContour(99); 
00103   }
00104   //  //                           0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
00105   //  Int_t SpMap[MAX_SPADIC] = {  0,  1,  2, 11, 12,  3,  6, 15, 18,  4,  5, 16, 17, 10, 14,  7,  8,  9, 13, 19 };  // Spadics in TRD order
00106   //  Int_t SuMap[MAX_SPADIC] = {  0,  1,  5,  3,  9, 10,  7, 17, 18, 15, 13,  2,  6, 16, 14,  4, 11, 12,  8, 19 };  // histo mapping
00107 
00108 
00109   //  // 19.10.2011                  // MS                           // FF          // unused
00110   //  Int_t SpMap[MAX_SPADIC] = {  0,  1,  2, 11, 12,  3,  6, 15, 18,  4, 16, 17,  5, 10, 14,  7,  8,  9, 13, 19 };  // map of Spadics in TRD order
00111   //  Int_t SuMap[MAX_SPADIC] = {  0,  1,  5,  3,  9, 12,  7, 17, 18, 15, 13,  2,  6, 16, 14,  4, 10, 11,  8, 19 };  // histo mapping
00112   //  //                           0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
00113 
00114 
00115   if (!fPar->reSortSusibo)
00116     for (Int_t sid = 0; sid < MAX_SPADIC; sid++)
00117       SuMap[sid] = sid;
00118 
00119   TString MsId[MSTRDNUM] = {"dummy","336_2010","336_2011","444_2010","444_2011"};
00120   const Int_t timeMemory = 1800; // 1h with 1 event per 2sec
00121   
00122   fSpadic_pidMixing = MakeTH1('I',"PIDmixing","PIDmixing",5,-2.5,2.5);
00123 
00124   fEpics_MonitorU[0] = MakeTH1('D',"EPICS_BeamMonitor/Cherenkov_1_U","Cherenkov 1", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00125   fEpics_MonitorI[0] = MakeTH1('D',"EPICS_BeamMonitor/Cherenkov_1_I","Cherenkov 1", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00126   fEpics_MonitorU[1] = MakeTH1('D',"EPICS_BeamMonitor/Cherenkov_2_U","Cherenkov 2", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00127   fEpics_MonitorI[1] = MakeTH1('D',"EPICS_BeamMonitor/Cherenkov_2_I","Cherenkov 2", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00128   fEpics_MonitorU[2] = MakeTH1('D',"EPICS_BeamMonitor/Scintillator_1_U","Scintillator 1", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00129   fEpics_MonitorI[2] = MakeTH1('D',"EPICS_BeamMonitor/Scintillator_1_I","Scintillator 1", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00130   fEpics_MonitorU[3] = MakeTH1('D',"EPICS_BeamMonitor/Scintillator_2_U","Scintillator 2", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00131   fEpics_MonitorI[3] = MakeTH1('D',"EPICS_BeamMonitor/Scintillator_2_I","Scintillator 2", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00132   fEpics_MonitorU[4] = MakeTH1('D',"EPICS_BeamMonitor/Calorimeter_Veto_U","Calorimeter Veto", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00133   fEpics_MonitorI[4] = MakeTH1('D',"EPICS_BeamMonitor/Calorimeter_Veto_I","Calorimeter Veto", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00134   fEpics_MonitorU[5] = MakeTH1('D',"EPICS_BeamMonitor/Calorimeter_U","Calorimeter", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00135   fEpics_MonitorI[5] = MakeTH1('D',"EPICS_BeamMonitor/Calorimeter_I","Calorimeter", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00136   fEpics_MonitorU[6] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_1_U","Hodoscope 1", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00137   fEpics_MonitorI[6] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_1_I","Hodoscope 1", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00138   fEpics_MonitorU[7] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_2_U","Hodoscope 2", timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00139   fEpics_MonitorI[7] = MakeTH1('D',"EPICS_BeamMonitor/Hodoscope_2_I","Hodoscope 2", timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00140 
00141   for (Int_t sl = 0; sl < MPOD00SLOT; sl++) {
00142     for (Int_t ch = 0; ch < MPOD00CHA; ch++) {
00143       obname.Form("EPICS_MS/MS_Mpod00/Slot%02i/00Slot%02iChannel%02i_U",sl,sl,ch);
00144       obtitle.Form("Mpod00 Slot%02i Channel%02i Voltage",sl,ch);
00145       fEpicsMSMpod00_Monitor_U[sl][ch] = MakeTH1('D',obname,obtitle,timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00146       obname.Form("EPICS_MS/MS_Mpod00/Slot%02i/00Slot%02iChannel%02i_I",sl,sl,ch);
00147       obtitle.Form("Mpod00 Slot%02i Channel%02i Current",sl,ch);
00148       fEpicsMSMpod00_Monitor_I[sl][ch] = MakeTH1('D',obname,obtitle,timeMemory,-timeMemory,0,"relative event id","LV current [A]");  // LV
00149     }
00150   }
00151   
00152   for (Int_t sl = 0; sl < MPOD01SLOT; sl++) {
00153     for (Int_t ch = 0; ch < MPOD01CHA; ch++) {
00154       obname.Form("EPICS_MS/MS_Mpod01/Slot%02i/01Slot%02iChannel%02i_U",sl,sl,ch);
00155       obtitle.Form("Mpod01 Slot%02i Channel%02i Voltage",sl,ch);
00156       fEpicsMSMpod01_Monitor_U[sl][ch] = MakeTH1('D',obname,obtitle,timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00157       obname.Form("EPICS_MS/MS_Mpod01/Slot%02i/01Slot%02iChannel%02i_I",sl,sl,ch);
00158       obtitle.Form("Mpod01 Slot%02i Channel%02i Current",sl,ch);
00159       fEpicsMSMpod01_Monitor_I[sl][ch] = MakeTH1('D',obname,obtitle,timeMemory,-timeMemory,0,"relative event id","HV current [nA]");  // HV
00160     }
00161   }
00162   
00163   obname.Form("MuensterFrankfurt/Spadic_S2Ncnt");
00164   obtitle.Form("Spadic S/N counter of good events");
00165   fSpadic_S2Ncnt = MakeTH1('D', obname.Data(), obtitle.Data(), MAX_SPADIC, 0.5, MAX_SPADIC+0.5,"Susibo ID", "S/N counter");
00166 
00167   obname.Form("MuensterFrankfurt/Spadic_S2N");
00168   obtitle.Form("Spadic S/N");
00169   fSpadic_S2N = MakeTH1('D', obname.Data(), obtitle.Data(), MAX_SPADIC, 0.5, MAX_SPADIC+0.5,"Susibo ID", "S/N");
00170   for (UInt_t sid = 1; sid < MAX_SPADIC; sid++)
00171     fSpadic_S2N->GetXaxis()->SetBinLabel(sid, SuDeId[sid].Data());
00172 
00173   obname.Form("MuensterFrankfurt/Spadic_S2Nclean");
00174   obtitle.Form("Spadic S/N after data cleaning");
00175   fSpadic_S2Ncleaned = MakeTH1('D', obname.Data(), obtitle.Data(), MAX_SPADIC, 0.5, MAX_SPADIC+0.5,"Susibo ID", "S/N");
00176   for (UInt_t sid = 1; sid < MAX_SPADIC; sid++)
00177     fSpadic_S2Ncleaned->GetXaxis()->SetBinLabel(sid, SuDeId[sid].Data());
00178 
00179   for (int i = 1; i < RICHNUM; ++i) {
00180     obname.Form("EPICS_MS/MAPMT%02d_U",i);
00181     obtitle.Form("MAPMT%02d_U",i);
00182     fEpics_RichU[i] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00183     obname.Form("EPICS_MS/MAPMT%02d_I",i);
00184     obtitle.Form("MAPMT%02d_I",i);
00185     fEpics_RichI[i] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","current [nA]");
00186   }
00187 
00188   for (int mst = 1; mst < MSTRDNUM; ++mst) {
00189     obname.Form("EPICS_MS/%s_AnodeU",MsId[mst].Data());
00190     obtitle.Form("MS%s_AnodeU",MsId[mst].Data());
00191     fEpicsMSTRD_AnodeU[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","anode voltage [V]");
00192     obname.Form("EPICS_MS/%s_AnodeI",MsId[mst].Data());
00193     obtitle.Form("MS%s_AnodeI",MsId[mst].Data());
00194     fEpicsMSTRD_AnodeI[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","anode current [nA]");
00195     obname.Form("EPICS_MS/%s_DriftU",MsId[mst].Data());
00196     obtitle.Form("MS%s_DriftU",MsId[mst].Data());
00197     fEpicsMSTRD_DriftU[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","drift voltage [V]");
00198     obname.Form("EPICS_MS/%s_DriftI",MsId[mst].Data());
00199     obtitle.Form("MS%s_DriftI",MsId[mst].Data());
00200     fEpicsMSTRD_DriftI[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","drift current [nA]");
00201     obname.Form("EPICS_MS/%s_SusiboU",MsId[mst].Data());
00202     obtitle.Form("MS%s_SusiboU",MsId[mst].Data());
00203     fEpicsMSTRD_SusU[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00204     obname.Form("EPICS_MS/%s_SusiboI",MsId[mst].Data());
00205     obtitle.Form("MS%s_SusiboI",MsId[mst].Data());
00206     fEpicsMSTRD_SusI[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","current [A]");
00207     obname.Form("EPICS_MS/%s_SpadicU",MsId[mst].Data());
00208     obtitle.Form("MS%s_SpadicU",MsId[mst].Data());
00209     fEpicsMSTRD_SpaU[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","voltage [V]");
00210     obname.Form("EPICS_MS/%s_SpadicI",MsId[mst].Data());
00211     obtitle.Form("MS%s_SpadicI",MsId[mst].Data());
00212     fEpicsMSTRD_SpaI[mst] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","current [A]");
00213   }
00214   for (Int_t i = 0; i < 4; i++) {
00215     obname.Form("EPICS_MS/T%d",i);
00216     obtitle.Form("MST%d",i);
00217     fEpicsMSTRD_T[i] = MakeTH1('D', obname.Data(), obtitle.Data(), timeMemory,-timeMemory,0,"relative event id","drift module temperatur [°C]");
00218   }
00219 
00220   obname.Form("MuensterFrankfurt/Spadic_TriggerEfficiency");
00221   obtitle.Form("number of good events after all cuts");
00222   fSpadic_efficiency = MakeTH1('I', obname.Data(), obtitle.Data(), MAX_SPADIC, -0.5, MAX_SPADIC-0.5,  "SuID", "good events after all cuts");
00223   fSpadic_efficiency->GetXaxis()->SetBinLabel( 1,"all");
00224   for (UInt_t sid = 1; sid < MAX_SPADIC; sid++) {
00225 
00226     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_FingerCorr", sid, sid);
00227     obtitle.Form("correlation with finger sintilator spadic %d MF (%s)", sid, SuDeId[sid].Data());
00228     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");
00229     fSpadic_FingerCorr[sid]->SetContour(99); 
00230 
00231     obname.Form("%d (%s)",sid, SuDeId[sid].Data());
00232     fSpadic_efficiency->GetXaxis()->SetBinLabel(1+sid, obname.Data());
00233       
00234     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_NoiseDistMF", sid, sid);
00235     obtitle.Form("RMS of ADC distribution of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00236     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]");
00237 
00238     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_NoiseDist2DMF", sid, sid);
00239     obtitle.Form("RMS of ADC distribution of spadic %d 2D MF (%s)", sid, SuDeId[sid].Data());
00240     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]");
00241     fSpadic_NoiseDist2DMF[sid]->SetContour(99);  
00242        
00243     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PedelPosMF", sid, sid);
00244     obtitle.Form("Pedestel (Mean of ADC value distribution) of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00245     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]");
00246 
00247     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PedelPos2DMF", sid, sid);
00248     obtitle.Form("Pedestel (Mean of ADC value distribution) of spadic %d 2D MF (%s)", sid, SuDeId[sid].Data());
00249     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]");
00250     fSpadic_PedelPos2DMF[sid]->SetContour(99); 
00251     
00252     for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
00253       obname.Form("Spadic_%d/Channel%d/Spadic%d_ch%d_ADCdistMF", sid, ch, sid, ch);
00254       obtitle.Form("ADC value distribution %2d  %2d MF (%s)", sid, ch, SuDeId[sid].Data());
00255       fSpadic_ADCdistMF[sid][ch] = MakeTH1('I', obname.Data(), obtitle.Data(), 256, -256/2, 256/2, "ADC value", "Counts");
00256     }
00257     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPE_pi2D", sid, sid);
00258     obtitle.Form("Average pulse shape of spadic %d (pion) 2D (%s)", sid, SuDeId[sid].Data());
00259     fSpadic_pi_shape2D[sid] = MakeTH2('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, 300, -44, 255);
00260     fSpadic_pi_shape2D[sid]->SetContour(99); 
00261 
00262     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPE_pi", sid, sid);
00263     obtitle.Form("Average pulse shape of spadic %d (pion) (%s)", sid, SuDeId[sid].Data());
00264     fSpadic_pi_shape[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00265 
00266     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPEcnt_pi", sid, sid);
00267     obtitle.Form("Counts for average pulse shape of spadic %d (pion) (%s)", sid, SuDeId[sid].Data());
00268     fSpadic_pi_shapecnt[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00269 
00270     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPE_el2D", sid, sid);
00271     obtitle.Form("Average pulse shape of spadic %d (electron) 2D (%s)", sid, SuDeId[sid].Data());
00272     fSpadic_el_shape2D[sid] = MakeTH2('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, 300, -44, 255);
00273     fSpadic_el_shape2D[sid]->SetContour(99); 
00274 
00275     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPE_el", sid, sid);
00276     obtitle.Form("Average pulse shape of spadic %d (electron) (%s)", sid, SuDeId[sid].Data());
00277     fSpadic_el_shape[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00278 
00279     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_SHAPEcnt_el", sid, sid);
00280     obtitle.Form("Counts for average pulse shape of spadic %d (electron) (%s)", sid, SuDeId[sid].Data());
00281     fSpadic_el_shapecnt[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);      
00282   
00283     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PID", sid, sid);
00284     obtitle.Form("Spadic %d Particle ID (%s)", sid, SuDeId[sid].Data());
00285     fSpadic_pid[sid] = MakeTH1('I', obname.Data(), obtitle.Data(),4,-0.5,3.5);
00286     fSpadic_pid[sid]->GetXaxis()->SetBinLabel( 1,"all");
00287     fSpadic_pid[sid]->GetXaxis()->SetBinLabel( 2,"no PID");
00288     fSpadic_pid[sid]->GetXaxis()->SetBinLabel( 3,"electron");
00289     fSpadic_pid[sid]->GetXaxis()->SetBinLabel( 4,"pion");
00290 
00291     S2N[sid] = new TLatex(0.1,0.8,"S/N=xy");
00292     S2N[sid]->SetTextAlign(12);
00293     S2N[sid]->SetTextSize(0.04);
00294     S2N[sid]->SetNDC();
00295     S2N[sid]->SetName(Form("S2N%dLatex",sid));
00296 
00297 
00298     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens", sid, sid);
00299     obtitle.Form("Spadic %d intensity (%s)", sid, SuDeId[sid].Data());
00300     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);
00301 
00302     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_pi", sid, sid);
00303     obtitle.Form("Spadic %d intensity (pion) (%s)", sid, SuDeId[sid].Data());
00304     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); 
00305 
00306     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Intens_el", sid, sid);
00307     obtitle.Form("Spadic %d intensity (electron) (%s)", sid, SuDeId[sid].Data());
00308     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); 
00309 
00310     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PadMax", sid, sid);
00311     obtitle.Form("Spadic %d pad with maximum charge (%s)", sid, SuDeId[sid].Data());
00312     fSpadic_padMax[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),NUM_SPADIC_CHA, 0, NUM_SPADIC_CHA); 
00313 
00314     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_RecoPos", sid, sid);
00315     obtitle.Form("Spadic %d reco. position (%s)", sid, SuDeId[sid].Data());
00316     fSpadic_recoPos[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),NUM_SPADIC_CHA * fPar->fPadwidth[sid], 0, NUM_SPADIC_CHA * fPar->fPadwidth[sid]); 
00317 
00318 
00319     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_Statistics", sid, sid);
00320     obtitle.Form("Spadic %d statistics (%s)", sid, SuDeId[sid].Data());           
00321     fSpadic_statistics[sid] = MakeTH1('D', obname.Data(), obtitle.Data(), 14, -0.5, 13.5); 
00322     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 1,"all events");
00323     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 2,"noise");
00324     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 3,"above threshold");
00325     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 4,"in time window");
00326     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 5,"above intens");
00327     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 6,"no overflow");
00328     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 7,"no undershoot");
00329     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 8,"not a border pad");
00330     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 9,"not multi hit");
00331     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel( 10,"good");
00332     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel(11,"pion");
00333     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel(12,"electron");
00334     fSpadic_statistics[sid]->GetXaxis()->SetBinLabel(13,"no ID");
00335    
00336     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_PRFMF", sid, sid);
00337     obtitle.Form("PRF of spadic %d MF (%s)", sid, SuDeId[sid].Data());
00338     fSpadic_PRFMF[sid] = MakeTH2('D', obname.Data(), obtitle.Data(), 400, -1.5, 1.5, 100, 0, 1);
00339     fSpadic_PRFMF[sid]->SetContour(99); 
00340 
00341     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_maxAmplitude", sid, sid);
00342     obtitle.Form("Spadic %d amplitude of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00343     fSpadic_maxAmplitude[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),300, -44, 256); 
00344 
00345     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_el_maxAmplitude", sid, sid);
00346     obtitle.Form("Spadic %d electron amplitude of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00347     fSpadic_el_maxAmplitude[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),300, -44, 256); 
00348 
00349     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_pi_maxAmplitude", sid, sid);
00350     obtitle.Form("Spadic %d pion amplitude of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00351     fSpadic_pi_maxAmplitude[sid] = MakeTH1('D', obname.Data(), obtitle.Data(),300, -44, 256); 
00352 
00353     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_hitTime", sid, sid);
00354     obtitle.Form("Spadic %d hit time of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00355     fSpadic_hitTime[sid] = MakeTH1('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE); 
00356 
00357     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_el_hitTime", sid, sid);
00358     obtitle.Form("Spadic %d electron hit time of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00359     fSpadic_el_hitTime[sid] = MakeTH1('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE);
00360  
00361     obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_pi_hitTime", sid, sid);
00362     obtitle.Form("Spadic %d pion hit time of signal with maximum charge (%s)", sid, SuDeId[sid].Data());
00363     fSpadic_pi_hitTime[sid] = MakeTH1('I', obname.Data(), obtitle.Data(),SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE); 
00364 
00365     //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
00366     obname.Form("Spadic%d/Spadic%d_minAmplitudeGate", sid, sid);
00367     obtitle.Form("minimum amplitude gate %d (%s)", sid, SuDeId[sid].Data());
00368     fSpadic_minAmplitudeCond[sid] = MakeWinCond(obname.Data(), 10, 255, fSpadic_maxAmplitude[sid]->GetName());
00369 
00370     obname.Form("Spadic%d/Spadic%d_minIntensityGate", sid, sid);
00371     obtitle.Form("minimum intensity gate %d (%s)", sid, SuDeId[sid].Data());
00372     fSpadic_minIntensCond[sid] = MakeWinCond(obname.Data(), 50, 255 * NUM_SPADIC_CHA * SPADIC_TRACE_SIZE, fSpadic_intens[sid]->GetName());
00373 
00374     obname.Form("Spadic%d/Spadic%d_hitTimeGate", sid, sid);
00375     obtitle.Form("hit time gate %d (%s)", sid, SuDeId[sid].Data());
00376     fSpadic_hitTimeCond[sid] = MakeWinCond(obname.Data(), 12, 25, fSpadic_hitTime[sid]->GetName());
00377 
00378     obname.Form("Spadic%d/Spadic%d_integWindow", sid, sid);
00379     obtitle.Form("integration window %d (%s)", sid, SuDeId[sid].Data());
00380     fSpadic_integWindow[sid] = MakeWinCond(obname.Data(), 0, SPADIC_TRACE_SIZE, fSpadic_el_shape[sid]->GetName());
00381 
00382     obname.Form("Spadic%d/Spadic%d_padMaxWindow", sid, sid);
00383     obtitle.Form("used pad max %d (%s)", sid, SuDeId[sid].Data());
00384     fSpadic_padMaxWindow[sid] = MakeWinCond(obname.Data(), 1, NUM_SPADIC_CHA-1, fSpadic_padMax[sid]->GetName());
00385 
00386     //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
00387 
00388     for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
00389       // trace histogram:
00390       obname.Form("MuensterFrankfurt/Spadic_%d/Channel%d/Spadic%d_ch%d_input", sid, ch, sid, ch);
00391       obtitle.Form("MSFF Trace %2d  %2d (%s)", sid, ch, SuDeId[sid].Data());
00392       fSpadic_input[sid][ch] = MakeTH1('F', obname.Data(), obtitle.Data(),
00393                                        SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, "time (40ns)");
00394 
00395       obname.Form("MuensterFrankfurt/Spadic_%d/Channel%d/Spadic%d_ch%d_output", sid, ch, sid, ch);
00396       obtitle.Form("MSFF Compensated %2d  %2d (%s)", sid, ch, SuDeId[sid].Data());
00397       fSpadic_output[sid][ch] = MakeTH1('F', obname.Data(), obtitle.Data(),
00398                                         SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, "time (40ns)");
00399     }
00400     obname.Form("MuensterFrankfurt/Alignment/Alignment_x_FiberHod_Spadic%d", sid);
00401     obtitle.Form("x Alignment Spadic %d (%s) to fiber hodoscope", sid, SuDeId[sid].Data());
00402     fFiberHod_x_alignment[sid] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA * fPar->fPadwidth[sid], -0.5 * fPar->fPadwidth[sid], (NUM_SPADIC_CHA-0.5) * fPar->fPadwidth[sid], 70, -35, 35, SuDeId[sid].Data(),"x pos. Fiber Hodoscope");
00403     fFiberHod_x_alignment[sid]->SetContour(99); 
00404 
00405     obname.Form("MuensterFrankfurt/Alignment/Alignment_y_FiberHod_Spadic%d", sid);
00406     obtitle.Form("y Alignment Spadic %d (%s) to fiber hodoscope", sid, SuDeId[sid].Data());
00407     fFiberHod_y_alignment[sid] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA * fPar->fPadwidth[sid], -0.5 * fPar->fPadwidth[sid], (NUM_SPADIC_CHA-0.5) * fPar->fPadwidth[sid], 70, -35, 35, SuDeId[sid].Data(),"y pos. Fiber Hodoscope");
00408     fFiberHod_y_alignment[sid]->SetContour(99); 
00409   }
00410 
00411   Int_t i = 0;
00412   for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
00413     for (UInt_t sid2 = sid; sid2 < MAX_SPADIC; sid2++) {
00414       obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", sid, sid2);
00415       obtitle.Form("Correlations Spadic %d (%s) Spadic %d (%s)", sid, SuDeId[sid].Data(), sid2, SuDeId[sid2].Data());
00416       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]);
00417       fSpadic_correlation[i]->SetContour(99); 
00418 
00419       obname.Form("MuensterFrankfurt/Alignment/Alignment_Spadic%d_%d", sid, sid2);
00420       obtitle.Form("Alignment Spadic %d (%s) Spadic %d (%s)", sid, SuDeId[sid].Data(), sid2, SuDeId[sid2].Data());
00421       fSpadic_alignment[i] = MakeTH2('I', obname.Data(), obtitle.Data(), NUM_SPADIC_CHA * fPar->fPadwidth[sid], -0.5 * fPar->fPadwidth[sid], (NUM_SPADIC_CHA-0.5) * fPar->fPadwidth[sid], NUM_SPADIC_CHA * fPar->fPadwidth[sid2], -0.5 * fPar->fPadwidth[sid2], (NUM_SPADIC_CHA-0.5) * fPar->fPadwidth[sid2], SuDeId[sid].Data(), SuDeId[sid2]);
00422       fSpadic_alignment[i]->SetContour(99); 
00423 
00424       obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", sid, sid, sid2);
00425       obtitle.Form("Average pulse shape of spadic %d (pion) (%s)", sid, SuDeId[sid].Data());
00426       fSpadic_pi_shapeRatio[i] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, SuDeId[sid].Data(), SuDeId[sid2] );
00427 
00428       obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", sid, sid, sid2);
00429       obtitle.Form("Average pulse shape of spadic %d (electron) (%s)", sid, SuDeId[sid].Data());
00430       fSpadic_el_shapeRatio[i] = MakeTH1('D', obname.Data(), obtitle.Data(), SPADIC_TRACE_SIZE, 0, SPADIC_TRACE_SIZE, SuDeId[sid].Data(), SuDeId[sid2]);
00431 
00432       i++;
00433       //cout << i << " " << sid << " " << sid2 << endl;
00434     }
00435   }
00436 
00437   //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<  PICTURE
00438 
00439   if (GetPicture("SpadicsHitPlane")==0) {
00440     TGo4Picture* pic = new TGo4Picture("SpadicsHitPlane","Spadics Hit Plane");
00441     pic->SetDivision(2,2);
00442     pic->Pic(0, 0)->AddObject(fSpadic_MSxyHitPadplane[0]);
00443     pic->Pic(0, 1)->AddObject(fSpadic_MSxyHitPadplane[1]);
00444     pic->Pic(1, 0)->AddObject(fSpadic_MSxyHitplane[0]);
00445     pic->Pic(1, 0)->SetLogScale(2,1);
00446     pic->Pic(1, 1)->AddObject(fSpadic_MSxyHitplane[1]);
00447     pic->Pic(1, 0)->SetLogScale(2,1);
00448     AddPicture(pic,"MuensterFrankfurt");
00449   }
00450 
00451   if (GetPicture("SpadicsSignal2Noise")==0) {
00452     TGo4Picture* pic = new TGo4Picture("SpadicsSignal2Noise","Signal to Noise");
00453     pic->SetDivision(1,1);
00454     pic->Pic(0, 0)->SetAutoScale(kFALSE);
00455     pic->Pic(0, 0)->SetRangeY(1, 255./20.);
00456     pic->Pic(0, 0)->AddObject(fSpadic_S2N);
00457     AddPicture(pic,"MuensterFrankfurt");
00458   }
00459 
00460   if (GetPicture("SpadicsFiberHodXAlignment")==0) {
00461     TGo4Picture* pic = new TGo4Picture("SpadicsFiberHodXAlignment","X");
00462     int numy = 4;
00463     int numx = (USED_SPADIC-1) / numy;
00464     if (numx*numy < (USED_SPADIC - 1)) 
00465       numx++;
00466     pic->SetDivision(numy, numx);
00467       
00468     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00469       int nx = (uid-1) / numy;
00470       int ny = (uid-1) % numy;
00471 
00472       pic->Pic(ny, nx)->AddObject(fFiberHod_x_alignment[SpaPosMap[uid]]);
00473     }
00474     AddPicture(pic,"MuensterFrankfurt");
00475   }
00476   if (GetPicture("SpadicsFiberHodYAlignment")==0) {
00477     TGo4Picture* pic = new TGo4Picture("SpadicsFiberHodYAlignment","Y");
00478     int numy = 4;
00479     int numx = (USED_SPADIC-1) / numy;
00480     if (numx*numy < (USED_SPADIC - 1)) 
00481       numx++;
00482     pic->SetDivision(numy, numx);
00483       
00484     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00485       int nx = (uid-1) / numy;
00486       int ny = (uid-1) % numy;
00487 
00488       pic->Pic(ny, nx)->AddObject(fFiberHod_y_alignment[SpaPosMap[uid]]);
00489     }
00490     AddPicture(pic,"MuensterFrankfurt");
00491   }
00492   if (GetPicture("SpadicsPID")==0) {
00493     TGo4Picture* pic = new TGo4Picture("SpadicsPID", "Particle ID");
00494     int numy = 4;
00495     int numx = (USED_SPADIC-1) / numy;
00496     if (numx*numy < (USED_SPADIC - 1)) 
00497       numx++;
00498     pic->SetDivision(numy, numx);
00499       
00500     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00501       int nx = (uid-1) / numy;
00502       int ny = (uid-1) % numy;
00503 
00504       pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00505       pic->Pic(ny, nx)->SetRangeY(1, 25000);
00506       pic->Pic(ny, nx)->AddObject(fSpadic_pid[SpaPosMap[uid]]);
00507     }
00508     AddPicture(pic,"MuensterFrankfurt");
00509   }
00510   if (GetPicture("SpadicsEfficiency")==0) {
00511     TGo4Picture* pic = new TGo4Picture("SpadicsEfficiency", "Trigger Efficiency");         
00512     pic->Pic(0, 0)->AddObject(fSpadic_efficiency);    
00513     AddPicture(pic,"MuensterFrankfurt");
00514   }
00515   if (GetPicture("MFmaxAmplitude")==0) {
00516     TGo4Picture* pic = new TGo4Picture("MFmaxAmplitude","max. amplitude on pad max");
00517     int numy = 4;
00518     int numx = (USED_SPADIC-1) / numy;
00519     if (numx*numy < (USED_SPADIC - 1)) 
00520       numx++;
00521     pic->SetDivision(numy, numx);
00522       
00523     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00524       int nx = (uid-1) / numy;
00525       int ny = (uid-1) % numy;
00526 
00527       pic->Pic(ny, nx)->AddObject(fSpadic_maxAmplitude[SpaPosMap[uid]]);
00528       pic->Pic(ny, nx)->AddObject(fSpadic_el_maxAmplitude[SpaPosMap[uid]]);
00529       pic->Pic(ny, nx)->AddObject(fSpadic_pi_maxAmplitude[SpaPosMap[uid]]);
00530       pic->Pic(ny, nx)->AddCondition(fSpadic_minAmplitudeCond[SpaPosMap[uid]]);
00531     }
00532     AddPicture(pic,"MuensterFrankfurt");
00533   }
00534 
00535   if (GetPicture("MFhitTime")==0) {
00536     TGo4Picture* pic = new TGo4Picture("MFhitTime","hit time on pad max");
00537     int numy = 4;
00538     int numx = (USED_SPADIC-1) / numy;
00539     if (numx*numy < (USED_SPADIC - 1)) 
00540       numx++;
00541     pic->SetDivision(numy, numx);
00542       
00543     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00544       int nx = (uid-1) / numy;
00545       int ny = (uid-1) % numy;
00546       pic->Pic(ny, nx)->AddObject(fSpadic_hitTime[SpaPosMap[uid]]);
00547       pic->Pic(ny, nx)->AddObject(fSpadic_el_hitTime[SpaPosMap[uid]]);
00548       pic->Pic(ny, nx)->AddObject(fSpadic_pi_hitTime[SpaPosMap[uid]]);
00549       pic->Pic(ny, nx)->AddCondition(fSpadic_hitTimeCond[SpaPosMap[uid]]);
00550     }
00551     AddPicture(pic,"MuensterFrankfurt");
00552   }
00553 
00554   if (GetPicture("MFmaxIntensity")==0) {
00555     TGo4Picture* pic = new TGo4Picture("MFmaxIntensity","integrated intensity on 3 max pads");
00556     int numy = 4;
00557     int numx = (USED_SPADIC-1) / numy;
00558     if (numx*numy < (USED_SPADIC - 1)) 
00559       numx++;
00560     pic->SetDivision(numy, numx);
00561       
00562     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00563       int nx = (uid-1) / numy;
00564       int ny = (uid-1) % numy;
00565 
00566       pic->Pic(ny, nx)->AddObject(fSpadic_intens[SpaPosMap[uid]]);
00567       pic->Pic(ny, nx)->AddCondition(fSpadic_minIntensCond[SpaPosMap[uid]]);
00568     }
00569     AddPicture(pic,"MuensterFrankfurt");
00570   }
00571   if (GetPicture("MFFingerCorr")==0) {
00572     TGo4Picture* pic = new TGo4Picture("MFFingerCorr","Correlation with Finger Sint.");
00573     int numy = 4;
00574     int numx = (USED_SPADIC-1) / numy;
00575     if (numx*numy < (USED_SPADIC - 1)) 
00576       numx++;
00577     pic->SetDivision(numy, numx);
00578       
00579     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00580       int nx = (uid-1) / numy;
00581       int ny = (uid-1) % numy;
00582 
00583       pic->Pic(ny, nx)->AddObject(fSpadic_FingerCorr[SpaPosMap[uid]]);
00584     }
00585     AddPicture(pic,"MuensterFrankfurt");
00586   }
00587   /*  
00588   // previously TSpadicProc.cxx 30.08.2011
00589 
00590   obname.Form("Traces_Spadic%d", sid);
00591   pSpadic_traces[sid] = GetPicture(obname.Data());
00592   if (pSpadic_traces[sid] == 0) {
00593   obtitle.Form("Pulse Traces of Spadic %d", sid);
00594   pSpadic_traces[sid] = new TGo4Picture(obname.Data(), obtitle.Data());
00595   pSpadic_traces[sid]->SetDivision(NUM_SPADIC_CHA / 4, 4);
00596 
00597   for (ch = 0; ch < NUM_SPADIC_CHA; ch++) {
00598   pSpadic_traces[sid]->Pic(ch / 4, ch % 4)->AddObject(fSpadic_input[sid][ch]);
00599   pSpadic_traces[sid]->Pic(ch / 4, ch % 4)->AddObject(fSpadic_trace_noisecorr[sid][ch]); 
00600   pSpadic_traces[sid]->Pic(ch / 4, ch % 4)->SetAutoScale(kFALSE);
00601   pSpadic_traces[sid]->Pic(ch / 4, ch % 4)->SetRangeY(-50, 255);
00602   }
00603          
00604   AddPicture(pSpadic_traces[sid]);
00605   }
00606   */
00607   /*
00608     if (GetPicture("")==0) {
00609     TGo4Picture* pic = new TGo4Picture("","");
00610     int numy = 4;
00611     int numx = (MAX_SPADIC-1) / numy;
00612     if (numx*numy < (MAX_SPADIC - 1)) numx++;
00613     pic->SetDivision(numy, numx);
00614       
00615     for (UInt_t sid = 1; sid < MAX_SPADIC; sid++) {
00616     int nx = (sid-1) / numy;
00617     int ny = (sid-1) % numy;
00618     pic->Pic(ny, nx)->AddObject();
00619     }
00620     AddPicture(pic,"MuensterFrankfurt");
00621     }
00622   */
00623   if (GetPicture("MSummary")==0) {
00624     TGo4Picture* pic = new TGo4Picture("MSummary"," ");
00625     int numy = 4;
00626     int numx = 4;//8;
00627     pic->SetDivision(numy, numx);
00628     int nx = 0;//(sid-1);
00629     for (UInt_t sid = 1; sid < 9; sid++) {     
00630       int ny = 0;
00631       if (sid % 2 == 1)
00632         continue;
00633       pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00634       pic->Pic(ny, nx)->SetRangeY(-20, 255);
00635       pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape[SpMap[sid]]);
00636       pic->Pic(ny, nx)->AddObject(fSpadic_el_shape[SpMap[sid]]);
00637       ny = 1;
00638       //pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00639       pic->Pic(ny, nx)->SetRangeY(-20, 255);
00640       pic->Pic(ny, nx)->SetLogScale(2,1);
00641       pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape2D[SpMap[sid]]);
00642       ny = 2;
00643       //pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00644       pic->Pic(ny, nx)->SetRangeY(-20, 255);
00645       pic->Pic(ny, nx)->SetLogScale(2,1);
00646       pic->Pic(ny, nx)->AddObject(fSpadic_el_shape2D[SpMap[sid]]);
00647       ny = 3;
00648       pic->Pic(ny, nx)->AddObject(fSpadic_intens[SpMap[sid]]);
00649       pic->Pic(ny, nx)->AddObject(fSpadic_el_intens[SpMap[sid]]);
00650       pic->Pic(ny, nx)->AddObject(fSpadic_pi_intens[SpMap[sid]]);
00651       nx++;
00652     }
00653     AddPicture(pic,"MuensterFrankfurt");
00654   }
00655 
00656   // reduced to 12
00657   if (GetPicture("MFShape")==0) {
00658     TGo4Picture* pic = new TGo4Picture("MFShape","Electron and Pion Pulse Shape");
00659     int numy = 4;
00660     int numx = (USED_SPADIC-1) / numy;
00661     if (numx*numy < (USED_SPADIC - 1)) 
00662       numx++;
00663     pic->SetDivision(numy, numx);
00664       
00665     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00666       int nx = (uid-1) / numy;
00667       int ny = (uid-1) % numy;
00668 
00669       pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00670       pic->Pic(ny, nx)->SetRangeY(-20, 255);
00671 
00672       pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape[SpaPosMap[uid]]);
00673       pic->Pic(ny, nx)->AddObject(fSpadic_el_shape[SpaPosMap[uid]]);
00674       pic->Pic(ny, nx)->AddObject( S2N[SpaPosMap[uid]]);
00675     }
00676     AddPicture(pic,"MuensterFrankfurt");
00677   }
00678 
00679   if (GetPicture("MFShapeRatio")==0) {
00680     const UInt_t first_MF_Spadic =  1;
00681     const UInt_t  last_MF_Spadic = 12;
00682     Int_t d_MF_Spadic = last_MF_Spadic - first_MF_Spadic + 1;
00683     TGo4Picture* pic = new TGo4Picture("MFShapeRatio", "MF Signal Shape Ratio");
00684     pic->SetDivision(d_MF_Spadic, d_MF_Spadic);
00685     for (UInt_t sid = first_MF_Spadic; sid <= last_MF_Spadic; sid++) {
00686       for (UInt_t sid2 = sid; sid2 <= last_MF_Spadic; sid2++) {
00687         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->SetAutoScale(kFALSE);
00688         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->SetRangeY(-1, 3);
00689 
00690         if (SpMap[sid] <= SpMap[sid2])
00691           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", SpMap[sid], SpMap[sid], SpMap[sid2]);
00692         else
00693           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", SpMap[sid2], SpMap[sid2], SpMap[sid]);
00694         his=GetHistogram(obname.Data());
00695         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(his);
00696         if (SpMap[sid] <= SpMap[sid2])
00697           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", SpMap[sid], SpMap[sid], SpMap[sid2]);
00698         else
00699           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", SpMap[sid2], SpMap[sid2], SpMap[sid]);
00700         his=GetHistogram(obname.Data());
00701 
00702         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(his);
00703         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(one);
00704         //cout << "  " << sid << " " << sid2 << endl;
00705       }
00706     }
00707     AddPicture(pic,"MuensterFrankfurt");
00708   }
00709 
00710   //  Int_t SbMap[MAX_SPADIC]      = {  0,  2, 12,  6, 18,  0,  0,  0,  0,  4, 16, 17,  5, 10, 14,  7,  8,  9, 13, 19 };  // map of bottom Spadics 
00711   if (GetPicture("MS4BotShapeRatio")==0) {
00712     const UInt_t first_MF_Spadic = 1;
00713     const UInt_t  last_MF_Spadic = 4;
00714     Int_t d_MF_Spadic = last_MF_Spadic - first_MF_Spadic + 1;
00715     TGo4Picture* pic = new TGo4Picture("MS4BotShapeRatio", "MS 4 bottom Signal Shape Ratio");
00716     pic->SetDivision(d_MF_Spadic-1, d_MF_Spadic-1);
00717     for (UInt_t sid = first_MF_Spadic; sid <= last_MF_Spadic; sid++) {
00718       for (UInt_t sid2 = sid; sid2 <= last_MF_Spadic; sid2++) {
00719         if (sid == sid2) continue;
00720 
00721         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->SetAutoScale(kFALSE);
00722         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->SetRangeY(-1, 3);
00723 
00724         if (SbMap[sid] <= SbMap[sid2])
00725           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", SbMap[sid], SbMap[sid], SbMap[sid2]);
00726         else
00727           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", SbMap[sid2], SbMap[sid2], SbMap[sid]);
00728         his=GetHistogram(obname.Data());
00729         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->AddObject(his);
00730         if (SbMap[sid] <= SbMap[sid2])
00731           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", SbMap[sid], SbMap[sid], SbMap[sid2]);
00732         else
00733           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", SbMap[sid2], SbMap[sid2], SbMap[sid]);
00734         his=GetHistogram(obname.Data());
00735 
00736         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->AddObject(his);
00737         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->AddObject(one);
00738         //cout << "  " << sid << " " << sid2 << endl;
00739       }
00740     }
00741     AddPicture(pic,"MuensterFrankfurt");
00742   }
00743 
00744   //  Int_t StMap[MAX_SPADIC]      = {  0,  1, 11,  3, 15,  0,  0,  0,  0,  4, 16, 17,  5, 10, 14,  7,  8,  9, 13, 19 };  // map of top    Spadics 
00745   if (GetPicture("MS4TopShapeRatio")==0) {
00746     const UInt_t first_MF_Spadic = 1;
00747     const UInt_t  last_MF_Spadic = 4;
00748     Int_t d_MF_Spadic = last_MF_Spadic - first_MF_Spadic + 1;
00749     TGo4Picture* pic = new TGo4Picture("MS4TopShapeRatio", "MS 4 bottom Signal Shape Ratio");
00750     pic->SetDivision(d_MF_Spadic-1, d_MF_Spadic-1);
00751     for (UInt_t sid = first_MF_Spadic; sid <= last_MF_Spadic; sid++) {
00752       for (UInt_t sid2 = sid; sid2 <= last_MF_Spadic; sid2++) {
00753         if (sid == sid2) continue;
00754 
00755         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->SetAutoScale(kFALSE);
00756         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->SetRangeY(-1, 3);
00757 
00758         if (StMap[sid] <= StMap[sid2])
00759           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", StMap[sid], StMap[sid], StMap[sid2]);
00760         else
00761           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_el_Ratio", StMap[sid2], StMap[sid2], StMap[sid]);
00762         his=GetHistogram(obname.Data());
00763         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->AddObject(his);
00764         if (StMap[sid] <= StMap[sid2])
00765           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", StMap[sid], StMap[sid], StMap[sid2]);
00766         else
00767           obname.Form("MuensterFrankfurt/Spadic_%d/Spadic%d_%d_SHAPE_pi_Ratio", StMap[sid2], StMap[sid2], StMap[sid]);
00768         his=GetHistogram(obname.Data());
00769 
00770         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->AddObject(his);
00771         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic-1)->AddObject(one);
00772         //cout << "  " << sid << " " << sid2 << endl;
00773       }
00774     }
00775     AddPicture(pic,"MuensterFrankfurt");
00776   }
00777 
00778   // reduced to 12
00779   if (GetPicture("MFShapeP2D")==0) {
00780     TGo4Picture* pic = new TGo4Picture("MFShapeP2D","Pion Pulse Shape 2D");
00781     int numy = 4;
00782     int numx = (USED_SPADIC-1) / numy;
00783     if (numx*numy < (USED_SPADIC - 1)) 
00784       numx++;
00785     pic->SetDivision(numy, numx);
00786       
00787     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00788       int nx = (uid-1) / numy;
00789       int ny = (uid-1) % numy;
00790 
00791       pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00792       pic->Pic(ny, nx)->SetRangeY(-20, 255);
00793 
00794       pic->Pic(ny, nx)->AddObject(fSpadic_pi_shape2D[SpaPosMap[uid]]);
00795     }
00796     AddPicture(pic,"MuensterFrankfurt");
00797   }
00798 
00799   // reduced to 12
00800   if (GetPicture("MFShapeE2D")==0) {
00801     TGo4Picture* pic = new TGo4Picture("MFShapeE2D","Electron Pulse Shape 2D");
00802     int numy = 4;
00803     int numx = (USED_SPADIC-1) / numy;
00804     if (numx*numy < (USED_SPADIC - 1)) 
00805       numx++;
00806     pic->SetDivision(numy, numx);
00807       
00808     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00809       int nx = (uid-1) / numy;
00810       int ny = (uid-1) % numy;
00811 
00812       pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00813       pic->Pic(ny, nx)->SetRangeY(-20, 255);
00814 
00815       pic->Pic(ny, nx)->AddObject(fSpadic_el_shape2D[SpaPosMap[uid]]);
00816     }
00817     AddPicture(pic,"MuensterFrankfurt");
00818   }
00819 
00820   // reduced to 12
00821   if (GetPicture("MFSpectrum")==0) {
00822     TGo4Picture* pic = new TGo4Picture("MFSpectrum","Integrated and Clustered Intens for Electrons and Pions");
00823     int numy = 4;
00824     int numx = (USED_SPADIC-1) / numy;
00825     if (numx*numy < (USED_SPADIC - 1)) 
00826       numx++;
00827     pic->SetDivision(numy, numx);
00828       
00829     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00830       int nx = (uid-1) / numy;
00831       int ny = (uid-1) % numy;
00832 
00833       pic->Pic(ny, nx)->AddObject(fSpadic_intens   [SpaPosMap[uid]]);
00834       pic->Pic(ny, nx)->AddObject(fSpadic_el_intens[SpaPosMap[uid]]);
00835       pic->Pic(ny, nx)->AddObject(fSpadic_pi_intens[SpaPosMap[uid]]);
00836     }
00837     AddPicture(pic,"MuensterFrankfurt");
00838   }
00839 
00840   // reduced to 12
00841   if (GetPicture("MFInputSpadics")==0) {
00842     TGo4Picture* pic = new TGo4Picture("MFInputSpadics", "Input: MSFF Superposition of all shapes");
00843     int numy = 4;
00844     int numx = (USED_SPADIC-1) / numy;
00845     if (numx*numy < (USED_SPADIC - 1)) 
00846       numx++;
00847     pic->SetDivision(numy, numx);
00848       
00849     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00850       int nx = (uid-1) / numy;
00851       int ny = (uid-1) % numy;
00852          
00853       pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00854       pic->Pic(ny, nx)->SetRangeY(-20, 255);
00855          
00856       for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) 
00857         pic->Pic(ny, nx)->AddObject(fSpadic_input[SpaPosMap[uid]][ch]);
00858     }
00859     AddPicture(pic,"MuensterFrankfurt");
00860   }
00861    
00862   // reduced to 12
00863   if (GetPicture("MFOutputSpadics")==0) {
00864     TGo4Picture* pic = new TGo4Picture("MFOutputSpadics", "Output: MSFF Superposition of all shapes");
00865     int numy = 4;
00866     int numx = (USED_SPADIC-1) / numy;
00867     if (numx*numy < (USED_SPADIC - 1)) 
00868       numx++;
00869     pic->SetDivision(numy, numx);
00870       
00871     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00872       int nx = (uid-1) / numy;
00873       int ny = (uid-1) % numy;
00874          
00875       pic->Pic(ny, nx)->SetAutoScale(kFALSE);
00876       pic->Pic(ny, nx)->SetRangeY(-20, 255);
00877          
00878       for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) 
00879         pic->Pic(ny, nx)->AddObject(fSpadic_output[SpaPosMap[uid]][ch]);
00880     }
00881     AddPicture(pic,"MuensterFrankfurt");
00882   }
00883 
00884   // reduced to 12
00885   if (GetPicture("MFSpadicsPRF")==0) {
00886     TGo4Picture* pic = new TGo4Picture("MFSpadicsPRF", "PRF for noise correction quality test MF");
00887     int numy = 4;
00888     int numx = (USED_SPADIC-1) / numy;
00889     if (numx*numy < (USED_SPADIC - 1)) 
00890       numx++;
00891     pic->SetDivision(numy, numx);
00892       
00893     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00894       int nx = (uid-1) / numy;
00895       int ny = (uid-1) % numy;
00896       pic->Pic(ny, nx)->AddObject(fSpadic_PRFMF[SpaPosMap[uid]]);
00897     }
00898     AddPicture(pic,"MuensterFrankfurt");
00899   }
00900 
00901   // reduced to 12
00902   if (GetPicture("MFSpadicsRecPos")==0) {
00903     TGo4Picture* pic = new TGo4Picture("MFSpadicsRecPos", "PRF based position reconstruction");
00904     int numy = 4;
00905     int numx = (USED_SPADIC-1) / numy;
00906     if (numx*numy < (USED_SPADIC - 1)) 
00907       numx++;
00908     pic->SetDivision(numy, numx);
00909       
00910     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00911       int nx = (uid-1) / numy;
00912       int ny = (uid-1) % numy;
00913 
00914       pic->Pic(ny, nx)->AddObject(fSpadic_recoPos[SpaPosMap[uid]]);
00915     }
00916     AddPicture(pic,"MuensterFrankfurt");
00917   }
00918 
00919   // reduced to 12
00920   if (GetPicture("MFStatistics")==0) {
00921     TGo4Picture* pic = new TGo4Picture("MFStatistics", "Beam and Chamber Statistics");
00922     int numy = 4;
00923     int numx = (USED_SPADIC-1) / numy;
00924     if (numx*numy < (USED_SPADIC - 1)) 
00925       numx++;
00926     pic->SetDivision(numy, numx);
00927       
00928     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00929       int nx = (uid-1) / numy;
00930       int ny = (uid-1) % numy;
00931 
00932       pic->Pic(ny, nx)->AddObject(fSpadic_statistics[SpaPosMap[uid]]);
00933     }
00934     AddPicture(pic,"MuensterFrankfurt");
00935   }
00936  
00937   // reduced to 12
00938   if (GetPicture("MFSpadicsADCdist")==0) {
00939     TGo4Picture* pic = new TGo4Picture("MFSpadicsADCdist", "Distribution of ADC values, for noise analysis");
00940     int numy = 4;
00941     int numx = (USED_SPADIC-1) / numy;
00942     if (numx*numy < (USED_SPADIC - 1))
00943       numx++;
00944     pic->SetDivision(numy, numx);
00945 
00946     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00947       int nx = (uid-1) / numy;
00948       int ny = (uid-1) % numy;
00949 
00950       for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) 
00951         pic->Pic(ny, nx)->AddObject(fSpadic_ADCdistMF[SpaPosMap[uid]][ch]);
00952     }
00953     AddPicture(pic,"MuensterFrankfurt");
00954   }
00955 
00956   // reduced to 12
00957   if (GetPicture("MFSpadicsNoiseDist")==0) {
00958     TGo4Picture* pic = new TGo4Picture("MFSpadicsNoiseDist", "Noise-Distribution (RMS) of ADC distribution");
00959     int numy = 4;
00960     int numx = (USED_SPADIC-1) / numy;
00961     if (numx*numy < (USED_SPADIC - 1))
00962       numx++;
00963     pic->SetDivision(numy, numx);
00964 
00965     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00966       int nx = (uid-1) / numy;
00967       int ny = (uid-1) % numy;
00968 
00969       pic->Pic(ny, nx)->AddObject(fSpadic_NoiseDistMF[SpaPosMap[uid]]);
00970     }
00971     AddPicture(pic,"MuensterFrankfurt");
00972   }
00973 
00974   // reduced to 12
00975   if (GetPicture("MFSpadicsNoiseDist2D")==0) {
00976     TGo4Picture* pic = new TGo4Picture("MFSpadicsNoiseDist2D", "Noise-Distribution (RMS) of ADC distribution 2D");
00977     int numy = 4;
00978     int numx = (USED_SPADIC-1) / numy;
00979     if (numx*numy < (USED_SPADIC - 1))
00980       numx++;
00981     pic->SetDivision(numy, numx);
00982 
00983     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
00984       int nx = (uid-1) / numy;
00985       int ny = (uid-1) % numy;
00986 
00987       pic->Pic(ny, nx)->AddObject(fSpadic_NoiseDist2DMF[SpaPosMap[uid]]);
00988     }
00989     AddPicture(pic,"MuensterFrankfurt");
00990   }
00991 
00992   // reduced to 12
00993   if (GetPicture("MFSpadicsPedelPos")==0) {
00994     TGo4Picture* pic = new TGo4Picture("MFSpadicsPedelPos", "Pedestel Position (Mean) of ADC distribution");
00995     int numy = 4;
00996     int numx = (USED_SPADIC-1) / numy;
00997     if (numx*numy < (USED_SPADIC - 1))
00998       numx++;
00999     pic->SetDivision(numy, numx);
01000 
01001     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
01002       int nx = (uid-1) / numy;
01003       int ny = (uid-1) % numy;
01004 
01005       pic->Pic(ny, nx)->AddObject(fSpadic_PedelPosMF[SpaPosMap[uid]]);
01006     }
01007     AddPicture(pic,"MuensterFrankfurt");
01008   }
01009 
01010   // reduced to 12
01011   if (GetPicture("MFSpadicsPedelPos2D")==0) {
01012     TGo4Picture* pic = new TGo4Picture("MFSpadicsPedelPos2D", "Pedestel Position (Mean) of ADC distribution 2D");
01013     int numy = 4;
01014     int numx = (USED_SPADIC-1) / numy;
01015     if (numx*numy < (USED_SPADIC - 1))
01016       numx++;
01017     pic->SetDivision(numy, numx);
01018 
01019     for (UInt_t uid = 1; uid < USED_SPADIC; uid++) {
01020       int nx = (uid-1) / numy;
01021       int ny = (uid-1) % numy;
01022 
01023       pic->Pic(ny, nx)->AddObject(fSpadic_PedelPos2DMF[SpaPosMap[uid]]);
01024     }
01025     AddPicture(pic,"MuensterFrankfurt");
01026   }
01027 
01028   if (GetPicture("HV_LV")==0) {
01029     TGo4Picture* pic = new TGo4Picture("HV_LV", "HV left: Drift  right: Anode  LV left: Spadic  right: Susibo");
01030 
01031     int numx = 4;
01032     int numy = MSTRDNUM-1;
01033     pic->SetDivision(numy, numx);
01034 
01035     for (Int_t i = 1; i < MSTRDNUM; i++) { 
01036       //HV
01037       pic->Pic(0, i-1)->SetAutoScale(kFALSE);
01038       pic->Pic(0, i-1)->SetRangeY(-40, 800);
01039       pic->Pic(0, i-1)->AddObject(fEpicsMSTRD_DriftU[i]);
01040       pic->Pic(0, i-1)->AddObject(fEpicsMSTRD_DriftI[i]);
01041       pic->Pic(1, i-1)->SetAutoScale(kFALSE);
01042       pic->Pic(1, i-1)->SetRangeY(-100, 2200); 
01043       pic->Pic(1, i-1)->AddObject(fEpicsMSTRD_AnodeU[i]);
01044       pic->Pic(1, i-1)->AddObject(fEpicsMSTRD_AnodeI[i]);
01045       //LV
01046       pic->Pic(2, i-1)->SetAutoScale(kFALSE);
01047       pic->Pic(2, i-1)->SetRangeY(-0.2, 6);
01048       pic->Pic(2, i-1)->AddObject(fEpicsMSTRD_SpaU[i]);
01049       pic->Pic(2, i-1)->AddObject(fEpicsMSTRD_SpaI[i]);
01050       pic->Pic(3, i-1)->SetAutoScale(kFALSE);
01051       pic->Pic(3, i-1)->SetRangeY(-0.2, 6);
01052       pic->Pic(3, i-1)->AddObject(fEpicsMSTRD_SusU[i]);
01053       pic->Pic(3, i-1)->AddObject(fEpicsMSTRD_SusI[i]);
01054     }
01055     AddPicture(pic,"MuensterEPICS");
01056   } 
01057 
01058   if (GetPicture("Temp")==0) {
01059     TGo4Picture* pic = new TGo4Picture("Temp", "Temp");
01060     pic->SetDivision(4, 1);
01061     pic->Pic(0, 0)->SetAutoScale(kFALSE);
01062     pic->Pic(0, 0)->SetRangeY(0, 70);
01063     pic->Pic(0, 0)->AddObject(fEpicsMSTRD_T[0]);
01064     pic->Pic(1, 0)->SetAutoScale(kFALSE);
01065     pic->Pic(1, 0)->SetRangeY(0, 70);
01066     pic->Pic(1, 0)->AddObject(fEpicsMSTRD_T[1]);
01067     pic->Pic(2, 0)->SetAutoScale(kFALSE);
01068     pic->Pic(2, 0)->SetRangeY(0, 70);
01069     pic->Pic(2, 0)->AddObject(fEpicsMSTRD_T[2]);
01070     pic->Pic(3, 0)->SetAutoScale(kFALSE);
01071     pic->Pic(3, 0)->SetRangeY(0, 70);
01072     pic->Pic(3, 0)->AddObject(fEpicsMSTRD_T[3]);
01073     AddPicture(pic,"MuensterEPICS");
01074   }
01075   
01076   if (GetPicture("Beam_Monitor_HV")==0) {
01077     TGo4Picture* pic = new TGo4Picture("Beam_Monitor_HV", "Beam_Monitor_HV");
01078     pic->SetDivision(4, 2);
01079     pic->Pic(0, 0)->SetAutoScale(kFALSE);
01080     pic->Pic(0, 0)->SetRangeY(-100, 3000);
01081     pic->Pic(0, 0)->AddObject(fEpics_MonitorU[0]);
01082     pic->Pic(0, 0)->AddObject(fEpics_MonitorI[0]);
01083     pic->Pic(0, 1)->SetAutoScale(kFALSE);
01084     pic->Pic(0, 1)->SetRangeY(-100, 3000);
01085     pic->Pic(0, 1)->AddObject(fEpics_MonitorU[1]);
01086     pic->Pic(0, 1)->AddObject(fEpics_MonitorI[1]);
01087 
01088     pic->Pic(1, 0)->SetAutoScale(kFALSE);
01089     pic->Pic(1, 0)->SetRangeY(-100, 3000);
01090     pic->Pic(1, 0)->AddObject(fEpics_MonitorU[2]);
01091     pic->Pic(1, 0)->AddObject(fEpics_MonitorI[2]);
01092     pic->Pic(1, 1)->SetAutoScale(kFALSE);
01093     pic->Pic(1, 1)->SetRangeY(-100, 3000);
01094     pic->Pic(1, 1)->AddObject(fEpics_MonitorU[3]);
01095     pic->Pic(1, 1)->AddObject(fEpics_MonitorI[3]);
01096 
01097     pic->Pic(2, 0)->SetAutoScale(kFALSE);
01098     pic->Pic(2, 0)->SetRangeY(-100, 3000);
01099     pic->Pic(2, 0)->AddObject(fEpics_MonitorU[4]);
01100     pic->Pic(2, 0)->AddObject(fEpics_MonitorI[4]);
01101     pic->Pic(2, 1)->SetAutoScale(kFALSE);
01102     pic->Pic(2, 1)->SetRangeY(-100, 3000);
01103     pic->Pic(2, 1)->AddObject(fEpics_MonitorU[5]);
01104     pic->Pic(2, 1)->AddObject(fEpics_MonitorI[5]);
01105 
01106     pic->Pic(3, 0)->SetAutoScale(kFALSE);
01107     pic->Pic(3, 0)->SetRangeY(-100, 3000);
01108     pic->Pic(3, 0)->AddObject(fEpics_MonitorU[6]);
01109     pic->Pic(3, 0)->AddObject(fEpics_MonitorI[6]);
01110     pic->Pic(3, 1)->SetAutoScale(kFALSE);
01111     pic->Pic(3, 1)->SetRangeY(-100, 3000);
01112     pic->Pic(3, 1)->AddObject(fEpics_MonitorU[7]);
01113     pic->Pic(3, 1)->AddObject(fEpics_MonitorI[7]);
01114     AddPicture(pic,"BeamMonitorEPICS");
01115   }
01116 
01117   for (Int_t sl = 0; sl < MPOD00SLOT; sl++) {
01118     TString name;
01119     name.Form("MS_MPOD00_SLOT%02i",sl);
01120     if (GetPicture(name)==0) {
01121       TGo4Picture* pic = new TGo4Picture(name,name);     
01122       Int_t nCol = Int_t(sqrt(MPOD00CHA) + 0.5);
01123       pic->SetDivision(nCol, nCol);
01124       Int_t iRow(0), iCol(0);
01125       for (Int_t ch = 0; ch < MPOD00CHA; ch++){
01126         if (iCol == nCol) {
01127           iRow++;
01128           iCol = 0;
01129         }
01130         pic->Pic(iRow, iCol)->SetAutoScale(kFALSE);
01131         pic->Pic(iRow, iCol)->SetRangeY(-100, 3000);
01132         pic->Pic(iRow, iCol)->AddObject(fEpicsMSMpod00_Monitor_U[sl][ch]);
01133         pic->Pic(iRow, iCol)->AddObject(fEpicsMSMpod00_Monitor_I[sl][ch]);
01134         iCol++;
01135       }
01136       AddPicture(pic,"MuensterEPICS");
01137     }   
01138   }
01139 
01140   for (Int_t sl = 0; sl < MPOD01SLOT; sl++) {
01141     TString name;
01142     name.Form("MS_MPOD01_SLOT%02i",sl);
01143     if (GetPicture(name)==0) {
01144       TGo4Picture* pic = new TGo4Picture(name,name);     
01145       Int_t nCol = Int_t(sqrt(MPOD01CHA) + 0.5);
01146       pic->SetDivision(nCol, nCol);
01147       Int_t iRow(0), iCol(0);
01148       for (Int_t ch = 0; ch < MPOD01CHA; ch++){
01149         if (iCol == nCol) {
01150           iRow++;
01151           iCol = 0;
01152         }
01153         pic->Pic(iRow, iCol)->SetAutoScale(kFALSE);
01154         pic->Pic(iRow, iCol)->SetRangeY(-100, 3000);
01155         pic->Pic(iRow, iCol)->AddObject(fEpicsMSMpod01_Monitor_U[sl][ch]);
01156         pic->Pic(iRow, iCol)->AddObject(fEpicsMSMpod01_Monitor_I[sl][ch]);
01157         iCol++;
01158       }
01159       AddPicture(pic,"MuensterEPICS");
01160     }   
01161   }
01162 
01163   if (GetPicture("RICH_HV")==0) {
01164     TGo4Picture* pic = new TGo4Picture("RICH_HV", "HV on MAPMTs");
01165 
01166     //                        0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16
01167     int mapx [RICHNUM] = {  0,  0,  0,  1,  1,  2,  2,  3,  3,  0,  0,  1,  1,  2,  2,  3,  3 };
01168     int mapy [RICHNUM] = {  0,  0,  1,  0,  1,  0,  1,  0,  1,  2,  3,  2,  3,  2,  3,  2,  3 };
01169     int numx = 4;
01170     int numy = 4;
01171     pic->SetDivision(numy, numx);
01172     int posx = 0;
01173     int posy = 0;
01174 
01175     for (Int_t i = 1; i < RICHNUM; i++) { 
01176       posx = mapx[i];
01177       posy = mapy[i];
01178       //      posx = (i-1) % numx;
01179       //      posy = (i-1) / numx;
01180 
01181       //RICH HV
01182       pic->Pic(posy, posx)->SetAutoScale(kFALSE);
01183       pic->Pic(posy, posx)->SetRangeY(-100, 2500); 
01184       pic->Pic(posy, posx)->AddObject(fEpics_RichU[i]);
01185       pic->Pic(posy, posx)->AddObject(fEpics_RichI[i]);
01186     }
01187     AddPicture(pic,"BeamMonitorEPICS");
01188   } 
01189   
01190 
01191   // 19.10.2011                  // MS                           // FF          // unused
01192   //  Int_t SpMap[MAX_SPADIC] = {  0,  1,  2, 11, 12,  3,  6, 15, 18,  4, 16, 17,  5, 10, 14,  7,  8,  9, 13, 19 };  // map of Spadics in TRD order
01193   //  Int_t SuMap[MAX_SPADIC] = {  0,  1,  5,  3,  9, 12,  7, 17, 18, 15, 13,  2,  6, 16, 14,  4, 10, 11,  8, 19 };  // histo mapping
01194 
01195   // all 12 Spadics
01196   if (GetPicture("MFCorrelations")==0) {
01197     const UInt_t first_MF_Spadic =  1;
01198     const UInt_t  last_MF_Spadic = 12;
01199     Int_t d_MF_Spadic = last_MF_Spadic - first_MF_Spadic + 1;
01200     TGo4Picture* pic = new TGo4Picture("MFCorrelations", "MF Beam and Chamber Correlation");
01201     pic->SetDivision(d_MF_Spadic, d_MF_Spadic);
01202     for (UInt_t sid = first_MF_Spadic; sid <= last_MF_Spadic; sid++) {
01203       for (UInt_t sid2 = sid; sid2 <= last_MF_Spadic; sid2++) {
01204         if (SpMap[sid] <= SpMap[sid2])
01205           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01206         else
01207           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01208         his=GetHistogram(obname.Data());
01209         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(his, "colz");
01210         //      pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->SetLogScale(2,1);
01211         //cout << "  " << sid << " " << sid2 << endl;
01212       }
01213     }
01214     AddPicture(pic,"MuensterFrankfurt");
01215   }
01216 
01217   if (GetPicture("MFAlignment")==0) {
01218     const UInt_t first_MF_Spadic =  1;
01219     const UInt_t  last_MF_Spadic = 12;
01220     Int_t d_MF_Spadic = last_MF_Spadic - first_MF_Spadic + 1;
01221     TGo4Picture* pic = new TGo4Picture("MFAlignment", "MF Beam and Chamber Alignment");
01222     pic->SetDivision(d_MF_Spadic, d_MF_Spadic);
01223     for (UInt_t sid = first_MF_Spadic; sid <= last_MF_Spadic; sid++) {
01224       for (UInt_t sid2 = sid; sid2 <= last_MF_Spadic; sid2++) {
01225         if (SpMap[sid] <= SpMap[sid2])
01226           obname.Form("MuensterFrankfurt/Alignment/Alignment_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01227         else
01228           obname.Form("MuensterFrankfurt/Alignment/Alignment_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01229         his=GetHistogram(obname.Data());
01230         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->AddObject(his, "colz");
01231         pic->Pic(sid-first_MF_Spadic, sid2-first_MF_Spadic)->SetLogScale(2,1);
01232         //cout << "  " << sid << " " << sid2 << endl;
01233       }
01234     }
01235     AddPicture(pic,"MuensterFrankfurt");
01236   }
01237 
01238   // all 8 Muenster Spadics
01239   const UInt_t first_M_Spadic = 1;
01240   const UInt_t  last_M_Spadic = 8;
01241   Int_t d_M_Spadic = last_M_Spadic - first_M_Spadic + 1;
01242   if (GetPicture("MS8Correlations")==0) {
01243     TGo4Picture* pic = new TGo4Picture("MS8Correlations", "MS 8 Beam and Chamber Correlation");
01244     pic->SetDivision(d_M_Spadic, d_M_Spadic);
01245     for (UInt_t sid = first_M_Spadic; sid <= last_M_Spadic; sid++) {
01246       for (UInt_t sid2 = sid; sid2 <= last_M_Spadic; sid2++) {
01247         if (SpMap[sid] <= SpMap[sid2])
01248           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01249         else
01250           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01251         his=GetHistogram(obname.Data());
01252         pic->Pic(sid-first_M_Spadic, sid2-first_M_Spadic)->AddObject(his, "colz");
01253         //      pic->Pic(sid-first_M_Spadic, sid2-first_M_Spadic)->SetLogScale(2,1);
01254         //cout << "  " << sid << " " << sid2 << endl;
01255       }
01256     }
01257     AddPicture(pic,"MuensterFrankfurt");
01258   }
01259 
01260   // all 4 Muenster 336 Spadics
01261   if (GetPicture("MS336Correlations")==0) {
01262     const UInt_t first_M336_Spadic = 1;
01263     const UInt_t  last_M336_Spadic = 4;
01264     Int_t d_M336_Spadic = last_M336_Spadic - first_M336_Spadic + 1;
01265     TGo4Picture* pic = new TGo4Picture("MS336Correlations", "MS 336 Beam and Chamber Correlation");
01266     pic->SetDivision(d_M336_Spadic, d_M336_Spadic);
01267     for (UInt_t sid = first_M336_Spadic; sid <= last_M336_Spadic; sid++) {
01268       for (UInt_t sid2 = sid; sid2 <= last_M336_Spadic; sid2++) {
01269         if (SpMap[sid] <= SpMap[sid2])
01270           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01271         else
01272           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01273         his=GetHistogram(obname.Data());
01274         pic->Pic(sid-first_M336_Spadic, sid2-first_M336_Spadic)->AddObject(his, "colz");
01275         //      pic->Pic(sid-first_M336_Spadic, sid2-first_M336_Spadic)->SetLogScale(2,1);
01276         //cout << "  " << sid << " " << sid2 << endl;
01277       }
01278     }
01279     AddPicture(pic,"MuensterFrankfurt");
01280   }
01281 
01282   // all 4 Muenster 444 Spadics
01283   if (GetPicture("MS444Correlations")==0) {
01284     const UInt_t first_M444_Spadic = 5;
01285     const UInt_t  last_M444_Spadic = 8;
01286     Int_t d_M444_Spadic = last_M444_Spadic - first_M444_Spadic + 1;
01287     TGo4Picture* pic = new TGo4Picture("MS444Correlations", "MS 444 Beam and Chamber Correlation");
01288     pic->SetDivision(d_M444_Spadic, d_M444_Spadic);
01289     for (UInt_t sid = first_M444_Spadic; sid <= last_M444_Spadic; sid++) {
01290       for (UInt_t sid2 = sid; sid2 <= last_M444_Spadic; sid2++) {
01291         if (SpMap[sid] <= SpMap[sid2])
01292           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01293         else
01294           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01295         his=GetHistogram(obname.Data());
01296         pic->Pic(sid-first_M444_Spadic, sid2-first_M444_Spadic)->AddObject(his, "colz");
01297         //      pic->Pic(sid-first_M444_Spadic, sid2-first_M444_Spadic)->SetLogScale(2,1);
01298         //cout << "  " << sid << " " << sid2 << endl;
01299       }
01300     }
01301     AddPicture(pic,"MuensterFrankfurt");
01302   }
01303 
01304   // all 4 Frankfurt Spadics
01305   if (GetPicture("FCorrelations")==0) {
01306     const UInt_t first_F_Spadic = 9;
01307     const UInt_t  last_F_Spadic = 12;   // 19.10.2011
01308     Int_t d_F_Spadic = last_F_Spadic - first_F_Spadic + 1;
01309     TGo4Picture* pic = new TGo4Picture("FCorrelations", "F Beam and Chamber Correlation");
01310     pic->SetDivision(d_F_Spadic, d_F_Spadic);
01311     for (UInt_t sid = first_F_Spadic; sid <= last_F_Spadic; sid++) {
01312       for (UInt_t sid2 = sid; sid2 <= last_F_Spadic; sid2++) {
01313         if (SpMap[sid] <= SpMap[sid2])
01314           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid], SpMap[sid2]);
01315         else
01316           obname.Form("MuensterFrankfurt/Correlations/Correlation_Spadic%d_%d", SpMap[sid2], SpMap[sid]);
01317         his=GetHistogram(obname.Data());
01318         pic->Pic(sid-first_F_Spadic, sid2-first_F_Spadic)->AddObject(his, "colz");
01319         //      pic->Pic(sid-first_F_Spadic, sid2-first_F_Spadic)->SetLogScale(2,1);
01320         //cout << "  " << sid << " " << sid2 << endl;
01321       }
01322     }
01323     AddPicture(pic,"MuensterFrankfurt");
01324   }
01325   
01326   if (GetPicture("MFSpadicsBeamProfile2D")==0) {
01327     TGo4Picture* pic = new TGo4Picture("MFSpadicsBeamProfile2D", "MF Spadics Beam Profile 2D");
01328   
01329     pic->SetDivision(2, 2);
01330 
01331     for (UInt_t uid = 0; uid < 4; uid++) {
01332       int nx = (uid) / 2;
01333       int ny = (uid) % 2;
01334 
01335       pic->Pic(ny, nx)->AddObject(fSpadic_beamProfil[uid]);
01336     }
01337     AddPicture(pic,"MuensterFrankfurt");
01338   }
01339 
01340   if (GetPicture("MFSpadicsDeltaPos2D")==0) {
01341     TGo4Picture* pic = new TGo4Picture("MFSpadicsDeltaPos2D", "MF Spadics delta pos. 2D");
01342   
01343     pic->SetDivision(2, 2);
01344 
01345     for (UInt_t uid = 0; uid < 4; uid++) {
01346       int nx = (uid) / 2;
01347       int ny = (uid) % 2;
01348 
01349       pic->Pic(ny, nx)->AddObject(fSpadic_deltaPos[uid]);
01350     }
01351     AddPicture(pic,"MuensterFrankfurt");
01352   }
01353   printf("**** TTRDMuensterFrankfurtProc: Histograms created \n");
01354   fflush ( stdout);
01355 
01356   
01357 
01358 }
01359 
01360 TTRDMuensterFrankfurtProc::~TTRDMuensterFrankfurtProc()
01361 {
01362 }
01363 
01364 void TTRDMuensterFrankfurtProc::InitEvent(TGo4EventElement* outevnt)
01365 {
01366    // first assign input event:
01367    // since input event object is never discarded within processor lifetime,
01368    // we just search for subevent by name once to speed up processing
01369    if(fSpadicInputEvent==0)
01370    {
01371       TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(GetInputEvent());
01372       if(btevent)
01373       {
01374          fCrateInputEvent=dynamic_cast<TMbsCrateEvent*>(btevent->GetSubEvent("MBSCRATE"));
01375          fSpadicInputEvent=dynamic_cast<TSpadicEvent*>(btevent->GetSubEvent("SPADIC"));
01376          fEpicsInputEvent=dynamic_cast<TEpicsEvent*>(btevent->GetSubEvent("EPICS"));
01377       }
01378       else
01379       {
01380          fSpadicInputEvent=dynamic_cast<TSpadicEvent*>(GetInputEvent());
01381 
01382       }
01383       if(fSpadicInputEvent==0) {
01384          GO4_STOP_ANALYSIS_MESSAGE("**** TTRDMuensterFrankfurtProc: Fatal error: input event is not a TSpadicEvent!!! STOP GO4");
01385       }
01386       if(fEpicsInputEvent==0) {
01387          Message(2,"**** TBeamMonitorProc: could not find TEpicsEvent!"); // but do not stop...
01388       }
01389 
01390    }
01391 
01392    // then assign output event
01393    // since output event object is never discarded within processor lifetime,
01394    // we just search for subevent by name once to speed up processing
01395    if(fOutputEvent==0)
01396    {
01397       TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(outevnt);
01398       if(btevent)
01399       {
01400          fOutputEvent=dynamic_cast<TTRDMuensterFrankfurtEvent*>(btevent->GetSubEvent("TRDMSFFM"));
01401          fHodo1 = dynamic_cast<TFiberHodEvent*>(btevent->GetSubEvent("Hodo1"));
01402          fBeamEvent = dynamic_cast<TBeamMonitorEvent*>(btevent->GetSubEvent("BEAM"));
01403       }
01404       else
01405       {
01406          fOutputEvent= dynamic_cast<TTRDMuensterFrankfurtEvent*>(outevnt);
01407       }
01408       if(fOutputEvent==0) {
01409          GO4_STOP_ANALYSIS_MESSAGE("**** TTRDMuensterFrankfurtProc: Fatal error: output event is not a TTRDMuensterFrankfurtEvent!!! STOP GO4");
01410       }
01411    }
01412 }
01413 
01414 void TTRDMuensterFrankfurtProc::FinalizeEvent()
01415 {
01416   // 19.10.2011                      // MS                           // FF          // unused
01417   //  Int_t SpMap[MAX_SPADIC] = {  0,  1,  2, 11, 12,  3,  6, 15, 18,  4, 16, 17,  5, 10, 14,  7,  8,  9, 13, 19 };  // map of Spadics in TRD order
01418   //  Int_t SuMap[MAX_SPADIC] = {  0,  1,  5,  3,  9, 12,  7, 17, 18, 15, 13,  2,  6, 16, 14,  4, 10, 11,  8, 19 };  // histo mapping
01419 
01420   Bool_t ChMap[MAX_SPADIC]; // = { false };
01421   // remap the bottom Spadics
01422   ChMap[SpMap[2]]  = true;   //  ChMap[ 2] = true;
01423   ChMap[SpMap[4]]  = true;   //  ChMap[12] = true;
01424   ChMap[SpMap[6]]  = true;   //  ChMap[ 6] = true;
01425   ChMap[SpMap[8]]  = true;   //  ChMap[18] = true;
01426                    
01427   ChMap[SpMap[1]]  = false;
01428   ChMap[SpMap[3]]  = false;
01429   ChMap[SpMap[5]]  = false;
01430   ChMap[SpMap[7]]  = false;
01431 
01432   ChMap[SpMap[9]]  = false;
01433   ChMap[SpMap[10]] = false;
01434   ChMap[SpMap[11]] = false;
01435   ChMap[SpMap[12]] = true;
01436 
01437   Int_t PID[MAX_SPADIC] = {8};
01438 
01439   if(fEpicsInputEvent && fEpicsInputEvent->IsValid()) // check if new update has been done
01440     {
01441       // map local variables to epics pvs in data stream:
01442       TString varName;
01443       for (Int_t sl = 0; sl < MPOD00SLOT; sl++) {
01444         for (Int_t ch = 0; ch < MPOD00CHA; ch++) {
01445           /*name scheme CBM:TRD:WIENLV_U%i%02i, LV*/
01446           varName.Form("CBM:TRD:WIENLV_U%i%02i:vmon",sl,ch);
01447           fEpicsMSMpod00_U[sl][ch] = fEpicsInputEvent->GetDouble(varName.Data());
01448           varName.Form("CBM:TRD:WIENLV_U%i%02i:imon",sl,ch);
01449           fEpicsMSMpod00_I[sl][ch] = fEpicsInputEvent->GetDouble(varName.Data());
01450         }
01451       }
01452       for (Int_t sl = 0; sl < MPOD01SLOT; sl++) {
01453         for (Int_t ch = 0; ch < MPOD01CHA; ch++) {
01454           /*name scheme CBM:TRD:ISEGHV_U%i%02i, HV*/
01455           varName.Form("CBM:TRD:ISEGHV_U%i%02i:vmon",sl,ch);
01456           fEpicsMSMpod01_U[sl][ch] = fEpicsInputEvent->GetDouble(varName.Data());
01457           varName.Form("CBM:TRD:ISEGHV_U%i%02i:imon",sl,ch);
01458           fEpicsMSMpod01_I[sl][ch] = fEpicsInputEvent->GetDouble(varName.Data());
01459         }
01460       }
01461       fEpicsMSTRD_Drift_U[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U102:vmon");
01462       fEpicsMSTRD_Drift_I[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U102:imon");
01463       fEpicsMSTRD_Anode_U[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U202:vmon");
01464       fEpicsMSTRD_Anode_I[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U202:imon");
01465       fEpicsMSTRD_Drift_U[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U103:vmon");
01466       fEpicsMSTRD_Drift_I[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U103:imon");
01467       fEpicsMSTRD_Anode_U[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U203:vmon");
01468       fEpicsMSTRD_Anode_I[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U203:imon");
01469       fEpicsMSTRD_Drift_U[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U104:vmon");
01470       fEpicsMSTRD_Drift_I[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U104:imon");
01471       fEpicsMSTRD_Anode_U[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U204:vmon");
01472       fEpicsMSTRD_Anode_I[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U204:imon");
01473       fEpicsMSTRD_Drift_U[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U105:vmon");
01474       fEpicsMSTRD_Drift_I[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U105:imon");
01475       fEpicsMSTRD_Anode_U[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U205:vmon");
01476       fEpicsMSTRD_Anode_I[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U205:imon");
01477       fEpicsMSTRD_Temp[0] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U0:temp");
01478       fEpicsMSTRD_Temp[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U100:temp");
01479       fEpicsMSTRD_Temp[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U200:temp");
01480       fEpicsMSTRD_Temp[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U300:temp");
01481       fEpicsMSTRD_Sus_U[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U1:vmon");
01482       fEpicsMSTRD_Sus_I[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U1:imon");
01483       fEpicsMSTRD_Spa_U[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U0:vmon");
01484       fEpicsMSTRD_Spa_I[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U0:imon");
01485       fEpicsMSTRD_Sus_U[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U3:vmon");
01486       fEpicsMSTRD_Sus_I[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U3:imon");
01487       fEpicsMSTRD_Spa_U[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U2:vmon");
01488       fEpicsMSTRD_Spa_I[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U2:imon");
01489       fEpicsMSTRD_Sus_U[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U5:vmon");
01490       fEpicsMSTRD_Sus_I[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U5:imon");
01491       fEpicsMSTRD_Spa_U[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U4:vmon");
01492       fEpicsMSTRD_Spa_I[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U4:imon");
01493       fEpicsMSTRD_Sus_U[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U7:vmon");
01494       fEpicsMSTRD_Sus_I[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U7:imon");
01495       fEpicsMSTRD_Spa_U[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U6:vmon");
01496       fEpicsMSTRD_Spa_I[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U6:imon");
01497       
01498       fEpics_Monitor_U[0] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U300:vmon");
01499       fEpics_Monitor_I[0] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U300:imon");
01500       fEpics_Monitor_U[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U301:vmon");
01501       fEpics_Monitor_I[1] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U301:imon");
01502       fEpics_Monitor_U[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U302:vmon");
01503       fEpics_Monitor_I[2] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U302:imon");
01504       fEpics_Monitor_U[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U303:vmon");
01505       fEpics_Monitor_I[3] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U303:imon");
01506       fEpics_Monitor_U[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U304:vmon");
01507       fEpics_Monitor_I[4] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U304:imon");
01508       fEpics_Monitor_U[5] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U305:vmon");
01509       fEpics_Monitor_I[5] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U305:imon");
01510       fEpics_Monitor_U[6] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U306:vmon");
01511       fEpics_Monitor_I[6] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U306:imon");
01512       fEpics_Monitor_U[7] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U307:vmon");
01513       fEpics_Monitor_I[7] = fEpicsInputEvent->GetDouble("CBM:TRD:ISEGHV_U307:imon");
01514       
01515       fEpics_Rich_U[1]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U0:vmon");
01516       fEpics_Rich_I[1]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U0:imon");
01517       fEpics_Rich_U[2]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U1:vmon");
01518       fEpics_Rich_I[2]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U1:imon");
01519       fEpics_Rich_U[3]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U2:vmon");
01520       fEpics_Rich_I[3]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U2:imon");
01521       fEpics_Rich_U[4]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U3:vmon");
01522       fEpics_Rich_I[4]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U3:imon");
01523       fEpics_Rich_U[5]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U4:vmon");
01524       fEpics_Rich_I[5]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U4:imon");
01525       fEpics_Rich_U[6]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U5:vmon");
01526       fEpics_Rich_I[6]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U5:imon");
01527       fEpics_Rich_U[7]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U6:vmon");
01528       fEpics_Rich_I[7]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U6:imon");
01529       fEpics_Rich_U[8]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U7:vmon");
01530       fEpics_Rich_I[8]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U7:imon");
01531 
01532       fEpics_Rich_U[9]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U8:vmon");
01533       fEpics_Rich_I[9]  = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U8:imon");
01534       fEpics_Rich_U[10] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U9:vmon");
01535       fEpics_Rich_I[10] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U9:imon");
01536       fEpics_Rich_U[11] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U10:vmon");
01537       fEpics_Rich_I[11] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U10:imon");
01538       fEpics_Rich_U[12] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U11:vmon");
01539       fEpics_Rich_I[12] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U11:imon");
01540       fEpics_Rich_U[13] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U12:vmon");
01541       fEpics_Rich_I[13] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U12:imon");
01542       fEpics_Rich_U[14] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U13:vmon");
01543       fEpics_Rich_I[14] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U13:imon");
01544       fEpics_Rich_U[15] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U14:vmon");
01545       fEpics_Rich_I[15] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U14:imon");
01546       fEpics_Rich_U[16] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U15:vmon");
01547       fEpics_Rich_I[16] = fEpicsInputEvent->GetDouble("CBM:GIE:ISEGHV_U15:imon");
01548       
01549       // JAM: we do not histogram these here, since this can be configured in generic epics monitor
01550       // however, special plots can be filled here.
01551     }
01552  
01553   if(fEpicsInputEvent /*&& fEpicsInputEvent->IsValid()*/){
01554     for (Int_t sl = 0; sl < MPOD00SLOT; sl++) {
01555       for (Int_t ch = 0; ch < MPOD00CHA; ch++) {
01556         Int_t nbin =  fEpicsMSMpod00_Monitor_U[sl][ch]->GetNbinsX();
01557         for (Int_t ibin = 1; ibin <= nbin; ibin++){
01558           if (ibin < nbin) {
01559             fEpicsMSMpod00_Monitor_U[sl][ch]->SetBinContent(ibin,fEpicsMSMpod00_Monitor_U[sl][ch]->GetBinContent(ibin + 1));
01560             fEpicsMSMpod00_Monitor_I[sl][ch]->SetBinContent(ibin,fEpicsMSMpod00_Monitor_I[sl][ch]->GetBinContent(ibin + 1));
01561           }
01562           else {
01563             fEpicsMSMpod00_Monitor_U[sl][ch]->SetBinContent(ibin,fEpicsMSMpod00_U[sl][ch]);
01564             fEpicsMSMpod00_Monitor_I[sl][ch]->SetBinContent(ibin,fEpicsMSMpod00_I[sl][ch]);  // LV I in A
01565           }
01566         }
01567       }
01568     }
01569 
01570     for (Int_t sl = 0; sl < MPOD01SLOT; sl++) {
01571       for (Int_t ch = 0; ch < MPOD01CHA; ch++) {
01572         Int_t nbin =  fEpicsMSMpod01_Monitor_U[sl][ch]->GetNbinsX();
01573         for (Int_t ibin = 1; ibin <= nbin; ibin++){
01574           if (ibin < nbin) {
01575             fEpicsMSMpod01_Monitor_U[sl][ch]->SetBinContent(ibin,fEpicsMSMpod01_Monitor_U[sl][ch]->GetBinContent(ibin + 1));
01576             fEpicsMSMpod01_Monitor_I[sl][ch]->SetBinContent(ibin,fEpicsMSMpod01_Monitor_I[sl][ch]->GetBinContent(ibin + 1));
01577           }
01578           else {
01579             fEpicsMSMpod01_Monitor_U[sl][ch]->SetBinContent(ibin,fEpicsMSMpod01_U[sl][ch]);
01580             fEpicsMSMpod01_Monitor_I[sl][ch]->SetBinContent(ibin,fEpicsMSMpod01_I[sl][ch] * 1e9 );  // HV I in nA
01581           }
01582         }
01583       }
01584     }
01585 
01586     for (Int_t i = 0; i < 8; i++) {
01587       Int_t nbin = fEpics_MonitorU[i]->GetNbinsX();
01588       for (Int_t ibin = 1; ibin <= nbin; ibin++){
01589         if (ibin < nbin) {
01590           fEpics_MonitorU[i]->SetBinContent(ibin, fEpics_MonitorU[i]->GetBinContent(ibin + 1));
01591           fEpics_MonitorI[i]->SetBinContent(ibin, fEpics_MonitorI[i]->GetBinContent(ibin + 1));
01592         }
01593         else {
01594           fEpics_MonitorU[i]->SetBinContent(ibin, fEpics_Monitor_U[i]);
01595           if (fPar->show_currentSpikes)
01596             fEpics_MonitorI[i]->SetBinContent(ibin, fEpics_Monitor_I[i] * 1e9 );  // scaleup I to make it visible in the plots
01597           else
01598             if (fEpics_Monitor_I[i] < 0.5)
01599               fEpics_MonitorI[i]->SetBinContent(ibin, fEpics_Monitor_I[i] * 1e9 );  // scaleup I to make it visible in the plots
01600             else
01601               fEpics_MonitorI[i]->SetBinContent(ibin, fEpics_MonitorI[i]->GetBinContent(ibin - 1) ); // use previous entry
01602         }
01603       }
01604     }
01605     
01606     for (Int_t mstrd = 1; mstrd < MSTRDNUM; mstrd++) {
01607       Int_t nbin = fEpicsMSTRD_AnodeU[mstrd]->GetNbinsX();
01608       for (Int_t ibin = 1; ibin <= nbin; ibin++){
01609         if (ibin < nbin) {
01610           fEpicsMSTRD_DriftU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_DriftU[mstrd]->GetBinContent(ibin + 1));
01611           fEpicsMSTRD_DriftI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_DriftI[mstrd]->GetBinContent(ibin + 1));
01612           fEpicsMSTRD_AnodeU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_AnodeU[mstrd]->GetBinContent(ibin + 1));
01613           fEpicsMSTRD_AnodeI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_AnodeI[mstrd]->GetBinContent(ibin + 1));
01614           fEpicsMSTRD_SpaU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_SpaU[mstrd]->GetBinContent(ibin + 1));
01615           fEpicsMSTRD_SpaI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_SpaI[mstrd]->GetBinContent(ibin + 1));
01616           fEpicsMSTRD_SusU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_SusU[mstrd]->GetBinContent(ibin + 1));
01617           fEpicsMSTRD_SusI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_SusI[mstrd]->GetBinContent(ibin + 1));
01618           if (mstrd == 1){
01619             fEpicsMSTRD_T[0]->SetBinContent(ibin, fEpicsMSTRD_T[0]->GetBinContent(ibin + 1));
01620             fEpicsMSTRD_T[1]->SetBinContent(ibin, fEpicsMSTRD_T[1]->GetBinContent(ibin + 1));
01621             fEpicsMSTRD_T[2]->SetBinContent(ibin, fEpicsMSTRD_T[2]->GetBinContent(ibin + 1));
01622             fEpicsMSTRD_T[3]->SetBinContent(ibin, fEpicsMSTRD_T[3]->GetBinContent(ibin + 1));
01623           }
01624         }
01625         else {
01626           // Drift HV
01627           fEpicsMSTRD_DriftU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Drift_U[mstrd]);
01628           if (fPar->show_currentSpikes)
01629             fEpicsMSTRD_DriftI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Drift_I[mstrd]  * 1e9);
01630           else
01631             if (fEpicsMSTRD_Drift_I[mstrd] < 0.5) // Filter know hardware errors
01632               fEpicsMSTRD_DriftI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Drift_I[mstrd] * 1e9);
01633           // Anode HV
01634           fEpicsMSTRD_AnodeU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Anode_U[mstrd]);
01635           if (fPar->show_currentSpikes)
01636             fEpicsMSTRD_AnodeI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Anode_I[mstrd] * 1e9);
01637           else
01638             if (fEpicsMSTRD_Anode_I[mstrd] < 0.5) // Filter know hardware errors
01639               fEpicsMSTRD_AnodeI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Anode_I[mstrd] * 1e9);
01640           // MS TRD LV
01641           fEpicsMSTRD_SpaU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Spa_U[mstrd]);
01642           fEpicsMSTRD_SpaI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Spa_I[mstrd] * 10);
01643           fEpicsMSTRD_SusU[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Sus_U[mstrd]);
01644           fEpicsMSTRD_SusI[mstrd]->SetBinContent(ibin, fEpicsMSTRD_Sus_I[mstrd]);
01645           if (mstrd == 1){
01646             fEpicsMSTRD_T[0]->SetBinContent(ibin, fEpicsMSTRD_Temp[0]);
01647             fEpicsMSTRD_T[1]->SetBinContent(ibin, fEpicsMSTRD_Temp[1]);
01648             fEpicsMSTRD_T[2]->SetBinContent(ibin, fEpicsMSTRD_Temp[2]);
01649             fEpicsMSTRD_T[3]->SetBinContent(ibin, fEpicsMSTRD_Temp[3]);
01650           }
01651         }
01652       }
01653     }
01654 
01655     // RICH
01656     for (Int_t irich = 1; irich < RICHNUM; irich++) {
01657       Int_t nbin = fEpics_RichU[irich]->GetNbinsX();
01658       for (Int_t ibin = 1; ibin <= nbin; ibin++){
01659         if (ibin < nbin) {
01660           fEpics_RichU[irich]->SetBinContent(ibin, fEpics_RichU[irich]->GetBinContent(ibin + 1));
01661           fEpics_RichI[irich]->SetBinContent(ibin, fEpics_RichI[irich]->GetBinContent(ibin + 1));
01662         } else {
01663           // Anode HV
01664           fEpics_RichU[irich]->SetBinContent(ibin, fEpics_Rich_U[irich]);
01665           if (fPar->show_currentSpikes)
01666             fEpics_RichI[irich]->SetBinContent(ibin, fEpics_Rich_I[irich] * 1e7);
01667           else
01668             if (fEpics_Rich_I[irich] < 0.5) // Filter know hardware errors
01669               fEpics_RichI[irich]->SetBinContent(ibin, fEpics_Rich_I[irich] * 1e7);
01670         }
01671       }
01672     }
01673   }
01674 
01675 
01676   if(fCrateInputEvent && fCrateInputEvent->IsPulser()) {
01677     // SL: do we need to process data when pulser event is there?
01678     // One could estimate some backgrounds for QDCs or Spadics here
01679     // For the moment just return
01680 
01681     return;
01682   }
01683 
01684 
01685   if(fBeamEvent) {
01686 
01687     Int_t xNrFiberHodCluster(0);
01688     Int_t yNrFiberHodCluster(0);
01689     Double_t xPosFiberHod(0);
01690     Double_t yPosFiberHod(0);
01691     if (fHodo1 && (fHodo1->NumHits()>0)) {
01692       xNrFiberHodCluster = fHodo1->NumHits();
01693       yNrFiberHodCluster = fHodo1->NumHits();
01694       xPosFiberHod = fHodo1->Hit(0).X;
01695       yPosFiberHod = fHodo1->Hit(0).Y;
01696     }
01697     else {
01698 
01699     }
01700     fSpadic_efficiency->Fill(0);
01701     Double_t rawData[NUM_SPADIC_CHA][SPADIC_TRACE_SIZE] = {{0.0}};
01702     Double_t cleanData[NUM_SPADIC_CHA][SPADIC_TRACE_SIZE] = {{0.0}};
01703     Double_t intensCh[NUM_SPADIC_CHA] = {0};
01704 
01705     Int_t maxChCorr[MAX_SPADIC] = {-1};
01706     Double_t dxPosCorr[MAX_SPADIC] = {0};
01707     Bool_t overnflowtingTB[NUM_SPADIC_CHA][SPADIC_TRACE_SIZE] = {{false}};
01708     Double_t intens[MAX_SPADIC] = {0};
01709     Double_t rowIntens[MAX_SPADIC] = {0};
01710  
01711     for (UInt_t sid = 1; sid < MAX_SPADIC; sid++)  //JAM: histogram index starts with 1 here!
01712       {
01713         TSpadicData* theSpadic=dynamic_cast<TSpadicData*>(fSpadicInputEvent->getEventElement(sid));
01714         if(theSpadic==0) continue; // skip not configured ones
01715         if(!theSpadic->IsValid()) continue; // required to suppress empty spadic data!
01716         //cout <<"TTRDMuensterFrankfurtProc has spadic data for sid"<<sid << endl;
01717         if (!fBeamEvent->fIsElectron && !fBeamEvent->fIsPion)
01718           PID[sid] = 0;
01719         if (fBeamEvent->fIsPion) 
01720           PID[sid] = -1;
01721         if (fBeamEvent->fIsElectron) 
01722           PID[sid] = 1;
01723 
01724         if (fPar->reSortChannel){
01725           if (fPar->ChMap[sid]) {
01726             Double_t tempSpadic[NUM_SPADIC_CHA][SPADIC_TRACE_SIZE];
01727             for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01728               for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
01729                 tempSpadic[ch][bin] = theSpadic->fSpadicCompensated[ch][bin];
01730               }
01731             }
01732             for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01733               for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
01734                 //              theSpadic->fSpadicCompensated[ch][bin] =  tempSpadic[UInt_t(ch - (NUM_SPADIC_CHA-1))][bin];
01735                 theSpadic->fSpadicCompensated[ch][bin] =  tempSpadic[UInt_t((NUM_SPADIC_CHA-1)-ch)][bin];
01736               }
01737             }
01738           }
01739         }
01740 
01741         // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Filter overflow events
01742         Bool_t overflow = false;
01743         Bool_t undershoot = false;
01744         for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01745           for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {         
01746             if (theSpadic->fSpadicOverflows[ch][bin]){
01747               overflow = true;
01748               overnflowtingTB[ch][bin] = true;
01749             }
01750             if (theSpadic->fSpadicUndershoots[ch][bin]){
01751               undershoot = true;
01752             }
01753           }
01754         }
01755           
01756         if (!fPar->Use_OverflowEvents && overflow)
01757           continue;
01758 
01759         Int_t maxCh(-1), maxSignal(0);
01760         Double_t baseline(0), signal(0);
01761         for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {            
01762           baseline = 0;
01763           signal = 0;
01764 
01765           // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Baseline correction
01766           if (fPar->Run_PedestleCorrection) {
01767             for (unsigned bin = 0; (Int_t)bin < fPar->pedestalTB; bin++) {
01768               baseline += theSpadic->fSpadicCompensated[ch][bin];
01769             }
01770             if (fPar->pedestalTB > 0 && fPar->pedestalTB < SPADIC_TRACE_SIZE)
01771               baseline /= fPar->pedestalTB;
01772             else
01773               baseline = 0;
01774             for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
01775               rawData[ch][bin] = theSpadic->fSpadicCompensated[ch][bin];
01776             }
01777           }
01779           Float_t pedestal[NUM_SPADIC_CHA] = {0.0};                     
01780           if (!theSpadic->fSpadicSignalCh[ch]){
01781             for (UInt_t bin = 0; bin < SPADIC_TRACE_SIZE-1; bin++){
01782               fSpadic_input[sid][ch]->SetBinContent(bin + 1,theSpadic->fSpadicCompensated[ch][bin]);
01783               pedestal[ch] += rawData[ch][bin];
01784               fSpadic_ADCdistMF[sid][ch]->Fill(rawData[ch][bin]);
01785             }
01786             pedestal[ch] /= SPADIC_TRACE_SIZE;
01787             fSpadic_PedelPos2DMF[sid]->Fill(ch,pedestal[ch]);
01788           } 
01789           fSpadic_NoiseDistMF[sid]->SetBinContent(ch+1, fSpadic_ADCdistMF[sid][ch]->GetRMS());          
01790           fSpadic_NoiseDist2DMF[sid]->Fill(ch, fSpadic_ADCdistMF[sid][ch]->GetRMS());
01791           fSpadic_PedelPosMF[sid]->SetBinContent(ch+1, fSpadic_ADCdistMF[sid][ch]->GetMean());          
01792                 
01794           for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
01795             rawData[ch][bin] -= baseline;
01796             signal += rawData[ch][bin];
01797 
01798           }
01799           
01800           // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Find channel with maximum signal
01801           if (signal > maxSignal){
01802             maxSignal = signal;
01803             maxCh = ch;
01804           }
01805         }
01806 
01807        
01808         // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Find correlated channel
01809           
01810         //      Float_t max = 0;
01811         //      Int_t maxCorr = -1;
01812         Int_t nSignalChannel = 0;
01813         Bool_t channelSignal[NUM_SPADIC_CHA] = {false};
01814         for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01815           if (theSpadic->fSpadicSignalCh[ch]) {
01816             nSignalChannel++;
01817             channelSignal[ch] = true;
01818           }
01819         }
01820         /*
01821           Double_t corrMatrix[NUM_SPADIC_CHA][NUM_SPADIC_CHA] = {{0}};
01822           for (Int_t iChannel = 0; iChannel < NUM_SPADIC_CHA; iChannel++){
01823           Double_t iAverage = 0;
01824           for (Int_t TimeBin = 0; TimeBin < SPADIC_TRACE_SIZE; TimeBin++)
01825           iAverage += rawData[iChannel][TimeBin];
01826           iAverage /= Float_t(NUM_SPADIC_CHA);
01827           for (Int_t jChannel = 0; jChannel < NUM_SPADIC_CHA; jChannel++){
01828           corrMatrix[iChannel][jChannel] = 0;
01829      
01830           Double_t jAverage = 0;
01831           for (Int_t TimeBin = 0; TimeBin < SPADIC_TRACE_SIZE; TimeBin++){
01832           jAverage += rawData[jChannel][TimeBin];
01833           }
01834           jAverage /= Float_t(NUM_SPADIC_CHA);
01835           Double_t Eij = 0;
01836           Double_t Ei = 0;
01837           Double_t Ej = 0;
01838           for (Int_t TimeBin = 0; TimeBin < SPADIC_TRACE_SIZE; TimeBin++){
01839           Eij += (rawData[iChannel][TimeBin] - iAverage) * (rawData[jChannel][TimeBin] - jAverage);
01840           Ei += fabs(rawData[iChannel][TimeBin] - iAverage);
01841           Ej += fabs(rawData[jChannel][TimeBin] - jAverage);
01842           }      
01843           corrMatrix[iChannel][jChannel] = (Eij / (Ei * Ej) - 0.0222) * 10000;
01844           if (corrMatrix[iChannel][jChannel] > max){
01845           max = corrMatrix[iChannel][jChannel];
01846           maxCorr = jChannel;
01847           }        
01848           }
01849           }
01850           for (Int_t iChannel = 0; iChannel < NUM_SPADIC_CHA; iChannel++){
01851           for (Int_t jChannel = 0; jChannel < NUM_SPADIC_CHA; jChannel++){
01852           corrMatrix[iChannel][jChannel] /= max;
01853           }
01854           }
01855           for (Int_t jChannel = 0; jChannel < NUM_SPADIC_CHA; jChannel++){
01856           if (corrMatrix[maxCorr][jChannel] >= 0.20){
01857           channelSignal[jChannel] = true;
01858           nSignalChannel++;
01859           }
01860           }
01861         */
01862         // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Noise correction
01863         Double_t maxAmp[NUM_SPADIC_CHA] = {0};
01864         Int_t hitTime[NUM_SPADIC_CHA] = {0};
01865         Double_t average;
01866 
01867         Double_t intens3pads = 0;
01868         Double_t intensSignalPads = 0;
01869         for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
01870           average = 0.;
01871           for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01872             //maxAmp[ch] = 0.;  
01873             //hitTime[ch] = 0.;
01874             //if (ch < maxCh-1 || ch > maxCh+1)
01875             if (!channelSignal[ch])
01876               average += rawData[ch][bin];
01877           }
01878           average /= (Double_t(NUM_SPADIC_CHA - nSignalChannel));             
01879           for (Int_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {
01880             //      TH1* tracehis = fSpadic_output[sid][ch]; 
01881             //if (!theSpadic->fSpadicOverflows[ch][bin])
01882             if (fPar->Run_NoiseCorrection)
01883               cleanData[ch][bin] = rawData[ch][bin] - average;
01884             else
01885               cleanData[ch][bin] = rawData[ch][bin];
01886 
01887             //tracehis
01888             fSpadic_output[sid][ch]->SetBinContent(bin + 1, cleanData[ch][bin]);
01889             if (fSpadic_integWindow[sid]->Test(bin)) {
01890               intensCh[ch] += cleanData[ch][bin];
01891               if (theSpadic->fSpadicSignalCh[ch])
01892                 intensSignalPads += cleanData[ch][bin];
01893               if (ch >= maxCh-1 && ch <= maxCh+1)
01894                 intens3pads += cleanData[ch][bin];
01895             }
01896             //if (ch == maxCh)
01897             if (cleanData[ch][bin] > maxAmp[ch]){
01898               maxAmp[ch] = cleanData[ch][bin];
01899               hitTime[ch] = bin;
01900             }
01901             rowIntens[sid] += intensCh[ch];
01902           }
01903 
01904         }
01905         fSpadic_maxAmplitude[sid]->Fill(maxAmp[maxCh]);
01906         fSpadic_hitTime[sid]->Fill(hitTime[maxCh]);
01907         if (fBeamEvent->fIsPion){
01908           fSpadic_pi_maxAmplitude[sid]->Fill(maxAmp[maxCh]);
01909           fSpadic_pi_hitTime[sid]->Fill(hitTime[maxCh]);
01910         }
01911         if (fBeamEvent->fIsElectron){
01912           fSpadic_el_maxAmplitude[sid]->Fill(maxAmp[maxCh]);
01913           fSpadic_el_hitTime[sid]->Fill(hitTime[maxCh]);
01914         }
01915         maxChCorr[sid] = maxCh;
01916         fSpadic_padMax[sid]->Fill(maxCh);
01917 
01918         if(fPar->Use_ClusteredSignal)
01919           intens[sid] = intensSignalPads;
01920         else
01921           intens[sid] = intens3pads;
01922         
01923         /*
01924           fSpadic_intens[sid]->Fill(intensSignalPads);
01925           if (fBeamEvent->fIsPion)
01926           fSpadic_pi_intens[sid]->Fill(intensSignalPads);
01927           if (fBeamEvent->fIsElectron) 
01928           fSpadic_el_intens[sid]->Fill(intensSignalPads);
01929         */
01930         if (fSpadic_hitTimeCond[sid]->Test(hitTime[maxCh])){
01931           if (fSpadic_minAmplitudeCond[sid]->Test(maxAmp[maxCh])){
01932             //if (maxCh >= 1 && maxCh < NUM_SPADIC_CHA - 1){
01933             if (!fPar->Merge_Rows) {
01934               if (fSpadic_padMaxWindow[sid]->Test(maxCh)) {
01935                 // 0 == all; 1 == noPID; 2 == electron; 3 == pion //
01936                 Int_t intensBin = fSpadic_intens[sid]->FindBin(intens[sid]);
01937                 Int_t pidBin = 1; 
01938                 Int_t nBin = fSpadic_intens[sid]->GetNbinsX();
01939                 Int_t nEntries;
01940                 Double_t value;
01941                 TH1 *spectrum=0;
01942                 if (fBeamEvent->fIsPion){
01943                   spectrum = fSpadic_pi_intens[sid];
01944                   pidBin = fSpadic_pid[sid]->FindBin(3);
01945                 }
01946                 if (fBeamEvent->fIsElectron){
01947                   spectrum = fSpadic_el_intens[sid];
01948                   pidBin = fSpadic_pid[sid]->FindBin(2);
01949                 }
01950                 if (!(fBeamEvent->fIsPion) && !(fBeamEvent->fIsElectron)){
01951                   pidBin = fSpadic_pid[sid]->FindBin(1);
01952                   nEntries = fSpadic_pid[sid]->GetBinContent(pidBin);
01953                   fSpadic_pid[sid]->SetBinContent(pidBin, nEntries + 1);
01954                 }
01955                 for (Int_t iBin = 1; iBin <= nBin; iBin++) {
01956                   nEntries = fSpadic_pid[sid]->GetBinContent(fSpadic_pid[sid]->FindBin(0));
01957                   value = fSpadic_intens[sid]->GetBinContent(iBin) * nEntries;
01958                   if (iBin == intensBin){
01959                     value++;
01960                     fSpadic_pid[sid]->SetBinContent(1, nEntries + 1);
01961                   }
01962                   fSpadic_intens[sid]->SetBinContent(iBin, value / (nEntries + 1));
01963                   if (pidBin > 2) {
01964                     nEntries = fSpadic_pid[sid]->GetBinContent(pidBin);
01965                     value = spectrum->GetBinContent(iBin) * nEntries;
01966                     if (iBin == intensBin){
01967                       value++;
01968                       fSpadic_pid[sid]->SetBinContent(pidBin, nEntries + 1);
01969                     }
01970                     spectrum->SetBinContent(iBin, value / (nEntries + 1));
01971                   }
01972                 }       
01973               }
01974             }
01975             if (fSpadic_minIntensCond[sid]->Test(intens[sid])){
01976               // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Signal/Noise
01977               Double_t avNoise = 0;
01978               Double_t maxNoise = 0;
01979               Double_t minNoise = 255;
01980               Double_t avSignal = 0;
01981               Double_t avNoiseClean = 0;
01982               Double_t avSignalClean = 0;
01983               for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
01984                 if (bin < 5){
01985                   avNoise += uint8_t(theSpadic->fSpadicPulse[maxCh][bin]);
01986                   if (uint8_t(theSpadic->fSpadicPulse[maxCh][bin]) > maxNoise)
01987                     maxNoise = uint8_t(theSpadic->fSpadicPulse[maxCh][bin]);
01988                   if (uint8_t(theSpadic->fSpadicPulse[maxCh][bin]) < minNoise)
01989                     minNoise = uint8_t(theSpadic->fSpadicPulse[maxCh][bin]);
01990                   avNoiseClean += cleanData[maxCh][bin];
01991                 }
01992                 if (bin > 14 && bin < 20){
01993                   avSignal += uint8_t(theSpadic->fSpadicPulse[maxCh][bin]);     
01994                   avSignalClean += cleanData[maxCh][bin];
01995                 }  
01996               }
01997               TString s2n = ("S/N=xx");
01998               if (avNoise != 0){
01999                 double val = avSignal / (maxNoise - minNoise); // /avNoise;
02000                 double weight = fSpadic_S2Ncnt->GetBinContent(sid);
02001                 double value0 = fSpadic_S2N->GetBinContent(sid);
02002                 s2n.Form("S/N=%f",(value0 * weight + val) / (weight + 1.));
02003                 fSpadic_S2N->SetBinContent(sid, (value0 * weight + val) / (weight + 1.));
02004                 fSpadic_S2Ncnt->SetBinContent(sid, weight + 1);
02005               }
02006               if (avNoiseClean != 0){
02007                 double  val = avSignalClean/avNoiseClean;
02008                 double  weight = fSpadic_S2Ncnt->GetBinContent(sid) -1;
02009                 double  value0 = fSpadic_S2Ncleaned->GetBinContent(sid);
02010                 fSpadic_S2Ncleaned->SetBinContent(sid, (value0 * weight + val) / (weight + 1.));                
02011               }
02012               S2N[sid]->SetText(0.1,0.8,s2n.Data());
02013               
02014               //maxChCorr[sid] = maxCh;
02015               //fSpadic_padMax[sid]->Fill(maxCh);
02016               // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PRF  
02017               //if (maxCh >= 1 && maxCh < NUM_SPADIC_CHA - 1){
02018               if (fSpadic_padMaxWindow[sid]->Test(maxCh)) {
02019                 fSpadic_efficiency->Fill(sid);
02020                 Double_t dxPos = 0.5 * log((intensCh[maxCh+1] / intensCh[maxCh-1])) / log((pow(intensCh[maxCh],2) / (intensCh[maxCh+1] * intensCh[maxCh-1])));
02021                 fSpadic_recoPos[sid]->Fill(dxPos * fPar->fPadwidth[sid] + maxCh * fPar->fPadwidth[sid]);
02022                 dxPosCorr[sid] = dxPos * fPar->fPadwidth[sid] + maxCh * fPar->fPadwidth[sid] + fPar->fPadwidth[sid];
02023                 Double_t chargePercent = intensCh[maxCh-1] / (intensCh[maxCh-1] + intensCh[maxCh] + intensCh[maxCh+1]);
02024                 fSpadic_PRFMF[sid]->Fill(-dxPos-1,chargePercent);
02025                 //PRF1D->Fill(-dxPos-pWidth,chargePercent);
02026                 chargePercent = intensCh[maxCh] / (intensCh[maxCh-1] + intensCh[maxCh] + intensCh[maxCh+1]);
02027                 fSpadic_PRFMF[sid]->Fill(dxPos,chargePercent);
02028                 //PRF1D->Fill(dxPos,chargePercent);
02029                 chargePercent = intensCh[maxCh+1] / (intensCh[maxCh-1] + intensCh[maxCh] + intensCh[maxCh+1]);
02030                 fSpadic_PRFMF[sid]->Fill(-dxPos+1,chargePercent);
02031                 //PRF1D->Fill(-dxPos+pWidth,chargePercent);
02032                 
02033               } 
02034 
02035               // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Average pulse shape
02036               //for (UInt_t ch = 0; ch < NUM_SPADIC_CHA; ch++) {              
02037               if (fBeamEvent->fIsPion) {
02038                 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02039                   double val = cleanData[maxCh][bin]; // take from previous ste
02040                   fSpadic_pi_shape2D[sid]->Fill(bin, val);
02041                   //double val = fSpadicInputEvent->fSpadicCompensated[sid][ch][bin]; // take from previous step
02042                   double weight = fSpadic_pi_shapecnt[sid]->GetBinContent(bin+1);
02043                   double value0 = fSpadic_pi_shape[sid]->GetBinContent(bin+1);
02044                         
02045                   fSpadic_pi_shape[sid]->SetBinContent(bin+1, (value0 * weight + val) / (weight + 1.));
02046                   fSpadic_pi_shapecnt[sid]->SetBinContent(bin+1, weight+1.);
02047                 }
02048               }         
02049               if (fBeamEvent->fIsElectron) {
02050                 for (unsigned bin = 0; bin < SPADIC_TRACE_SIZE; bin++) {
02051                   double val = cleanData[maxCh][bin];
02052                   fSpadic_el_shape2D[sid]->Fill(bin, val);
02053                   //double val = fSpadicInputEvent->fSpadicCompensated[sid][ch][bin]; // take from previous step
02054                   double weight = fSpadic_el_shapecnt[sid]->GetBinContent(bin+1);
02055                   double value0 = fSpadic_el_shape[sid]->GetBinContent(bin+1);
02056                         
02057                   fSpadic_el_shape[sid]->SetBinContent(bin+1, (value0 * weight + val) / (weight + 1.));
02058                   fSpadic_el_shapecnt[sid]->SetBinContent(bin+1, weight+1.);
02059                 }        
02060               }
02061 
02062               //        } // for ch
02063             }//fSpadic_minIntensCond
02064           }//fSpadic_minAmplitudeCond
02065         }//fSpadic_hitTimeCond
02066         // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Multihit 
02067          
02068         //      Int_t maxCounter = 0;
02069         Bool_t multiHit = false;
02070         /*
02071           Double_t delta(0), preDelta(0);
02072           for (Int_t bin = 0; bin < SPADIC_TRACE_SIZE-1; bin++){
02073           delta = cleanData[maxCh][bin+1] - cleanData[maxCh][bin];            
02074           if (delta < 0 && preDelta > 0 && cleanData[maxCh][bin] >= 0.75 * maxAmp[maxCh])
02075           maxCounter++;
02076           if(maxCounter > 2)
02077           multiHit = true;
02078             
02079           preDelta = delta;
02080           }
02081         */
02082         // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Statistics
02083         fSpadic_statistics[sid]->Fill(0);           // all triggerd events
02084         if (fSpadic_minAmplitudeCond[sid]->Test(maxAmp[maxCh])) 
02085           {
02086             fSpadic_statistics[sid]->Fill(2);         // events above noise level
02087             if (fSpadic_hitTimeCond[sid]->Test(hitTime[maxCh]))
02088               {
02089                 fSpadic_statistics[sid]->Fill(3);
02090                 if (fSpadic_minIntensCond[sid]->Test(intens[sid]))
02091                   {
02092                     fSpadic_statistics[sid]->Fill(4);
02093                     if (!overflow)   fSpadic_statistics[sid]->Fill(5);       // not overflow events  
02094                     if (!undershoot) fSpadic_statistics[sid]->Fill(6);
02095                     //if (maxCh >= 1 && maxCh < NUM_SPADIC_CHA-1){
02096                     if (fSpadic_padMaxWindow[sid]->Test(maxCh))
02097                       {
02098                         fSpadic_statistics[sid]->Fill(7);     // pad max is in the center                
02099                         if (!multiHit)
02100                           {
02101                             fSpadic_statistics[sid]->Fill(8);     // hit has 1 maximum
02102                             fSpadic_statistics[sid]->Fill(9);     //  (good event)
02103                             if (fBeamEvent->fIsPion) fSpadic_statistics[sid]->Fill(10);   // good pion event                 
02104                             if (fBeamEvent->fIsElectron) fSpadic_statistics[sid]->Fill(11); // good electron event
02105                             if (!fBeamEvent->fIsPion && !fBeamEvent->fIsElectron)
02106                               {
02107                                 fSpadic_statistics[sid]->Fill(12); // good event but not electron or pion
02108                               }
02109                           }
02110                       }       
02111                   }
02112               }
02113           }
02114         //}
02115         
02116         if (!fSpadic_minAmplitudeCond[sid]->Test(maxAmp[maxCh]) || 
02117             !fSpadic_hitTimeCond[sid]->Test(hitTime[maxCh])     || 
02118             !fSpadic_minIntensCond[sid]->Test(intens[sid])      ||
02119             overflow                                            ||
02120             multiHit
02121             ){
02122           fSpadic_statistics[sid]->Fill(1);         // noise events
02123         }
02124 
02125       }// for sid
02126     //Int_t pairs[4][4] = {{1,2}, {11,12}, {3,6}, {15,18}};;
02127     for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
02128       if (fPar->Merge_Rows) {
02129         //if (fSpadic_padMaxWindow[sid]->Test(maxCh)) {
02130         // 0 == all; 1 == noPID; 2 == electron; 3 == pion //
02131         Int_t intensBin=0;
02132         if (sid == 4 || sid == 16 || sid == 17|| sid == 5)
02133           intensBin = fSpadic_intens[sid]->FindBin(intens[sid]);
02134         else {
02135           if (sid == 1 || sid == 2)
02136             intensBin = fSpadic_intens[sid]->FindBin(intens[1] + intens[2]);
02137           if (sid == 11 || sid == 12)
02138             intensBin = fSpadic_intens[sid]->FindBin(intens[11] + intens[12]);
02139           if (sid == 3 || sid == 6)
02140             intensBin = fSpadic_intens[sid]->FindBin(intens[3] + intens[6]);
02141           if (sid == 15 || sid == 18)
02142             intensBin = fSpadic_intens[sid]->FindBin(intens[15] + intens[18]);
02143         }
02144 
02145         Int_t pidBin = 1; 
02146         Int_t nBin = fSpadic_intens[sid]->GetNbinsX();
02147         Int_t nEntries;
02148         Double_t value;
02149         TH1 *spectrum=0;
02150         if (fBeamEvent->fIsPion){
02151           spectrum = fSpadic_pi_intens[sid];
02152           pidBin = fSpadic_pid[sid]->FindBin(3);
02153         }
02154         if (fBeamEvent->fIsElectron){
02155           spectrum = fSpadic_el_intens[sid];
02156           pidBin = fSpadic_pid[sid]->FindBin(2);
02157         }
02158         if (!(fBeamEvent->fIsPion) && !(fBeamEvent->fIsElectron)){
02159           pidBin = fSpadic_pid[sid]->FindBin(1);
02160           nEntries = fSpadic_pid[sid]->GetBinContent(pidBin);
02161           fSpadic_pid[sid]->SetBinContent(pidBin, nEntries + 1);
02162         }
02163         for (Int_t iBin = 1; iBin <= nBin; iBin++) {
02164           nEntries = fSpadic_pid[sid]->GetBinContent(fSpadic_pid[sid]->FindBin(0));
02165           value = fSpadic_intens[sid]->GetBinContent(iBin) * nEntries;
02166           if (iBin == intensBin){
02167             value++;
02168             fSpadic_pid[sid]->SetBinContent(1, nEntries + 1);
02169           }
02170           fSpadic_intens[sid]->SetBinContent(iBin, value / (nEntries + 1));
02171           if (pidBin > 2) {
02172             nEntries = fSpadic_pid[sid]->GetBinContent(pidBin);
02173             value = spectrum->GetBinContent(iBin) * nEntries;
02174             if (iBin == intensBin){
02175               value++;
02176               fSpadic_pid[sid]->SetBinContent(pidBin, nEntries + 1);
02177             }
02178             spectrum->SetBinContent(iBin, value / (nEntries + 1));
02179           }
02180         }       
02181         //      }
02182       }
02183     }
02184     Bool_t mixing = false;
02185     for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
02186       for (UInt_t sid2 = 1; sid2 < MAX_SPADIC; sid2++) {
02187         if (PID[sid] != PID[sid2])
02188           mixing = true;
02189         fSpadic_pidMixing->Fill(PID[sid] - PID[sid2]);
02190       }
02191     }
02192     /*
02193       if (mixing){
02194       for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++)
02195       printf("%d ",PID[sid]);
02196       printf("\n");
02197       }
02198     */
02199     // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Correlation
02200 
02201     Int_t i = 0;
02202     for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
02203       if (fCrateInputEvent->fData1182[0][0] > 450)
02204         fSpadic_FingerCorr[sid]->Fill(maxChCorr[sid],0);
02205       if (fCrateInputEvent->fData1182[0][3] > 450)
02206         fSpadic_FingerCorr[sid]->Fill(maxChCorr[sid],1);
02207       if (fCrateInputEvent->fData1182[0][5] > 450)
02208         fSpadic_FingerCorr[sid]->Fill(maxChCorr[sid],2);
02209       if (fCrateInputEvent->fData1182[0][7] > 450)
02210         fSpadic_FingerCorr[sid]->Fill(maxChCorr[sid],3);
02211    
02212       for (UInt_t sid2 = sid; sid2 < MAX_SPADIC; sid2++) {          
02213         if (maxChCorr[sid] > -1 && maxChCorr[sid2] > -1){
02214           if (fPar->Run_SpadicCorrelation) 
02215             fSpadic_correlation[i]->Fill(maxChCorr[sid],maxChCorr[sid2]);//Correlation
02216           if (fPar->Run_Alignment) 
02217             fSpadic_alignment[i]->Fill(dxPosCorr[sid],dxPosCorr[sid2]);//Alignment
02218           for (Int_t bin = 0; bin <= SPADIC_TRACE_SIZE; bin++) {
02219             if (fSpadic_el_shape[sid2]->GetBinContent(bin+1) != 0)
02220               fSpadic_el_shapeRatio[i]->SetBinContent(bin+1, fSpadic_el_shape[sid]->GetBinContent(bin+1) / fSpadic_el_shape[sid2]->GetBinContent(bin+1));
02221             if (fSpadic_pi_shape[sid2]->GetBinContent(bin+1) != 0)
02222               fSpadic_pi_shapeRatio[i]->SetBinContent(bin+1, fSpadic_pi_shape[sid]->GetBinContent(bin+1) / fSpadic_pi_shape[sid2]->GetBinContent(bin+1));
02223           }
02224           i++;
02225         }
02226       } 
02227     }
02228     // <<<<<<<<<<<<<<<< y TRD
02229     Int_t pairs[4][2] = {{ 1, 2},{11,12},{10, 6},{15,18}};
02230     Float_t yPos[4] = {0.0};
02231     Float_t ratio = 0.0;
02232     for (Int_t pid = 0; pid < 4; pid++) {
02233       //      y = a*exp(-0.5*((x-b)/c)^2); b=0; a=1; y==Q1/Q2; c=para;
02234       //      x = c*sqrt(-2*ln(y/a))+b;
02235       //      x = c*sqrt(-2*ln(Q1/Q2));
02236       /*
02237         if (intens[pairs[pid][0]] < intens[pairs[pid][1]])
02238         ratio = intens[pairs[pid][0]] / intens[pairs[pid][1]];
02239         else
02240         ratio = intens[pairs[pid][1]] / intens[pairs[pid][0]];
02241       */
02242       //yPos[pid] = fPar->sigmaPRF[pid] * sqrt(-2.0 * log (intens[pairs[pid][0]] / intens[pairs[pid][1]]));
02243       //yPos[pid] = fPar->sigmaPRF[pid] * sqrt(-2.0 * log(ratio));
02244       yPos[pid] = fPar->sigmaPRF[pid] * sqrt(-2.0 * log (rowIntens[pairs[pid][0]] / rowIntens[pairs[pid][1]]));
02245 
02246       Float_t averageX = 0;
02247       Int_t counter = 0;
02248       if (dxPosCorr[pairs[pid][0]] > 0){
02249         averageX += dxPosCorr[pairs[pid][0]];
02250         counter++;
02251       }
02252       if (dxPosCorr[pairs[pid][1]] > 0){
02253         averageX += dxPosCorr[pairs[pid][1]];
02254         counter++;
02255       }
02256       averageX /= counter;
02257       if (intens[pairs[pid][0]] < intens[pairs[pid][1]])
02258         yPos[pid] *= -1.;
02259       fSpadic_beamProfil[pid]->Fill(averageX, yPos[pid]);
02260     }
02261     for (Int_t pid = 0; pid < 2; pid++) {
02262       fSpadic_deltaPos[pid]->Fill(dxPosCorr[pairs[pid][1]], dxPosCorr[pairs[pid][1]]-dxPosCorr[pairs[pid+2][1]]);
02263       fSpadic_deltaPos[pid+2]->Fill(yPos[pid], yPos[pid]-yPos[pid+2]);
02264     }
02265     
02266     fSpadic_MSxyHitplane[0]->Fill(
02267                                   dxPosCorr[2]-3.5*fPar->fPadwidth[2],
02268                                   dxPosCorr[12]-3.5*fPar->fPadwidth[12]);
02269     fSpadic_MSxyHitplane[1]->Fill(
02270                                   dxPosCorr[6]-3.5*fPar->fPadwidth[6],
02271                                   dxPosCorr[18]-3.5*fPar->fPadwidth[18]);
02272     
02273     fSpadic_MSxyHitPadplane[0]->Fill(
02274                                      (maxChCorr[2] -3.5)*fPar->fPadwidth[2],
02275                                      -(maxChCorr[12]-3.5)*fPar->fPadwidth[12]);
02276     fSpadic_MSxyHitPadplane[1]->Fill(
02277                                      (maxChCorr[6] -3.5)*fPar->fPadwidth[6],
02278                                      -(maxChCorr[18]-3.5)*fPar->fPadwidth[18]);
02279     // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FiberHod
02280     // <<<<<<<<<<<<<<<< x
02281     if (xNrFiberHodCluster > 0)
02282       for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
02283         fFiberHod_x_alignment[sid]->Fill(dxPosCorr[sid],xPosFiberHod);
02284       }
02285     // <<<<<<<<<<<<<<<< y
02286     if (yNrFiberHodCluster > 0)
02287       for (UInt_t sid = 1; sid < MAX_SPADIC-1; sid++) {
02288         fFiberHod_y_alignment[sid]->Fill(dxPosCorr[sid],yPosFiberHod);
02289       }
02290     //Int_t pairs[4][2] = {{ 1, 2},{ 3, 6},{11,12},{15,18}};
02291   
02292   } // BeamEvent
02293 }