DmxShowerPlane.cxx

Go to the documentation of this file.

//$Id: DmxShowerPlane.cxx,v 1.77 2007/11/11 07:36:22 rhatcher Exp $
//
//DmxShowerPlane.cxx
//
//DmxShowerPlane owns a container of DmxHypothesis objects.  It finds
//the best hypothesis and second best hypothesis based on the 
//DmxStatistic goodness of fit.
//
//Author:  B. Rebel 6/2000

#include "DeMux/DmxShowerPlane.h"
#include "DeMux/DmxHypothesis.h"
#include "MessageService/MsgService.h"
#include "Navigation/NavKey.h"
#include "Navigation/NavSet.h"
#include "MINF_Classes/MINFast.h"
#include "Conventions/PlaneView.h"
#include "UgliGeometry/UgliStripHandle.h"
#include "UgliGeometry/UgliScintPlnHandle.h"
#include "Plex/PlexStripEndId.h"
#include "Algorithm/AlgConfig.h"
#include "TMath.h"

XXXITRIMP(TObject)

//a NavKey to select only valid DmxHypothesis objects
static NavKey KeyValidHypo( const DmxHypothesis *hypo){
  //return hypo->IsValid() == Bool_t::kTrue;
  return (Int_t)hypo->IsValid() == 1;
}

//a NavKey to sort DmxHypothesis objects
static NavKey KeyStat( const DmxHypothesis *hypo){
  return hypo->GetStat();
}

ClassImp(DmxShowerPlane)

//______________________________________________________________________
CVSID("$Id: DmxShowerPlane.cxx,v 1.77 2007/11/11 07:36:22 rhatcher Exp $");

//----------------------------------------------------------------------
DmxShowerPlane::DmxShowerPlane() :
  fBestHypo(0),
  fHypothesisArray(0),
  fSecondBestHypo(0),
  fSetHypo(0),
  fThirdBestHypo(0),
  fUgh(0)
{
}

