1 / 34

Root Based Analysis for FMS Why an Alternate Analysis Code? Steve Heppelmann Penn State

Root Based Analysis for FMS Why an Alternate Analysis Code? Steve Heppelmann Penn State. The Fortran code is difficult to understand. It is Difficult for students/”new people” to learn to use The lack of integration into STAR software

calais
Télécharger la présentation

Root Based Analysis for FMS Why an Alternate Analysis Code? Steve Heppelmann Penn State

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Root Based Analysis for FMSWhy an Alternate Analysis Code?Steve Heppelmann Penn State • The Fortran code is difficult to understand. • It is Difficult for students/”new people” to learn to use • The lack of integration into STAR software • barrier for STAR collaborators to use the FMS within an integrated STAR analysis. • There are significant problems in FPD/FMS analysis that require more people working at the most basic level. They need to have transparent and flexible tools.

  2. Many analysis jobs are done with this same main ntp2hst program. Work of individuals, (Les, Akio, Greg, Larissa) or other specific analysis tasks are selected or disabled by many compiler options. History always accumulates. Code changes by growing larger. Original FPD/FMS analysis package involves executing a long Fortran main program called ntp2hst including about 40 subroutines all in one file with about 10,000 lines and with calls to additional Fortran routines in other files shown below (20,000 to 30,000 lines). In addition, lots of Paw Kumacs exist to process standard output files (hbook histograms). The output kumacs also call Fortran and allow one to select, view , merge and sort the histograms in ntp2hst output files.

  3. Problems with Unstructured Analysis code. Experts can always use the code that they write. However, for others it is not so easy. • Too much knowledge is needed: Many types of analysis are done by setting compile options. For a newcomer to do analysis in an unstructured environment, an individual must understand the consequences of each compiler option, even for issues unrelated to what is desired. Just reading through ntp2hst.F takes more than a day for someone experienced with the details of data structures, HBOOK, PAW, GEANT, PYTHIA, the FPD, the FPD++, the FMS and the 10 to 20 text files containing Calibration, Mapping, …. • Dangerous side effects: This makes use of code dangerous unless the entire history of uses is understood at a level that is never clear. It is not easy to limit the scope of usage. • Barrier to Entry: A newcomer who wants to use this code, is likely to have a limited role, just following scripted analysis paths. Creative analysis is limited to the experts. It is easy for everyone using the code in the same way to repeat the same mistake. It is more difficult for an individual to figure out “cross check” tests. The barrier to doing simple introductory analysis is nearly as high as the barrier to very complicated analysis. This eliminates new people, in particular students. • Explicit Event Loop: Because the program structure has it’s own internal event loop structure and maintains essential control over the global context (Common Blocks etc.), it is difficult to integrate the code into other analysis (like StRoot). • Code is nonlocal: It is difficult to try to break down the analysis into functional blocks that can either be understood completely in isolation or can be functionally understood without details.

  4. PSU Version of Analysis: Make a pi0 mass peak from 1 data file segment with script “Simple.C” (46 lines) >cp ${data_files}/run9069064.rzd.gz ./ 9069064_1/ > cd 9069064_1 ; gunzip run*.gz ; h2root run *.root >root “../Simple.C” Simple Example Analysis Steps (Run 9069064.25) Trigger data Ntuple File Run9069064.25.rzd Root Tree Run9069064.25.root h2root gROOT->Reset();gSystem->Load("../../Fpdchan.so”);TH1F* mhist=new TH1F("mhist","mhist",100,0.,1.);TMatrix* pmADC[4], Energy[4];FilesSet* p_files=new FilesSet("/star/u/heppel/ABatch/rootfms", "lb_trg2008/fms/fmsped_2008.txt", "lb_trg2008/fms/fmsgain.20080526.txt", "lb_trg2008/fms/fpdcorr_itr10_20080828.txt", "fpd08/fill.txt", "Fake", "fpd08/spinpat", "lb_trg2008/fms/geom_2008pp_0227.txt", "lb_trg2008/fms/qtmap.txt", "lb_trg2008/fms/qtmap2pp_set121.txt");dataSet d("./run*.root",p_files,"h111_08");Int_tnevts=d.Input->GetEntries(); // # events in chain PSU Code Example • FilesSet* p_files • TheFilesSetClass maintains the various • energy calibration files (gain, gaincorr). • pedestal files, • fill files, that associate fill with run. • spin pattern files • detector geometry files, • FMS mapping files • Detector cell to patch panel • Patch panel to qt channel • .These are the same text files used in the Fortran ntp2hst analysis.

  5. dataSet d(“./run*.root",p_files,"h111_08"); • This is the class that opens the root files containing trees, which in turn were made from ntuples. It reads the input file, provides the context including calibration etc. This is a little like the StChain class in STAR software. • The class contains a TChain object called Input. • It initializes the chain with the line shown. • It contains a method d.Input.GetEntries() that can be called to find the number of events in the event in the chain. • “d” contains all of the branches that allow access to all the original ntuple variables of the input data file. • “d” figures out the run number from the file name and initializes the gain/ped structures. They are: • CalibStr* Rped; • CalibStr* Rgain; • CalibStr* Rgaincorr; • CalibStr* RunPed; • These objects reflect the corresponding txt files and provide all acces to this calibration. Other callibration Classes that live in dataSet are: • Fill* RFill; • RunData* thisRunDat; • The spin information is stored and is accessed in the Fill Structure. Run dependent information is kept in theRunDataclass. “Simple.C” (lines 1-16) gROOT->Reset();gSystem->Load("../../Fpdchan.so”);TH1F* mhist=new TH1F("mhist","mhist",100,0.,1.);TMatrix* pmADC[4], Energy[4];FilesSet* p_files=new FilesSet("/star/u/heppel/ABatch/rootfms", "lb_trg2008/fms/fmsped_2008.txt", "lb_trg2008/fms/fmsgain.20080526.txt", "lb_trg2008/fms/fpdcorr_itr10_20080828.txt", "fpd08/fill.txt", "Fake", "fpd08/spinpat", "lb_trg2008/fms/geom_2008pp_0227.txt", "lb_trg2008/fms/qtmap.txt", "lb_trg2008/fms/qtmap2pp_set121.txt");dataSet d("./run*.root",p_files,"h111_08");Int_tnevts=d.Input->GetEntries(); // # events in chain PSU Code Example

  6. The Rest of “Simple.C” (lines 17-46) for(Int_tevt=0; evt<nevts; evt++){d.GetEntry(evt); if(!d.decodeQT()){printf("Decode QT error \n");continue;}; for(Int_ti=0;i<4;i++) {pmADC[i]=new TMatrix(d.dMatrixQt(i)); Energy[i]=new TMatrix(d.Em(pmADC[i],2,i+1)); }; for(Int_ti=0;i<4;i++) //loop over Large Small x North South FMS { if(Energy[i]->Sum()>1) {Yiqunrec(Energy[i],d.pGeom,d.Rgain,d.Rgaincorr,2,i+1); if(rec.NPh==2) {TLorentzVector P_phot1=rec.mom(0);TLorentzVector P_phot2=rec.mom(1);Float_t e1=P_phot1.E();Float_t e2=P_phot2.E(); if(i>1 && e1>3 && e2>3); if(e1+e2>20)mhist>Fill((P_phot1+P_phot2).Mag()); }; }; }; for(int k=0;k<4;k++){ if(Energy[k])delete Energy[k]; if(pmADC[k])delete pmADC[k];};}; • The Loop: (with dataSet d) • Call d.decodeQT() to unpack all QT data for this event. This really calls the decode method of the Qt object in d. • The a matrix of ADC values and a matrix of energies for each of 4 FMS detector modules are • TMatrix* pmADC[4] • TMatrix* Energy[4[ • each use the row/col convention originally defined in the Fortran analysis. • If detector summed energy is >1, call photon reconstruction “Yiqun” for each of 4 FMS modules. The object created is. • Yiqunrec • The Yiqun class reconstructs on construction. All fitted results are available through therecobject. • Four momentum is returned here for two photon per detector events. • Determine 2 photon mass. • Increment histogram. PSU Code Example

  7. The plot made by “Simple.C” (lines 1-47 above) Original file =Run9069064.25.rzd (10k triggers) > root ../Simple.C root.ext [0] mhist->Draw() Mass (GeV/c)

  8. Mapping, Alignment, Calibration, Fill dependent and Run Dependent Objects dataSet object “d” is initialized with one or more root “Tree” files. They are combined into a TChain. Similar An TObjArray of a RunData objects is maintained. A pointer to the current one is anchored in “d”. RunData* thisRun= d.thisRun When looping through the chain, a new run number causes the thisRun pointer to be updated.The thisRun object includes information about the run dependent quantities like run dependent pedestals. CalibStr* runped= d.thisRun.RunPed and run dependent luminosity vs. spin ratios. An included Fill* Rfillobject is updated whenever the run number changes. It contains the spin patterns. A Qt* pQt object is created with FMS cell mapping files. pQt->Decode(ndat,Qtdat,0) converts raw data to ADC matrices. dataSet d("./run*.root",p_files,"h111_08"); … //begin loop … d.GetEntry(evt); ….. Yiqunrec(EMat,d.pGeom,d.Rgain,d.Rgaincorr,EW,NSTB); Ped =d.thisRun->RunPed->GetValue(EW,NSTB,row,col) Nfill=d.RFill->GetFillNumber() Bspin=d.RFill->BlueSpin(d.bunchid7bit); Yspin=d.Rfill->YellowSpin(d.bunchid7bit); TVector3 vstar=rec.ph_coord_lab(0); TVector3 vfms = d.pGeom->LocalXYZ(EW,NSTB,vlocal); If(d.pGeom->GlobalXYZ(EQ,NSTB,vfms)==vstar) good=true; PSU Code Example • CalibStr* Rped=d.Rped; // fmsped_2008.txt • CalibStr* Rgain=d.Rgain; //fmsgain.20080526.txt • CalibStr* Rgaincorr=d.Rgaincorr; //fmscorr.8.txt • CalibStr* RunPed=d.thisRun->RunPed; // null • Geom* pGeom=d.pGeom; //geom_2008pp_0227.txt • Fill* Rfill = d.Rfill; //fill.txt • Qt* pQt=d.pQt; //qtmap.txt qtmap2pp_set121.txt • RunData* thisRun=d.thisRun //spinpat/*.txt; • // “fake” luminosity file

  9. FMS Channel Mapping 3/20/2009 This represents our first attempt to figure out the mapping for FMS in 2009. This is reflected in our first version of mapping files:  The mapping files are in /direct/star+u/heppel/FMSMap2009/ qtmap2pp_set121.txt (unchanged mapping between physical cells and panel) qtmap2009V1.txt (Our version 1 of the 2009 mapping from qt to panel) We at PSU make the following assumptions 1) qtmap2pp_set121.txt was and still is correct. 2) The photocopies of the spreadsheet from Dec-Jan are still meaningful. 3) The slot numbers are A=1,B=2, C=3,……… J=10 and the extra slot that is not in the trigger is called “L=12”. (We completely guessed this one). The following representations of maps show physical locations in the format (2 digit channel #)(1 character slot letter)(1 digit crate number) Several members of the FMS group had worked together to verify a spreadsheet that documented FMS RUN 9 mapping. After many requests over many months, these spreadsheet data have never been released to the full FMS group.

  10. Moving From “*.txt” Files toward Database Alternate constructors for CalibStr Geom Fill RunData Qt that initialize from a data base could be written in a very short time if these database entries were defined. Currently, these classes can all be streamed to a root file. To save calibration with output data. CalibStr* pgain; Tfile file(“output.root” , ”recreate”); pgain->Write(“gain”); Output.root Tfile file(“output.root” ); CalibStr* pgain=(CalibStr*) file.GetKey("gaincorr")->ReadObj();

  11. CalibStr* gain CalibStr* gaincor gSystem->Load("../../Fpdchan.so"); CalibStr gain(9069064,"fmsgain.20080526.txt"); CalibStrgaincorr(9069064,"fpdcorr_itr10_20080828.txt"); //total gains Small South FMS Run 8 Transverse TH2F hgain(*gain.tm(2,4)); TH2F hgaincorr(*gaincorr.tm(2,4)); TH2F FullGain(hgain*hgaincorr); FullGain.SetStats(0); FullGain.Draw("text"); CalibStrgaincorr(9069064, "fpdcorr_itr10_20080828.txt"); row col

  12. Yiqun Class Yiqun Constructor An instanced of Yiqun is created with Yiqun* rec=new Yiqun( pEm,pgeom, pgain, pgaincorr, iew, nstb); The constructor takes arguments a pointer to a TMatrixof corrected energies a pointer to Geomobject a pointer to a CalibStr object representing the gains a pointer to a CalibStr object representing the gaincorrs an integer IEW {1=East; 2=West} an integer NSTB {ie. 1=Large FMS North … 4 = Small FMS South} • Related Classes: • TowerFPD – a sortable TObject representation of single tower • HitCluster - a collection of TowerFPD (includes TObjArray) with summary info • Photon – Photon interpretation associated with clusters • FitTower – object that contains info associated with Fitting including shower shape function and Minuit FCN’s (some global stuff used by Minuit) • TowerUtil - Clustering code

  13. Using Yiqun Class

  14. CalibStrgaincorr(9069064, "fpdcorr_itr10_20080828.txt"); Shower Shape Function Tables from 2003 Analysis note by S. Heppelmann The distribution of reconstructed photon positions within a cell. Left: nominal shower shape. Right: another shape. During Run 3, I did a study that showed that this parameterization was not consistent with FPD data. I suggested a better parameterization. It was not adopted. Consequence, Energy and Fit Errors and Biases are very dependent upon location in FPD, FMS. In particular in region near missing cells.

  15. X vs Y distribution for each photon in reconstructed in the FMS from 2 photon events. (Run 8 FMS) CalibStrgaincorr(9069064, "fpdcorr_itr10_20080828.txt")

  16. Secondary Files: poutTree Class(OFile.root) Run9xxxx trigger data Condor job Run Analysis Root scripts Reconstruct calling Yiqunclass for each FMS detector The PSU package contains a class poutTree manages an output Tree file that plays a role similar to a microdst. An output tree is created (TTree* pout ) that stores reconstructed photon TLorentzVectors obtained from “Yiqun” reconstruction class as well as an additional minimal set of variables related to trigger, spin, etc. The poutTree manages that tree and the Ofile.root file to which it is written. Analysis to create “OFile.root” tree files from trigger ntuple data files is done in parallel through Condor. Secondary analysis with root reads and interprets the Ofile.root data, using the poutTree class. The root scripts for such higher level physics analysis can be again quite simple, ~100 lines. run9xxxx.rzd.gz run9xxxx.root TChain of secondary reconstructed photon data. TTree files likerun9xxxx/OFile.root A chains of OFile.root files, that represents all of the Run 8 transverse pp data (of length ~ 5-8 Gbytes) can be processed on a laptop in 10-30 minutes depending on the complexity of the analysis. Indeed, the entire PSU package can be compiled and run on a laptop running Linux.

  17. Gain Matching The standard Fortran analysis to determine gains runs ntp2hist produces many predefined histograms. Paw kumacs are used to manipulate these Hbook plots, including a mass plot associated with every FMS cell. We at PSU have been excluded in discussions about any developments or innovations as to how this analysis is done. Ntp2hst Histogram merging Paw analysis of histograms (kumacs) See Larisa’s talk??? Rgaincorr1.txt Rgaincorr2.txt

  18. Cell Classincludes • The Cell class collects all data and physics distributions that can enable the most flexible cell by cell analysis, to obtain energy calibration for each cell. Included in the Cell class is: • p_Mcell ( 2 photon mass distribution for events with one photon pointing to this cell) • p_EphXY ( Photon energy distribution for photons pointing to this cell) • p_dxdyM (an array of mass distributions for events with one photon in this cell and one in a neighboring cell for each of the neighboring cells). • p_adc Raw ADC distributions. • Methods for fitting mass or energy distributions etc. • A TObjArray of all Cell objects is maintained and streamed to a root output file.

  19. Iteration cycle for Energy Gain.Updating gaincorr1.txt gaincorr1.txt gaincorr2.txt Condor job Run Analysis Root scripts Collect ADC Distribution Reconstruct calling Yiqunclass for each FMS detector Run9xxxx trigger data Secondary root Scripts that analyze data and update the TOBjArray of Cell objects. Determine new gaincorr values from information stored in the TObjArray of Cell objects. run9xxxx.rzd.gz run9xxxx.root TChain of secondary reconstructed photon data. TTree files likerun9xxxx/OFile.root

  20. Run 9 Real Time Gain Matching Link to Real Time Gain Analysis for last week of Run 9 • The same Qt class that reads Qt data and produces a matrix of ADC values for further analysis can also be used to • evaluate the Run 9 trigger algorithm, • apply the trigger algorithm to Qt data, • compare the result of application of algorithm to DSM trigger information. • Our class Qt • converts raw data to arrays of ADC values • Set up the L1 trigger condition for trigger simulation of current data • Stores both Qt raw adc data ad stores DSM data from the trigger. • Additional classes, written by Leun Eun, include • TrigQt which iterprets the QT class to • Extract a list of trigger Clusters from a Qt event. • Identifies the where the trigger is satisfied. • ClusterQt which represents each cluster within the Qt for this event • Len posted a summary of this comparison and trigger distributions every few days through all of run 9. • Link to Len’s Trigger monitoring page

  21. Using PSU code with StRoot>root4star RunFmsSeePI0.C void RunFmsSeePi0(intnevents = 5000, const char* file = "9065073.list") { gROOT->Macro("loadMuDst.C"); gROOT->Macro("LoadLogger.C"); gSystem->Load("StFmsAnalysisMaker"); StChain* chain = new StChain; StMuDstMaker* muDstMaker = new StMuDstMaker(0,0,"",file,".",1000,"MuDst"); StMuDbReader* muDB = StMuDbReader::instance(); // Instantiate your makers here StFmsAnalysisMaker* fms = new StFmsAnalysisMaker; fms->SetPrintLevel(0); fms->SetFile("fms.root"); chain->Init(); // Event loop cout<<"Prepare to process "<<nevents<<" events.\n"; for (intiEvent = 1; iEvent <= nevents; ++iEvent) { if(iEvent%100==1)cout<<"iEvent="<<iEvent<<"\n"; chain->Clear(); int status = chain->Make(iEvent); fms->SetPrintLevel(0); if (status % 10 == kStEOF || status % 10 == kStFatal) break; } } StFmsAnalysisMaker* fms

  22. StFmsAnalysisMaker.h // -*- mode: C++ -*- #ifndef ST_FMS_ANALYSIS_MAKER_H #define ST_FMS_ANALYSIS_MAKER_H // ROOT class TFile; class TH1F; class TH2F; // PSU-FMS package class FilesSet; class Geom; class Qt; class CalibStr; class FitTower; class Yiqun; class Edep; // STAR #include "StMaker.h" class StFmsAnalysisMaker : public StMaker { public: StFmsAnalysisMaker(const char* name = "StFmsAnalysisMaker") : StMaker(name) {} ~StFmsAnalysisMaker() {} void Clear(Option_t* option = ""); int Init(); int Make(); int Finish(); void SetFile(const char* filename) { mFileName = filename; } TMatrix* GetEnergy(Int_t nstb0){if(nstb0>=0 && nstb0<4) { return Energy[nstb0]; } else return 0;} TH2F* get_MvsE(){return MvsE;}; void SetPrintLevel(Int_tlev=1){PrintLevel=lev;}; Yiqun* p_rec[4]; CalibStr* GetRgain(){return Rgain;}; CalibStr* GetRgaincorr(){return Rgaincorr;}; Qt* GetQt(){return mQt;}; private: TStringmFileName; TFile* mFile; Int_tcurrentRunNumber; FilesSet* mFiles; Geom* mGeom; Qt* mQt; CalibStr* Rped; CalibStr* Rgain; CalibStr* Rgaincorr; TMatrix* Energy[4]; TH2F* MvsE; Int_tPrintLevel; TH1F* Fmsfr3[4]; TH1F* Fmsfr2[4]; TH1F* Fmsfr1[4]; TH2F* XYMod[4]; ClassDef(StFmsAnalysisMaker,1); }; #endif // ST_FMS_ANALYSIS_MAKER_H

  23. StFmsAnalysisMaker::Init() intStFmsAnalysisMaker::Init() { // Create a new ROOT file. Note, any existing file // will be overwritten. mFile = TFile::Open(mFileName,"recreate"); // Make sure the file was created successfully by // checking that mFile is non-zero. assert(mFile); FitTower::we.myRand=NULL; //ugly global stuff // Read in pedestal, gains, calibration, etc. files // via PSU package mFiles = new FilesSet("/star/u/heppel/BatchDir/rootfms", "lb_trg2008/fms/fmsped_2008.txt", "lb_trg2008/fms/fmsgain.20080526.txt", "lb_trg2008/fms/fpdcorr_itr10_20080828.txt", "fpd08/fill.txt", "Fake", "fpd08/spinpat", "lb_trg2008/fms/geom_2008pp_0227.txt", "lb_trg2008/fms/qtmap.txt", "lb_trg2008/fms/qtmap2pp_set121.txt"); mGeom = new Geom(mFiles); mQt=new Qt(mFiles); mQt->EnableqtHist(); MvsE=new TH2F("MvsE","MvsE",200,0.,2.,100,0.,100.); currentRunNumber= 9067059; // Some number from run 8 Rped=new CalibStr(currentRunNumber,mFiles->p_fpdped()->Path()); Rgain=new CalibStr(currentRunNumber,mFiles->p_fpdgain()->Path()); Rgaincorr=new CalibStr(currentRunNumber,mFiles->p_fpdgaincorr()->Path()); for(int k=0;k<4;k++) { Energy[k]=new TMatrix(*(Rgaincorr->tm(2,k+1))); *(Energy[k])=0.; p_rec[k]=0; };

  24. Data Small North Shower Fitted 1 Event From Run 8 (9069064) Left: is actual data from FMS. Right: is the fitted energy from the shower shape. The Bottom row corresponds to FMS Small South, the row above that corresponds to FMS Small North, …). The “*” shows the reconstructed photon position. Dark blue cells are dead.

  25. gSystem->Load("../../Fpdchan.so"); CalibStr gain(9069064,"fmsgain.20080526.txt"); CalibStrgaincorr(9069064,"fpdcorr_itr10_20080828.txt"); //total gains Small South FMS Run 8 Transverse TH2F hgain(*gain.tm(2,4)); TH2F hgaincorr(*gaincorr.tm(2,4)); TH2F FullGain(hgain*hgaincorr); FullGain.SetStats(0); FullGain.Draw("text"); Data Small North Shower Fitted FMS Small North GeV/(ADC Count) Left: is actual data in FMS Right: is the energy from the shower shape. The Bottom row corresponds to FMS Small South, the row above that corresponds to FMS Small North, …). The “*” shows the reconstructed photon position. Dark blue cells are dead.

  26. http://www.star.bnl.gov/protected/spin/larisa/run8/ene_corr.htmlhttp://www.star.bnl.gov/protected/spin/larisa/run8/ene_corr.html Post “Gain Correction” Run 8 Non-Linear Analysis a=1.06 B= -.0028 • This analysis similar to old FPD analysis • Similar to FPD correction • Not ever discussed in a public FMS meeting

  27. .135/mgg 2 Photon Events FMS South mass ratio vs. 1st Photon raw Energy 2nd Photon raw energy= 5 GeV

  28. Run 8 FMS South a=1.1 b= -.0062 Can a “per photon” non-linear correction to these gains values explain the data? X

  29. a=1.06 b= -.0028 Run 8 FMS South

  30. South Small Cell FMS: • The relationship between FMS ADC and photon Energy is not yet understood. • We need to discuss and work together on this. • Issues for consideration involve • Photon cluster and fitting algorithms (Can not be a black box) • Non-uniform gain (High Voltage) settings in FMS. • Interaction of 1) and 2) with interactive gain matching cyles. Correction Implied by Pi0 Mass Run 9 (preliminary) FMS South Correction Implied by Pi0 Mass Run 8 FMS South

  31. ConclusionMore interaction between collaborators is needed to resolve FMS analysis issues. • Current gain corrections are obtained by iteration of reconstruction. Results have been justified by noting consistency with some Monte Carlo distributions. • The reconstruction code has never been optimized (ie. Shower Shape etc.) and is not currently well understood. • The effects of detector edges, holes and gain non-uniformities has never been adequately understood as to how it affects the convergence of the iteration process toward a cell by cell gain solution. • Position dependence of reconstructed photons in over the detector surface has been a problem with FPD Run 6/ FMS Run 8/ FMS Run9. • Using pi0 mass to determine a photon energy non-linear gain correction for the FPD/FMS detectors is not internally consistent. • The inability to set up FMS high voltages so that neighboring cells have similar trigger rates is a huge problem which exacerbates all of the above issues. • Because information is not shared freely among FMS collaborators these issues have not received proper attention.

  32. Extra Slides

  33. p0 mass region with Center Cut Eta mass region with Center Cut Mgg Mgg Nevents Zgg Zgg Run 6: Pi0 and Eta in Center Cut

  34. Run 9 Run 8 Comparison p0 mass region with Center Cut Eta mass region with Center Cut Mgg Mgg Nevents Zgg Zgg Run 9 Mass Distribution E1+E2=45 GeV Run 8 Mass Distribution E1+E2=45 GeV Run 9: Z Distribution M=Mpi ; E1+E2=45 GeV Run 8: Z Distribution M=Mpi ; E1+E2=45 GeV Run 9: Z Distribution M=Meta; E1+E2=45 GeV Run 8: Z Distribution M=Meta ; E1+E2=45 GeV

More Related