PlexValidate.cxx

Go to the documentation of this file.

// $Id: PlexValidate.cxx,v 1.14 2005/08/26 18:47:04 rhatcher Exp $
//
// PlexValidate
//
// PlexValidate is a test harness for Plexus package
//
// Author:  R. Hatcher 2000.05.05
//

#include "Plex/PlexValidate.h"

#include "Plex/PlexStripEndId.h"
#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexLoanPool.h"

#include "Validity/VldContext.h"

#include "MessageService/MsgService.h"
CVSID("$Id: PlexValidate.cxx,v 1.14 2005/08/26 18:47:04 rhatcher Exp $");

ClassImp(PlexValidate)

//______________________________________________________________________________
PlexValidate::PlexValidate()
{
   // Default constructor


   MsgService* msvc = MsgService::Instance();
   MsgStream*  mstr = msvc->GetStream("Plex");
   
   mstr->SetLogLevel(Msg::kVerbose); // spew out everything for debugging
   mstr->SetFormat(Msg::kVerbose,0xffff);

}

//______________________________________________________________________________
PlexValidate::~PlexValidate()
{
   // delete all the owned sub-objects

}

//______________________________________________________________________________
Bool_t PlexValidate::RunAllTests()
{
   Int_t fail = 0;

   if (!TestPlaneId()) fail++;
   if (!TestStripEndId()) fail++;
//   if (!TestAltL()) fail++;

   MSG("Plex",Msg::kInfo)
      << "PlexValidate::RunAllTests had " << fail << " failures " 
      << endl << endl;
  
   return (!fail);
  
}

