GSI Object Oriented Online Offline (Go4): Go4Fit/TGo4FitParsList.cxx Source File

Go to the documentation of this file.
00001 // $Id: TGo4FitParsList.cxx 933 2013-01-29 15:27:58Z linev $
00002 //-----------------------------------------------------------------------
00003 //       The GSI Online Offline Object Oriented (Go4) Project
00004 //         Experiment Data Processing at EE department, GSI
00005 //-----------------------------------------------------------------------
00006 // Copyright (C) 2000- GSI Helmholtzzentrum f�r Schwerionenforschung GmbH
00007 //                     Planckstr. 1, 64291 Darmstadt, Germany
00008 // Contact:            http://go4.gsi.de
00009 //-----------------------------------------------------------------------
00010 // This software can be used under the license agreements as stated
00011 // in Go4License.txt file which is part of the distribution.
00012 //-----------------------------------------------------------------------
00013 
00014 #include "TGo4FitParsList.h"
00015 
00016 #include "Riostream.h"
00017 #include "TClass.h"
00018 #include "TStyle.h"
00019 #include "TString.h"
00020 
00021 #include "TGo4FitParameter.h"
00022 
00023 TGo4FitParsList::TGo4FitParsList() :
00024    TGo4FitNamed(), fxPars(), fbCanRollbackPars(kFALSE)
00025 {
00026 
00027 }
00028 
00029 TGo4FitParsList::TGo4FitParsList(Bool_t IsParsOwned) :
00030       TGo4FitNamed(), fxPars(), fbCanRollbackPars(kFALSE)
00031 {
00032    fxPars.SetOwner(IsParsOwned);
00033 }
00034 
00035 TGo4FitParsList::TGo4FitParsList(const char* Name, const char* Title, Bool_t IsParsOwned) :
00036          TGo4FitNamed(Name,Title), fxPars(), fbCanRollbackPars(kFALSE)
00037 {
00038    fxPars.SetOwner(IsParsOwned);
00039 }
00040 
00041 TGo4FitParsList::~TGo4FitParsList()
00042 {
00043 }
00044 
00045 Int_t TGo4FitParsList::GetParIndex(const TGo4FitParameter* par)
00046 {
00047    for(Int_t i=0;i<NumPars();i++)
00048      if(GetPar(i)==par) return i;
00049    return -1;
00050 }
00051 
00052 Double_t TGo4FitParsList::GetParValue(const char* ParName)
00053 {
00054    TGo4FitParameter* par = Find(ParName);
00055    if(par) return par->GetValue();
00056       else return 0.;
00057 }
00058 
00059 Bool_t TGo4FitParsList::SetParValue(const char* ParName, Double_t iValue)
00060 {
00061    TGo4FitParameter* par = Find(ParName);
00062    if(par) { par->SetValue(iValue); return kTRUE; }
00063       else return kFALSE;
00064 }
00065 
00066 void TGo4FitParsList::GetParsValues(Double_t* pars)
00067 {
00068    for(Int_t i=0;i<NumPars();i++)
00069      pars[i] = Get(i)->GetValue();
00070 }
00071 
00072 void TGo4FitParsList::SetParsValues(Double_t* pars)
00073 {
00074    if (pars)
00075      for(Int_t i=0;i<NumPars();i++)
00076         Get(i)->SetValue(pars[i]);
00077 }
00078 
00079 Double_t TGo4FitParsList::GetParError(const char* ParName)
00080 {
00081    TGo4FitParameter* par = Find(ParName);
00082    if(par) return par->GetError();
00083       else return 0.;
00084 }
00085 
00086 Bool_t TGo4FitParsList::SetParError(const char* ParName, Double_t iError)
00087 {
00088    TGo4FitParameter* par = Find(ParName);
00089    if(par) { par->SetError(iError); return kTRUE; }
00090       else return kFALSE;
00091 }
00092 
00093 Bool_t TGo4FitParsList::SetParFixed(const char* ParName, Bool_t iFixed)
00094 {
00095    TGo4FitParameter* par = Find(ParName);
00096    if(par) { par->SetFixed(iFixed); return kTRUE; }
00097       else return kFALSE;
00098 }
00099 
00100 Bool_t TGo4FitParsList::GetParFixed(const char* ParName)
00101 {
00102    TGo4FitParameter* par = Find(ParName);
00103    if(par) return par->GetFixed();
00104       else return kFALSE;
00105 }
00106 
00107 Int_t TGo4FitParsList::NumFixedPars()
00108 {
00109    Int_t res = 0;
00110    for (Int_t n=0; n<NumPars(); n++)
00111       if (Get(n)->GetFixed()) res++;
00112    return res;
00113 }
00114 
00115 Int_t TGo4FitParsList::NumFreePars()
00116 {
00117    return NumPars()-NumFixedPars();
00118 }
00119 
00120 
00121 Bool_t TGo4FitParsList::SetParRange(const char* ParName, Double_t RangeMin, Double_t RangeMax)
00122 {
00123    TGo4FitParameter* par = Find(ParName);
00124    if(par) { par->SetRange(RangeMin,RangeMax); return kTRUE; }
00125       else return kFALSE;
00126 }
00127 
00128 Bool_t TGo4FitParsList::GetParRange(const char* ParName, Double_t& RangeMin, Double_t& RangeMax)
00129 {
00130    TGo4FitParameter* par = Find(ParName);
00131    if(par) return par->GetRange(RangeMin,RangeMax);
00132       else return kFALSE;
00133 }
00134 
00135 Bool_t TGo4FitParsList::SetParEpsilon(const char* ParName, Double_t Epsilon)
00136 {
00137    TGo4FitParameter* par = Find(ParName);
00138    if(par) { par->SetEpsilon(Epsilon); return kTRUE; }
00139       else return kFALSE;
00140 }
00141 
00142 Bool_t TGo4FitParsList::GetParEpsilon(const char* ParName, Double_t& Epsilon)
00143 {
00144    TGo4FitParameter* par = Find(ParName);
00145    if(par) return par->GetEpsilon(Epsilon);
00146       else return kFALSE;
00147 }
00148 
00149 void TGo4FitParsList::SetParName(Int_t n, const char* name)
00150 {
00151    if(Get(n)) Get(n)->SetName(name);
00152 }
00153 
00154 const char* TGo4FitParsList::GetParName(Int_t n)
00155 {
00156    if(Get(n)) return Get(n)->GetName();
00157          else return 0;
00158 }
00159 
00160 const char* TGo4FitParsList::GetParFullName(Int_t n)
00161 {
00162    if(Get(n)) return Get(n)->GetFullName();
00163          else return 0;
00164 }
00165 
00166 void TGo4FitParsList::SetParsNames(const char* name0, const char* name1, const char* name2, const char* name3, const char* name4,
00167                                    const char* name5, const char* name6, const char* name7, const char* name8, const char* name9) {
00168   SetParName(0,name0);
00169   SetParName(1,name1);
00170   SetParName(2,name2);
00171   SetParName(3,name3);
00172   SetParName(4,name4);
00173   SetParName(5,name5);
00174   SetParName(6,name6);
00175   SetParName(7,name7);
00176   SetParName(8,name8);
00177   SetParName(9,name9);
00178 }
00179 
00180 void TGo4FitParsList::SetParsValues(Double_t par0, Double_t par1, Double_t par2, Double_t par3, Double_t par4,
00181                                     Double_t par5, Double_t par6, Double_t par7, Double_t par8, Double_t par9) {
00182   if(Get(0)) Get(0)->SetValue(par0);
00183   if(Get(1)) Get(1)->SetValue(par1);
00184   if(Get(2)) Get(2)->SetValue(par2);
00185   if(Get(3)) Get(3)->SetValue(par3);
00186   if(Get(4)) Get(4)->SetValue(par4);
00187   if(Get(5)) Get(5)->SetValue(par5);
00188   if(Get(6)) Get(6)->SetValue(par6);
00189   if(Get(7)) Get(7)->SetValue(par7);
00190   if(Get(8)) Get(8)->SetValue(par8);
00191   if(Get(9)) Get(9)->SetValue(par9);
00192 }
00193 
00194 void TGo4FitParsList::MemorizePars()
00195 {
00196    for(Int_t i=0;i<NumPars();i++)
00197       Get(i)->MemorizeValue();
00198    fbCanRollbackPars = kTRUE;
00199 }
00200 
00201 void TGo4FitParsList::RememberPars()
00202 {
00203    for(Int_t i=0;i<NumPars();i++)
00204       Get(i)->RememberValue();
00205 }
00206 
00207 Bool_t TGo4FitParsList::IsAllParsFixed()
00208 {
00209    for(Int_t i=0;i<NumPars();i++)
00210       if (!Get(i)->GetFixed()) return kFALSE;
00211    return kTRUE;
00212 }
00213 
00214 void TGo4FitParsList::Print(Option_t* option) const
00215 {
00216    TGo4FitParsList* lst = (TGo4FitParsList*) this;
00217    if ((lst->NumPars()>0) && fxPars.IsOwner()) {
00218       std::cout << "  List of parameters:" << std::endl;
00219       for(Int_t n=0;n<lst->NumPars();n++)
00220          lst->GetPar(n)->Print(option);
00221    }
00222 }
00223 
00224 void TGo4FitParsList::PrintPars() const
00225 {
00226    std::cout << std::endl << "*** LIST OF PARAMETERS VALUE ***" << std::endl;
00227 
00228    TGo4FitParsList* l = (TGo4FitParsList*) this;
00229 
00230    int maxparlen = 14;
00231    for(Int_t np=0;np<l->NumPars();np++) {
00232       int len = strlen(l->GetParFullName(np));
00233       if (len>maxparlen) maxparlen = len;
00234    }
00235 
00236    TString tt = TString::Format("%s%ds %s%s %s%s","%",maxparlen,"%",gStyle->GetStatFormat(),"%",gStyle->GetStatFormat());
00237 
00238    for(Int_t n=0;n<l->NumPars();n++)
00239       std::cout << Form(tt.Data(), l->GetParFullName(n), l->GetPar(n)->GetValue(), l->GetPar(n)->GetError()) << std::endl;
00240 }
00241 
00242 void TGo4FitParsList::SetParsOwner(TGo4FitNamed* iOwner)
00243 {
00244    for(Int_t i=0;i<NumPars();i++)
00245       Get(i)->SetOwner(iOwner);
00246 }
00247 
00248 TGo4FitParameter* TGo4FitParsList::CreatePar(const char* ParName, const char* Title, Double_t iValue)
00249 {
00250   if (Find(ParName)==0) return AddPar(new TGo4FitParameter(ParName,Title,iValue));
00251                    else return Find(ParName);
00252 }
00253 
00254 TGo4FitParameter* TGo4FitParsList::Find(const char* ParName)
00255 {
00256    for(Int_t i=0;i<NumPars();i++)
00257       if (strcmp(Get(i)->GetName(),ParName)==0) return Get(i);
00258 
00259    for(Int_t i=0;i<NumPars();i++)
00260       if (strcmp(Get(i)->GetFullName(),ParName)==0) return Get(i);
00261 
00262    return 0;
00263 }
00264 
00265 TGo4FitParameter* TGo4FitParsList::Find(const char* OwnerFullName, const char* ParName)
00266 {
00267    for(Int_t i=0;i<NumPars();i++) {
00268       TGo4FitParameter* par = Get(i);
00269       if (par->GetOwner()==0) continue;
00270       if ( (strcmp(par->GetOwnerFullName(),OwnerFullName)==0) &&
00271            (strcmp(par->GetName(),ParName)==0) ) return par;
00272    }
00273    return 0;
00274 }
00275 
00276 TGo4FitParameter* TGo4FitParsList::Find(TGo4FitParameter* par)
00277 {
00278    for(Int_t i=0;i<NumPars();i++)
00279      if (Get(i)==par) return par;
00280    return 0;
00281 }
00282 
00283 Bool_t TGo4FitParsList::RemoveParByIndex(Int_t indx)
00284 {
00285   if((indx>=0) && (indx<NumPars())) return RemovePar(Get(indx));
00286                                else return kFALSE;
00287 }
00288 
00289 Bool_t TGo4FitParsList::RemovePar(const char* name)
00290 {
00291    return RemovePar(FindPar(name));
00292 }
00293 
00294 Bool_t TGo4FitParsList::RemovePar(TGo4FitParameter* par)
00295 {
00296    if (fxPars.FindObject(par)) {
00297       fbCanRollbackPars = kFALSE;
00298       fxPars.Remove(par);
00299       if (fxPars.IsOwner()) delete par;
00300       return kTRUE;
00301    } else return kFALSE;
00302 }
00303 
00304 void TGo4FitParsList::CollectParsTo(TGo4FitParsList & list)
00305 {
00306    for(Int_t i=0;i<NumPars();i++) {
00307       TGo4FitParameter* par = Get(i);
00308       if (list.GetParIndex(par)<0) list.AddPar(par);
00309    }
00310 }
00311 
00312 void TGo4FitParsList::ClearParsBlocking()
00313 {
00314    for(Int_t i=0;i<NumPars();i++)
00315      Get(i)->ClearBlocked();
00316 }
00317 
00318 void TGo4FitParsList::ClearPars()
00319 {
00320    fxPars.Clear();
00321    fbCanRollbackPars = kFALSE;
00322 }
00323 
00324 
00325 TGo4FitParameter* TGo4FitParsList::AddPar(TGo4FitParameter* par)
00326 {
00327   fxPars.AddLast(par);
00328   if ((par!=0) && fxPars.IsOwner()) par->SetOwner(this);
00329   fbCanRollbackPars = kFALSE;
00330   return par;
00331 }
00332 
00333 TGo4FitParameter* TGo4FitParsList::InsertPar(TGo4FitParameter* par, Int_t indx)
00334 {
00335    if (indx<0) fxPars.AddLast(par);
00336    else fxPars.AddAt(par,indx);
00337    if ((par!=0) && fxPars.IsOwner()) par->SetOwner(this);
00338    fbCanRollbackPars = kFALSE;
00339    return par;
00340 }
00341 
00342 void TGo4FitParsList::Streamer(TBuffer& b)
00343 {
00344    if (b.IsReading()) {
00345       TGo4FitParsList::Class()->ReadBuffer(b, this);
00346       Bool_t IsOwner;
00347       b >> IsOwner;
00348       if (IsOwner) {
00349          fxPars.Streamer(b);
00350          SetParsOwner(this);
00351       }
00352    } else {
00353       TGo4FitParsList::Class()->WriteBuffer(b, this);
00354       b << fxPars.IsOwner();
00355       if (fxPars.IsOwner())
00356          fxPars.Streamer(b);
00357    }
00358 }