//----------------------------------------------------------------------
//this constructor uses the TObjectItr and a NavKey selection funciton to
//loop over only the valid hypotheses
DmxShowerPlane::DmxShowerPlane(AlgConfig &acd, CandDeMuxDigitHandleItr &cdhitr, 
                                                           Int_t planeNumber) :
  fBestCoG(0.),
  fBestHypo(0),
  fCoG(0.),
  fCompare(0),
  fHypothesisArray(new TObjArray(acd.GetInt("NumberOfHypotheses"), 0)),
  fIsValid(false), 
  fIsStray(false), 
  fIsGolden(false),
  fNumberOfHypotheses(acd.GetInt("NumberOfHypotheses")), 
  fNumberOfStrips(0),
  fPlaneCharge(0.),
  fPlaneNumber(planeNumber),
  fPlaneType(DmxPlaneTypes::kShower),
  fPlaneView(PlaneView::kUnknown),
  fSecondBestCoG(0.),
  fSecondBestHypo(0),
  fSetHypo(0),
  fThirdBestCoG(0.),
  fThirdBestHypo(0),
  fStripsSet(0),
  fUgh(0)
{
          //use the AlgConfig object to find the number of hypotheses needed and build
          //the TObjArray to hold them

          Int_t hypothesisSize = acd.GetInt("HypothesisSize");

          //get the ugli geometry handle from a cand digit
          fUgh = new UgliGeomHandle(*cdhitr.Ptr()->GetVldContext());

          Int_t lowerStrip = 0;
          Int_t upperStrip = 0;
          for(Int_t i = 0; i < fNumberOfHypotheses; i++){
                  lowerStrip = i;
                  upperStrip = i + (hypothesisSize - 1);
                  fHypothesisArray->AddAt(new DmxHypothesis(acd, cdhitr, lowerStrip, upperStrip), lowerStrip);
          }

          //set the comparison flag using the AlgConfigDeMux file.  1  = compare for largest value
          //0 = compare for smallest value

          //create a DmxHypothesisItr over the hypotheses
          DmxHypothesisItr hypoItr(fHypothesisArray);
  
          fCompare = hypoItr.Ptr()->GetCompareFlag();

          //create a KeyFunc to sort hypotheses by lower bound
          DmxHypothesisKeyFunc *hypStatKF = hypoItr.CreateKeyFunc();
      
          //program the KeyFunc with the sort function
          hypStatKF->SetFun(KeyStat);

          //get the NavSet from the iterator and pass the KeyFunc to it
          hypoItr.GetSet()->AdoptSortKeyFunc(hypStatKF);
  
          //clear the KF pointer because we no longer own the KeyFunc

          hypStatKF = 0;
    
          //program a new KF to select the valid hypotheses
          DmxHypothesisKeyFunc *validKF = hypoItr.CreateKeyFunc();
   
          //program the KF
          validKF->SetFun(KeyValidHypo);
 
          //adopt it as a selection function
          hypoItr.GetSet()->AdoptSelectKeyFunc(validKF);
          validKF = 0;
  
          //set the iterator to the best statistic valid hypo
          hypoItr.ResetLast();
          fBestHypo = dynamic_cast<DmxHypothesis *>(hypoItr.Ptr());
          fSecondBestHypo = dynamic_cast<DmxHypothesis *>(hypoItr.Ptr());
          fThirdBestHypo = dynamic_cast<DmxHypothesis *>(hypoItr.Ptr());
 
          //loop over all valid hypotheses

          DmxHypothesis *hypo = 0;

          //MSG("Dmx", Msg::kDebug) << "Start Comparison for best Hypothesis" << endl;
          hypoItr.ResetFirst();

          if( hypoItr.SizeSelect() > 1 ){

                  fIsValid = true;

                  for(Int_t i = 1; i < 4; i++){

                          //loop over the valid hypotheses and set the 3 best
                          while( (hypo = hypoItr()) ){
      
                                  //get the hypotheses from the TObjArray of Hypothesis Objects
                                  //they all should be valid because we are using the selection key on 
                                  //IsValid()
        
                                  //figure out the most strips that can be used in this plane
                                  if(hypo->GetNumberOfStripsUsed()>fNumberOfStrips) 
                                          fNumberOfStrips = hypo->GetNumberOfStripsUsed();
                                                        
                                  if( i == 1 && CompareHypotheses(hypo, fBestHypo) == DmxCompareTypes::kBetter ){
                                          fBestHypo = hypo;
                                  }
                                  else if( i == 2 && CompareHypotheses(hypo, fBestHypo) == DmxCompareTypes::kWorse 
                                                   && CompareHypotheses(hypo, fSecondBestHypo) == DmxCompareTypes::kBetter){
                                          fSecondBestHypo = hypo;
                                  }
                                  else if( i == 3 && CompareHypotheses(hypo, fSecondBestHypo) == DmxCompareTypes::kWorse 
                                                   && CompareHypotheses(hypo, fThirdBestHypo) == DmxCompareTypes::kBetter){
                                          fThirdBestHypo = hypo;
                                  }
                
                          }//end while iterator is valid
                          hypoItr.ResetFirst();
                  }//end loops to find best 3 hyps
          }//end if more than one valid hypothesis
          else if(hypoItr.SizeSelect() == 1){
    
                  //only 1 valid hypothesis, set the three best to it
                  fBestHypo = hypoItr.Ptr();
                  fSecondBestHypo = hypoItr.Ptr();
                  fThirdBestHypo = hypoItr.Ptr();

                  //check to see if this is a golden plane - since all of the best hypotheses are 
                  //the same, the best just has to have over 90% of its signal mated
                  if(fBestHypo->GetMatedSignalRatio()>=0.9){
                          fIsGolden = true;
                          SetStrips("best");
                  }
  
          } //end if only one valid hypothesis in the plane
 
          if(hypoItr.SizeSelect() == 2){
                  //only 2 valid hypotheses, set the third best to be the same as the second best
                  fThirdBestHypo = fSecondBestHypo;
  
                  //check to see if this is a golden plane
                  //there are two ways: 
                  //1) the best hypothesis has more than 90% of signal nated and the second best
                  //best has more than 10% less than the best. 
                  //2) the best hypothesis has more than 90% of signal mated and second best hypothesis 
                  //has less than 10% less than the best, but their cogs are less than 3 strips
                  //apart.
                  //Otherwise, it is not a golden plane - you dont know which one is correct.  
                  //because the third best is the second best, dont worry about it.

                  if(fBestHypo->GetMatedSignalRatio()>=0.9 
                         && fSecondBestHypo->GetMatedSignalRatio()<0.8){
                          fIsGolden = true;
                          SetStrips("best");
                  }
                  else if(fBestHypo->GetMatedSignalRatio()>=0.9 
                                  && TMath::Abs(fBestHypo->GetCoG()-fSecondBestHypo->GetCoG())<3.){
                          fIsGolden = true;
                          SetStrips("best");
                  }
        }//end if only 2 valid hypotheses
        else if(hypoItr.SizeSelect() >= 3){

                //check to see if this is a golden plane
                //there are two ways: 
                //1) the best hypothesis has more than 90% of signal nated and the second best
                //best and third best both have more than 10% less than the best. 
                //2) the best hypothesis has more than 90% of signal mated and second and third best hypotheses 
                //have less than 10% less than the best, but their cogs are less than 3 strips
                //apart from the best.
                //Otherwise, it is not a golden plane - you dont know which one is correct.  
                //because the third best is the second best, dont worry about it.

                if(fBestHypo->GetMatedSignalRatio()>=0.9 
                        && fSecondBestHypo->GetMatedSignalRatio()<0.8
                        && fThirdBestHypo->GetMatedSignalRatio()<0.8){
                        fIsGolden = true;
                        SetStrips("best");
                }
                else if(fBestHypo->GetMatedSignalRatio()>=0.9 
                                && TMath::Abs(fBestHypo->GetCoG()-fSecondBestHypo->GetCoG())<3.
                                && TMath::Abs(fBestHypo->GetCoG()-fThirdBestHypo->GetCoG())<3.){
                        fIsGolden = true;
                        SetStrips("best");
                }
                else if(fBestHypo->GetMatedSignalRatio()>=0.9 
                                && fSecondBestHypo->GetMatedSignalRatio()>=0.8
                                && TMath::Abs(fBestHypo->GetCoG()-fSecondBestHypo->GetCoG())<3.
                                && fThirdBestHypo->GetMatedSignalRatio()<0.8){
                        fIsGolden = true;
                        SetStrips("best");
                }
                else if(fBestHypo->GetMatedSignalRatio()>=0.9 
                                && fSecondBestHypo->GetMatedSignalRatio()<0.8
                                && fThirdBestHypo->GetMatedSignalRatio()>=0.8
                                && TMath::Abs(fBestHypo->GetCoG()-fThirdBestHypo->GetCoG())<3.){
                        fIsGolden = true;
                        SetStrips("best");
                }
    
                //check to see if two of the hypotheses are much better than the third.
                //only have to look at the fThirdBestHypo because if the best hypo was 
                //much better than the second and third best, this would be a golden plane
                //if so, then set the third best hypo to the second best hypo
                if(fBestHypo->GetMatedSignalRatio()-fThirdBestHypo->GetMatedSignalRatio()>0.2
                        &&fSecondBestHypo->GetMatedSignalRatio()-fThirdBestHypo->GetMatedSignalRatio()>0.2)
                        fThirdBestHypo = fSecondBestHypo;

        }//end if more than three hypotheses, test for golden plane status

        //clear the selection function
        hypoItr.GetSet()->AdoptSelectKeyFunc(0);
  
        //get the total charge in the plane
        cdhitr.Reset();  
        fPlaneView = cdhitr.Ptr()->GetPlexSEIdAltL().GetPlaneView();
        while(cdhitr.IsValid()){
                if(cdhitr.Ptr()->GetDeMuxDigitFlagWord() == 0) fPlaneCharge += cdhitr.Ptr()->GetCharge();
                MSG("DmxShower", Msg::kDebug) << "plane = " << cdhitr.Ptr()->GetPlexSEIdAltL().GetPlane()
                                                                         << " digit charge = " << cdhitr.Ptr()->GetCharge() << endl;
                cdhitr.Next();
        }
  
        //set the cog to the best cog for now
        if(fBestHypo && !fIsGolden) SetStrips("best");
        //MSG("DmxShower", Msg::kDebug) << "plane " << fPlaneNumber << " is golden " << (Int_t)fIsGolden << endl;
        return;
}

