Ignore:
Timestamp:
09/17/04 14:47:10 (20 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Mars/mhcalib
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationCam.cc

    r5093 r5098  
    337337// --------------------------------------------------------------------------
    338338//
    339 // Creates new MHCalibrationCam only for the averaged areas:
    340 // the rest has to be retrieved directly, e.g. via:
    341 //     MHCalibrationCam *cam = MParList::FindObject("MHCalibrationCam");
    342 //  -  cam->GetAverageSector(5).DrawClone();
    343 //  -  (*cam)[100].DrawClone()
    344 //
    345 TObject *MHCalibrationCam::Clone(const char *) const
    346 {
    347 
    348   //
    349   // FIXME, this might be done faster and more elegant, by direct copy.
    350   //
    351   MHCalibrationCam *cam = (MHCalibrationCam*)this->Clone();
    352 
    353   cam->fRunNumbers             = fRunNumbers;
    354 
    355   /*
    356   cam->fPulserFrequency        = fPulserFrequency;
    357   cam->fFlags                  = fFlags;
    358   cam->fNbins                  = fNbins;
    359   cam->fFirst                  = fFirst;
    360   cam->fLast                   = fLast;
    361   */
    362   if (!IsAverageing())
    363     return cam;
    364 
    365   //  const Int_t nhi   = fHiGainArray->GetEntries();
    366   //  const Int_t nlo   = fLoGainArray->GetEntries();
    367   const Int_t navhi = fAverageHiGainAreas->GetEntries();
    368   //  const Int_t nsehi = fAverageHiGainSectors->GetEntries();
    369  
    370   //  cam->fHiGainArray->Expand(nhi);
    371   //  cam->fLoGainArray->Expand(nlo);
    372   cam->fAverageHiGainAreas->Expand(navhi);
    373   //  cam->fAverageHiGainSectors->Expand(nsehi);
    374   //  cam->fAverageLoGainSectors->Expand(nselo);
    375 
    376   /*
    377   for (int i=0; i<nhi; i++)
    378     {
    379       delete (*cam->fHiGainArray)[i];
    380       (*cam->fHiGainArray)[i] = (*fHiGainArray)[i]->Clone();
    381     }
    382   for (int i=0; i<nlo; i++)
    383     {
    384       delete (*cam->fLoGainArray)[i];
    385       (*cam->fLoGainArray)[i] = (*fLoGainArray)[i]->Clone();
    386     }
    387   */
    388  
    389   for (int i=0; i<navhi; i++)
    390     (*cam->fAverageHiGainAreas)[i] = (*fAverageHiGainAreas)[i]->Clone();
    391 
    392   //  for (int i=0; i<nsehi; i++)
    393   //    (*cam->fAverageHiGainSectors)[i] = (*fAverageHiGainSectors)[i]->Clone();
    394 
    395   if (IsLoGain())
    396     {
    397 
    398       const Int_t navlo = fAverageLoGainAreas->GetEntries();
    399 
    400       cam->fAverageLoGainAreas->Expand(navlo);
    401       //      cam->fAverageLoGainSectors->Expand(nselo);
    402       //  const Int_t nselo = fAverageLoGainSectors->GetEntries();
    403      
    404       for (int i=0; i<navlo; i++)
    405         (*cam->fAverageLoGainAreas)[i] = (*fAverageLoGainAreas)[i]->Clone();
    406 
    407       //      for (int i=0; i<nselo; i++)
    408       //        (*cam->fAverageLoGainSectors)[i] = (*fAverageLoGainSectors)[i]->Clone();
    409     }
    410 
    411   cam->fAverageAreaNum         = fAverageAreaNum;
    412   cam->fAverageAreaSat         = fAverageAreaSat;
    413   cam->fAverageAreaSigma       = fAverageAreaSigma;     
    414   cam->fAverageAreaSigmaVar    = fAverageAreaSigmaVar;   
    415   cam->fAverageAreaRelSigma    = fAverageAreaRelSigma;
    416   cam->fAverageAreaRelSigmaVar = fAverageAreaRelSigmaVar;   
    417   cam->fAverageSectorNum       = fAverageSectorNum;     
    418 
    419   return cam;
    420 }
    421 
    422 // --------------------------------------------------------------------------
    423 //
    424339// Gets the pointers to:
    425340// - MGeomCam

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationCam.h

    r5037 r5098  
    154154  virtual void ResetHists();
    155155 
    156   // Clone
    157   TObject *Clone(const char *name="") const;
    158 
    159156  // Draw
    160157  void   Draw(const Option_t *opt);

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargeBlindCam.cc

    r5091 r5098  
    405405}
    406406
    407 
    408 // --------------------------------------------------------------------------
    409 //
    410 // This Clone-function has to be different from the MHCalibrationCam
    411 // Clone function since it does not store and display the averaged values
    412 // (in fAverageAreas), but the blind pixels stored in fHiGainArray.
    413 //
    414 // Creates new MHCalibrationChargeBlindCam and
    415 // Clones MHCalibrationChargeBlindPix's individually
    416 //
    417 TObject *MHCalibrationChargeBlindCam::Clone(const char *name) const
    418 {
    419 
    420   MHCalibrationChargeBlindCam *cam = new MHCalibrationChargeBlindCam();
    421 
    422   //
    423   // Copy the data members
    424   //
    425   cam->fRunNumbers             = fRunNumbers;
    426   cam->fPulserFrequency        = fPulserFrequency;
    427   cam->fFlags                  = fFlags;
    428   cam->fNbins                  = fNbins;
    429   cam->fFirst                  = fFirst;
    430   cam->fLast                   = fLast;
    431   cam->fFitFunc                = fFitFunc;
    432 
    433   const Int_t nhi = fHiGainArray->GetEntries();
    434  
    435   cam->fHiGainArray->Expand(nhi);
    436 
    437   for (int i=0; i<nhi; i++)
    438     (*cam->fHiGainArray)[i] = (*fHiGainArray)[i]->Clone();
    439 
    440   return cam;
    441 }
    442 
    443407// -----------------------------------------------------------------------------
    444408//

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargeBlindCam.h

    r5090 r5098  
    4747  MHCalibrationChargeBlindCam(const char *name=NULL, const char *title=NULL);
    4848
    49   // Clone
    50   TObject *Clone(const char *name="") const;
    51  
    5249  // Draw
    5350  void  Draw(Option_t *opt="");

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargeBlindPix.cc

    r5084 r5098  
    231231}
    232232
    233 #if 0
    234 // --------------------------------------------------------------------------
    235 //
    236 // ATTENTION: This nasty Clone function is necessary since the ROOT cloning
    237 //            lead to crashes on SOME machines (unfortunately not mine...).
    238 //            This function is a workaround in order to achieve the correct
    239 //            DrawClone() behaviour.
    240 //
    241 TObject *MHCalibrationChargeBlindPix::Clone(const char *name) const
    242 {
    243 
    244   MHCalibrationChargeBlindPix &pix =
    245     *new MHCalibrationChargeBlindPix(name ? name : fName.Data(),fTitle.Data());
    246 
    247   //
    248   // Copy MHGausEvents data members
    249   //
    250   pix.fBinsAfterStripping   = fBinsAfterStripping;
    251   pix.fCurrentSize          = fCurrentSize;
    252   pix.fFlags                = fFlags;
    253   pix.fPowerProbabilityBins = fPowerProbabilityBins;
    254 
    255   if (fHPowerProbability)
    256     pix.fHPowerProbability=(TH1I*)fHPowerProbability->Clone();
    257  
    258   if (fPowerSpectrum)
    259     pix.fPowerSpectrum = new TArrayF(*fPowerSpectrum);
    260 
    261   pix.fEvents = fEvents;
    262 
    263   if (fFGausFit)
    264     pix.fFGausFit=(TF1*)fFGausFit->Clone();
    265   if (fFExpFit)
    266     pix.fFExpFit=(TF1*)fFExpFit->Clone();
    267 
    268   pix.fFirst = fFirst;
    269 
    270   if (fGraphEvents)
    271     pix.fGraphEvents=(TGraph*)fGraphEvents->Clone();
    272   if (fGraphPowerSpectrum)
    273     pix.fGraphPowerSpectrum=(TGraph*)fGraphPowerSpectrum->Clone();
    274 
    275   pix.fHGausHist = fHGausHist;
    276 
    277   pix.fLast      = fLast;
    278   pix.fMean      = fMean;
    279   pix.fMeanErr   = fMeanErr;
    280   pix.fNbins     = fNbins;
    281   pix.fNDFLimit  = fNDFLimit;
    282   pix.fSigma     = fSigma;
    283   pix.fSigmaErr  = fSigmaErr;
    284   pix.fProb      = fProb;
    285   pix.fProbLimit = fProbLimit;
    286 
    287   //
    288   // Copy MHCalibrationPix data members
    289   //
    290   pix.fEventFrequency       = fEventFrequency;
    291   pix.fBlackoutLimit        = fBlackoutLimit;
    292   pix.fSaturated            = fSaturated;     
    293   pix.fPickupLimit          = fPickupLimit;   
    294   pix.fPixId                = fPixId;       
    295 
    296   //
    297   // Copy MHCalibrationChargeBlindPix data members
    298   //
    299   pix.fSinglePheCut         =  fSinglePheCut;
    300   pix.fNumSinglePheLimit    =  fNumSinglePheLimit;   
    301 
    302   fASinglePheFADCSlices.Copy(pix.fASinglePheFADCSlices);
    303   fAPedestalFADCSlices.Copy( pix.fAPedestalFADCSlices); 
    304  
    305   pix.fSinglePheFit   = (TF1*)fSinglePheFit->Clone();
    306 
    307   pix.fNumSinglePhes  = fNumSinglePhes; 
    308   pix.fNumPedestals   = fNumPedestals;   
    309   pix.fLambda         = fLambda;           
    310   pix.fLambdaCheck    = fLambdaCheck;     
    311   pix.fMu0            = fMu0;             
    312   pix.fMu1            = fMu1;             
    313   pix.fSigma0         = fSigma0;           
    314   pix.fSigma1         = fSigma1;           
    315   pix.fLambdaErr      = fLambdaErr;         
    316   pix.fLambdaCheckErr = fLambdaCheckErr;
    317   pix.fMu0Err         = fMu0Err;           
    318   pix.fMu1Err         = fMu1Err;           
    319   pix.fSigma0Err      = fSigma0Err;       
    320   pix.fSigma1Err      = fSigma1Err;       
    321   pix.fChisquare      = fChisquare;       
    322   pix.fNDF            = fNDF;             
    323   pix.fProb           = fProb;             
    324 
    325   return &pix;
    326 }
    327 #endif
    328 
    329233/*
    330234// --------------------------------------------------------------------------

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargeBlindPix.h

    r5050 r5098  
    8888  void Reset() {}
    8989 
    90   //  TObject *Clone(const char *) const;
    91 
    9290  // Getters
    9391  const Double_t GetLambda        ()  const { return fLambda;         }

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargeCam.cc

    r5083 r5098  
    12721272}
    12731273
    1274 
    1275 // --------------------------------------------------------------------------
    1276 //
    1277 // Our own clone function is necessary since root 3.01/06 or Mars 0.4
    1278 // I don't know the reason.
    1279 //
    1280 // Creates new MHCalibrationChargeCam only for the Averaged Areas,
    1281 // the rest has to be retrieved directly, e.g. via:
    1282 //  MHCalibrationChargeCam *cam = MParList::FindObject("MHCalibrationChargeCam");
    1283 //  -  cam->GetAverageSector(5).DrawClone();
    1284 //  -  (*cam)[100].DrawClone()
    1285 //
    1286 #if 0
    1287 TObject *MHCalibrationChargeCam::Clone(const char *name) const
    1288 {
    1289 
    1290   const Int_t navhi = fAverageHiGainAreas->GetEntries();
    1291   //  const Int_t nsehi = fAverageHiGainSectors->GetEntries();
    1292   //  const Int_t nselo = fAverageLoGainSectors->GetEntries();
    1293  
    1294   //
    1295   // FIXME, this might be done faster and more elegant, by direct copy.
    1296   //
    1297   MHCalibrationChargeCam *cam = new MHCalibrationChargeCam();
    1298 
    1299   cam->fColor                  = fColor;
    1300   cam->fPulserFrequency        = fPulserFrequency;
    1301   cam->fFlags                  = fFlags;
    1302   cam->fRunNumbers             = fRunNumbers;
    1303   cam->fNbins                  = fNbins;
    1304   cam->fFirst                  = fFirst;
    1305   cam->fLast                   = fLast;
    1306 
    1307   if (!IsAverageing())
    1308     return cam;
    1309 
    1310   cam->fAverageHiGainAreas->Expand(navhi);
    1311 
    1312   for (int i=0; i<navhi; i++)
    1313     (*cam->fAverageHiGainAreas)  [i] = (*fAverageHiGainAreas)  [i]->Clone();
    1314   //  cam->fAverageHiGainSectors->Expand(nsehi);
    1315   //  for (int i=0; i<nsehi; i++)
    1316   //    (*cam->fAverageHiGainSectors)[i] = (*fAverageHiGainSectors)[i]->Clone();
    1317 
    1318   if (IsLoGain())
    1319     {
    1320       const Int_t navlo = fAverageLoGainAreas->GetEntries();
    1321       cam->fAverageLoGainAreas->Expand(navlo);
    1322      
    1323       for (int i=0; i<navlo; i++)
    1324         (*cam->fAverageLoGainAreas)  [i] = (*fAverageLoGainAreas)  [i]->Clone();
    1325       //      cam->fAverageLoGainSectors->Expand(nselo);
    1326       //      for (int i=0; i<nselo; i++)
    1327       //        (*cam->fAverageLoGainSectors)[i] = (*fAverageLoGainSectors)[i]->Clone();
    1328     }
    1329  
    1330   cam->fAverageAreaNum         = fAverageAreaNum;
    1331   cam->fAverageAreaSat         = fAverageAreaSat;
    1332   cam->fAverageAreaSigma       = fAverageAreaSigma;     
    1333   cam->fAverageAreaSigmaVar    = fAverageAreaSigmaVar;   
    1334   cam->fAverageAreaRelSigma    = fAverageAreaRelSigma;
    1335   cam->fAverageAreaRelSigmaVar = fAverageAreaRelSigmaVar;   
    1336   cam->fAverageSectorNum       = fAverageSectorNum;     
    1337 
    1338   return cam;
    1339 
    1340 }
    1341 #endif
    1342 
    13431274// -----------------------------------------------------------------------------
    13441275//

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargeCam.h

    r5083 r5098  
    105105  ~MHCalibrationChargeCam() {}
    106106 
    107   //TObject *Clone(const char *name="") const;
    108 
    109107  void SetLoGainNbins       ( const Int_t  i )       { fLoGainNbins   = i; }
    110108  void SetLoGainFirst       ( const Axis_t f )       { fLoGainFirst   = f; }

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargePINDiode.cc

    r5083 r5098  
    197197// --------------------------------------------------------------------------
    198198//
    199 // Use the MHCalibrationChargePix::Clone function and clone additionally
    200 // the rest of the data members.
    201 //
    202 #if 0
    203 TObject *MHCalibrationChargePINDiode::Clone(const char *name) const
    204 {
    205 
    206   MHCalibrationChargePINDiode &pix = (MHCalibrationChargePINDiode&)*MHCalibrationChargePix::Clone(name);
    207   //
    208   // Copy data members
    209   //
    210   pix.fHRmsCharge = fHRmsCharge;
    211 
    212   pix.fRmsChargeFirst    = fRmsChargeFirst;       
    213   pix.fRmsChargeLast     = fRmsChargeLast;       
    214   pix.fRmsChargeNbins    = fRmsChargeNbins;       
    215   pix.fRmsChargeMean     = fRmsChargeMean;       
    216   pix.fRmsChargeMeanErr  = fRmsChargeMeanErr;     
    217   pix.fRmsChargeSigma    = fRmsChargeSigma;       
    218   pix.fRmsChargeSigmaErr = fRmsChargeSigmaErr;   
    219   pix.fTimeLowerLimit    = fTimeLowerLimit;       
    220   pix.fTimeUpperLimit    = fTimeUpperLimit;       
    221 
    222   return &pix;
    223 }
    224 #endif
    225 
    226 // --------------------------------------------------------------------------
    227 //
    228199// Gets or creates the pointers to:
    229200// - MExtractedSignalPINDiode

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargePINDiode.h

    r5083 r5098  
    6666  ~MHCalibrationChargePINDiode(){}
    6767
    68 //  TObject *Clone(const char* name="") const;
    69  
    7068  Bool_t SetupFill(const MParList *pList);
    7169  Bool_t ReInit   (      MParList *pList);

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargePix.cc

    r4962 r5098  
    8080 
    8181}
    82 
    83 #if 0
    84 // --------------------------------------------------------------------------
    85 //
    86 // ATTENTION: This nasty Clone function is necessary since the ROOT cloning
    87 //            lead to crashes on SOME machines (unfortunately not mine...).
    88 //            This function is a workaround in order to achieve the correct
    89 //            DrawClone() behaviour.
    90 //
    91 TObject *MHCalibrationChargePix::Clone(const char *name) const
    92 {
    93 
    94   MHCalibrationChargePix &pix =
    95     *new MHCalibrationChargePix(name ? name : fName.Data(),fTitle.Data());
    96   //
    97   // Copy MHGausEvents data members
    98   //
    99   pix.fBinsAfterStripping   = fBinsAfterStripping;
    100   pix.fCurrentSize          = fCurrentSize;
    101   pix.fFlags                = fFlags;
    102   pix.fPowerProbabilityBins = fPowerProbabilityBins;
    103 
    104   if (fHPowerProbability)
    105     pix.fHPowerProbability=(TH1I*)fHPowerProbability->Clone();
    106  
    107   if (fPowerSpectrum)
    108     pix.fPowerSpectrum = new TArrayF(*fPowerSpectrum);
    109 
    110   pix.fEvents = fEvents;
    111 
    112   if (fFGausFit)
    113     pix.fFGausFit=(TF1*)fFGausFit->Clone();
    114   if (fFExpFit)
    115     pix.fFExpFit=(TF1*)fFExpFit->Clone();
    116 
    117   pix.fFirst = fFirst;
    118 
    119   if (fGraphEvents)
    120     pix.fGraphEvents=(TGraph*)fGraphEvents->Clone();
    121   if (fGraphPowerSpectrum)
    122     pix.fGraphPowerSpectrum=(TGraph*)fGraphPowerSpectrum->Clone();
    123 
    124   pix.fHGausHist = fHGausHist;
    125 
    126   pix.fLast      = fLast;
    127   pix.fMean      = fMean;
    128   pix.fMeanErr   = fMeanErr;
    129   pix.fNbins     = fNbins;
    130   pix.fNDFLimit  = fNDFLimit;
    131   pix.fSigma     = fSigma;
    132   pix.fSigmaErr  = fSigmaErr;
    133   pix.fProb      = fProb;
    134   pix.fProbLimit = fProbLimit;
    135 
    136   //
    137   // Copy MHCalibrationPix data members
    138   //
    139   pix.fEventFrequency       = fEventFrequency;
    140   pix.fBlackoutLimit        = fBlackoutLimit;
    141   pix.fSaturated            = fSaturated;     
    142   pix.fPickupLimit          = fPickupLimit;   
    143   pix.fPixId                = fPixId;       
    144 
    145   //
    146   // Copy MHCalibrationChargePix data members
    147   //
    148   pix.fHAbsTime = fHAbsTime;
    149 
    150   return &pix;
    151 }
    152 #endif
    15382
    15483// --------------------------------------------------------------------------

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationChargePix.h

    r4962 r5098  
    2121  MHCalibrationChargePix(const char *name=NULL, const char *title=NULL);
    2222  ~MHCalibrationChargePix() {}
    23 
    24   //  TObject *Clone(const char* name="") const;
    2523
    2624  void Reset(); 

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationPix.cc

    r5004 r5098  
    9292}
    9393
    94 
    95 #if 0
    96 // --------------------------------------------------------------------------
    97 //
    98 // ATTENTION: This nasty Clone function is necessary since the ROOT cloning
    99 //            lead to crashes on SOME machines (unfortunately not mine...).
    100 //            This function is a workaround in order to achieve the correct
    101 //            DrawClone() behaviour.
    102 //
    103 TObject *MHCalibrationPix::Clone(const char *name) const
    104 {
    105 
    106   MHCalibrationPix &pix = *new MHCalibrationPix(name ? name : fName.Data(),fTitle.Data());
    107  
    108   //
    109   // Copy MHGausEvents data members
    110   //
    111   pix.fBinsAfterStripping   = fBinsAfterStripping;
    112   pix.fCurrentSize          = fCurrentSize;
    113   pix.fFlags                = fFlags;
    114   pix.fPowerProbabilityBins = fPowerProbabilityBins;
    115 
    116   if (fHPowerProbability)
    117     pix.fHPowerProbability=(TH1I*)fHPowerProbability->Clone();
    118  
    119   if (fPowerSpectrum)
    120     pix.fPowerSpectrum = new TArrayF(*fPowerSpectrum);
    121 
    122   pix.fEvents = fEvents;
    123 
    124   if (fFGausFit)
    125     pix.fFGausFit=(TF1*)fFGausFit->Clone();
    126   if (fFExpFit)
    127     pix.fFExpFit=(TF1*)fFExpFit->Clone();
    128 
    129   pix.fFirst = fFirst;
    130 
    131   if (fGraphEvents)
    132     pix.fGraphEvents=(TGraph*)fGraphEvents->Clone();
    133   if (fGraphPowerSpectrum)
    134     pix.fGraphPowerSpectrum=(TGraph*)fGraphPowerSpectrum->Clone();
    135 
    136   pix.fHGausHist = fHGausHist;
    137 
    138   pix.fLast      = fLast;
    139   pix.fMean      = fMean;
    140   pix.fMeanErr   = fMeanErr;
    141   pix.fNbins     = fNbins;
    142   pix.fNDFLimit  = fNDFLimit;
    143   pix.fSigma     = fSigma;
    144   pix.fSigmaErr  = fSigmaErr;
    145   pix.fProb      = fProb;
    146   pix.fProbLimit = fProbLimit;
    147 
    148   //
    149   // Copy data members
    150   //
    151   pix.fBlackoutLimit        = fBlackoutLimit;
    152   pix.fSaturated            = fSaturated;     
    153   pix.fPickupLimit          = fPickupLimit;   
    154   pix.fPixId                = fPixId;       
    155 
    156   return &pix;
    157 }
    158 #endif
    159 
    16094// -----------------------------------------------------------------------------
    16195//

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationPix.h

    r4994 r5098  
    2727  void  Clear(Option_t *o="");
    2828
    29   //  TObject *Clone(const char* name="") const;
    30  
    3129  // Getters
    3230  const Double_t GetBlackout       () const; 

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationRelTimeCam.cc

    r5083 r5098  
    170170// --------------------------------------------------------------------------
    171171//
    172 // Our own clone function is necessary since root 3.01/06 or Mars 0.4
    173 // I don't know the reason.
    174 //
    175 // Creates new MHCalibrationRelTimeCam
    176 //
    177 #if 0
    178 TObject *MHCalibrationRelTimeCam::Clone(const char *name) const
    179 {
    180 
    181   const Int_t navhi = fAverageHiGainAreas->GetEntries();
    182   const Int_t navlo = fAverageLoGainAreas->GetEntries();
    183   const Int_t nsehi = fAverageHiGainSectors->GetEntries();
    184   const Int_t nselo = fAverageLoGainSectors->GetEntries();
    185  
    186   //
    187   // FIXME, this might be done faster and more elegant, by direct copy.
    188   //
    189   MHCalibrationRelTimeCam *cam = new MHCalibrationRelTimeCam();
    190 
    191   cam->fAverageHiGainAreas->Expand(navhi);
    192   cam->fAverageHiGainSectors->Expand(nsehi);
    193 
    194   for (int i=0; i<navhi; i++)
    195     (*cam->fAverageHiGainAreas)  [i] = (*fAverageHiGainAreas)  [i]->Clone();
    196   for (int i=0; i<nsehi; i++)
    197     (*cam->fAverageHiGainSectors)[i] = (*fAverageHiGainSectors)[i]->Clone();
    198 
    199   if (IsLoGain())
    200     {
    201       cam->fAverageLoGainAreas->Expand(navlo);
    202       cam->fAverageLoGainSectors->Expand(nselo);
    203      
    204       for (int i=0; i<navlo; i++)
    205         (*cam->fAverageLoGainAreas)  [i] = (*fAverageLoGainAreas)  [i]->Clone();
    206       for (int i=0; i<nselo; i++)
    207         (*cam->fAverageLoGainSectors)[i] = (*fAverageLoGainSectors)[i]->Clone();
    208     }
    209 
    210   cam->fAverageAreaNum         = fAverageAreaNum;
    211   cam->fAverageAreaSat         = fAverageAreaSat;
    212   cam->fAverageAreaSigma       = fAverageAreaSigma;     
    213   cam->fAverageAreaSigmaVar    = fAverageAreaSigmaVar;   
    214   cam->fAverageAreaRelSigma    = fAverageAreaRelSigma;
    215   cam->fAverageAreaRelSigmaVar = fAverageAreaRelSigmaVar;   
    216   cam->fAverageSectorNum       = fAverageSectorNum;     
    217   cam->fRunNumbers             = fRunNumbers;
    218 
    219   cam->fColor                  = fColor;
    220   cam->fPulserFrequency        = fPulserFrequency;
    221   cam->fFlags                  = fFlags;
    222 
    223   return cam;
    224 
    225 }
    226 #endif
    227 
    228 // --------------------------------------------------------------------------
    229 //
    230172// Gets or creates the pointers to:
    231173// - MCalibrationRelTimeCam

  • trunk/MagicSoft/Mars/mhcalib/MHCalibrationRelTimeCam.h

    r5083 r5098  
    5555  ~MHCalibrationRelTimeCam() {}
    5656
    57   //TObject *Clone(const char *name="") const;
    58 
    5957  UInt_t GetReferencePixel() const { return fReferencePixel; }
    6058

  • trunk/MagicSoft/Mars/mhcalib/MHGausEvents.cc

    r5084 r5098  
    265265}
    266266
    267 // --------------------------------------------------------------------------
    268 //
    269 // Use the MH::Clone function and clone additionally the rest of the
    270 // data members.
    271 //
    272 #if 0
    273 TObject *MHGausEvents::Clone(const char *name) const
    274 {
    275 
    276   MHGausEvents &pix = (MHGausEvents&)*MH::Clone(name);
    277 
    278   /*
    279   //
    280   // Copy data members
    281   //
    282   pix.fBinsAfterStripping   = fBinsAfterStripping;
    283   pix.fCurrentSize          = fCurrentSize;
    284   pix.fFlags                = fFlags;
    285   pix.fPowerProbabilityBins = fPowerProbabilityBins;
    286 
    287   if (fHPowerProbability)
    288     pix.fHPowerProbability=(TH1I*)fHPowerProbability->Clone();
    289  
    290   if (fPowerSpectrum)
    291     pix.fPowerSpectrum = new TArrayF(*fPowerSpectrum);
    292 
    293   if (fFGausFit)
    294     pix.fFGausFit=(TF1*)fFGausFit->Clone();
    295   if (fFExpFit)
    296     pix.fFExpFit=(TF1*)fFExpFit->Clone();
    297 
    298   pix.fFirst = fFirst;
    299 
    300   if (fGraphEvents)
    301     pix.fGraphEvents=(TGraph*)fGraphEvents->Clone();
    302   if (fGraphPowerSpectrum)
    303     pix.fGraphPowerSpectrum=(TGraph*)fGraphPowerSpectrum->Clone();
    304 
    305   pix.fHGausHist = fHGausHist;
    306 
    307   pix.fEventFrequency       = fEventFrequency;
    308   pix.fLast      = fLast;
    309   pix.fMean      = fMean;
    310   pix.fMeanErr   = fMeanErr;
    311   pix.fNbins     = fNbins;
    312   pix.fNDFLimit  = fNDFLimit;
    313   pix.fSigma     = fSigma;
    314   pix.fSigmaErr  = fSigmaErr;
    315   pix.fProb      = fProb;
    316   pix.fProbLimit = fProbLimit;
    317   */
    318   return &pix;
    319 }
    320 #endif
    321 
    322267// -----------------------------------------------------------------------------
    323268//

  • trunk/MagicSoft/Mars/mhcalib/MHGausEvents.h

    r5083 r5098  
    7676  ~MHGausEvents();
    7777
    78   //TObject *Clone(const char* name="") const;
    79  
    8078  void Clear(Option_t *o="");
    8179  void Reset(); 
Note: See TracChangeset for help on using the changeset viewer.