Changeset 19365 for trunk/FACT++/gui

Timestamp:

11/08/18 16:01:17 (6 years ago)

Author:

tbretz

Message:

Implemented the FAMOUS camera layout as an alternative in case the mapping file contains exactly 64 G-APD IDs.

Location:

trunk/FACT++/gui

Files:

• BasicGlCamera.cc (modified) (4 diffs)
• BasicGlCamera.h (modified) (1 diff)

trunk/FACT++/gui/BasicGlCamera.cc

@@ -77 +77 @@
 
 
-        hexRadius = 0.015f;
-        hexTolerance = hexRadius/100.0f;
         viewSize = 1.0f;
-        calculatePixelsCoords();
-
-        buildVerticesList();
 /*
        ifstream fin1("Trigger-Patches.txt");
@@ -256 +251 @@
     {
     }
+    bool BasicGlCamera::isFACT() const
+    {
+        return hexRadius<0.02;
+    }
     void BasicGlCamera::assignPixelMap(const PixelMap& map)
     {
         fPixelMap = map;
 
+        int cnt = 0;
         for (auto it=fPixelMap.begin(); it!=fPixelMap.end(); it++)
         {
             hardwareMapping[it->index] = it->hw();
             softwareMapping[it->hw()]  = it->index;
-        }
+            if (it->gapd>0)
+                cnt++;
+        }
+
+        if (cnt==64)
+        {
+            cout << "INFO: 64 SiPMs found -- assuming HAWC's Eye geometry." << endl;
+            hexRadius = 0.065f;
+        }
+        else
+            hexRadius = 0.015f;
 
         //now construct the correspondance between pixels and patches
@@ -896 +906 @@
     void BasicGlCamera::updateNeighbors(int currentPixel)
     {
+        hexTolerance = hexRadius/100.0f;
+
         float squaredDistance = 0;
         for (int i=0;i<currentPixel;i++)
@@ -948 +960 @@
     void BasicGlCamera::calculatePixelsCoords()
     {
-        if (pixelsCoords[0][1] >= (0.299999-hexRadius) && pixelsCoords[0][1] <= (0.300001-hexRadius))
+        if (fabs(pixelsCoords[0][1])>0.000001)
             return;
-        pixelsCoords[0][0] = 0;
-        pixelsCoords[0][1] = 0.3 - hexRadius;
-        pixelsCoords[0][2] = 0;
-        pixelsCoords[1][0] = 0;
-        pixelsCoords[1][1] = 0.3+hexRadius;
-        pixelsCoords[1][2] = 0;
-        neighbors[0][0] = 1;
-        neighbors[1][3] = 0;
-        //from which side of the previous hexagon are we coming from ?
-        int fromSide = 3;
-        //to which side are we heading to ?
-        int toSide = 0;
-        for (int i=2;i<MAX_NUM_PIXELS;i++)
-        {
-            toSide = fromSide-1;
-            if (toSide < 0)
-                toSide =5;
-            while (neighbors[i-1][toSide] >= 0)
+
+        /****************** HAWC's Eye camera layout **************************/
+        if (!isFACT())
+        {
+            static const double gsSin60 = sqrt(3.)/2;
+
+            pixelsCoords[0][0] = 0;
+            pixelsCoords[0][1] = 0;
+
+            uint32_t cnt  = 1;
+            for (int32_t ring=1; ring<=4; ring++)
             {
-                toSide--;
+                for (int32_t s=0; s<6; s++)
+                {
+                    for (int i=1; i<=ring; i++)
+                    {
+                        switch (s)
+                        {
+                        case 0: // Direction South East
+                            pixelsCoords[cnt][0] =  ring-i;
+                            pixelsCoords[cnt][1] = (ring+i)*0.5;
+                            break;
+
+                        case 1: // Direction North East
+                            pixelsCoords[cnt][0] = -i;
+                            pixelsCoords[cnt][1] = ring-i*0.5;
+                            break;
+
+                        case 2: // Direction North
+                            pixelsCoords[cnt][0] = -ring;
+                            pixelsCoords[cnt][1] = ring*0.5-i;
+                            break;
+
+                        case 3: // Direction North West
+                            pixelsCoords[cnt][0] = -(ring-i);
+                            pixelsCoords[cnt][1] = -(ring+i)*0.5;
+                            break;
+
+                        case 4: // Direction South West
+                            pixelsCoords[cnt][0] = i;
+                            pixelsCoords[cnt][1] = 0.5*i-ring;
+                            break;
+
+                        case 5: // Direction South
+                            pixelsCoords[cnt][0] = ring;
+                            pixelsCoords[cnt][1] = i-ring*0.5;
+                            break;
+
+                        }
+                        cnt++;
+                    }
+                }
+            }
+
+            pixelsCoords[cnt][0] = -4;
+            pixelsCoords[cnt][1] = -4;
+
+            cnt++;
+
+            pixelsCoords[cnt][0] =  4;
+            pixelsCoords[cnt][1] = -4;
+
+            cnt++;
+
+            pixelsCoords[cnt][0] = 4;
+            pixelsCoords[cnt][1] = 4;
+
+            cnt++;
+
+            for (int i=0; i<8; i++)
+            {
+                pixelsCoords[cnt+i][0] = i-3.5;
+                pixelsCoords[cnt+i][1] = 7.5 + i%2;
+            }
+
+            cnt += 8;
+
+            for (;cnt<MAX_NUM_PIXELS; cnt++)
+            {
+                pixelsCoords[cnt][0] =  1000;
+                pixelsCoords[cnt][1] =  1000;
+            }
+
+            for (int i=0; i<MAX_NUM_PIXELS; i++)
+            {
+                if (i<64)
+                {
+                    pixelsCoords[i][1] += 1;
+                    pixelsCoords[i][0] *= gsSin60;
+                }
+
+                pixelsCoords[i][0] *= 2*hexRadius;
+                pixelsCoords[i][1] *= 2*hexRadius;
+                pixelsCoords[i][2]  = 0;
+            }
+        }
+        else
+        {
+            /************************ FACT Camera layout **************************/
+            pixelsCoords[0][0] = 0;
+            pixelsCoords[0][1] = 0.3 - hexRadius;
+            pixelsCoords[0][2] = 0;
+            pixelsCoords[1][0] = 0;
+            pixelsCoords[1][1] = 0.3+hexRadius;
+            pixelsCoords[1][2] = 0;
+            neighbors[0][0] = 1;
+            neighbors[1][3] = 0;
+            //from which side of the previous hexagon are we coming from ?
+            int fromSide = 3;
+            //to which side are we heading to ?
+            int toSide = 0;
+            for (int i=2;i<MAX_NUM_PIXELS;i++)
+            {
+                toSide = fromSide-1;
                 if (toSide < 0)
-                    toSide = 5;
+                    toSide =5;
+                while (neighbors[i-1][toSide] >= 0)
+                {
+                    toSide--;
+                    if (toSide < 0)
+                        toSide = 5;
             }
-            fromSide = toSide + 3;
-            if (fromSide > 5)
-                fromSide -= 6;
-            //ok. now we now in which direction we're heading
-            pixelsCoords[i][0] = pixelsCoords[i-1][0];
-            pixelsCoords[i][1] = pixelsCoords[i-1][1];
-            pixelsCoords[i][2] = pixelsCoords[i-1][2];
-            switch (toSide)
-            {
-            case 0:
-                pixelsCoords[i][1] += 2*hexRadius;
-            break;
-            case 1:
-                pixelsCoords[i][0] += (2*hexRadius)*sin(M_PI/3.0);
-                pixelsCoords[i][1] += (2*hexRadius)*cos(M_PI/3.0);
-            break;
-            case 2:
-                pixelsCoords[i][0] += (2*hexRadius)*sin(M_PI/3.0);
-                pixelsCoords[i][1] -= (2*hexRadius)*cos(M_PI/3.0);
-            break;
-            case 3:
-                pixelsCoords[i][1] -= 2*hexRadius;
-            break;
-            case 4:
-                pixelsCoords[i][0] -= (2*hexRadius)*sin(M_PI/3.0);
-                pixelsCoords[i][1] -= (2*hexRadius)*cos(M_PI/3.0);
-            break;
-            case 5:
-                pixelsCoords[i][0] -= (2*hexRadius)*sin(M_PI/3.0);
-                pixelsCoords[i][1] += (2*hexRadius)*cos(M_PI/3.0);
-            break;
-            };
-//            pixelsCoords[i][1] -= hexRadius;
-
-            updateNeighbors(i);
-        }
-        //Ok. So now we've circled around all the way to MAX_NUM_PIXELS
-        //do the required shifts so that it matches the fact camera up to ACTUAL_NUM_PIXELS pixels
-        //remember the location pixels 1438 and 1439, and re-assign them later on
-        GLfloat backupCoords[4];
-        skipPixels(1200, 1);
-        skipPixels(1218, 3);
-        skipPixels(1236, 1);
-        skipPixels(1256, 1);
-        skipPixels(1274, 3);
-        skipPixels(1292, 3);
-        skipPixels(1309, 6);
-        skipPixels(1323, 7);
-        skipPixels(1337, 6);
-        skipPixels(1354, 6);
-        skipPixels(1368, 7);
-        //la c'est dans 1390 qu'il y a 1439
-         backupCoords[0] = pixelsCoords[1390][0];
-         backupCoords[1] = pixelsCoords[1390][1];
-        skipPixels(1382, 9);
-         skipPixels(1394, 12);
-        skipPixels(1402, 15);
-        skipPixels(1410, 12);
-        //la c'est dans 1422 qu'il y a 1438
-        backupCoords[2] = pixelsCoords[1422][0];
-        backupCoords[3] = pixelsCoords[1422][1];
-        skipPixels(1422, 12);
-        skipPixels(1430, 15);
-
-        pixelsCoords[1438][0] = backupCoords[2];
-        pixelsCoords[1438][1] = backupCoords[3];
-        pixelsCoords[1439][0] = backupCoords[0];
-        pixelsCoords[1439][1] = backupCoords[1];
-   }
+                fromSide = toSide + 3;
+                if (fromSide > 5)
+                    fromSide -= 6;
+                //ok. now we now in which direction we're heading
+                pixelsCoords[i][0] = pixelsCoords[i-1][0];
+                pixelsCoords[i][1] = pixelsCoords[i-1][1];
+                pixelsCoords[i][2] = pixelsCoords[i-1][2];
+                switch (toSide)
+                {
+                case 0:
+                    pixelsCoords[i][1] += 2*hexRadius;
+                    break;
+                case 1:
+                    pixelsCoords[i][0] += (2*hexRadius)*sin(M_PI/3.0);
+                    pixelsCoords[i][1] += (2*hexRadius)*cos(M_PI/3.0);
+                    break;
+                case 2:
+                    pixelsCoords[i][0] += (2*hexRadius)*sin(M_PI/3.0);
+                    pixelsCoords[i][1] -= (2*hexRadius)*cos(M_PI/3.0);
+                    break;
+                case 3:
+                    pixelsCoords[i][1] -= 2*hexRadius;
+                    break;
+                case 4:
+                    pixelsCoords[i][0] -= (2*hexRadius)*sin(M_PI/3.0);
+                    pixelsCoords[i][1] -= (2*hexRadius)*cos(M_PI/3.0);
+                    break;
+                case 5:
+                    pixelsCoords[i][0] -= (2*hexRadius)*sin(M_PI/3.0);
+                    pixelsCoords[i][1] += (2*hexRadius)*cos(M_PI/3.0);
+                    break;
+                };
+                //            pixelsCoords[i][1] -= hexRadius;
+
+                updateNeighbors(i);
+            }
+            //Ok. So now we've circled around all the way to MAX_NUM_PIXELS
+            //do the required shifts so that it matches the fact camera up to ACTUAL_NUM_PIXELS pixels
+            //remember the location pixels 1438 and 1439, and re-assign them later on
+            GLfloat backupCoords[4];
+            skipPixels(1200, 1);
+            skipPixels(1218, 3);
+            skipPixels(1236, 1);
+            skipPixels(1256, 1);
+            skipPixels(1274, 3);
+            skipPixels(1292, 3);
+            skipPixels(1309, 6);
+            skipPixels(1323, 7);
+            skipPixels(1337, 6);
+            skipPixels(1354, 6);
+            skipPixels(1368, 7);
+            //la c'est dans 1390 qu'il y a 1439
+            backupCoords[0] = pixelsCoords[1390][0];
+            backupCoords[1] = pixelsCoords[1390][1];
+            skipPixels(1382, 9);
+            skipPixels(1394, 12);
+            skipPixels(1402, 15);
+            skipPixels(1410, 12);
+            //la c'est dans 1422 qu'il y a 1438
+            backupCoords[2] = pixelsCoords[1422][0];
+            backupCoords[3] = pixelsCoords[1422][1];
+            skipPixels(1422, 12);
+            skipPixels(1430, 15);
+
+            pixelsCoords[1438][0] = backupCoords[2];
+            pixelsCoords[1438][1] = backupCoords[3];
+            pixelsCoords[1439][0] = backupCoords[0];
+            pixelsCoords[1439][1] = backupCoords[1];
+        }
+    }
+
     void BasicGlCamera::buildVerticesList()
     {
+        hexTolerance = hexRadius/100.0f;
+
         numVertices = 0;
          GLfloat cVertex[2];

trunk/FACT++/gui/BasicGlCamera.h

@@ -172 +172 @@
     bool autoRefresh;
 
+    bool isFACT() const;
+
   private:
     void skipPixels(int start, int howMany);