//----------------------------------------------------------------------
DmxShowerPlane::~DmxShowerPlane()
{
  fHypothesisArray->Delete();
  delete fHypothesisArray;
  delete fUgh;
  //MSG("Dmx", Msg::kDebug) << "deleting Shower Plane for plane " 
  //              << fPlaneNumber << endl;
}

//----------------------------------------------------------------------
Int_t DmxShowerPlane::GetNumberOfStrips() const
{       
        return fNumberOfStrips;
}
//----------------------------------------------------------------------
DmxHypothesis *DmxShowerPlane::GetBestHypothesis()
{
    return fBestHypo;
}

//----------------------------------------------------------------------
Float_t DmxShowerPlane::GetCoG() const
{
  //get the strip end id for the center of gravity for this hypothesis
  PlexStripEndId seid(Detector::kFar,fPlaneNumber,TMath::Nint(fCoG));
  UgliStripHandle ush = fUgh->GetStripHandle(seid);

  return ush.GetTPos();
  //return fCoG;
}

//----------------------------------------------------------------------
Float_t DmxShowerPlane::GetStripCoG() const
{
  return fCoG;
}

//----------------------------------------------------------------------
Float_t DmxShowerPlane::GetHypothesisCoG(Int_t hypoLowerBound)
{
        Float_t hypCoG = dynamic_cast<DmxHypothesis *>(fHypothesisArray->At(hypoLowerBound))->GetCoG();
        
        //get the strip end id for the center of gravity for this hypothesis
        PlexStripEndId seid(Detector::kFar,fPlaneNumber,TMath::Nint(hypCoG));
        UgliStripHandle ush = fUgh->GetStripHandle(seid);
        
        return ush.GetTPos();           
}