//______________________________________________________________________________
Bool_t PlexValidate::TestPlaneId(void)
{
   // Test PlaneId encoding/decoding and printout
   // test only the part that isn't accessible via PlexStripEndId

   cout << "Test PlaneId (en|de)coding and printout" << endl << endl;

   Int_t fail = 0;

   cout << "default ctor:        " << flush;
   PlexPlaneId defctor;
   defctor.Print("");

   PlexPlaneId active(Detector::kFar,0,kFALSE);
   PlexPlaneId steel(Detector::kFar,0,kTRUE);

   cout << "active Far plane 0: \"" << active.AsString() << "\"" << endl;
   cout << "steel  Far plane 0: \"" << steel.AsString()  << "\"" << endl;

   if (active.IsSteel()) {
      fail++;
      cout << " active thought it was steel " << endl;
   }
   if (! steel.IsSteel()) {
      fail++;
      cout << " steel thought it was ! steel " << endl;
   }

   PlexPlaneId flipflop = steel;

   flipflop.SetIsSteel(kTRUE);
   if ( ! (steel == flipflop) ) fail++;
   flipflop.SetIsSteel(kFALSE);
   if ( ! (active == flipflop) ) fail++;

   MSG("Plex",Msg::kInfo)
      << "PlexValidate::TestPlaneId had " << fail << " failures " 
      << endl << endl;

   return (!fail);

}
//______________________________________________________________________________
Bool_t PlexValidate::TestStripEndId(void)
{
   // Test StripEndId encoding/decoding and printout

   cout << "Test StripEndId (en|de)coding and printout" << endl << endl;

   Int_t fail = 0;

   cout << "default ctor:          ";
   PlexStripEndId defctor;
   defctor.Print("");

   cout << endl << "test building and unpacking PlexStripEndId's" << endl;
   Detector::Detector_t detectors[5] =
   { Detector::kNear, Detector::kFar, Detector::kCalib,
     Detector::kTestStand, Detector::kMapper };

   Int_t lastplanes[5] =
     { 282, 249+249-1, 64, 10, 10 };

   StripEnd::StripEnd_t ends[8] =
   { StripEnd::kUnknown, StripEnd::kNegative, StripEnd::kPositive,
     StripEnd::kEast, StripEnd::kWest, StripEnd::kUp, StripEnd::kDown,
     StripEnd::kWhole };

   StripEnd::StripEnd_t *subparts = ends;

   PlaneView::PlaneView_t views[5] =
   { PlaneView::kX, PlaneView::kY, PlaneView::kU, PlaneView::kV,
     PlaneView::kUnknown };

   PlaneCoverage::PlaneCoverage_t coverages[5] =
   { PlaneCoverage::kUnknown, PlaneCoverage::kUninstrumented, 
     PlaneCoverage::kNearPartial, PlaneCoverage::kNearFull,
     PlaneCoverage::kComplete };


   //for (Int_t i=0; i<5; i++ ) {
   for (Int_t i=0; i<4; i++ ) {
      cout << endl << Detector::AsString(detectors[i]);
      Int_t last_plane = lastplanes[i];
      Int_t fail_detector = 0;
      for (Int_t iplane=0; iplane<=last_plane; iplane++) {
         if (iplane>2 && iplane<last_plane-6) continue;
         cout << endl << "   plane " << setw(4) << iplane << "  strip ";
         for (Int_t istrip=0; istrip<256; istrip++) {
            if (istrip>2 && istrip<254) continue;
            cout << setw(3) << istrip << " ";
            for (Int_t j=0; j<8; j++) {
               for (Int_t k=0; k<8; k++) {
                  for (Int_t m=0; m<5; m++) {
                     for (Int_t n=0; n<5; n++) {

                        Bool_t success = 
                           BuildAndTestSEId(detectors[i],iplane,istrip,
                                            ends[j],subparts[k],
                                            views[m],coverages[n]);
                        if (!success) fail_detector++;
                     }
                  }
               }
            }
         }
      }
      cout << endl << " had " << fail_detector << " failures " << endl;
      fail += fail_detector;
   }
   cout << endl;

   PlexStripEndId seid0(Detector::kNear,1,2,StripEnd::kWest);

   // copy formatted (unpacked) PlexStripEndId string to temp
   // otherwise the result of printf are unpredictable
   // (since AsString() uses a static space in which to write)
   char string0[40];
   char string1[40];

   cout << endl;

   strcpy(string0,seid0.AsString());
   printf("     %s  SameStrip SameEnd OppositeEnd\n",string0);

   for (Int_t itest=0; itest<7; itest++) {

      Bool_t samestrip, sameend, otherend;
      Bool_t samestriptrue, sameendtrue,otherendtrue;  
      Int_t  failtest = 0;
      
      PlexStripEndId seid1;
      switch (itest) {
      case 0:
         seid1 = PlexStripEndId(Detector::kNear,1,2,StripEnd::kWest);
         samestriptrue = kTRUE;
         sameendtrue   = kTRUE;
         otherendtrue  = kFALSE;
         break;
      case 1:
         seid1 = PlexStripEndId(Detector::kNear,1,2,StripEnd::kEast);
         samestriptrue = kTRUE;
         sameendtrue   = kFALSE;
         otherendtrue  = kTRUE;
         break;
      case 2:
         seid1 = seid0.GetOppositeSEId();
         samestriptrue = kTRUE;
         sameendtrue   = kFALSE;
         otherendtrue  = kTRUE;
         break;
      case 3:
         seid1 = PlexStripEndId(Detector::kFar,1,2,StripEnd::kEast);
         samestriptrue = kFALSE;
         sameendtrue   = kFALSE;
         otherendtrue  = kFALSE;
         break;
      case 4:
         seid1 = PlexStripEndId(Detector::kNear,2,2,StripEnd::kEast);
         samestriptrue = kFALSE;
         sameendtrue   = kFALSE;
         otherendtrue  = kFALSE;
         break;
      case 5:
         seid1 = PlexStripEndId(Detector::kNear,3,2,StripEnd::kEast);
         samestriptrue = kFALSE;
         sameendtrue   = kFALSE;
         otherendtrue  = kFALSE;
         break;
      default:
         samestriptrue = kFALSE;
         sameendtrue   = kFALSE;
         otherendtrue  = kFALSE;
         break;
      }

      strcpy(string1,seid1.AsString());
      samestrip = seid0.IsSameStrip(seid1);
      sameend   = seid0.IsSameStripEnd(seid1);
      otherend  = seid0.IsOppositeStripEnd(seid1);

      printf(" vs. %s %9d %7d %11d\n",
             string1,samestrip,sameend,otherend);

      if (samestrip != samestriptrue) failtest++;
      if (sameend   != sameendtrue) failtest++;
      if (otherend  != otherendtrue) failtest++;

      if (failtest) {
         fail++;
         cout << " ^^^^^^^^^  incorrect results " << endl;
      }

   }
   cout << endl;

   MSG("Plex",Msg::kInfo)
      << " Test output to MSG service: " << seid0 << endl;

   MSG("Plex",Msg::kInfo)
      << "PlexValidate::TestStripEndId had " << fail << " failures " 
      << endl << endl;

   return (!fail);
}

