Ignore:
Timestamp:
08/25/04 13:20:16 (20 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/mjobs
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/mjobs/JobsLinkDef.h

    r4723 r4729  
    55#pragma link off all functions;
    66
     7#pragma link C++ class MJob+;
    78#pragma link C++ class MSequence+;
    89

  • trunk/MagicSoft/Mars/mjobs/MJCalibrateSignal.cc

    r4723 r4729  
    4343#include "MLogManip.h"
    4444
    45 #include "MSequence.h"
    4645#include "MDirIter.h"
    4746#include "MParList.h"
    … …  
    8382//
    8483MJCalibrateSignal::MJCalibrateSignal(const char *name, const char *title)
    85     : fOverwrite(kFALSE), fMaxEvents(0)
    8684{
    8785    fName  = name  ? name  : "MJCalibrateSignal";
    … …  
    8987}
    9088
    91 MJCalibrateSignal::~MJCalibrateSignal()
     89Bool_t MJCalibrateSignal::WriteResult()
    9290{
    93 }
    94 
    95 Bool_t MJCalibrateSignal::WriteResult(const MSequence &seq)
    96 {
    97     if (fOutputPath.IsNull())
     91    if (fPathOut.IsNull())
     92    {
     93        *fLog << inf << "No output path specified via SetPathOut - no output written." << endl;
    9894        return kTRUE;
    99 
    100     const TString oname = Form("%s/calped%06d.root", (const char*)fOutputPath, seq.GetSequence());
     95    }
     96
     97    const TString oname = Form("%s/calped%06d.root", (const char*)fPathOut, fSequence.GetSequence());
    10198
    10299    *fLog << inf << "Writing to file: " << oname << endl;
    … …  
    115112}
    116113
    117 void MJCalibrateSignal::SetOutputPath(const char *path)
    118 {
    119     fOutputPath = path;
    120     if (fOutputPath.EndsWith("/"))
    121         fOutputPath = fOutputPath(0, fOutputPath.Length()-1);
    122 }
    123 void MJCalibrateSignal::SetInputPath(const char *path)
    124 {
    125     fInputPath = path;
    126     if (fInputPath.EndsWith("/"))
    127         fInputPath = fInputPath(0, fInputPath.Length()-1);
    128 }
    129 
    130 void MJCalibrateSignal::CheckEnv(const char *env)
    131 {
    132     TEnv e(env);
    133 
    134     TString e1 = e.GetValue("MJCalibrateSignal.OutputPath", "");
    135     if (!e1.IsNull())
    136     {
    137         e1.ReplaceAll("\015", "");
    138         SetOutputPath(e1);
    139     }
    140 
    141     fMaxEvents = e.GetValue("MJCalibrateSignal.MaxEvents", fMaxEvents);
    142 }
    143 
    144 Bool_t MJCalibrateSignal::ReadCalibration(const MSequence &seq, const char *path,
    145                                           MCalibrationCam &calcam,
     114Bool_t MJCalibrateSignal::ReadCalibration(MCalibrationCam &calcam,
    146115                                          MCalibrationCam &qecam,
    147116                                          MCalibrationCam &tmcam,
    148117                                          MBadPixelsCam &badpix, MTask* &ext1, MTask* &ext2) const
    149118{
    150     TString inpath(path);
    151     if (inpath.EndsWith("/"))
    152         inpath = inpath(0, inpath.Length()-1);
    153 
    154     const TString fname = Form("%s/calib%06d.root", inpath.Data(), seq.GetSequence());
     119    const TString fname = Form("%s/calib%06d.root", fPathIn.Data(), fSequence.GetSequence());
    155120
    156121    TFile file(fname, "READ");
    … …  
    211176}
    212177
    213 Bool_t MJCalibrateSignal::ProcessFile(const MSequence &seq, const char *env, const char *path)
     178Bool_t MJCalibrateSignal::ProcessFile(MPedestalCam &pedcam)
    214179{
     180    if (!fSequence.IsValid())
     181    {
     182        *fLog << err << "ERROR - Sequence invalid!" << endl;
     183        return kFALSE;
     184    }
     185
     186    //if (!CheckEnv())
     187    //    return kFALSE;
     188
     189    CheckEnv();
     190
     191    // --------------------------------------------------------------------------------
     192
    215193    *fLog << inf;
    216194    fLog->Separator(GetDescriptor());
    217195    *fLog << "Calculate calibrated data from runs ";
    218     *fLog << seq.GetName() << endl;
     196    *fLog << fSequence.GetName() << endl;
    219197    *fLog << endl;
    220198
    221     CheckEnv(env);
    222 
    223     // -------------------------------------------------------------------------------
    224 
    225     MJPedestal job1;
    226     job1.SetSequence(&seq);
    227     job1.SetDisplay(fDisplay);;
    228     job1.SetEnv(env);
    229 
    230     if (!job1.ProcessFile())
    231         return kFALSE;
    232 
    233199    // --------------------------------------------------------------------------------
    234200
    235201    MDirIter iter;
    236     if (seq.SetupDatRuns(iter, fInputPath)==0)
    237     {
    238             *fLog << err << "ERROR - No input files of sequence found!" << endl;
    239             return kFALSE;
     202    const Int_t n0 = fSequence.SetupDatRuns(iter, fPathData);
     203    const Int_t n1 = fSequence.GetNumDatRuns();
     204    if (n0==0)
     205    {
     206        *fLog << err << "ERROR - No input files of sequence found!" << endl;
     207        return kFALSE;
     208    }
     209    if (n0!=n1)
     210    {
     211        *fLog << err << "ERROR - Number of files found (" << n0 << ") doesn't match number of files in sequence (" << n1 << ")" << endl;
     212        return kFALSE;
    240213    }
    241214
    … …  
    249222    MTask *extractor2=0;
    250223
    251     if (!ReadCalibration(seq, path, calcam, qecam, tmcam, badpix, extractor1, extractor2))
     224    if (!ReadCalibration(calcam, qecam, tmcam, badpix, extractor1, extractor2))
    252225        return kFALSE;
    253226
    … …  
    270243    plist.AddToList(&tmcam);
    271244    plist.AddToList(&badcam);
    272     plist.AddToList(&job1.GetPedestalCam());
     245    plist.AddToList(&pedcam);
    273246
    274247    // Setup Tasklist
    … …  
    314287    MFillH fill5(&evt5, "MArrivalTime",        "FillTimes");
    315288
    316     MWriteRootFile write(2, Form("%s{s/_D_/_Y_}", fOutputPath.Data()), fOverwrite);
     289    MWriteRootFile write(2, Form("%s{s/_D_/_Y_}", fPathOut.Data()), fOverwrite);
    317290    write.AddContainer("MCerPhotEvt",    "Events");
    318291    write.AddContainer("MPedPhotCam",    "Events");
    … …  
    347320    evtloop.SetDisplay(fDisplay);
    348321    evtloop.SetLogStream(fLog);
    349     evtloop.ReadEnv(env);
     322    if (GetEnv())
     323        evtloop.ReadEnv(*GetEnv());
    350324
    351325    // Execute first analysis
    … …  
    358332    tlist.PrintStatistics();
    359333
    360     if (!WriteResult(seq))
     334    if (!WriteResult())
    361335        return kFALSE;
    362336

  • trunk/MagicSoft/Mars/mjobs/MJCalibrateSignal.h

    r4723 r4729  
    22#define MARS_MJCalibrateSignal
    33
    4 #ifndef MARS_MParContainer
    5 #include "MParContainer.h"
     4#ifndef MARS_MJob
     5#include "MJob.h"
    66#endif
    77
    … …  
    1111class MParList;
    1212class MSequence;
     13class MPedestalCam;
    1314class MBadPixelsCam;
    1415class MCalibrationCam;
    … …  
    1718class MCalibrationChargeCam;
    1819
    19 class MJCalibrateSignal : public MParContainer
     20class MJCalibrateSignal : public MJob
    2021{
    2122private:
    22     TString fOutputPath;        // Directory to write signal*.root file to
    23     TString fInputPath;         // Directory to read  calib*.root file from
    24 
    25     Bool_t fOverwrite;          // Allow overwriting files
    26     Int_t  fMaxEvents;          // Maximum number of events
    27 
    28     void   CheckEnv(const char *env);
    29     Bool_t WriteResult(const MSequence &seq);
    30     Bool_t ReadCalibration(const MSequence &seq, const char *path, MCalibrationCam &calcam,
     23    Bool_t WriteResult();
     24    Bool_t ReadCalibration(MCalibrationCam &calcam,
    3125                           MCalibrationCam &qecam, MCalibrationCam &tmcam,
    3226                           MBadPixelsCam &badpix, MTask* &ext1, MTask* &ext2) const;
    … …  
    3428public:
    3529    MJCalibrateSignal(const char *name=NULL, const char *title=NULL);
    36     ~MJCalibrateSignal();
    3730
    38     Bool_t ProcessFile(const MSequence &seq, const char *env, const char *path=0);
    39 
    40     void SetOutputPath(const char *path=".");
    41     void SetInputPath(const char *path=".");
    42     void SetMaxEvents(Int_t max) { fMaxEvents = max; }
    43 
    44     void SetOverwrite(Bool_t b=kTRUE) { fOverwrite=b; }
    45 
    46     MStatusDisplay *GetDisplay() { return fDisplay; }
     31    Bool_t ProcessFile(MPedestalCam &cam);
    4732
    4833    ClassDef(MJCalibrateSignal, 0) // Tool to create a pedestal file (MPedestalCam)

  • trunk/MagicSoft/Mars/mjobs/MJCalibration.cc

    r4723 r4729  
    8787#include "MJCalibration.h"
    8888
    89 #include <TEnv.h>
    9089#include <TFile.h>
    9190#include <TStyle.h>
    … …  
    174173const Float_t  MJCalibration::fgRefQEInner                = 0.18;           
    175174const Float_t  MJCalibration::fgRefQEOuter                = 0.12;
     175
     176
    176177// --------------------------------------------------------------------------
    177178//
    … …  
    184185//
    185186MJCalibration::MJCalibration(const char *name, const char *title)
    186     : fEnv(0), fRuns(0), fSequence(0), fExtractor(NULL), fTimeExtractor(NULL),
     187    : fRuns(0), fExtractor(NULL), fTimeExtractor(NULL),
    187188      fColor(MCalibrationCam::kNONE), fDisplayType(kNormalDisplay),
    188       fRelTimes(kFALSE), fDataCheck(kFALSE), fDebug(kFALSE), fOverwrite(kFALSE)
    189 {
    190 
    191   fName  = name  ? name  : "MJCalibration";
    192   fTitle = title ? title : "Tool to create the calibration constants for one calibration run";
    193 
    194   SetUseBlindPixel();
    195   SetUsePINDiode();
    196 
    197 }
    198 
    199 MJCalibration::~MJCalibration()
    200 {
    201     if (fEnv)
    202         delete fEnv;
     189      fRelTimes(kFALSE), fDataCheck(kFALSE), fDebug(kFALSE)
     190{
     191    fName  = name  ? name  : "MJCalibration";
     192    fTitle = title ? title : "Tool to create the calibration constants for one calibration run";
     193
     194    SetUseBlindPixel();
     195    SetUsePINDiode();
    203196}
    204197
    … …  
    255248    TString title = fDisplay->GetTitle();
    256249    title += "--  Calibration ";
    257     title += fSequence ? Form("calib%06d", fSequence->GetSequence()) : fRuns->GetRunsAsString();
     250    title += fSequence.IsValid() ? Form("calib%06d", fSequence.GetSequence()) : fRuns->GetRunsAsString();
    258251    title += "  --";
    259252    fDisplay->SetTitle(title);
    … …  
    11261119Bool_t MJCalibration::FindColor()
    11271120{
    1128     if (fSequence)
     1121    if (fSequence.IsValid())
    11291122    {
    11301123        fColor = MCalibrationCam::kCT1;
    … …  
    12221215const char* MJCalibration::GetOutputFile() const
    12231216{
    1224     if (fSequence)
    1225         return Form("%s/calib%06d.root", (const char*)fOutputPath, fSequence->GetSequence());
     1217    if (fSequence.IsValid())
     1218        return Form("%s/calib%06d.root", (const char*)fPathOut, fSequence.GetSequence());
    12261219    if (!fRuns)
    12271220        return "";
    12281221
    1229     return Form("%s/%s-F1.root", (const char*)fOutputPath, (const char*)fRuns->GetRunsAsFileName());
     1222    return Form("%s/%s-F1.root", (const char*)fPathOut, (const char*)fRuns->GetRunsAsFileName());
    12301223}
    12311224
    … …  
    12401233}
    12411234
    1242 void MJCalibration::SetEnv(const char *env)
    1243 {
    1244     if (fEnv)
    1245         delete fEnv;
    1246     fEnv = new TEnv(env);
    1247 }
    1248 
    12491235// --------------------------------------------------------------------------
    12501236//
    12511237// MJCalibration allows to setup several option by a resource file:
    1252 //   MJCalibration.OutputPath: path
    1253 //   MJCalibration.InputPath: path
    12541238//   MJCalibration.Display: full, datacheck, normal
    12551239//   MJCalibration.RelTimeCalibration: yes,no
    … …  
    12611245// For more details see the class description and the corresponding Getters
    12621246//
    1263 void MJCalibration::CheckEnv()
    1264 {
    1265     if (!fEnv)
    1266         return;
    1267 
    1268     TString e1 = fEnv->GetValue(Form("%s.OutputPath", fName.Data()), "");
    1269     if (!e1.IsNull())
    1270     {
    1271         e1.ReplaceAll("\015", "");
    1272         SetOutputPath(e1);
    1273     }
    1274 
    1275     TString col = fEnv->GetValue(Form("%s.Color", fName.Data()), "");
     1247Bool_t MJCalibration::CheckEnv()
     1248{
     1249    if (!MJob::CheckEnv())
     1250        return kFALSE;
     1251
     1252    TString col = GetEnv("Color", "");
    12761253    if (!col.IsNull())
    12771254    {
    12781255    }
    12791256
    1280     TString dis = fEnv->GetValue(Form("%s.Display", fName.Data()), "");
     1257    TString dis = GetEnv("Display", "");
    12811258    if (dis.BeginsWith("Full", TString::kIgnoreCase))
    12821259        SetFullDisplay();
    … …  
    12861263        SetNormalDisplay();
    12871264
    1288     SetRelTimeCalibration(fEnv->GetValue(Form("%s.RelTimeCalibration", fName.Data()), fRelTimes));
    1289     SetDataCheck(fEnv->GetValue(Form("%s.Datacheck", fName.Data()), fDataCheck));
    1290     SetDebug(fEnv->GetValue(Form("%s.Debug", fName.Data()), fDebug));
    1291     SetUseBlindPixel(fEnv->GetValue(Form("%s.UseBlindPixel", fName.Data()), IsUseBlindPixel()));
    1292     SetUsePINDiode(fEnv->GetValue(Form("%s.UsePINDiode", fName.Data()), IsUsePINDiode()));
    1293 
    1294     SetOverwrite(fEnv->GetValue(Form("%s.AllowOverwrite", fName.Data()), fOverwrite));
    1295     SetInputPath(fEnv->GetValue(Form("%s.InputPath", fName.Data()), fInputPath));
     1265    SetRelTimeCalibration(GetEnv("RelTimeCalibration", fRelTimes));
     1266    SetDataCheck(GetEnv("Datacheck", fDataCheck));
     1267    SetDebug(GetEnv("Debug", fDebug));
     1268    SetUseBlindPixel(GetEnv("UseBlindPixel", IsUseBlindPixel()));
     1269    SetUsePINDiode(GetEnv("UsePINDiode", IsUsePINDiode()));
     1270
     1271    return kTRUE;
    12961272}
    12971273
    … …  
    13121288{
    13131289
    1314   Int_t run = fSequence ? fSequence->GetLastRun() : fRuns->GetRuns()[fRuns->GetNumRuns()-1];
     1290  Int_t run = fSequence.IsValid() ? fSequence.GetLastRun() : fRuns->GetRuns()[fRuns->GetNumRuns()-1];
    13151291 
    13161292  //
    … …  
    13941370Bool_t MJCalibration::ProcessFile(MPedestalCam &pedcam)
    13951371{
    1396     if (!fRuns && !fSequence)
    1397     {
    1398         *fLog << err << "No Runs choosen... abort." << endl;
    1399         return kFALSE;
    1400     }
    1401 
    1402     if (!fSequence && fRuns->GetNumRuns() != fRuns->GetNumEntries())
    1403     {
    1404         *fLog << err << "Number of files found doesn't match number of runs... abort."
    1405             << fRuns->GetNumRuns() << " vs. " << fRuns->GetNumEntries() << endl;
    1406         return kFALSE;
    1407     }
     1372    if (!fSequence.IsValid())
     1373    {
     1374        if (!fRuns)
     1375        {
     1376            *fLog << err << "No Runs choosen... abort." << endl;
     1377            return kFALSE;
     1378        }
     1379
     1380        if (fRuns->GetNumRuns() != fRuns->GetNumEntries())
     1381        {
     1382            *fLog << err << "Number of files found doesn't match number of runs... abort."
     1383                << fRuns->GetNumRuns() << " vs. " << fRuns->GetNumEntries() << endl;
     1384            return kFALSE;
     1385        }
     1386    }
     1387
     1388    //if (!CheckEnv())
     1389    //    return kFALSE;
     1390
     1391    CheckEnv();
     1392
     1393    // --------------------------------------------------------------------------------
    14081394
    14091395    *fLog << inf;
    … …  
    14141400
    14151401    *fLog << "Calculate MCalibrationCam from ";
    1416     if (fSequence)
    1417         *fLog << "Sequence #" << fSequence->GetSequence() << endl;
     1402    if (fSequence.IsValid())
     1403        *fLog << "Sequence #" << fSequence.GetSequence() << endl;
    14181404    else
    14191405        *fLog << "Runs " << fRuns->GetRunsAsString() << endl;
    14201406    *fLog << endl;
    14211407
    1422     CheckEnv();
     1408    // --------------------------------------------------------------------------------
    14231409
    14241410    // Setup Tasklist
    … …  
    14321418
    14331419    MDirIter iter;
    1434     if (fSequence)
    1435     {
    1436         if (fSequence->SetupCalRuns(iter, fInputPath)==0)
     1420    if (fSequence.IsValid())
     1421    {
     1422        const Int_t n0 = fSequence.SetupCalRuns(iter, fPathData);
     1423        const Int_t n1 = fSequence.GetNumCalRuns();
     1424        if (n0==0)
    14371425        {
    14381426            *fLog << err << "ERROR - No input files of sequence found!" << endl;
    14391427            return kFALSE;
    14401428        }
     1429        if (n0!=n1)
     1430        {
     1431            *fLog << err << "ERROR - Number of files found (" << n0 << ") doesn't match number of files in sequence (" << n1 << ")" << endl;
     1432            return kFALSE;
     1433        }
    14411434    }
    14421435
    14431436    if (fDataCheck)
    14441437    {
    1445         rawread.AddFiles(fSequence ? iter : *fRuns);
     1438        rawread.AddFiles(fSequence.IsValid() ? iter : *fRuns);
    14461439        tlist.AddToList(&rawread);
    14471440    }
    … …  
    14491442    {
    14501443        read.DisableAutoScheme();
    1451         read.AddFiles(fSequence ? iter : *fRuns);
     1444        read.AddFiles(fSequence.IsValid() ? iter : *fRuns);
    14521445        tlist.AddToList(&read);
    14531446    }
    … …  
    14781471    MCalibrationRelTimeCalc  timecalc;
    14791472
    1480     if (!fSequence)
    1481     {
    1482         calcalc.SetOutputPath(fOutputPath);
     1473    if (!fSequence.IsValid())
     1474    {
     1475        calcalc.SetOutputPath(fPathOut);
    14831476        calcalc.SetOutputFile(Form("%s-ChargeCalibStat.txt",(const char*)fRuns->GetRunsAsFileName()));
    14841477    }
    … …  
    15641557    evtloop.SetDisplay(fDisplay);
    15651558    evtloop.SetLogStream(fLog);
    1566     if (fEnv)
    1567         evtloop.ReadEnv(*fEnv);
     1559    if (GetEnv())
     1560        evtloop.ReadEnv(*GetEnv());
    15681561
    15691562    //if (!WriteEventloop(evtloop))
    … …  
    16881681// --------------------------------------------------------------------------
    16891682//
    1690 // Set the path for output files, written by WriteResult()
    1691 //
    1692 void MJCalibration::SetOutputPath(const char *path)
    1693 {
    1694     fOutputPath = path;
    1695     if (fOutputPath.EndsWith("/"))
    1696         fOutputPath = fOutputPath(0, fOutputPath.Length()-1);
    1697 }
    1698 
    1699 // --------------------------------------------------------------------------
    1700 //
    1701 // Set the path from which the sequence files are read
    1702 //
    1703 void MJCalibration::SetInputPath(const char *path)
    1704 {
    1705     fInputPath = path;
    1706     if (fInputPath.EndsWith("/"))
    1707         fInputPath = fInputPath(0, fInputPath.Length()-1);
    1708 }
    1709 
    1710 // --------------------------------------------------------------------------
    1711 //
    17121683// Set the useage of the Blind Pixel device
    17131684//
    … …  
    17281699Bool_t MJCalibration::WriteEventloop(MEvtLoop &evtloop) const
    17291700{
    1730     if (fOutputPath.IsNull())
     1701    if (fPathOut.IsNull())
    17311702        return kTRUE;
    17321703
    … …  
    17531724Bool_t MJCalibration::WriteTasks(MTask *t1, MTask *t2) const
    17541725{
    1755     if (fOutputPath.IsNull())
     1726    if (fPathOut.IsNull())
    17561727        return kTRUE;
    17571728
    … …  
    17941765Bool_t MJCalibration::WriteResult()
    17951766{
    1796     if (fOutputPath.IsNull())
     1767    if (fPathOut.IsNull())
    17971768        return kTRUE;
    17981769

  • trunk/MagicSoft/Mars/mjobs/MJCalibration.h

    r4723 r4729  
    22#define MARS_MJCalibration
    33
     4#ifndef MARS_MJob
     5#include "MJob.h"
     6#endif
    47#ifndef MARS_MCalibrationChargeCam
    58#include "MCalibrationChargeCam.h"
    … …  
    2124#endif
    2225
    23 class TEnv;
     26class TH1D;
     27
    2428class MTask;
    2529class MRunIter;
    26 class MSequence;
    2730class MParList;
    2831class MPedestalCam;
    … …  
    3033class MExtractTime;
    3134class MEvtLoop;
    32 
    3335class MExtractBlindPixel;
    3436class MHCalibrationChargeBlindCam;
    3537class MHCamera;
    36 class TH1D;
    37 class MJCalibration : public MParContainer
     38
     39class MJCalibration : public MJob
    3840{
    3941private:
    … …  
    5759  static const Float_t  fgRefQEOuter;                  //! Reference value for the quantum eff. cascades - outer
    5860
    59   TString fOutputPath;                                 // Path to the output files
    60   TString fInputPath;                                  // Path to get the data files from
    61  
    62   TEnv           *fEnv;                                // Input setup-file
    6361  MRunIter       *fRuns;                               // Calibration files
    64   MSequence      *fSequence;                           // Sequence
    6562 
    6663  MExtractor     *fExtractor;                          // Signal extractor
    … …  
    9794  Bool_t fDataCheck;                                   // Flag if the data check is run on raw data
    9895  Bool_t fDebug;                                       // Flag if debug option is passed onto cal. classes
    99   Bool_t fOverwrite;                                   // Allow to overwite existing files
    10096 
    10197  void   DisplayResult        ( MParList &plist );
    … …  
    109105  Bool_t WriteEventloop(MEvtLoop &evtloop) const;
    110106  Bool_t WriteTasks(MTask *t1, MTask *t2) const;
    111   void  CheckEnv();
     107  Bool_t CheckEnv();
    112108 
    113109  // WORKAROUNDS!!!
    … …  
    117113 
    118114public:
    119 
    120115  MJCalibration(const char *name=NULL, const char *title=NULL);
    121   ~MJCalibration();
    122116 
    123117  const char* GetOutputFile() const;
    124   void SetEnv(const char *env);
    125118 
    126119  MCalibrationChargeCam  &GetCalibrationCam() { return fCalibrationCam; }
    … …  
    137130  void SetQECam(const MCalibrationQECam &qe)     { qe.Copy(fQECam);        }
    138131  void SetColor(const MCalibrationCam::PulserColor_t color) { fColor = color; }
    139  
    140   void SetInput(MRunIter *iter) { fRuns=iter; }
    141   void SetSequence(MSequence *seq) { fSequence=seq; }
    142   void SetOutputPath(const char *path=".");
    143   void SetInputPath(const char *path=".");
    144   void SetOverwrite(Bool_t b=kTRUE) { fOverwrite=b; }
    145132 
    146133  // Displays
    … …  
    161148  void SetUseBlindPixel(const Bool_t b=kTRUE);
    162149  void SetUsePINDiode(const Bool_t b=kTRUE);
    163  
     150
     151  // Precessing
    164152  Bool_t ReadCalibrationCam();
    165153  Bool_t ProcessFile(MPedestalCam &pedcam);
    166154  Bool_t Process(MPedestalCam &pedcam);
    167155
    168   MStatusDisplay *GetDisplay() { return fDisplay; }
    169  
    170156  ClassDef(MJCalibration, 0) // Tool to run a calibration per pulser colour and intensity
    171157};

  • trunk/MagicSoft/Mars/mjobs/MJPedestal.cc

    r4723 r4729  
    9090//
    9191MJPedestal::MJPedestal(const char *name, const char *title)
    92     : fEnv(0), fRuns(0), fSequence(0), fExtractor(NULL), fDisplayType(kNormalDisplay),
    93       fDataCheck(kFALSE), fUseData(kFALSE), fOverwrite(kFALSE), fMaxEvents(0)
     92    : fRuns(0), fExtractor(NULL), fDisplayType(kNormalDisplay),
     93      fDataCheck(kFALSE), fUseData(kFALSE)
    9494{
    9595    fName  = name  ? name  : "MJPedestal";
    … …  
    9797}
    9898
    99 MJPedestal::~MJPedestal()
    100 {
    101     if (fEnv)
    102         delete fEnv;
    103 }
    104 
    10599const char* MJPedestal::GetOutputFile() const
    106100{
    107     if (fSequence)
    108         return Form("%s/calped%06d.root", (const char*)fOutputPath, fSequence->GetSequence());
     101    if (fSequence.IsValid())
     102        return Form("%s/calped%06d.root", (const char*)fPathOut, fSequence.GetSequence());
    109103
    110104    if (!fRuns)
    111105        return "";
    112106
    113     return Form("%s/%s-F0.root", (const char*)fOutputPath, (const char*)fRuns->GetRunsAsFileName());
     107    return Form("%s/%s-F0.root", (const char*)fPathOut, (const char*)fRuns->GetRunsAsFileName());
    114108}
    115109
    … …  
    160154    TString title = fDisplay->GetTitle();
    161155    title += "--  Pedestal ";
    162     if (fSequence)
    163         title += fSequence->GetName();
     156    if (fSequence.IsValid())
     157        title += fSequence.GetName();
    164158    else
    165159        if (fRuns)  // FIXME: What to do if an environmentfile was used?
    … …  
    468462Bool_t MJPedestal::WriteResult()
    469463{
    470     if (fOutputPath.IsNull())
     464    if (fPathOut.IsNull())
    471465        return kTRUE;
    472466
    … …  
    503497}
    504498
    505 void MJPedestal::SetOutputPath(const char *path)
    506 {
    507     fOutputPath = path;
    508     if (fOutputPath.EndsWith("/"))
    509         fOutputPath = fOutputPath(0, fOutputPath.Length()-1);
    510 }
    511 
    512 // --------------------------------------------------------------------------
    513 //
    514 // Set the path from which the sequence files are read
    515 //
    516 void MJPedestal::SetInputPath(const char *path)
    517 {
    518     fInputPath = path;
    519     if (fInputPath.EndsWith("/"))
    520         fInputPath = fInputPath(0, fInputPath.Length()-1);
    521 }
    522 
    523 void MJPedestal::SetEnv(const char *env)
    524 {
    525     if (fEnv)
    526         delete fEnv;
    527     fEnv = new TEnv(env);
    528 }
    529 
    530499Bool_t MJPedestal::Process()
    531500{
    … …  
    536505}
    537506
    538 // --------------------------------------------------------------------------
    539 //
    540 // MJPedestsl allows to setup several option by a resource file:
    541 //   MJPedestal.OutputPath: path
    542 //   MJPedestal.MaxEvents: 1000
    543 //   MJPedestal.AllowOverwrite: yes, no
    544 //   MJPedestal.UseData: yes, no (use DatRuns from sequence instead of PedRuns)
    545 //
    546 // For more details see the class description and the corresponding Getters
    547 //
    548 void MJPedestal::CheckEnv()
    549 {
    550     if (!fEnv)
    551         return;
    552 
    553     TString e1 = fEnv->GetValue(Form("%s.OutputPath", fName.Data()), "");
    554     if (!e1.IsNull())
    555     {
    556         e1.ReplaceAll("\015", "");
    557         SetOutputPath(e1);
    558     }
    559 
    560     SetMaxEvents(fEnv->GetValue(Form("%s.MaxEvents", fName.Data()), fMaxEvents));
    561     SetOverwrite(fEnv->GetValue(Form("%s.AllowOverwrite", fName.Data()), fOverwrite));
    562 
    563     fUseData = fEnv->GetValue(Form("%s.UseData", fName.Data()), fUseData);
    564 }
    565 
    566507Bool_t MJPedestal::ProcessFile()
    567508{
    568     if (!fRuns && !fEnv && !fSequence)
    569     {
    570         *fLog << err << "Neither AddRuns nor SetSequence nor SetEnv was called... abort." << endl;
    571         return kFALSE;
    572     }
    573     if (!fSequence && fRuns && fRuns->GetNumRuns() != fRuns->GetNumEntries())
    574     {
    575         *fLog << err << "Number of files found doesn't match number of runs... abort." << endl;
    576         return kFALSE;
    577     }
     509    if (!fSequence.IsValid())
     510    {
     511        if (!fRuns)
     512        {
     513            *fLog << err << "Neither AddRuns nor SetSequence nor SetEnv was called... abort." << endl;
     514            return kFALSE;
     515        }
     516        if (fRuns && fRuns->GetNumRuns() != fRuns->GetNumEntries())
     517        {
     518            *fLog << err << "Number of files found doesn't match number of runs... abort." << endl;
     519            return kFALSE;
     520        }
     521    }
     522
     523    //if (!CheckEnv())
     524    //    return kFALSE;
     525
     526    CheckEnv();
     527
     528    // --------------------------------------------------------------------------------
    578529
    579530    *fLog << inf;
    580531    fLog->Separator(GetDescriptor());
    581532    *fLog << "Calculate MPedestalCam from Runs ";
    582     if (fSequence)
    583         *fLog << fSequence->GetName() << endl;
     533    if (fSequence.IsValid())
     534        *fLog << fSequence.GetName() << endl;
    584535    else
    585536        if (fRuns)
    586537            *fLog << fRuns->GetRunsAsString() << endl;
    587538        else
    588             *fLog << "in " << fEnv->GetName() << endl;
     539            *fLog << "in Resource File." << endl;
    589540    *fLog << endl;
    590541
    591     CheckEnv();
     542    // --------------------------------------------------------------------------------
    592543
    593544    MParList  plist;
    … …  
    600551
    601552    MDirIter iter;
    602     if (fSequence)
    603     {
    604         const Int_t n = fUseData ? fSequence->SetupDatRuns(iter, fInputPath) : fSequence->SetupPedRuns(iter, fInputPath);
    605         if (n==0)
     553    if (fSequence.IsValid())
     554    {
     555        const Int_t n0 = fUseData ? fSequence.SetupDatRuns(iter, fPathData) : fSequence.SetupPedRuns(iter, fPathData);
     556        const Int_t n1 = fUseData ? fSequence.GetNumDatRuns() : fSequence.GetNumPedRuns();
     557        if (n0==0)
    606558        {
    607559            *fLog << err << "ERROR - No input files of sequence found!" << endl;
    608560            return kFALSE;
    609561        }
     562        if (n0!=n1)
     563        {
     564            *fLog << err << "ERROR - Number of files found (" << n0 << ") doesn't match number of files in sequence (" << n1 << ")" << endl;
     565            return kFALSE;
     566        }
    610567    }
    611568
    612569    if (fDataCheck)
    613570    {
    614         if (fRuns || fSequence)
    615             rawread.AddFiles(fSequence ? iter : *fRuns);
     571        if (fRuns || fSequence.IsValid())
     572            rawread.AddFiles(fSequence.IsValid() ? iter : *fRuns);
    616573        tlist.AddToList(&rawread);
    617574    }
    … …  
    619576    {
    620577        read.DisableAutoScheme();
    621         if (fRuns || fSequence)
    622             read.AddFiles(fSequence ? iter : *fRuns);
     578        if (fRuns || fSequence.IsValid())
     579            read.AddFiles(fSequence.IsValid() ? iter : *fRuns);
    623580        tlist.AddToList(&read);
    624581    }
    625     // Enable logging to file
    626     //*fLog.SetOutputFile(lname, kTRUE);
    627582
    628583    // Setup Tasklist
    … …  
    662617    evtloop.SetDisplay(fDisplay);
    663618    evtloop.SetLogStream(fLog);
    664     if (fEnv)
    665         evtloop.ReadEnv(*fEnv);
     619    if (GetEnv())
     620        evtloop.ReadEnv(*GetEnv());
    666621
    667622    //    if (!WriteEventloop(evtloop))

  • trunk/MagicSoft/Mars/mjobs/MJPedestal.h

    r4723 r4729  
    22#define MARS_MJPedestal
    33
     4#ifndef MARS_MJob
     5#include "MJob.h"
     6#endif
    47#ifndef MARS_MPedestalCam
    58#include "MPedestalCam.h"
    … …  
    912#endif
    1013
    11 class TEnv;
    1214class TCanvas;
    1315class MParList;
    14 class MSequence;
    1516class MRunIter;
    1617class MHCamera;
    … …  
    1920class MEvtLoop;
    2021
    21 class MJPedestal : public MParContainer
     22class MJPedestal : public MJob
    2223{
    2324private:
    … …  
    3940    static const Float_t  fgRefPedRmsGalacticOuter;
    4041   
    41     TString fOutputPath;        // Directory where the F0-files get stored
    42     TString fInputPath;         // Directory from which to read the data files
    43 
    44     TEnv       *fEnv;           // Input setup-file
    4542    MRunIter   *fRuns;          // Used pedestal runs
    46     const MSequence  *fSequence;      // Sequence
    47 
    4843    MExtractor *fExtractor;     // Signal extractor, used to find the nr. of used FADC slices
    4944
    … …  
    5752    Bool_t fDataCheck;          // Flag if the data check is run on raw data
    5853    Bool_t fUseData;            // Use data-runs from sequence instead of pedestal runs
    59     Bool_t fOverwrite;          // Allow to overwite existing files
    60 
    61     Int_t fMaxEvents;           // Maximum number of events
    6254
    6355    Bool_t ReadPedestalCam();
    … …  
    7062    void   FixDataCheckHist(TH1D *hist) const;
    7163   
    72     void   CheckEnv();
    73 
    7464public:
    7565    MJPedestal(const char *name=NULL, const char *title=NULL);
    76     ~MJPedestal();
    7766
    7867    MPedestalCam &GetPedestalCam()            { return fPedestalCam; }
    … …  
    8877    void SetExtractor(MExtractor* ext) { fExtractor = ext; }
    8978    void SetInput(MRunIter *iter) { fRuns = iter; }
    90     void SetSequence(const MSequence *seq, Bool_t usedata=kFALSE) { fSequence = seq; }
    91     void SetOutputPath(const char *path=".");
    92     void SetInputPath(const char *path=".");
    93     void SetEnv(const char *env);
    94     void SetOverwrite(Bool_t b=kTRUE) { fOverwrite=b; }
    95     void SetMaxEvents(Int_t max) { fMaxEvents = max; }
    9679
    9780    void SetDataCheck(const Bool_t b=kTRUE) { fDataCheck = b; SetDataCheckDisplay(); }
    … …  
    10083    void SetNormalDisplay()    { fDisplayType = kNormalDisplay;    }
    10184
    102     MStatusDisplay *GetDisplay() { return fDisplay; }
    103 
    10485    ClassDef(MJPedestal, 0) // Tool to create a pedestal file (MPedestalCam)
    10586};

  • trunk/MagicSoft/Mars/mjobs/MSequence.cc

    r4722 r4729  
    8484    }
    8585
    86     Int_t num = 0;
    87 
    8886    for (int i=0; i<arr.GetSize(); i++)
    8987    {
    … …  
    9593
    9694        // Add Path/File to TIter
    97         num += iter.AddDirectory(d, n, 0);
    98     }
    99     return num;
     95        iter.AddDirectory(d, n, 0);
     96    }
     97    return iter.GetNumEntries();
    10098}
    10199

  • trunk/MagicSoft/Mars/mjobs/MSequence.h

    r4722 r4729  
    3939
    4040public:
     41    MSequence() : fSequence((UInt_t)-1), fLastRun((UInt_t)-1),
     42        fNumEvents((UInt_t)-1), fPeriod((UInt_t)-1) { }
    4143    MSequence(const char *fname);
     44    MSequence(const MSequence &s) : fSequence(s.fSequence), fStart(s.fStart),
     45        fLastRun(s.fLastRun), fNumEvents(s.fNumEvents), fPeriod(s.fPeriod),
     46        fNight(s.fNight), fProject(s.fProject), fSource(s.fSource),
     47        fTriggerTable(s.fTriggerTable), fHvSettings(s.fHvSettings),
     48        fRuns(s.fRuns), fCalRuns(s.fCalRuns), fPedRuns(s.fPedRuns),
     49        fDatRuns(s.fDatRuns) { }
    4250
    4351    void Print(Option_t *o="") const;
    … …  
    5058    Int_t SetupCalRuns(MDirIter &iter, const char *path=0) const;
    5159
     60    Int_t GetNumAllRuns() const { return fRuns.GetSize(); }
     61    Int_t GetNumDatRuns() const { return fDatRuns.GetSize(); }
     62    Int_t GetNumPedRuns() const { return fPedRuns.GetSize(); }
     63    Int_t GetNumCalRuns() const { return fCalRuns.GetSize(); }
     64
    5265    // Getter
    5366    UInt_t GetSequence() const { return fSequence; }

  • trunk/MagicSoft/Mars/mjobs/Makefile

    r4723 r4729  
    2525#manalysis: MChisqEval (MParameters)
    2626
    27 SRCFILES = MSequence.cc \
     27SRCFILES = MJob.cc \
     28           MSequence.cc \
    2829           MJPedestal.cc \
    2930           MJCalibration.cc \
Note: See TracChangeset for help on using the changeset viewer.