//----------------------------------------------------------------------
DmxHypothesis *DmxShowerPlane::GetHypothesis(Int_t hypoLowerBound)
{
    return dynamic_cast<DmxHypothesis *>(fHypothesisArray->At(hypoLowerBound));
}

//----------------------------------------------------------------------
DmxHypothesis *DmxShowerPlane::GetSecondBestHypothesis()
{
  return fSecondBestHypo;
}

//----------------------------------------------------------------------
DmxHypothesis *DmxShowerPlane::GetSetHypothesis()
{
  return fSetHypo;
}

//----------------------------------------------------------------------
DmxHypothesis *DmxShowerPlane::GetThirdBestHypothesis()
{
  return fThirdBestHypo;
}

//----------------------------------------------------------------------
Float_t DmxShowerPlane::GetBestCoG() const
{
  //get the strip end id for the center of gravity for this hypothesis
  PlexStripEndId seid(Detector::kFar,fPlaneNumber,TMath::Nint(fBestHypo->GetCoG()));
  UgliStripHandle ush = fUgh->GetStripHandle(seid);

  return ush.GetTPos();
  //return fBestHypo->GetCoG();
}

//----------------------------------------------------------------------
Float_t DmxShowerPlane::GetSecondBestCoG() const 
{
  //get the strip end id for the center of gravity for this hypothesis
  PlexStripEndId seid(Detector::kFar,fPlaneNumber,TMath::Nint(fSecondBestHypo->GetCoG()));
  UgliStripHandle ush = fUgh->GetStripHandle(seid);

  return ush.GetTPos();
  //return fSecondBestHypo->GetCoG();
}

//----------------------------------------------------------------------
Float_t DmxShowerPlane::GetThirdBestCoG() const 
{
  //get the strip end id for the center of gravity for this hypothesis
  PlexStripEndId seid(Detector::kFar,fPlaneNumber,TMath::Nint(fThirdBestHypo->GetCoG()));
  UgliStripHandle ush = fUgh->GetStripHandle(seid);

  return ush.GetTPos();
  //return fThirdBestHypo->GetCoG();
}

//----------------------------------------------------------------------
Bool_t DmxShowerPlane::GetStripsSetFlag() const
{
  return fStripsSet == 1;
}

//----------------------------------------------------------------------
Bool_t DmxShowerPlane::IsValid() const
{
  return fIsValid;
}

//----------------------------------------------------------------------
Bool_t DmxShowerPlane::IsStray() const
{
  return fIsStray;
}

//----------------------------------------------------------------------
Bool_t DmxShowerPlane::IsGolden() const
{
  return fIsGolden;
}