//______________________________________________________________________________
Bool_t PlexValidate::TestAltL(void)
{
   // Test StripEndId Alt List

   cout << "Test PlexSEIdAltL" << endl << endl;

   Int_t fail = 0;

   PlexStripEndId seid;
   
   printf("\n start with empty list:\n");
   PlexSEIdAltL alt;
   alt.Print("");

   printf("\n add one entry, then drop:\n");
   PlexStripEndId seidxxx;

   PlexPixelSpotId spotidxxx;
   //cout << " seid " << seidxxx << " spotid " << spotidxxx << endl;
   alt.AddStripEndId(seidxxx,spotidxxx);
   //alt.AddStripEndId(PlexStripEndId(),PlexPixelSpotId());

   alt.Print("");
   alt.DropCurrent();
   alt.Print("");
   printf("IsValid() returns %d\n",(int)alt.IsValid());

   printf("\n add three real entries:\n");
   PlexStripEndId seid11(Detector::kNear,1,2,StripEnd::kEast);
   PlexStripEndId seid12(Detector::kFar ,3,4,StripEnd::kWest);
   PlexStripEndId seid13(Detector::kCalib,5,6,StripEnd::kUp);

   PlexPixelSpotId spot11(Detector::kNear,ElecType::kQIE,'E','U',1,2,0,1,2);
   PlexPixelSpotId spot12(Detector::kFar,ElecType::kVA,'W','L',1,2,0,1,2);
   PlexPixelSpotId spot13(Detector::kCalib,ElecType::kVA,'E','U',1,2,0,1,2);

   alt.AddStripEndId(seid11,spot11,1);
   alt.AddStripEndId(seid12,spot12,20);
   alt.AddStripEndId(seid13,spot13,4);

   alt.Print("");
   printf("move back 2\n");
   alt.Previous();
   alt.Previous();
   alt.Print("");
   printf("move forward 2\n");
   alt.Next();
   alt.Next();
   alt.Print("");
   printf("move forward 1 more\n");
   alt.Next();
   alt.Print("");

   alt.SetFirst();
   printf("SetFirst()    gives %s weight %g\n",
          (alt.GetCurrentSEId()).AsString(),alt.GetCurrentWeight());

   alt.SetLast();
   printf("SetLast()     gives %s weight %g\n",
          (alt.GetCurrentSEId()).AsString(),alt.GetCurrentWeight());


   printf("GetBestX()    gives %s weight %g\n",
          (alt.GetBestSEId()).AsString(),alt.GetBestWeight());

   alt.SetLast();
   printf("SetLast()    IsValid returns %d\n",(int)alt.IsValid());
   alt.Next();
   printf("out-of-range IsValid returns %d\n",(int)alt.IsValid());
   alt.SetFirst();
   printf("SetFirst()   IsValid returns %d\n",(int)alt.IsValid());
   alt.Previous();
   printf("out-of-range IsValid returns %d\n",(int)alt.IsValid());

#ifdef WILL_ASSERT
   alt.SetLast();
   alt.Next();
   printf("SetLast()+1   gives %s weight %g\n",
          (alt.GetCurrentSEId()).AsString(),alt.GetCurrentWeight());

   alt.SetFirst();
   alt.Previous();
   printf("SetFirst()-1  gives %s weight %g\n",
          (alt.GetCurrentSEId()).AsString(),alt.GetCurrentWeight());
#endif

   printf("\n iterate\n");
   alt.SetFirst();
   while (alt.IsValid()) {
      printf(" SEId %s weight %g\n",
          (alt.GetCurrentSEId()).AsString(),alt.GetCurrentWeight());
      alt.Next();
   };


#ifdef SILLYMEMLEAKCHECK
   printf("\n check for memory leaks by repeated copy construction\n");
   printf("   look for size change in 'top'\n");
   printf("  ...hey it ain't pretty, but it's a stopgap solution\n");
   cout << flush;
   cout << "type x<return> to continue" << endl;
   char c;
   cin >> c;
   for (Int_t j=0; j<10; j++) {
      for (Int_t i=0; i<100000; i++) {
         PlexSEIdAltL alt2(alt);
         
         alt2 = alt;
      }
      //      cout << " outer loop " << j << endl;
   }
   alt = alt;
   alt.Print();
   printf("\n");
#endif

   Int_t plane;
   StripEnd::StripEnd_t end;

   cout << "using previous AltL: " << endl;
   plane = alt.GetPlane();
   cout << " alt list returned Plane " << plane << endl;
   end = alt.GetEnd();
   cout << " alt list returned End " << StripEnd::AsString(end) << endl;

   cout << "using empty AltL: " << endl;
   PlexSEIdAltL alt2;
   plane = alt2.GetPlane();
   cout << " alt list returned Plane " << plane << endl;
   end = alt2.GetEnd();
   cout << " alt list returned End " << StripEnd::AsString(end) << endl;

   cout << "using new AltL: " << endl;
   PlexStripEndId seid21(Detector::kNear,1,1,StripEnd::kEast);
   PlexStripEndId seid22(Detector::kNear,1,2,StripEnd::kEast);
   PlexStripEndId seid23(Detector::kNear,1,3,StripEnd::kEast);

   PlexPixelSpotId spot21(Detector::kNear,ElecType::kQIE,'E','U',1,2,0,1,1);
   PlexPixelSpotId spot22(Detector::kNear,ElecType::kQIE,'E','U',1,2,0,1,2);
   PlexPixelSpotId spot23(Detector::kNear,ElecType::kQIE,'E','U',1,2,0,1,3);

   alt2.AddStripEndId(seid21,spot21,0);
   alt2.AddStripEndId(seid22,spot22,1);
   alt2.AddStripEndId(seid23,spot23,0);

   alt2.Print();
   plane = alt2.GetPlane();
   cout << " alt list returned Plane " << plane << endl;
   end = alt2.GetEnd();
   cout << " alt list returned End " << StripEnd::AsString(end) << endl;
   printf(" drop entries with zero weights\n");
   alt2.DropZeroWeights();
   alt2.Print();

   printf("\n working on:\n");
   alt.Print();
   printf("\n");

   printf("\n Normalize the weights:\n");
   alt.NormalizeWeights();

   MSG("Plex",Msg::kInfo)
      << " Test output to MSG service: " << endl
      << alt << " ... done " << endl << endl;


   printf("loop in reverse, drop all elements with weight < 0.799\n");
   alt.SetLast();
   while ( alt.IsValid() ) {
      if ( alt.GetCurrentWeight() < 0.799 ) alt.DropCurrent();
      alt.Previous();
   }
   alt.Print();
   printf("\n");

   printf(" clear all weights\n");
   alt.ClearWeights();
   alt.Print();
   printf("\n");

   printf("drop all zero weight entries (should give empty list)\n");
   alt.SetLast();
   while ( alt.IsValid() ) {
      if ( alt.GetCurrentWeight() == 0.0 ) alt.DropCurrent();
      alt.Previous();
   }
   alt.Print();
   printf("\n");


   cout << "using new AltL: " << endl;
   PlexStripEndId seid31(Detector::kNear,1,1,StripEnd::kEast);
   PlexStripEndId seid32(Detector::kNear,1,2,StripEnd::kEast);
   PlexStripEndId seid33(Detector::kNear,1,3,StripEnd::kEast);
   PlexStripEndId seid34(Detector::kNear,1,4,StripEnd::kEast);
   PlexStripEndId seid35(Detector::kNear,1,5,StripEnd::kEast);

   PlexPixelSpotId spot31(Detector::kNear,ElecType::kQIE,'E','U',1,2,0,1,1);
   PlexPixelSpotId spot32(Detector::kNear,ElecType::kQIE,'E','U',1,2,0,1,2);
   PlexPixelSpotId spot33(Detector::kNear,ElecType::kQIE,'E','U',1,2,0,1,3);
   PlexPixelSpotId spot34(Detector::kNear,ElecType::kQIE,'E','U',1,2,0,1,4);
   PlexPixelSpotId spot35(Detector::kNear,ElecType::kQIE,'E','U',1,2,0,1,5);

   alt.AddStripEndId(seid31,spot31,1);
   alt.AddStripEndId(seid32,spot32,2);
   alt.AddStripEndId(seid33,spot33,3);
   alt.AddStripEndId(seid34,spot34,4);
   alt.AddStripEndId(seid35,spot35,3);

   alt.Print();
   cout << "KeepTopWeights(3,true) " << endl;
   alt.KeepTopWeights(3,kTRUE);
   alt.Print();
   cout << "KeepTopWeights(3,false) " << endl;
   alt.KeepTopWeights(3,kFALSE);
   alt.Print();
   cout << "KeepTopWeights(2,false) " << endl;
   alt.KeepTopWeights(2,kFALSE);
   alt.Print();
   cout << "KeepTopWeights(1) " << endl;
   alt.KeepTopWeights(1);
   alt.Print();

   MSG("Plex",Msg::kInfo)
      << "PlexValidate::TestAltL had " << fail << " failures " << endl;
   return (!fail);
}

