Changeset 14896 for trunk


Ignore:
Timestamp:
02/13/13 10:34:54 (12 years ago)
Author:
tbretz
Message:
Added MCalibrateFact and MCalibrateDrsTimes
Location:
trunk/Mars
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/Mars/Makefile.conf.linux

    r12753 r14896  
    1919OPTIM    := -O5 -std=c++0x -Wall -Winit-self -fno-exceptions -fPIC -Wpointer-arith -Wcast-align -Woverloaded-virtual
    2020# ggc 4.3: removed -Wshadow -fnonnull-objects -Wtraditional -Wnested-externs -Wconversion
    21 DEBUG    :=
     21DEBUG    := -g
    2222ARCHDEF  := -D__LINUX__
    2323SOFLAG   := -shared

  • trunk/Mars/mbase/BaseLinkDef.h

    r11559 r14896  
    1919#pragma link C++ class izstream+;
    2020#pragma link C++ class fits+;
     21#pragma link C++ class ofits+;
    2122//#pragma link C++ class MBzlib2+;
     23
     24// mcore
     25#pragma link C++ class DrsCalibrateTime+;
    2226
    2327// Basic Network Tools

  • trunk/Mars/mbase/Makefile

    r11872 r14896  
    7070           MObjLookup.cc \
    7171           ../mcore/izstream.h \
    72            ../mcore/fits.h
     72           ../mcore/fits.h \
     73           ../mcore/DrsCalib.h
    7374
    7475############################################################

  • trunk/Mars/mcalib/CalibLinkDef.h

    r8657 r14896  
    1212
    1313#pragma link C++ class MCalibrateData+;
     14#pragma link C++ class MCalibrateFact+;
    1415#pragma link C++ class MCalibrateRelTimes+;
    1516
    … …  
    3940#pragma link C++ class MCalibrationChargePINDiode+;
    4041
     42#pragma link C++ class MCalibrateDrsTimes+;
     43
    4144#endif

  • trunk/Mars/mcalib/Makefile

    r9518 r14896  
    2121INCLUDES = -I. -I../mbase -I../mgui -I../mgeom -I../mhcalib -I../mhbase \
    2222           -I../manalysis -I../mraw -I../mtools -I../mmc -I../mhist  \
    23            -I../mimage -I../msignal -I../mbadpixels -I../mpedestal
     23           -I../mimage -I../msignal -I../mbadpixels -I../mpedestal -I../mcore
    2424# mhbase:    MBinning MH
    2525# mgui:      MCamEvent (McalibrationCam)
    … …  
    3434           MCalibCalcFromPast.cc \
    3535           MCalibrateData.cc \
     36           MCalibrateFact.cc \
    3637           MCalibConstCam.cc \
    3738           MCalibConstPix.cc \
    … …  
    3940           MCalibrationPatternDecode.cc \
    4041           MCalibrateRelTimes.cc \
     42           MCalibrateDrsTimes.cc \
    4143           MCalibrationCam.cc \
    4244           MCalibrationPix.cc  \

  • trunk/Mars/mcore/fits.h

    r14860 r14896  
    420420
    421421#ifdef __CINT__
    422     typedef char Pointers[56];
     422    typedef char Pointers[48];
    423423#else
    424424    typedef unordered_map<string, void*> Pointers;

  • trunk/Mars/mdata/MDataArray.cc

    r8910 r14896  
    114114{
    115115    const MDataPhrase data(rule);
    116     if (!data.IsValid())
    117         return -1;
     116//    if (!data.IsValid())
     117//        return -1;
    118118
    119119    const TString r(data.GetRule());

  • trunk/Mars/mhflux/MHThetaSq.cc

    r9851 r14896  
    130130    MBinning binsa(nbins, 0, nbins*intmax/nsig);
    131131
     132    gLog << inf << "Theta-cut set to " << intmax << "deg" << endl;
     133
    132134    // Apply binning
    133135    binsa.Apply(fHistTime);
    … …  
    177179void MHThetaSq::InitMapping(MHMatrix *mat, Int_t type)
    178180{
     181    return MHAlpha::InitMapping(mat, type);
     182
    179183    if (fMatrix)
    180184        return;

  • trunk/Mars/mhist/HistLinkDef.h

    r8614 r14896  
    55#pragma link off all functions;
    66
    7 //#pragma link C++ class MHFadcCam+;
     7#pragma link C++ class MDrsCalibration+;
     8#pragma link C++ class MDrsCalibrationTime+;
     9#pragma link C++ class MHDrsCalibration+;
     10#pragma link C++ class MHDrsCalibrationT+;
     11#pragma link C++ class MHDrsCalibrationCheck+;
    812//#pragma link C++ class MHFadcPix+;
    913
    … …  
    1620
    1721//#pragma link C++ class MHCompProb+;
    18 #pragma link C++ class MHHadronness+;   
     22#pragma link C++ class MHHadronness+;
    1923
    2024#pragma link C++ class MHCamera+;

  • trunk/Mars/mhist/Makefile

    r9519 r14896  
    2222           -I../mgui -I../mgeom -I../mdata -I../mfilter -I../mimage \
    2323           -I../mpointing -I../mmc  -I../mastro -I../msignal        \
    24            -I../mbadpixels -I../mcalib -I../mreport -I../mtrigger
     24           -I../mbadpixels -I../mcalib -I../mreport -I../mtrigger   \
     25           -I../mcore -I../mpedestal
    2526
    2627SRCFILES = MHEvent.cc \
     28           MHDrsCalib.cc \
    2729           MHCamEvent.cc \
    2830           MHCamEventRot.cc \

  • trunk/Mars/mjobs/JobsLinkDef.h

    r9275 r14896  
    1818
    1919#pragma link C++ class MJPedestal+;
     20#pragma link C++ class MJPedestalF+;
    2021#pragma link C++ class MJStar+;
    2122#pragma link C++ class MJCut+;

  • trunk/Mars/mjobs/Makefile

    r9518 r14896  
    3333           MJSimulation.cc \
    3434           MJPedestal.cc \
     35           MJPedestalF.cc \
    3536           MJCalib.cc \
    3637           MJCalibration.cc \

  • trunk/Mars/mmuon/MHSingleMuon.cc

    r10166 r14896  
    211211    for (Int_t i=0; i<entries; i++)
    212212    {
    213         const MSignalPix &pix  = (*fSignalCam)[i];
    214         const MGeom      &gpix = (*fGeomCam)[i];
     213        const MSignalPix &pix = (*fSignalCam)[i];
     214        if (fUseCleanedSignal && !pix.IsPixelUsed())
     215            continue;
     216
     217        const MGeom  &gpix = (*fGeomCam)[i];
    215218
    216219        const Float_t dx = gpix.GetX() - cenx;
    … …  
    227230        }
    228231
    229         // use only the inner pixles. FIXME: This is geometry dependent
     232        // use only the inner pixels. FIXME: This is geometry dependent
    230233        if (gpix.GetAidx()>0)
    231234            continue;
    … …  
    234237    }
    235238
    236     // Setup the function and perform the fit
    237     TF1 g1("g1", "gaus");//, -fHistTime.GetXmin(), fHistTime.GetXmax());
    238 
    239     // Choose starting values as accurate as possible
    240     g1.SetParameter(0, fHistTime.GetMaximum());
    241     g1.SetParameter(1, 0);
    242     g1.SetParameter(2, 0.7); // FIXME! GetRMS instead???
    243 
    244     // According to fMuonSearchPar->GetTimeRMS() identified muons
    245     // do not have an arrival time rms>3
    246     g1.SetParLimits(1, -1.7, 1.7);
    247     g1.SetParLimits(2,  0,   3.4);
    248 
    249     // options : N  do not store the function, do not draw
    250     //           I  use integral of function in bin rather than value at bin center
    251     //           R  use the range specified in the function range
    252     //           Q  quiet mode
    253     if (fHistTime.Fit(&g1, "QNB"))
    254         return kTRUE;
    255 
    256     fRelTimeMean  = g1.GetParameter(1);
    257     fRelTimeSigma = g1.GetParameter(2);
     239    if (!fUseCleanedSignal)
     240    {
     241        // Setup the function and perform the fit
     242        TF1 g1("g1", "gaus");//, -fHistTime.GetXmin(), fHistTime.GetXmax());
     243
     244        // Choose starting values as accurate as possible
     245        g1.SetParameter(0, fHistTime.GetMaximum());
     246        g1.SetParameter(1, 0);
     247        g1.SetParameter(2, 0.7); // FIXME! GetRMS instead???
     248
     249        // According to fMuonSearchPar->GetTimeRMS() identified muons
     250        // do not have an arrival time rms>3
     251        g1.SetParLimits(1, -1.7, 1.7);
     252        g1.SetParLimits(2,  0,   3.4);
     253
     254        // options : N  do not store the function, do not draw
     255        //           I  use integral of function in bin rather than value at bin center
     256        //           R  use the range specified in the function range
     257        //           Q  quiet mode
     258        if (fHistTime.Fit(&g1, "QNB"))
     259            return kTRUE;
     260
     261        fRelTimeMean  = g1.GetParameter(1);
     262        fRelTimeSigma = g1.GetParameter(2);
     263    }
     264    else
     265    {
     266        fRelTimeMean  = fMuonSearchPar->GetTime();
     267        fRelTimeSigma = fMuonSearchPar->GetTimeRms();
     268    }
    258269
    259270    // The mean arrival time which was subtracted before will
    … …  
    264275    {
    265276        const MSignalPix &pix  = (*fSignalCam)[i];
    266         const MGeom      &gpix = (*fGeomCam)[i];
     277        if (fUseCleanedSignal && !pix.IsPixelUsed())
     278            continue;
     279
     280        const MGeom &gpix = (*fGeomCam)[i];
    267281
    268282        const Float_t dx = gpix.GetX() - cenx;
    … …  
    273287        // if the signal is not near the estimated circle, it is ignored.
    274288        if (TMath::Abs(dist-fMuonSearchPar->GetRadius())<fMargin &&
    275             TMath::Abs(pix.GetArrivalTime()-tm0) < 2*fRelTimeSigma)
     289            (fUseCleanedSignal || TMath::Abs(pix.GetArrivalTime()-tm0) < 2*fRelTimeSigma))
    276290        {
    277291            fHistPhi.Fill(TMath::ATan2(dx, dy)*TMath::RadToDeg(), pix.GetNumPhotons());
    … …  
    393407{
    394408    Int_t first, last;
    395 
    396409    if (!FindRangeAboveThreshold(fHistWidth, thres, first, last))
    397410        return kFALSE;

  • trunk/Mars/mmuon/MHSingleMuon.h

    r9153 r14896  
    2323
    2424    Double_t fMargin;               //!
     25    Bool_t   fUseCleanedSignal;     //!
    2526
    2627    TProfile fHistPhi;    // Histogram of photon distribution along the arc.
    … …  
    4950    Double_t GetRelTimeSigma() const { return fRelTimeSigma; }
    5051
     52    void SetUseCleanedSignal(Bool_t b=kTRUE) { fUseCleanedSignal = b; }
     53
    5154    Float_t CalcSize() const;
    5255

  • trunk/Mars/mmuon/MMuonSearchPar.cc

    r9376 r14896  
    295295
    296296    //SetReadyToSave();
    297 }
     297}
     298
     299Bool_t MMuonSearchPar::CalcFact(const MGeomCam &geom, const MSignalCam &evt)
     300{
     301    // ===================== Reset cleaning ======================
     302
     303    for (UInt_t idx=0; idx<evt.GetNumPixels(); idx++)
     304    {
     305        MSignalPix &pix = evt[idx];
     306        if (pix.IsPixelUnmapped())
     307            continue;
     308
     309        pix.SetPixelUnused();
     310        pix.SetPixelCore(kFALSE);
     311    }
     312
     313    // ============ Do muon cleaning / calculate COG =============
     314
     315    // The window must be large enough that the earliest and latest
     316    // events do not get a biased timerms
     317    double time_min   =  -19.5;
     318    double time_max   =  -4.5;
     319    double signal_min =  2.30;
     320    double delta_t    =  1.75;
     321
     322    Double_t sumx = 0.;
     323    Double_t sumy = 0.;
     324    Double_t sumw = 0.;
     325    for (UInt_t i=0; i<evt.GetNumPixels(); i++)
     326    {
     327        MSignalPix &pix = evt[i];
     328
     329        if (pix.GetNumPhotons()<signal_min)
     330            continue;
     331        if (pix.GetArrivalTime()>=time_max || pix.GetArrivalTime()<time_min)
     332            continue;
     333        if (pix.IsPixelUnmapped())
     334            continue;
     335
     336        const MGeom &gpix = geom[i];
     337
     338        const double x = gpix.GetX();
     339        const double y = gpix.GetY();
     340
     341        int counter = 0;
     342        for (int j=0; j<gpix.GetNumNeighbors(); j++)
     343        {
     344            const int idx = gpix.GetNeighbor(j);
     345
     346            const MSignalPix &spix = evt[idx];
     347
     348            if (spix.GetNumPhotons()<signal_min)
     349                continue;
     350            if (spix.GetArrivalTime()>=time_max || spix.GetArrivalTime()<time_min)
     351                continue;
     352            if (spix.IsPixelUnmapped())
     353                continue;
     354
     355            if (TMath::Abs(pix.GetArrivalTime()-spix.GetArrivalTime())>delta_t)
     356                continue;
     357
     358            counter++;
     359        }
     360
     361        if (counter==0)
     362            continue;
     363
     364        sumx += pix.GetNumPhotons()*x;
     365        sumy += pix.GetNumPhotons()*y;
     366        sumw += pix.GetNumPhotons();
     367
     368        pix.SetPixelUsed();
     369        pix.SetPixelCore();
     370    }
     371
     372    if (sumw==0)
     373        return kFALSE;
     374
     375    sumx /= sumw;
     376    sumy /= sumw;
     377
     378    // ==============  Fit circle to resulting data ===============
     379
     380    Double_t sigma, rad;
     381    CalcMinimumDeviation(geom, evt, sumx, sumy, sigma, rad);
     382
     383    fCenterX   = sumx;
     384    fCenterY   = sumy;
     385    fRadius    = rad;
     386    fDeviation = sigma;
     387
     388    return kTRUE;
     389}
    298390
    299391void MMuonSearchPar::Print(Option_t *) const

  • trunk/Mars/mmuon/MMuonSearchPar.h

    r8911 r14896  
    5252    void   Calc(const MGeomCam &geom, const MSignalCam &evt,
    5353                const MHillas &hillas);
     54    Bool_t CalcFact(const MGeomCam &geom, const MSignalCam &evt);
    5455
    5556    // TObject

  • trunk/Mars/mmuon/MMuonSearchParCalc.cc

    r7009 r14896  
    7676Int_t MMuonSearchParCalc::PreProcess(MParList *pList)
    7777{
    78     fHillas = (MHillas*)pList->FindObject("MHillas");
    79     if (!fHillas)
     78    fHillas = 0;
     79    if (!fUseFactAlgorithm)
    8080    {
    81         *fLog << err << "MHillas not found... aborting." << endl;
    82         return kFALSE;
     81        fHillas = (MHillas*)pList->FindObject("MHillas");
     82        if (!fHillas)
     83        {
     84            *fLog << err << "MHillas not found... aborting." << endl;
     85            return kFALSE;
     86        }
    8387    }
    8488
    … …  
    108112Int_t MMuonSearchParCalc::Process()
    109113{
    110     fMuonPar->Calc(*fGeomCam, *fSignalCam, *fHillas);
     114    if (fUseFactAlgorithm)
     115        fMuonPar->CalcFact(*fGeomCam, *fSignalCam);
     116    else
     117        fMuonPar->Calc(*fGeomCam, *fSignalCam, *fHillas);
     118
    111119    return kTRUE;
    112120}

  • trunk/Mars/mmuon/MMuonSearchParCalc.h

    r6979 r14896  
    1919    MMuonSearchPar *fMuonPar;     //! Pointer to the output container for the new image parameters
    2020
     21    Bool_t fUseFactAlgorithm;
     22
    2123    Int_t PreProcess(MParList *plist);
    2224    Int_t Process();
    … …  
    2527    MMuonSearchParCalc(const char *name=NULL, const char *title=NULL);
    2628
     29    void SetUseFactAlgorithm(Bool_t b=kTRUE) { fUseFactAlgorithm = kTRUE; }
     30
    2731    ClassDef(MMuonSearchParCalc, 0) // task to calculate muon parameters
    2832};

  • trunk/Mars/mpedestal/MPedCalcPedRun.cc

    r10166 r14896  
    256256void MPedCalcPedRun::Calc()
    257257{
    258     if (fIsNotPedRun && !IsPedBitSet())
    259         return;
     258//    if (fIsNotPedRun && !IsPedBitSet())
     259//        return;
    260260
    261261    MRawEvtPixelIter pixel(fRawEvt);

  • trunk/Mars/mpedestal/Makefile

    r11873 r14896  
    4242           MHPedestalCor.cc \
    4343           MPedestalSubtract.cc \
    44            MPedestalSubtractedEvt.cc
     44           MPedestalSubtractedEvt.cc \
     45           MDrsCalibApply.cc
    4546
    4647############################################################

  • trunk/Mars/mpedestal/PedestalLinkDef.h

    r8154 r14896  
    2020#pragma link C++ class MPedestalSubtractedEvt+;
    2121
     22#pragma link C++ class MDrsCalibApply+;
     23#pragma link C++ class MDrsCalibResult+;
     24
    2225#pragma link C++ class MHPedestalCor+;
    2326
Note: See TracChangeset for help on using the changeset viewer.