//----------------------------------------------------------------------
DmxCompareTypes::CompareType_t DmxShowerPlane::CompareHypotheses(DmxHypothesis *hypo1, DmxHypothesis *hypo2)
{
  //when fCompare = 0, look for the lower value of the statistic
  //when fCompare = 1, look for the higher value of the statistic
  //Compare() returns a DmxCompareType
  
  DmxCompareTypes::CompareType_t stat = DmxCompareTypes::kWorse;
  
  //only compare the TieBreakers because you have already sorted the hypotheses by statistic value
  if(fCompare == 0){ 
    if(hypo1->GetStat() < hypo2->GetStat()) stat = DmxCompareTypes::kBetter;
    else if( hypo1->GetStat() == hypo2->GetStat() ){
      if( hypo1->GetTieBreakerStat() < hypo2->GetTieBreakerStat() )  stat = DmxCompareTypes::kBetter; 
      else if( hypo1->GetTieBreakerStat() == hypo2->GetTieBreakerStat() ) stat = DmxCompareTypes::kSame;
    }    
  }
  else if(fCompare == 1){ 
    if(hypo1->GetStat() > hypo2->GetStat()) stat = DmxCompareTypes::kBetter;
    else if( hypo1->GetStat() == hypo2->GetStat() ){
      if( hypo1->GetTieBreakerStat() > hypo2->GetTieBreakerStat() )  stat = DmxCompareTypes::kBetter; 
      else if( hypo1->GetTieBreakerStat() == hypo2->GetTieBreakerStat() ) stat = DmxCompareTypes::kSame;
    }
  }
  return stat;
}

//----------------------------------------------------------------------
void DmxShowerPlane::SetStrips()
{
  if(fBestHypo) SetStrips("best");
//   else MSG("DMX", Msg::kWarning)<<"no best hypothesis, strips not set"<<endl;
  return;
}

//----------------------------------------------------------------------
//the option determines which of the 3 best choice hypotheses to use. if
//"best" use the best, "second" the second best, "third", the third best
void DmxShowerPlane::SetStrips(const Char_t *option)
{
  fStripsSet = 1;
  Int_t hypLowerBound = 0;
  Float_t fitCoG = 0.;
  //set the strips to the hypothesis centered about the CoG for whichever 
  //of the top three is chosen
  if(strcmp(option, "best") == 0 && fBestHypo) fitCoG = fBestHypo->GetCoG();
  else if(strcmp(option, "second") == 0 && fSecondBestHypo) fitCoG = fSecondBestHypo->GetCoG();
  else if(strcmp(option, "third") == 0 && fThirdBestHypo) fitCoG = fThirdBestHypo->GetCoG();

  if(fitCoG >= 11.5 && fitCoG <= 179.5){hypLowerBound = TMath::Nint(fitCoG-11.5);}
  else if(fitCoG < 11.5){hypLowerBound = 0;}
  else if(fitCoG > 179.5){hypLowerBound = 168;}

  if(hypLowerBound <= fNumberOfHypotheses){
    dynamic_cast<DmxHypothesis *>(fHypothesisArray->At(hypLowerBound))->SetStrips(); 
    fCoG = dynamic_cast<DmxHypothesis *>(fHypothesisArray->At(hypLowerBound))->GetCoG();
    fSetHypo = dynamic_cast<DmxHypothesis *>(fHypothesisArray->At(hypLowerBound));
  }
  else{ 
//     MSG("Dmx", Msg::kWarning) << "chosen hypothesis does not exist," 
//                            << " attempt to set strips failed" << endl;
    fSetHypo = 0;
  }
  return;
}

//----------------------------------------------------------------------
Int_t DmxShowerPlane::GetHypothesisLowerBound(Float_t tPos) const
{
  //change the transverse position for the fit into a strip number
  PlexStripEndId seid(Detector::kFar, fPlaneNumber, 1);
  UgliScintPlnHandle usph = fUgh->GetScintPlnHandle(seid);
  UgliStripHandle ush = usph.GetClosestStrip(tPos);
  Float_t fitCoG = 1.*ush.GetSEId().GetStrip();
  
  Int_t hypLowerBound = 0;
  if(fitCoG >= 11.5 && fitCoG <= 179.5){hypLowerBound = TMath::Nint(fitCoG-11.5);}
  else if(fitCoG < 11.5){hypLowerBound = 0;}
  else if(fitCoG > 179.5){hypLowerBound = 168;}
  
  return hypLowerBound;
}