//______________________________________________________________________________
Bool_t PlexValidate::BuildAndTestSEId(Detector::Detector_t detector,
                  Int_t plane, Int_t strip,
                  StripEnd::StripEnd_t end,
                  StripEnd::StripEnd_t subpart,
                  PlaneView::PlaneView_t view,
                  PlaneCoverage::PlaneCoverage_t cover)
{
   PlexStripEndId seid(detector,plane,strip,end,subpart,view,cover);
   Int_t fail = 0;

   enum failenum {
     faildetector = 0x01,
     failplane    = 0x02,
     failstrip    = 0x04,
     failend      = 0x08,
     failsubpart  = 0x10,
     failplnview  = 0x20,
     failplncover = 0x40
   };

   if (seid.GetDetector() != detector )  fail |= faildetector;
   if (seid.GetPlane() != plane )        fail |= failplane;
   if (seid.GetStrip() != strip )        fail |= failstrip;
   if (seid.GetEnd()   != end )          fail |= failend;
   if (seid.GetSubPart() != subpart )    fail |= failsubpart;
   if (seid.GetPlaneView() != view && 
       view != PlaneView::kUnknown )     fail |= failplnview;
   if (seid.GetPlaneCoverage() != cover && 
       cover != PlaneCoverage::kUnknown) fail |= failplncover;

   if (fail) {
      MSG("Plex",Msg::kWarning) 
        << "PlexValidate::BuildAndTestSEId failed (0x" 
        << hex << fail << dec << ") for "
        << seid.AsString() 
        << " != " << Detector::AsString(detector)
        << "/" << plane 
        << "/" << strip
        << "/" << StripEnd::AsString(end)
        << "/" << StripEnd::AsString(subpart)
        << "/" << PlaneView::AsString(view)
        << "/" << PlaneCoverage::AsString(cover)
        << endl;
   }

   Bool_t success = ! fail;
   return success;
}
//______________________________________________________________________________

---