//----------------------------------------------------------------------
void DmxShowerPlane::SetStrips(Float_t tPos)
{

  //change the transverse position for the fit into a strip number
  PlexStripEndId seid(Detector::kFar, fPlaneNumber, 1);
  UgliScintPlnHandle usph = fUgh->GetScintPlnHandle(seid);
  UgliStripHandle ush = usph.GetClosestStrip(tPos);
  Float_t fitCoG = 1.*ush.GetSEId().GetStrip();
  
  //Float_t fitCoG = tPos;
  //MSG("DMXX", Msg::kDebug) << "\tfit in strip vs plane space " << fPlaneNumber << "\t" << fitCoG << endl; 
  //MSG("DMXX", Msg::kDebug) << "\tfit in tpos vs z space " << GetZPosition() << "\t" << tPos << endl; 

  Int_t hypLowerBound = 0;
  if(fitCoG >= 11.5 && fitCoG <= 179.5){hypLowerBound = TMath::Nint(fitCoG-11.5);}
  else if(fitCoG < 11.5){hypLowerBound = 0;}
  else if(fitCoG > 179.5){hypLowerBound = 168;}
  
  fStripsSet = 1;
  
  if(hypLowerBound <= fNumberOfHypotheses){
    dynamic_cast<DmxHypothesis *>(fHypothesisArray->At(hypLowerBound))->SetStrips(); 
    fCoG = dynamic_cast<DmxHypothesis *>(fHypothesisArray->At(hypLowerBound))->GetCoG();
    fSetHypo = dynamic_cast<DmxHypothesis *>(fHypothesisArray->At(hypLowerBound));
  }
  else{ 
//     MSG("Dmx", Msg::kWarning) << "chosen hypothesis does not exist," 
//                            << " attempt to set strips failed" << endl;
    fSetHypo = 0;
  }
  return;
}

//----------------------------------------------------------------------
Float_t DmxShowerPlane::GetPlaneCharge() const
{
  return fPlaneCharge;
}

//----------------------------------------------------------------------
Int_t DmxShowerPlane::GetPlaneNumber() const
{
  return fPlaneNumber;
}

//----------------------------------------------------------------------
Float_t DmxShowerPlane::GetTimingOffset()
{
  if(fSetHypo){
    return fSetHypo->GetTimingOffset(fUgh);
  }
//   else MSG("DmxShower", Msg::kWarning) << "no set hypothesis in plane " 
//                                     << fPlaneNumber << endl;
  
  return -10.;
}

//----------------------------------------------------------------------
Float_t DmxShowerPlane::GetZPosition() const
{
  PlexStripEndId seid(Detector::kFar, fPlaneNumber, 1);
  UgliScintPlnHandle usph = fUgh->GetScintPlnHandle(seid);
  return usph.GetZ0();
  //return 1.*fPlaneNumber;
}

//----------------------------------------------------------------------
DmxPlaneTypes::PlaneType_t DmxShowerPlane::GetPlaneType() const 
{
  return fPlaneType;
}

//----------------------------------------------------------------------
PlaneView::PlaneView_t DmxShowerPlane::GetPlaneView() const
{
  return fPlaneView;
}

//-----------------------------------------------------------------------
void DmxShowerPlane::PrintRecon()
{
  MSG("Dmx", Msg::kInfo) << "Plane = " << fPlaneNumber 
                         << "\tIsValid = " << fIsValid << endl;
  fSetHypo->PrintRecon();
}

//-----------------------------------------------------------------------
void DmxShowerPlane::PrintRecon(Int_t hypoLowerBound)
{
  MSG("DMX", Msg::kInfo) << "Plane\t" << fPlaneNumber << endl;
  dynamic_cast<DmxHypothesis *>(fHypothesisArray->At(hypoLowerBound))->PrintRecon();
}

//----------------------------------------------------------------------
//if the argument is 0, the set falg is unset, if it is 1, the flag is set
void DmxShowerPlane::SetStripsSetFlag(Int_t flag)
{
  if(flag == 0 || flag == 1){fStripsSet = flag;}
  else MSG("Dmx", Msg::kError) << "input flag value is not an option" << endl;
}

//----------------------------------------------------------------------
void DmxShowerPlane::SetStray(bool stray)
{
  fIsStray = stray;
  return;
}

//----------------------------------------------------------------------
void DmxShowerPlane::SetGolden(bool golden)
{
  fIsGolden = golden;
  return;
}

---